week1 tweaks

[lambda.git] / week1.mdwn

diff --git a/week1.mdwn b/week1.mdwn
index 316cfa4..c68da8a 100644 (file)
--- a/week1.mdwn
+++ b/week1.mdwn
@@ -114,19 +114,19 @@ The lambda calculus we'll be focusing on for the first part of the course has no
 Here is its syntax:
 
 <blockquote>
 Here is its syntax:
 
 <blockquote>

-       **Variables**: `x`, `y`, `z`, ...
+<strong>Variables</strong>: <code>x</code>, <code>y</code>, <code>z</code>...

 </blockquote>
 
 Each variable is an expression. For any expressions M and N and variable a, the following are also expressions:
 
 <blockquote>
 </blockquote>
 
 Each variable is an expression. For any expressions M and N and variable a, the following are also expressions:
 
 <blockquote>

-       **Abstract**: <code>(&lambda;a M)</code>
+<strong>Abstract</strong>: <code>(&lambda;a M)</code>

 </blockquote>
 
 </blockquote>
 

-We'll tend to write <code>(&lambda;a M)</code> as just `( \a M )`.
+We'll tend to write <code>(&lambda;a M)</code> as just `(\a M)`, so we don't have to write out the markup code for the <code>&lambda;</code>. You can yourself write <code>(&lambda;a M)</code> or `(\a M)` or `(lambda a M)`.

 
 <blockquote>
 
 <blockquote>

-       **Application**: `(M N)`
+<strong>Application</strong>: <code>(M N)</code>

 </blockquote>
 
 Some authors reserve the term "term" for just variables and abstracts. We won't participate in that convention; we'll probably just say "term" and "expression" indiscriminately for expressions of any of these three forms.
 </blockquote>
 
 Some authors reserve the term "term" for just variables and abstracts. We won't participate in that convention; we'll probably just say "term" and "expression" indiscriminately for expressions of any of these three forms.


@@ -142,7 +142,7 @@ Examples of expressions:
        (x (\x x))
        ((\x (x x)) (\x (x x)))
 
        (x (\x x))
        ((\x (x x)) (\x (x x)))
 

-The lambda calculus has an associated proof theory. For now, we can regard the proof theory as having just one rule, called the rule of "beta-reduction" or "beta-contraction". Suppose you have some expression of the form:
+The lambda calculus has an associated proof theory. For now, we can regard the proof theory as having just one rule, called the rule of **beta-reduction** or "beta-contraction". Suppose you have some expression of the form:

 
        ((\a M) N)
 
 
        ((\a M) N)
 


@@ -150,7 +150,7 @@ that is, an application of an abstract to some other expression. This compound f
 
 The rule of beta-reduction permits a transition from that expression to the following:
 
 
 The rule of beta-reduction permits a transition from that expression to the following:
 

-       M {a:=N}
+       M [a:=N]

 
 What this means is just `M`, with any *free occurrences* inside `M` of the variable `a` replaced with the term `N`.
 
 
 What this means is just `M`, with any *free occurrences* inside `M` of the variable `a` replaced with the term `N`.
 


@@ -167,7 +167,7 @@ For instance:
 
 >      T is defined to be `(x (\x (\y (x (y z)))))`
 
 
 >      T is defined to be `(x (\x (\y (x (y z)))))`
 

-The first occurrence of `x` in `T` is free.  The `\x` we won't regard as being an occurrence of `x`. The next occurrence of `x` occurs within a form that begins with `\x`, so it is bound as well. The occurrence of `y` is bound; and the occurrence of `z` is free.
+The first occurrence of `x` in T is free.  The `\x` we won't regard as being an occurrence of `x`. The next occurrence of `x` occurs within a form that begins with `\x`, so it is bound as well. The occurrence of `y` is bound; and the occurrence of `z` is free.

 
 Here's an example of beta-reduction:
 
 
 Here's an example of beta-reduction:
 


@@ -185,33 +185,33 @@ Different authors use different notations. Some authors use the term "contractio
 
        M ~~> N
 
 
        M ~~> N
 

-We'll mean that you can get from M to N by one or more reduction steps. Hankin uses the symbol -> for one-step contraction, and the symbol ->> for zero-or-more step reduction. Hindley and Seldin use (triangle..sub1) and (triangle).
+We'll mean that you can get from M to N by one or more reduction steps. Hankin uses the symbol <code><big><big>&rarr;</big></big></code> for one-step contraction, and the symbol <code><big><big>&#8608;</big></big></code> for zero-or-more step reduction. Hindley and Seldin use <code><big><big><big>&#8883;</big></big></big><sub>1</sub></code> and <code><big><big><big>&#8883;</big></big></big></code>.

 
 When M and N are such that there's some P that M reduces to by zero or more steps, and that N also reduces to by zero or more steps, then we say that M and N are **beta-convertible**. We'll write that like this:
 
        M <~~> N
 
 
 When M and N are such that there's some P that M reduces to by zero or more steps, and that N also reduces to by zero or more steps, then we say that M and N are **beta-convertible**. We'll write that like this:
 
        M <~~> N
 

-This is what plays the role of equality in the lambda calculus. Hankin uses the symbol `=` for this. So too do Hindley and Seldin.
+This is what plays the role of equality in the lambda calculus. Hankin uses the symbol `=` for this. So too do Hindley and Seldin. Personally, I keep confusing that with the relation to be described next, so let's use this notation instead. Note that `M <~~> N` doesn't mean that each of `M` and `N` are reducible to each other; that only holds when `M` and `N` are the same expression. (Or, with our convention of only saying "reducible" for one or more reduction steps, it never holds.)

 
 

-In the metatheory, it's also sometimes useful to talk about formulas that are syntactically equivalent *before any reductions take place*. Hankin uses the symbol (three bars) for this. So too do Hindley and Seldin. We'll use that too, and will avoid using `=` when discussing metatheory for the lambda calculus. Instead we'll use `<~~>` as we said above. When we want to introduce a stipulative definition, we'll write it out longhand, as in:
+In the metatheory, it's also sometimes useful to talk about formulas that are syntactically equivalent *before any reductions take place*. Hankin uses the symbol <code>&equiv;</code> for this. So too do Hindley and Seldin. We'll use that too, and will avoid using `=` when discussing metatheory for the lambda calculus. Instead we'll use `<~~>` as we said above. When we want to introduce a stipulative definition, we'll write it out longhand, as in:

 
 >      T is defined to be `(M N)`.
 
 We'll regard the following two expressions:
 
 
 >      T is defined to be `(M N)`.
 
 We'll regard the following two expressions:
 

-       (\x x y)
+       (\x (x y))

 
 

-       (\z z y)
+       (\z (z y))

 
 as syntactically equivalent, since they only involve a typographic change of a bound variable. Read Hankin section 2.3 for discussion of different attitudes one can take about this.
 
 Note that neither of those expressions are identical to:
 
 
 as syntactically equivalent, since they only involve a typographic change of a bound variable. Read Hankin section 2.3 for discussion of different attitudes one can take about this.
 
 Note that neither of those expressions are identical to:
 

-       (\x x w)
+       (\x (x w))

 
 because here it's a free variable that's been changed. Nor are they identical to:
 
 
 because here it's a free variable that's been changed. Nor are they identical to:
 

-       (\y y y)
+       (\y (y y))

 
 because here the second occurrence of `y` is no longer free.
 
 
 because here the second occurrence of `y` is no longer free.
 


@@ -224,11 +224,11 @@ Shorthand
 The grammar we gave for the lambda calculus leads to some verbosity. There are several informal conventions in widespread use, which enable the language to be written more compactly. (If you like, you could instead articulate a formal grammar which incorporates these additional conventions. Instead of showing it to you, we'll leave it as an exercise for those so inclined.)
 
 
 The grammar we gave for the lambda calculus leads to some verbosity. There are several informal conventions in widespread use, which enable the language to be written more compactly. (If you like, you could instead articulate a formal grammar which incorporates these additional conventions. Instead of showing it to you, we'll leave it as an exercise for those so inclined.)
 
 

-Dot notation: dot means "put a left paren here, and put the right
+**Dot notation** Dot means "put a left paren here, and put the right

 paren as far the right as possible without creating unbalanced
 parentheses". So:
 
 paren as far the right as possible without creating unbalanced
 parentheses". So:
 

-       (\x (\y (xy)))
+       (\x (\y (x y)))

 
 can be abbreviated as:
 
 
 can be abbreviated as:
 


@@ -236,23 +236,23 @@ can be abbreviated as:
 
 and:
 
 
 and:
 

-       (\x \y. (z y) z)
+       (\x (\y. (z y) z))

 
 would abbreviate:
 
 
 would abbreviate:
 

-       (\x \y ((z y) z))
+       (\x (\y ((z y) z)))

 
 This on the other hand:
 
 
 This on the other hand:
 

-       ((\x \y. (z y) z)
+       (\x (\y. z y) z)

 
 would abbreviate:
 
 
 would abbreviate:
 

-       ((\x (\y (z y))) z)
+       (\x (\y (z y)) z)

 
 

-Parentheses: outermost parentheses around applications can be dropped. Moreover, applications will associate to the left, so `M N P` will be understood as `((M N) P)`. Finally, you can drop parentheses around abstracts, but not when they're part of an application. So you can abbreviate:
+**Parentheses** Outermost parentheses around applications can be dropped. Moreover, applications will associate to the left, so `M N P` will be understood as `((M N) P)`. Finally, you can drop parentheses around abstracts, but not when they're part of an application. So you can abbreviate:

 
 

-       (\x x y)
+       (\x. x y)

 
 as:
 
 
 as:
 


@@ -266,7 +266,7 @@ and:
 
        z (\x. x y)
 
 
        z (\x. x y)
 

-Merging lambdas: an expression of the form `(\x (\y M))`, or equivalently, `(\x. \y. M)`, can be abbreviated as:
+**Merging lambdas** An expression of the form `(\x (\y M))`, or equivalently, `(\x. \y. M)`, can be abbreviated as:

 
        (\x y. M)
 
 
        (\x y. M)