Lecture 6 (2015-09-21)
Stack machines; the lambda calculus

**Stack machines**

|Command|Input stack||Output stack|
|:-|-:|:-:|:-|
|IPush n|s|-->|n:s|
|IPlus|n1:n2:s|-->|n1 + n2:s|
|ITimes|n1:n2:s|-->|n1 * n2:s|
|INeg|n:s|-->|(0-n):s|

**The lambda calculus**

The lambda calculus is a notation for *anonymous* functions. We
typically write math functions with names, like: f(x) = x + 1. In the
lambda calculus, we write functions anonymously. For example, f is
equivalent to λx. x + 1.

We introduced an *equational* semantics with two axioms.

The first, *alpha equivalence*, says that we can rename variables so
long as we do it consistently:

(&lambda;x. e) =<sub>&alpha;</sub> (&lambda;y. e[y/x])

The second, *beta equivalence*, says how to apply functions:

(&lambda;x. e<sub>1</sub>) e<sub>2</sub> = e<sub>1</sub>[<sup>e<sub>2</sub></sup>/<sub>x</sub>]

A variable is *free* when it's not under &lambda; that binds it. In
&lambda;x. x y, the variable y is free but x is *bound*.

We defined substitution as follows:

||||
|-:|:-:|:-|
|x[e/x] |=| e|
|y[e/x] |=| y|
|(e<sub>1</sub> e<sub>2</sub>)[e/x] |=| e<sub>1</sub>[e/x] e<sub>2</sub>[e/x]|
|(&lambda;x. e')[e/x] |=| &lambda;x. e'|
|(&lambda;y. e')[e/x] |=| &lambda;y. e'[e/x]|

Note that the definition above only *really* makes sense when e---the
term being substituted for x---doesn't have free variables. When e has
free variables, we need to worry about *capture*, where a free
variable in e becomes bound. The standard way of defining
capture-avoiding substitution is to imagine that we have some infinite
source of *fresh* variables, which don't appear in any given term
we're considering. We then change the last line to read:

(&lambda;y. e')[e/x] = &lambda;z. e'[z/y][e/x] where z is fresh

The freshness of z makes sure that neither e' nor e mention z at all.

**Church encodings**

We also defined a bunch of *Church encodings*, named after <a
href="https://en.wikipedia.org/wiki/Alonzo_Church">Alonzo Church</a>,
the progenitor and master encoder of the lambda calculus.

We first defined the Church booleans:

true = &lambda;x. &lambda y. x
false = &lambda;x. &lambda y. x

Then, to check our work, we defined a conditional:

cond = &lambda;p. &lambda;t. &lambda;e. p t e

We can then see that: 

cond true e<sub>1</sub> e<sub>2</sub> = e<sub>1</sub>

and:

cond false e<sub>1</sub> e<sub>2</sub> = e<sub>2</sub>

That is... it really works! The idea here is to *operationalize* every
thing. The booleans are typicaly defined as **2** = { &perp;, &#x22A4;
}, but we instead say that the *Church booleans* are the functions that make a
choice between two things.

We can define numbers, too. A *Church numeral* is a function that
takes two arguments and applies the first one some number of times.

So 0 is the function that never applies its first argument:

zero = &lambda;s. &lambda;z. z

And 1 applies it once:

one = &lambda;s. &lambda;z. s z

And two applies it twice:

two = &lambda;s. &lambda;z. s (s z)

We can write the *successor function*, which takes a number and then
yields its successor.

succ = &lambda;n. &lambda;s. &lambda;z. s (n s z)

**Types**

Naive Church encodings don't always work in Haskell due to typing, but
we can *think* of each of these Church encodings as having a type.

> type ChurchBoolean = a -> a -> a
> type ChurchNumeral = (a -> a) -> a -> a

**Shorthand notation**

When a function takes a bunch of arguments---like succ above---we
sometimes write a single lambda, like so:

succ = &lambda;n s z. s (n s z)