2 Basics of Lambda Calculus
3 =========================
5 The lambda calculus we'll be focusing on for the first part of the course has no types. (Some prefer to say it instead has a single type---but if you say that, you have to say that functions from this type to this type also belong to this type. Which is weird.)
7 Here is its syntax:
9 <blockquote>
10 <strong>Variables</strong>: <code>x</code>, <code>y</code>, <code>z</code>...
11 </blockquote>
13 Each variable is an expression. For any expressions M and N and variable a, the following are also expressions:
15 <blockquote>
16 <strong>Abstract</strong>: <code>(&lambda;a M)</code>
17 </blockquote>
19 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)`.
21 <blockquote>
22 <strong>Application</strong>: <code>(M N)</code>
23 </blockquote>
26 Some authors reserve the term "term" for just variables and abstracts. We'll probably just say "term" and "expression" indiscriminately for expressions of any of these three forms.
28 Examples of expressions:
30         x
31         (y x)
32         (x x)
33         (\x y)
34         (\x x)
35         (\x (\y x))
36         (x (\x x))
37         ((\x (x x)) (\x (x x)))
39 The lambda calculus has an associated proof theory. For now, we can regard the
40 proof theory as having just one rule, called the rule of **beta-reduction** or
41 "beta-contraction". Suppose you have some expression of the form:
43         ((\ a M) N)
45 that is, an application of an abstract to some other expression. This compound form is called a **redex**, meaning it's a "beta-reducible expression." `(\a M)` is called the **head** of the redex; `N` is called the **argument**, and `M` is called the **body**.
47 The rule of beta-reduction permits a transition from that expression to the following:
49         M [a:=N]
51 What this means is just `M`, with any *free occurrences* inside `M` of the variable `a` replaced with the term `N`.
53 What is a free occurrence?
55 >       An occurrence of a variable `a` is **bound** in T if T has the form `(\a N)`.
57 >       If T has the form `(M N)`, any occurrences of `a` that are bound in `M` are also bound in T, and so too any occurrences of `a` that are bound in `N`.
59 >       An occurrence of a variable is **free** if it's not bound.
61 For instance:
64 >       T is defined to be `(x (\x (\y (x (y z)))))`
66 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.
68 Here's an example of beta-reduction:
70         ((\x (y x)) z)
72 beta-reduces to:
74         (y z)
76 We'll write that like this:
78         ((\x (y x)) z) ~~> (y z)
80 Different authors use different notations. Some authors use the term "contraction" for a single reduction step, and reserve the term "reduction" for the reflexive transitive closure of that, that is, for zero or more reduction steps. Informally, it seems easiest to us to say "reduction" for one or more reduction steps. So when we write:
82         M ~~> N
84 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>.