Cálculo lambda

arXiv:0804.3434v2[cs.LO]26Dec2013
Lecture Notes on the Lambda Calculus
Peter Selinger
Department of Mathematics and Statistics
Dalhousie University, Halifax, Canada
Abstract
This is a set of lecture notes that developed out of courses on the lambda
calculus that I taught at the University of Ottawa in 2001 and at Dalhousie
University in 2007 and 2013. Topics covered in these notes include the un-
typed lambda calculus, the Church-Rosser theorem, combinatory algebras,
the simply-typed lambda calculus, the Curry-Howard isomorphism, weak
and strong normalization, polymorphism, type inference, denotational se-
mantics, complete partial orders, and the language PCF.
Contents
1 Introduction 6
1.1 Extensional vs. intensional view of functions . . . . . . . . . . . 6
1.2 The lambda calculus . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Untyped vs. typed lambda-calculi . . . . . . . . . . . . . . . . . 8
1.4 Lambda calculus and computability . . . . . . . . . . . . . . . . 9
1.5 Connections to computer science . . . . . . . . . . . . . . . . . . 10
1.6 Connections to logic . . . . . . . . . . . . . . . . . . . . . . . . 10
1.7 Connections to mathematics . . . . . . . . . . . . . . . . . . . . 11
2 The untyped lambda calculus 11
2.1 Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1

2.2 Free and bound variables, α-equivalence . . . . . . . . . . . . . . 13
2.3 Substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Introduction to β-reduction . . . . . . . . . . . . . . . . . . . . . 17
2.5 Formal deﬁnitions of β-reduction and β-equivalence . . . . . . . 18
3 Programming in the untyped lambda calculus 19
3.1 Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Natural numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3 Fixed points and recursive functions . . . . . . . . . . . . . . . . 22
3.4 Other data types: pairs, tuples, lists, trees, etc. . . . . . . . . . . . 24
4 The Church-Rosser Theorem 26
4.1 Extensionality, η-equivalence, and η-reduction . . . . . . . . . . . 26
4.2 Statement of the Church-Rosser Theorem, and some consequences 28
4.3 Preliminary remarks on the proof of the Church-Rosser Theorem . 30
4.4 Proof of the Church-Rosser Theorem . . . . . . . . . . . . . . . . 32
4.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5 Combinatory algebras 38
5.1 Applicative structures . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 Combinatory completeness . . . . . . . . . . . . . . . . . . . . . 40
5.3 Combinatory algebras . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 The failure of soundness for combinatory algebras . . . . . . . . . 43
5.5 Lambda algebras . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.6 Extensional combinatory algebras . . . . . . . . . . . . . . . . . 49
6 Simply-typed lambda calculus, propositional logic, and the Curry-
Howard isomorphism 51
6.1 Simple types and simply-typed terms . . . . . . . . . . . . . . . . 51
6.2 Connections to propositional logic . . . . . . . . . . . . . . . . . 54
6.3 Propositional intuitionistic logic . . . . . . . . . . . . . . . . . . 56
2

6.4 An alternative presentation of natural deduction . . . . . . . . . . 58
6.5 The Curry-Howard Isomorphism . . . . . . . . . . . . . . . . . . 60
6.6 Reductions in the simply-typed lambda calculus . . . . . . . . . . 62
6.7 A word on Church-Rosser . . . . . . . . . . . . . . . . . . . . . 63
6.8 Reduction as proof simpliﬁcation . . . . . . . . . . . . . . . . . . 64
6.9 Getting mileage out of the Curry-Howard isomorphism . . . . . . 65
6.10 Disjunction and sum types . . . . . . . . . . . . . . . . . . . . . 66
6.11 Classical logic vs. intuitionistic logic . . . . . . . . . . . . . . . . 68
6.12 Classical logic and the Curry-Howard isomorphism . . . . . . . . 70
7 Weak and strong normalization 71
7.1 Deﬁnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
7.2 Weak and strong normalization in typed lambda calculus . . . . . 72
8 Polymorphism 73
8.1 Syntax of System F . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.2 Reduction rules . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.3 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
8.3.1 Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . 75
8.3.2 Natural numbers . . . . . . . . . . . . . . . . . . . . . . 76
8.3.3 Pairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
8.4 Church-Rosser property and strong normalization . . . . . . . . . 77
8.5 The Curry-Howard isomorphism . . . . . . . . . . . . . . . . . . 78
8.6 Supplying the missing logical connectives . . . . . . . . . . . . . 79
8.7 Normal forms and long normal forms . . . . . . . . . . . . . . . 80
8.8 The structure of closed normal forms . . . . . . . . . . . . . . . . 82
8.9 Application: representation of arbitrary data in System F . . . . . 84
9 Type inference 86
9.1 Principal types . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3

9.2 Type templates and type substitutions . . . . . . . . . . . . . . . 87
9.3 Unifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
9.4 The unification algorithm . . . . . . . . . . . . . . . . . . . . . . 90
9.5 The type inference algorithm . . . . . . . . . . . . . . . . . . . . 92
10 Denotational semantics 93
10.1 Set-theoretic interpretation . . . . . . . . . . . . . . . . . . . . . 94
10.2 Soundness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
10.3 Completeness . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
11 The language PCF 98
11.1 Syntax and typing rules . . . . . . . . . . . . . . . . . . . . . . . 99
11.2 Axiomatic equivalence . . . . . . . . . . . . . . . . . . . . . . . 100
11.3 Operational semantics . . . . . . . . . . . . . . . . . . . . . . . . 101
11.4 Big-step semantics . . . . . . . . . . . . . . . . . . . . . . . . . 103
11.5 Operational equivalence . . . . . . . . . . . . . . . . . . . . . . . 105
11.6 Operational approximation . . . . . . . . . . . . . . . . . . . . . 106
11.7 Discussion of operational equivalence . . . . . . . . . . . . . . . 106
11.8 Operational equivalence and parallel or . . . . . . . . . . . . . . 107
12 Complete partial orders 109
12.1 Why are sets not enough, in general? . . . . . . . . . . . . . . . . 109
12.2 Complete partial orders . . . . . . . . . . . . . . . . . . . . . . . 109
12.3 Properties of limits . . . . . . . . . . . . . . . . . . . . . . . . . 111
12.4 Continuous functions . . . . . . . . . . . . . . . . . . . . . . . . 111
12.5 Pointed cpo’s and strict functions . . . . . . . . . . . . . . . . . . 112
12.6 Products and function spaces . . . . . . . . . . . . . . . . . . . . 112
12.7 The interpretation of the simply-typed lambda calculus in com-
plete partial orders . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.8 Cpo’s and fixed points . . . . . . . . . . . . . . . . . . . . . . . 114
4

12.9 Example: Streams . . . . . . . . . . . . . . . . . . . . . . . . . . 115
13 Denotational semantics of PCF 116
13.1 Soundness and adequacy . . . . . . . . . . . . . . . . . . . . . . 116
13.2 Full abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
14 Acknowledgements 119
15 Bibliography 120
5

1 Introduction
1.1 Extensional vs. intensional view of functions
What is a function? In modern mathematics, the prevalent notion is that of “func-
tions as graphs”: each function f has a fixed domain X and codomain Y , and a
function f : X → Y is a set of pairs f ⊆ X × Y such that for each x ∈ X, there
exists exactly one y ∈ Y such that (x, y) ∈ f. Two functions f, g : X → Y are
considered equal if they yield the same output on each input, i.e., f(x) = g(x) for
all x ∈ X. This is called the extensional view of functions, because it specifies
that the only thing observable about a function is how it maps inputs to outputs.
However, before the 20th century, functions were rarely looked at in this way.
An older notion of functions is that of “functions as rules”. In this view, to give
a function means to give a rule for how the function is to be calculated. Often,
such a rule can be given by a formula, for instance, the familiar f(x) = x2
or
g(x) = sin(ex
) from calculus. As before, two functions are extensionally equal if
they have the same input-output behavior; but now we can also speak of another
notion of equality: two functions are intensionally1
equal if they are given by
(essentially) the same formula.
When we think of functions as given by formulas, it is not always necessary to
know the domain and codomain of a function. Consider for instance the function
f(x) = x. This is, of course, the identity function. We may regard it as a function
f : X → X for any set X.
In most of mathematics, the “functions as graphs” paradigm is the most elegant
and appropriate way of dealing with functions. Graphs define a more general
class of functions, because it includes functions that are not necessarily given by
a rule. Thus, when we prove a mathematical statement such as “any differen-
tiable function is continuous”, we really mean this is true for all functions (in the
mathematical sense), not just those functions for which a rule can be given.
On the other hand, in computer science, the “functions as rules” paradigm is often
more appropriate. Think of a computer program as defining a function that maps
input to output. Most computer programmers (and users) do not only care about
the extensional behavior of a program (which inputs are mapped to which out-
puts), but also about how the output is calculated: How much time does it take?
How much memory and disk space is used in the process? How much communi-
cation bandwidth is used? These are intensional questions having to do with the
1Note that this word is intentionally spelled “intensionally”.
6

particular way in which a function was deﬁned.
1.2 The lambda calculus
The lambda calculus is a theory of functions as formulas. It is a system for ma-
nipulating functions as expressions.
Let us begin by looking at another well-known language of expressions, namely
arithmetic. Arithmetic expressions are made up from variables (x, y, z . . .), num-
bers (1, 2, 3, . . .), and operators (“+”, “−”, “×” etc.). An expression such as x+y
stands for the result of an addition (as opposed to an instruction to add, or the
statement that something is being added). The great advantage of this language
is that expressions can be nested without any need to mention the intermediate
results explicitly. So for instance, we write
A = (x + y) × z2
,
and not
let w = x + y, then let u = z2
, then let A = w × u.
The latter notation would be tiring and cumbersome to manipulate.
The lambda calculus extends the idea of an expression language to include func-
tions. Where we normally write
Let f be the function x → x2
. Then consider A = f(5),
in the lambda calculus we just write
A = (λx.x2
)(5).
The expression λx.x2
stands for the function that maps x to x2
(as opposed to the
statement that x is being mapped to x2
). As in arithmetic, we use parentheses to
group terms.
It is understood that the variable x is a local variable in the term λx.x2
. Thus, it
does not make any difference if we write λy.y2
instead. A local variable is also
called a bound variable.
One advantage of the lambda notation is that it allows us to easily talk about
higher-order functions, i.e., functions whose inputs and/or outputs are themselves
functions. An example is the operation f → f ◦ f in mathematics, which takes a
7

function f and maps it to f ◦ f, the composition of f with itself. In the lambda
calculus, f ◦ f is written as
λx.f(f(x)),
and the operation that maps f to f ◦ f is written as
λf.λx.f(f(x)).
The evaluation of higher-order functions can get somewhat complex; as an exam-
ple, consider the following expression:
(λf.λx.f(f(x)))(λy.y2
) (5)
Convince yourself that this evaluates to 625. Another example is given in the
following exercise:
Exercise 1. Evaluate the lambda-expression
(λf.λx.f(f(f(x)))) (λg.λy.g(g(y))) (λz.z + 1) (0).
We will soon introduce some conventions for reducing the number of parentheses
in such expressions.
1.3 Untyped vs. typed lambda-calculi
We have already mentioned that, when considering “functions as rules”, is not
always necessary to know the domain and codomain of a function ahead of time.
The simplest example is the identity function f = λx.x, which can have any set X
as its domain and codomain, as long as domain and codomain are equal. We say
that f has the type X → X. Another example is the function g = λf.λx.f(f(x))
that we encountered above. One can check that g maps any function f : X → X
to a function g(f) : X → X. In this case, we say that the type of g is
(X → X) → (X → X).
By being ﬂexible about domains and codomains, we are able to manipulate func-
tions in ways that would not be possible in ordinary mathematics. For instance, if
f = λx.x is the identity function, then we have f(x) = x for any x. In particular,
we can take x = f, and we get
f(f) = (λx.x)(f) = f.
8

Note that the equation f(f) = f never makes sense in ordinary mathematics,
since it is not possible (for set-theoretic reasons) for a function to be included in
its own domain.
As another example, let ω = λx.x(x).
Exercise 2. What is ω(ω)?
We have several options regarding types in the lambda calculus.
• Untyped lambda calculus. In the untyped lambda calculus, we never specify
the type of any expression. Thus we never specify the domain or codomain
of any function. This gives us maximal flexibility. It is also very unsafe,
because we might run into situations where we try to apply a function to an
argument that it does not understand.
• Simply-typed lambda calculus. In the simply-typed lambda calculus, we
always completely specify the type of every expression. This is very similar
to the situation in set theory. We never allow the application of a function
to an argument unless the type of the argument is the same as the domain of
the function. Thus, terms such as f(f) are ruled out, even if f is the identity
function.
• Polymorphically typed lambda calculus. This is an intermediate situation,
where we may specify, for instance, that a term has a type of the form
X → X for all X, without actually specifying X.
As we will see, each of these alternatives has dramatically different properties
from the others.
1.4 Lambda calculus and computability
In the 1930’s, several people were interested in the question: what does it mean for
a function f : N → N to be computable? An informal definition of computability
is that there should be a pencil-and-paper method allowing a trained person to
calculate f(n), for any given n. The concept of a pencil-and-paper method is not
so easy to formalize. Three different researchers attempted to do so, resulting in
the following definitions of computability:
1. Turing defined an idealized computer we now call a Turing machine, and
postulated that a function is computable (in the intuitive sense) if and only
if it can be computed by such a machine.
9

2. Gödel defined the class of general recursive functions as the smallest set of
functions containing all the constant functions, the successor function, and
closed under certain operations (such as compositions and recursion). He
postulated that a function is computable (in the intuitive sense) if and only
if it is general recursive.
3. Church defined an idealized programming language called the lambda cal-
culus, and postulated that a function is computable (in the intuitive sense) if
and only if it can be written as a lambda term.
It was proved by Church, Kleene, Rosser, and Turing that all three computational
models were equivalent to each other, i.e., each model defines the same class
of computable functions. Whether or not they are equivalent to the “intuitive”
notion of computability is a question that cannot be answered, because there is no
formal definition of “intuitive computability”. The assertion that they are in fact
equivalent to intuitive computability is known as the Church-Turing thesis.
1.5 Connections to computer science
The lambda calculus is a very idealized programming language; arguably, it is the
simplest possible programming language that is Turing complete. Because of its
simplicity, it is a useful tool for defining and proving properties of programs.
Many real-world programming languages can be regarded as extensions of the
lambda calculus. This is true for all functional programming languages, a class
that includes Lisp, Scheme, Haskell, and ML. Such languages combine the lambda
calculus with additional features, such as data types, input/output, side effects,
updatable memory, object orientated features, etc. The lambda calculus provides
a vehicle for studying such extensions, in isolation and jointly, to see how they
will affect each other, and to prove properties of programming language (such as:
a well-formed program will not crash).
The lambda calculus is also a tool used in compiler construction, see e.g. [8, 9].
1.6 Connections to logic
In the 19th and early 20th centuries, there was a philosophical dispute among
mathematicians about what a proof is. The so-called constructivists, such as
Brouwer and Heyting, believed that to prove that a mathematical object exists, one
10

must be able to construct it explicitly. Classical logicians, such as Hilbert, held
that it is sufficient to derive a contradiction from the assumption that it doesn’t
exist.
Ironically, one of the better-known examples of a proof that isn’t constructive is
Brouwer’s proof of his own fixed point theorem, which states that every continu-
ous function on the unit disk has a fixed point. The proof is by contradiction and
does not give any information on the location of the fixed point.
The connection between lambda calculus and constructive logics is via the “proofs-
as-programs” paradigm. To a constructivist, a proof (of an existence statement)
must be a “construction”, i.e., a program. The lambda calculus is a notation for
such programs, and it can also be used as a notion for (constructive) proofs.
For the most part, constructivism has not prevailed as a philosophy in mainstream
mathematics. However, there has been renewed interest in constructivism in the
second half of the 20th century. The reason is that constructive proofs give more
information than classical ones, and in particular, they allow one to compute solu-
tions to problems (as opposed to merely knowing the existence of a solution). The
resulting algorithms can be useful in computational mathematics, for instance in
computer algebra systems.
1.7 Connections to mathematics
One way to study the lambda calculus is to give mathematical models of it, i.e.,
to provide spaces in which lambda terms can be given meaning. Such models are
constructed using methods from algebra, partially ordered sets, topology, category
theory, and other areas of mathematics.
2 The untyped lambda calculus
2.1 Syntax
The lambda calculus is a formal language. The expressions of the language are
called lambda terms, and we will give rules for manipulating them.
Definition. Assume given an infinite set V of variables, denoted by x, y, z etc.
The set of lambda terms is given by the following Backus-Naur Form:
Lambda terms: M, N ::= x (MN) (λx.M)
11

The above Backus-Naur Form (BNF) is a convenient abbreviation for the follow-
ing equivalent, more traditionally mathematical definition:
Definition. Assume given an infinite set V of variables. Let A be an alphabet
consisting of the elements of V, and the special symbols “(”, “)”, “λ”, and “.”. Let
A∗
be the set of strings (finite sequences) over the alphabet A. The set of lambda
terms is the smallest subset Λ ⊆ A∗
such that:
• Whenever x ∈ V then x ∈ Λ.
• Whenever M, N ∈ Λ then (MN) ∈ Λ.
• Whenever x ∈ V and M ∈ Λ then (λx.M) ∈ Λ.
Comparing the two equivalent definitions, we see that the Backus-Naur Form is
a convenient notation because: (1) the definition of the alphabet can be left im-
plicit, (2) the use of distinct meta-symbols for different syntactic classes (x, y, z
for variables and M, N for terms) eliminates the need to explicitly quantify over
the sets V and Λ. In the future, we will always present syntactic definitions in the
BNF style.
The following are some examples of lambda terms:
(λx.x) ((λx.(xx))(λy.(yy))) (λf.(λx.(f(fx))))
Note that in the definition of lambda terms, we have built in enough mandatory
parentheses to ensure that every term M ∈ Λ can be uniquely decomposed into
subterms. This means, each term M ∈ Λ is of precisely one of the forms x,
(MN), (λx.M). Terms of these three forms are called variables, applications,
and lambda abstractions, respectively.
We use the notation (MN), rather than M(N), to denote the application of a func-
tion M to an argument N. Thus, in the lambda calculus, we write (fx) instead
of the more traditional f(x). This allows us to economize more efficiently on the
use of parentheses. To avoid having to write an excessive number of parentheses,
we establish the following conventions for writing lambda terms:
Convention. • We omit outermost parentheses. For instance, we write MN
instead of (MN).
• Applications associate to the left; thus, MNP means (MN)P. This is
convenient when applying a function to a number of arguments, as in fxyz,
which means ((fx)y)z.
12

• The body of a lambda abstraction (the part after the dot) extends as far
to the right as possible. In particular, λx.MN means λx.(MN), and not
(λx.M)N.
• Multiple lambda abstractions can be contracted; thus λxyz.M will abbre-
viate λx.λy.λz.M.
It is important to note that this convention is only for notational convenience; it
does not affect the “ofﬁcial” deﬁnition of lambda terms.
Exercise 3. (a) Write the following terms with as few parenthesis as possible,
without changing the meaning or structure of the terms:
(i) (λx.(λy.(λz.((xz)(yz))))),
(ii) (((ab)(cd))((ef)(gh))),
(iii) (λx.((λy.(yx))(λv.v)z)u)(λw.w).
(b) Restore all the dropped parentheses in the following terms, without chang-
ing the meaning or structure of the terms:
(i) xxxx,
(ii) λx.xλy.y,
(iii) λx.(xλy.yxx)x.
2.2 Free and bound variables, α-equivalence
In our informal discussion of lambda terms, we have already pointed out that the
terms λx.x and λy.y, which differ only in the name of their bound variable, are
essentially the same. We will say that such terms are α-equivalent, and we write
M =α N. In the rare event that we want to say that two terms are precisely equal,
symbol for symbol, we say that M and N are identical and we write M ≡ N. We
reserve “=” as a generic symbol used for different purposes.
An occurrence of a variable x inside a term of the form λx.N is said to be bound.
The corresponding λx is called a binder, and we say that the subterm N is the
scope of the binder. A variable occurrence that is not bound is free. Thus, for
example, in the term
M ≡ (λx.xy)(λy.yz),
x is bound, but z is free. The variable y has both a free and a bound occurrence.
The set of free variables of M is {y, z}.
13

More generally, the set of free variables of a term M is denoted FV (M), and it is
defined formally as follows:
FV (x) = {x},
FV (MN) = FV (M) ∪ FV (N),
FV (λx.M) = FV (M) {x}.
This definition is an example of a definition by recursion on terms. In other words,
in defining FV (M), we assume that we have already defined FV (N) for all
subterms of M. We will often encounter such recursive definitions, as well as
inductive proofs.
Before we can formally define α-equivalence, we need to define what it means
to rename a variable in a term. If x, y are variables, and M is a term, we write
M{y/x} for the result of renaming x as y in M. Renaming is formally defined as
follows:
x{y/x} ≡ y,
z{y/x} ≡ z, if x = z,
(MN){y/x} ≡ (M{y/x})(N{y/x}),
(λx.M){y/x} ≡ λy.(M{y/x}),
(λz.M){y/x} ≡ λz.(M{y/x}), if x = z.
Note that this kind of renaming replaces all occurrences of x by y, whether free,
bound, or binding. We will only apply it in cases where y does not already occur
in M.
Finally, we are in a position to formally define what it means for two terms to be
“the same up to renaming of bound variables”:
Definition. We define α-equivalence to be the smallest congruence relation =α
on lambda terms, such that for all terms M and all variables y that do not occur in
M,
λx.M =α λy.(M{y/x}).
Recall that a relation on lambda terms is an equivalence relation if it satisfies rules
(refl), (symm), and (trans). It is a congruence if it also satisfies rules (cong) and
(ξ). Thus, by definition, α-equivalence is the smallest relation on lambda terms
satisfying the six rules in Table 1.
It is easy to prove by induction that any lambda term is α-equivalent to another
term in which the names of all bound variables are distinct from each other and
from any free variables. Thus, when we manipulate lambda terms in theory and
14

(refl)
M = M
(symm)
M = N
N = M
(trans)
M = N N = P
M = P
(cong)
M = M′
N = N′
MN = M′
N′
(ξ)
M = M′
λx.M = λx.M′
(α)
y ∈ M
λx.M = λy.(M{y/x})
Table 1: The rules for alpha-equivalence
in practice, we can (and will) always assume without loss of generality that bound
variables have been renamed to be distinct. This convention is called Barendregt’s
variable convention.
As a remark, the notions of free and bound variables and α-equivalence are of
course not particular to the lambda calculus; they appear in many standard math-
ematical notations, as well as in computer science. Here are four examples where
the variable x is bound.
1
0
x2
dx
10
x=1
1
x
limx→∞ e−x
int succ(int x) { return x+1; }
2.3 Substitution
In the previous section, we defined a renaming operation, which allowed us to
replace a variable by another variable in a lambda term. Now we turn to a less
trivial operation, called substitution, which allows us to replace a variable by a
lambda term. We will write M[N/x] for the result of replacing x by N in M. The
definition of substitution is complicated by two circumstances:
1. We should only replace free variables. This is because the names of bound
variables are considered immaterial, and should not affect the result of a
substitution. Thus, x(λxy.x)[N/x] is N(λxy.x), and not N(λxy.N).
15

2. We need to avoid unintended “capture” of free variables. Consider for ex-
ample the term M ≡ λx.yx, and let N ≡ λz.xz. Note that x is free in N
and bound in M. What should be the result of substituting N for y in M?
If we do this naively, we get
M[N/y] = (λx.yx)[N/y] = λx.Nx = λx.(λz.xz)x.
However, this is not what we intended, since the variable x was free in N,
and during the substitution, it got bound. We need to account for the fact
that the x that was bound in M was not the “same” x as the one that was
free in N. The proper thing to do is to rename the bound variable before the
substitution:
M[N/y] = (λx′
.yx′
)[N/y] = λx′
.Nx′
= λx′
.(λz.xz)x′
.
Thus, the operation of substitution forces us to sometimes rename a bound vari-
able. In this case, it is best to pick a variable from V that has not been used yet as
the new name of the bound variable. A variable that is currently unused is called
fresh. The reason we stipulated that the set V is infinite was to make sure a fresh
variable is always available when we need one.
Definition. The (capture-avoiding) substitution of N for free occurrences of x in
M, in symbols M[N/x], is defined as follows:
x[N/x] ≡ N,
y[N/x] ≡ y, if x = y,
(MP)[N/x] ≡ (M[N/x])(P[N/x]),
(λx.M)[N/x] ≡ λx.M,
(λy.M)[N/x] ≡ λy.(M[N/x]), if x = y and y ∈ FV (N),
(λy.M)[N/x] ≡ λy′
.(M{y′
/y}[N/x]), if x = y, y ∈ FV (N), and y′
fresh.
This definition has one technical flaw: in the last clause, we did not specify which
fresh variable to pick, and thus, technically, substitution is not well-defined. One
way to solve this problem is to declare all lambda terms to be identified up to
α-equivalence, and to prove that substitution is in fact well-defined modulo α-
equivalence. Another way would be to specify which variable y′
to choose: for
instance, assume that there is a well-ordering on the set V of variables, and stipu-
late that y′
should be chosen to be the least variable that does not occur in either
M or N.
16

2.4 Introduction to β-reduction
Convention. From now on, unless stated otherwise, we identify lambda terms up
to α-equivalence. This means, when we speak of lambda terms being “equal”, we
mean that they are α-equivalent. Formally, we regard lambda terms as equivalence
classes modulo α-equivalence. We will often use the ordinary equality symbol
M = N to denote α-equivalence.
The process of evaluating lambda terms by “plugging arguments into functions”
is called β-reduction. A term of the form (λx.M)N, which consists of a lambda
abstraction applied to another term, is called a β-redex. We say that it reduces
to M[N/x], and we call the latter term the reduct. We reduce lambda terms by
ﬁnding a subterm that is a redex, and then replacing that redex by its reduct. We
repeat this as many times as we like, or until there are no more redexes left to
reduce. A lambda term without any β-redexes is said to be in β-normal form.
For example, the lambda term (λx.y)((λz.zz)(λw.w)) can be reduced as follows.
Here, we underline each redex just before reducing it:
(λx.y)((λz.zz)(λw.w)) →β (λx.y)((λw.w)(λw.w))
→β (λx.y)(λw.w)
→β y.
The last term, y, has no redexes and is thus in normal form. We could reduce the
same term differently, by choosing the redexes in a different order:
(λx.y)((λz.zz)(λw.w)) →β y.
As we can see from this example:
- reducing a redex can create new redexes,
- reducing a redex can delete some other redexes,
- the number of steps that it takes to reach a normal form can vary, depending
on the order in which the redexes are reduced.
We can also see that the ﬁnal result, y, does not seem to depend on the order in
which the redexes are reduced. In fact, this is true in general, as we will prove
later.
If M and M′
are terms such that M →→β M′
, and if M′
is in normal form, then
we say that M evaluates to M′
.
17

Not every term evaluates to something; some terms can be reduced forever without
reaching a normal form. The following is an example:
(λx.xx)(λy.yyy) →β (λy.yyy)(λy.yyy)
→β (λy.yyy)(λy.yyy)(λy.yyy)
→β . . .
This example also shows that the size of a lambda term need not decrease during
reduction; it can increase, or remain the same. The term (λx.xx)(λx.xx), which
we encountered in Section 1, is another example of a lambda term that does not
reach a normal form.
2.5 Formal definitions of β-reduction and β-equivalence
The concept of β-reduction can be defined formally as follows:
Definition. We define single-step β-reduction to be the smallest relation →β on
terms satisfying:
(β)
(λx.M)N →β M[N/x]
(cong1)
M →β M′
MN →β M′
N
(cong2)
N →β N′
MN →β MN′
(ξ)
M →β M′
λx.M →β λx.M′
Thus, M →β M′
iff M′
is obtained from M by reducing a single β-redex of M.
Definition. We write M →→β M′
if M reduces to M′
in zero or more steps.
Formally, →→β is defined to be the reflexive transitive closure of →β, i.e., the
smallest reflexive transitive relation containing →β.
Finally, β-equivalence is obtained by allowing reduction steps as well as inverse
reduction steps, i.e., by making →β symmetric:
Definition. We write M =β M′
if M can be transformed into M′
by zero or
more reduction steps and/or inverse reduction steps. Formally, =β is defined to
be the reflexive symmetric transitive closure of →β, i.e., the smallest equivalence
relation containing →β.
18

Exercise 4. This definition of β-equivalence is slightly different from the one
given in class. Prove that they are in fact the same.
3 Programming in the untyped lambda calculus
One of the amazing facts about the untyped lambda calculus is that we can use it
to encode data, such as booleans and natural numbers, as well as programs that
operate on the data. This can be done purely within the lambda calculus, without
adding any additional syntax or axioms.
We will often have occasion to give names to particular lambda terms; we will
usually use boldface letters for such names.
3.1 Booleans
We begin by defining two lambda terms to encode the truth values “true” and
“false”:
T = λxy.x
F = λxy.y
Let and be the term λab.abF. Verify the following:
and TT →→β T
and TF →→β F
and FT →→β F
and FF →→β F
Note that T and F are normal forms, so we can really say that a term such as
and TT evaluates to T. We say that and encodes the boolean function “and”. It
is understood that this coding is with respect to the particular coding of “true” and
“false”. We don’t claim that and MN evaluates to anything meaningful if M or
N are terms other than T and F.
Incidentally, there is nothing unique about the term λab.abF. It is one of many
possible ways of encoding the “and” function. Another possibility is λab.bab.
Exercise 5. Find lambda terms or and not that encode the boolean functions “or”
and “not”. Can you find more than one term?
19

Moreover, we define the term if then else = λx.x. This term behaves like an
“if-then-else” function — specifically, we have
if then else TMN →→β M
if then else FMN →→β N
for all lambda terms M, N.
3.2 Natural numbers
If f and x are lambda terms, and n 0 a natural number, write fn
x for the term
f(f(. . . (fx) . . .)), where f occurs n times. For each natural number n, we define
a lambda term n, called the nth Church numeral, as n = λfx.fn
x. Here are the
first few Church numerals:
0 = λfx.x
1 = λfx.fx
2 = λfx.f(fx)
3 = λfx.f(f(fx))
. . .
This particular way of encoding the natural numbers is due to Alonzo Church,
who was also the inventor of the lambda calculus. Note that 0 is in fact the same
term as F; thus, when interpreting a lambda term, we should know ahead of time
whether to interpret the result as a boolean or a numeral.
The successor function can be defined as follows: succ = λnfx.f(nfx). What
does this term compute when applied to a numeral?
succ n = (λnfx.f(nfx))(λfx.fn
x)
→β λfx.f((λfx.fn
x)fx)
→→β λfx.f(fn
x)
= λfx.fn+1
x
= n + 1
Thus, we have proved that the term succ does indeed encode the successor func-
tion, when applied to a numeral. Here are possible definitions of addition and
multiplication:
add = λnmfx.nf(mfx)
mult = λnmf.n(mf).
20

Exercise 6. (a) Manually evaluate the lambda terms add 2 3 and mult 2 3.
(b) Prove that add n m →→β n + m, for all natural numbers n, m.
(c) Prove that mult n m →→β n · m, for all natural numbers n, m.
Definition. Suppose f : Nk
→ N is a k-ary function on the natural numbers, and
that M is a lambda term. We say that M (numeralwise) represents f if for all
n1, . . . , nk ∈ N,
M n1 . . . nk →→β f(n1, . . . , nk) .
This definition makes explicit what it means to be an “encoding”. We can say, for
instance, that the term add = λnmfx.nf(mfx) represents the addition function.
The definition generalizes easily to boolean functions, or functions of other data
types.
Often handy is the function iszero from natural numbers to booleans, which is
defined by
iszero (0) = true
iszero (n) = false, if n = 0.
Convince yourself that the following term is a representation of this function:
iszero = λnxy.n(λz.y)x.
Exercise 7. Find lambda terms that represent each of the following functions:
(a) f(n) = (n + 3)2
,
(b) f(n) =
true if n is even,
false if n is odd,
(c) exp (n, m) = nm
,
(d) pred (n) = n − 1.
Note: part (d) is not easy. In fact, Church believed for a while that it was impos-
sible, until his student Kleene found a solution. (In fact, Kleene said he found
the solution while having his wisdom teeth pulled, so his trick for defining the
predecessor function is sometimes referred to as the “wisdom teeth trick”.)
We have seen how to encode some simple boolean and arithmetic functions. How-
ever, we do not yet have a systematic method of constructing such functions. What
21

we need is a mechanism for defining more complicated functions from simple
ones. Consider for example the factorial function, defined by:
0! = 1
n! = n · (n − 1)!, if n = 0.
The encoding of such functions in the lambda calculus is the subject of the next
section. It is related to the concept of a fixed point.
3.3 Fixed points and recursive functions
Suppose f is a function. We say that x is a fixed point of f if f(x) = x. In
arithmetic and calculus, some functions have fixed points, while others don’t. For
instance, f(x) = x2
has two fixed points 0 and 1, whereas f(x) = x + 1 has no
fixed points. Some functions have infinitely many fixed points, notably f(x) = x.
We apply the notion of fixed points to the lambda calculus. If F and N are lambda
terms, we say that N is a fixed point of F if FN =β N. The lambda calculus
contrasts with arithmetic in that every lambda term has a fixed point. This is
perhaps the first surprising fact about the lambda calculus we learn in this course.
Theorem 3.1. In the untyped lambda calculus, every term F has a fixed point.
Proof. Let A = λxy.y(xxy), and define Θ = AA. Now suppose F is any lambda
term, and let N = ΘF. We claim that N is a fixed point of F. This is shown by
the following calculation:
N = ΘF
= AAF
= (λxy.y(xxy))AF
→→β F(AAF)
= F(ΘF)
= FN.
The term Θ used in the proof is called Turing’s fixed point combinator.
The importance of fixed points lies in the fact that they allow us to solve equations.
After all, finding a fixed point for f is the same thing as solving the equation
x = f(x). This covers equations with an arbitrary right-hand side, whose left-
hand side is x. From the above theorem, we know that we can always solve such
equations in the lambda calculus.
22

To see how to apply this idea, consider the question from the last section, namely,
how to define the factorial function. The most natural definition of the factorial
function is recursive, and we can write it in the lambda calculus as follows:
fact n = if then else (iszero n)(1)(mult n(fact(pred n)))
Here we have used various abbreviations for lambda terms that were introduced in
the previous section. The evident problem with a recursive definition such as this
one is that the term to be defined, fact , appears both on the left- and the right-hand
side. In other words, to find fact requires solving an equation!
We now apply our newfound knowledge of how to solve fixed point equations in
the lambda calculus. We start by rewriting the problem slightly:
fact = λn. if then else (iszero n)(1)(mult n(fact (pred n)))
fact = (λf.λn. if then else (iszero n)(1)(mult n(f(pred n)))) fact
Let us temporarily write F for the term
λf.λn. if then else (iszero n)(1)(mult n(f(pred n))).
Then the last equation becomes fact = F fact, which is a fixed point equation.
We can solve it up to β-equivalence, by letting
fact = ΘF
= Θ(λf.λn. if then else (iszero n)(1)(mult n(f(pred n))))
Note that fact has disappeared from the right-hand side. The right-hand side is a
closed lambda term that represents the factorial function. (A lambda term is called
closed if it contains no free variables).
To see how this definition works in practice, let us evaluate fact 2. Recall from
the proof of Theorem 3.1 that ΘF →→β F(ΘF), therefore fact →→β F fact.
fact 2 →→β F fact 2
→→β if then else (iszero 2)(1)(mult 2(fact(pred 2)))
→→β if then else (F)(1)(mult 2(fact(pred 2)))
→→β mult 2(fact (pred 2))
→→β mult 2(fact 1)
→→β mult 2(F fact 1)
→→β . . .
→→β mult 2(mult 1(fact 0))
→→β mult 2(mult 1(F fact 0))
→→β mult 2(mult 1(if then else (iszero 0)(1)(mult 0(fact(pred 0)))))
→→β mult 2(mult 1(if then else (T)(1)(mult 0(fact (pred 0)))))
23

→→β mult 2(mult 1 1)
→→β 2
Note that this calculation, while messy, is completely mechanical. You can easily
convince yourself that fact 3 reduces to mult 3(fact 2), and therefore, by the
above calculation, to mult 3 2, and finally to 6. It is now a matter of a simple
induction to prove that fact n →→β n!, for any n.
Exercise 8. Write a lambda term that represents the Fibonacci function, defined
by
f(0) = 1, f(1) = 1, f(n + 2) = f(n + 1) + f(n), for n 2
Exercise 9. Write a lambda term that represents the characteristic function of the
prime numbers, i.e., f(n) = true if n is prime, and false otherwise.
Exercise 10. We have remarked at the beginning of this section that the number-
theoretic function f(x) = x + 1 does not have a fixed point. On the other hand,
the lambda term F = λx. succ x, which represents the same function, does have
a fixed point by Theorem 3.1. How can you reconcile the two statements?
Exercise 11. The first fixed point combinator for the lambda calculus was discov-
ered by Curry. Curry’s fixed point combinator, which is also called the paradoxi-
cal fixed point combinator, is the term Y = λf.(λx.f(xx))(λx.f(xx)).
(a) Prove that this is indeed a fixed point combinator, i.e., that YF is a fixed
point of F, for any term F.
(b) Turing’s fixed point combinator not only satisfies ΘF =β F(ΘF), but also
ΘF →→β F(ΘF). We used this fact in evaluating fact 2. Does an analo-
gous property hold for Y? Does this affect the outcome of the evaluation of
fact 2?
(c) Can you find another fixed point combinator, besides Curry’s and Turing’s?
3.4 Other data types: pairs, tuples, lists, trees, etc.
So far, we have discussed lambda terms that represented functions on booleans
and natural numbers. However, it is easily possible to encode more general data
structures in the untyped lambda calculus. Pairs and tuples are of interest to ev-
erybody. The examples of lists and trees are primarily interesting to people with
24

experience in a list-processing language such as LISP or PROLOG; you can safely
ignore these examples if you want to.
Pairs. If M and N are lambda terms, we define the pair M, N to be the
lambda term λz.zMN. We also define two terms π1 = λp.p(λxy.x) and π2 =
λp.p(λxy.y). We observe the following:
π1 M, N →→β M
π2 M, N →→β N
The terms π1 and π2 are called the left and right projections.
Tuples. The encoding of pairs easily extends to arbitrary n-tuples. If M1, . . . , Mn
are terms, we define the n-tuple M1, . . . , Mn as the lambda term λz.zM1 . . . Mn,
and we define the ith projection πn
i = λp.p(λx1 . . . xn.xi). Then
πn
i M1, . . . , Mn →→β Mi, for all 1 i n.
Lists. A list is different from a tuple, because its length is not necessarily fixed.
A list is either empty (“nil”), or else it consists of a first element (the “head”)
followed by another list (the “tail”). We write nil for the empty list, and H :: T
for the list whose head is H and whose tail is T . So, for instance, the list of the
first three numbers can be written as 1 :: (2 :: (3 :: nil )). We usually omit the
parentheses, where it is understood that ”::” associates to the right. Note that every
list ends in nil .
In the lambda calculus, we can define nil = λxy.y and H :: T = λxy.xHT .
Here is a lambda term that adds a list of numbers:
addlist l = l(λh t. add h(addlist t))(0).
Of course, this is a recursive definition, and must be translated into an actual
lambda term by the method of Section 3.3. In the definition of addlist , l and t are
lists of numbers, and h is a number. If you are very diligent, you can calculate the
sum of last weekend’s Canadian lottery results by evaluating the term
addlist (4 :: 22 :: 24 :: 32 :: 42 :: 43 :: nil ).
Note that lists enable us to give an alternative encoding of the natural numbers: We
can encode a natural number as a list of booleans, which we interpret as the binary
digits 0 and 1. Of course, with this encoding, we would have to carefully redesign
our basic functions, such as successor, addition, and multiplication. However, if
25

done properly, such an encoding would be a lot more efficient (in terms of number
of β-reductions to be performed) than the encoding by Church numerals.
Trees. A binary tree is a data structure that can be one of two things: either a leaf,
labeled by a natural number, or a node, which has a left and a right subtree. We
write leaf (N) for a leaf labeled N, and node (L, R) for a node with left subtree L
and right subtree R. We can encode trees as lambda terms, for instance as follows:
leaf (n) = λxy.xn, node (L, R) = λxy.yLR
As an illustration, here is a program (i.e., a lambda term) that adds all the numbers
at the leafs of a given tree.
addtree t = t(λn.n)(λl r. add (addtree l)(addtree r)).
Exercise 12. This is a voluntary programming exercise.
(a) Write a lambda term that calculates the length of a list.
(b) Write a lambda term that calculates the depth (i.e., the nesting level) of a
tree. You may need to define a function max that calculates the maximum
of two numbers.
(c) Write a lambda term that sorts a list of numbers. You may assume given a
term less that compares two numbers.
4 The Church-Rosser Theorem
4.1 Extensionality, η-equivalence, and η-reduction
In the untyped lambda calculus, any term can be applied to another term. There-
fore, any term can be regarded as a function. Consider a term M, not containing
the variable x, and consider the term M′
= λx.Mx. Then for any argument A,
we have MA =β M′
A. So in this sense, M and M′
define “the same function”.
Should M and M′
be considered equivalent as terms?
The answer depends on whether we want to accept the principle that “if M and M′
define the same function, then M and M′
are equal”. This is called the principle
of extensionality, and we have already encountered it in Section 1.1. Formally, the
extensionality rule is the following:
(ext∀)
∀A.MA = M′
A
M = M′ .
26

In the presence of the axioms (ξ), (cong), and (β), it can be easily seen that MA =
M′
A is true for all terms A if and only if Mx = M′
x, where x is a fresh variable.
Therefore, we can replace the extensionality rule by the following equivalent, but
simpler rule:
(ext)
Mx = M′
x, where x ∈ FV (M, M′
)
M = M′ .
Note that we can apply the extensionality rule in particular to the case where M′
=
λx.Mx, where x is not free in M. As we have remarked above, Mx =β M′
x,
and thus extensionality implies that M = λx.Mx. This last equation is called the
η-law (eta-law):
(η) M = λx.Mx, where x ∈ FV (M).
In fact, (η) and (ext) are equivalent in the presence of the other axioms of the
lambda calculus. We have already seen that (ext) and (β) imply (η). Conversely,
assume (η), and assume that Mx = M′
x, for some terms M and M′
not con-
taining x freely. Then by (ξ), we have λx.Mx = λx.M′
x, hence by (η) and
transitivity, M = M′
. Thus (ext) holds.
We note that the η-law does not follow from the axioms and rules of the lambda
calculus that we have considered so far. In particular, the terms x and λy.xy
are not β-equivalent, although they are clearly η-equivalent. We will prove that
x =β λy.xy in Corollary 4.5 below.
Single-step η-reduction is the smallest relation →η satisfying (cong1), (cong2),
(ξ), and the following axiom (which is the same as the η-law, directed right to
left):
(η) λx.Mx →η M, where x ∈ FV (M).
Single-step βη-reduction →βη is deﬁned as the union of the single-step β- and
η-reductions, i.e., M →βη M′
iff M →β M′
or M →η M′
. Multi-step η-
reduction →→η, multi-step βη-reduction →→βη, as well as η-equivalence =η and
βη-equivalence =βη are deﬁned in the obvious way as we did for β-reduction and
equivalence. We also get the evident notions of η-normal form, βη-normal form,
etc.
27

4.2 Statement of the Church-Rosser Theorem, and some con-
sequences
Theorem (Church and Rosser, 1936). Let →→ denote either →→β or →→βη. Suppose
M, N, and P are lambda terms such that M →→ N and M →→ P. Then there
exists a lambda term Z such that N →→ Z and P →→ Z.
In pictures, the theorem states that the following diagram can always be com-
pleted:
M
1111❄❄❄❄❄
⑧⑧⑧⑧⑧
P

N
1111
Z
This property is called the Church-Rosser property, or conﬂuence. Before we
prove the Church-Rosser Theorem, let us highlight some of its consequences.
Corollary 4.1. If M =β N then there exists some Z with M, N →→β Z. Similarly
for βη.
Proof. Please refer to Figure 1 for an illustration of this proof. Recall that =β is
the reﬂexive symmetric transitive closure of →β. Suppose that M =β N. Then
there exist n 0 and terms M0, . . . , Mn such that M = M0, N = Mn, and
for all i = 1 . . . n, either Mi−1 →β Mi or Mi →β Mi−1. We prove the claim
by induction on n. For n = 0, we have M = N and there is nothing to show.
Suppose the claim has been proven for n−1. Then by induction hypothesis, there
exists a term Z′
such that M →→β Z′
and Mn−1 →→β Z′
. Further, we know that
either N →β Mn−1 or Mn−1 →β N. In case N →β Mn−1, then N →→β Z′
,
and we are done. In case Mn−1 →β N, we apply the Church-Rosser Theorem
to Mn−1, Z′
, and N to obtain a term Z such that Z′
→→β Z and N →→β Z.
Since M →→β Z′
→→β Z, we are done. The proof in the case of βη-reduction is
identical.
Corollary 4.2. If N is a β-normal form and N =β M, then M →→β N, and
similarly for βη.
Proof. By Corollary 4.1, there exists some Z with M, N →→β Z. But N is a
normal form, thus N =α Z.
28

M5
11❄❄❄❄❄
⑧⑧⑧⑧⑧
M6
11❄❄❄❄❄

M7

M3
11❄❄❄❄❄
⑧⑧⑧⑧⑧
M4

M2
⑧⑧⑧⑧⑧
M0
11❄❄❄❄❄
M1
1111
Z′′
1111
Z′
1111
Z
Figure 1: The proof of Corollary 4.1
Corollary 4.3. If M and N are β-normal forms such that M =β N, then M =α
N, and similarly for βη.
Proof. By Corollary 4.2, we have M →→β N, but since M is a normal form, we
have M =α N.
Corollary 4.4. If M =β N, then neither or both have a β-normal form. Similarly
for βη.
Proof. Suppose that M =β N, and that one of them has a β-normal form. Say,
for instance, that M has a normal form Z. Then N =β Z, hence N →→β Z by
Corollary 4.2.
Corollary 4.5. The terms x and λy.xy are not β-equivalent. In particular, the
η-rule does not follow from the β-rule.
Proof. The terms x and λy.xy are both β-normal forms, and they are not α-
equivalent. It follows by Corollary 4.3 that x =β λy.xy.
29

4.3 Preliminary remarks on the proof of the Church-Rosser
Theorem
Consider any binary relation → on a set, and let →→ be its reflexive transitive
closure. Consider the following three properties of such relations:
(a) M
1111❄❄❄❄❄
⑧⑧⑧⑧⑧
P

N
1111
Z
(b) M
11❄❄❄❄❄
⑧⑧⑧⑧⑧
P

N
1111
Z
(c) M
11❄❄❄❄❄
⑧⑧⑧⑧⑧
P

N
11
Z
Each of these properties states that for all M, N, P, if the solid arrows exist, then
there exists Z such that the dotted arrows exist. The only difference between (a),
(b), and (c) is the difference between where → and →→ are used.
Property (a) is the Church-Rosser property. Property (c) is called the diamond
property (because the diagram is shaped like a diamond).
A naive attempt to prove the Church-Rosser Theorem might proceed as follows:
First, prove that the relation →β satisfies property (b) (this is relatively easy to
prove); then use an inductive argument to conclude that it also satisfies property
(a).
Unfortunately, this does not work: the reason is that in general, property (b) does
not imply property (a)! An example of a relation that satisfies property (b) but not
property (a) is shown in Figure 2. In other words, a proof of property (b) is not
sufficient in order to prove property (a).
On the other hand, property (c), the diamond property, does imply property (a).
This is very easy to prove by induction, and the proof is illustrated in Figure 3. But
unfortunately, β-reduction does not satisfy property (c), so again we are stuck.
To summarize, we are faced with the following dilemma:
• β-reduction satisfies property (b), but property (b) does not imply property
(a).
• Property (c) implies property (a), but β-reduction does not satisfy property
(c).
On the other hand, it seems hopeless to prove property (a) directly. In the next
30

•
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
11❅❅❅❅❅
•
⑦⑦⑦⑦⑦
•
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
•
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
11❅❅❅❅❅
•
⑦⑦⑦⑦⑦
•
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
•
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
11❅❅❅❅❅
•
⑦⑦⑦⑦⑦
•
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
•
11❅❅❅❅❅ •
⑦⑦⑦⑦⑦
11❅❅❅❅❅ •
11❅❅❅❅❅
•
ÒÒ☎☎☎☎☎☎
•
ÒÒ☎☎☎☎☎☎
((✿✿✿✿✿✿ •
ÒÒ☎☎☎☎☎☎
...
...
...
Figure 2: An example of a relation that satisﬁes property (b), but not property (a)
•
11❄❄❄
⑧⑧⑧
•
11❄❄❄

•
11❄❄❄

•

•
11⑧⑧⑧
•
11
•
11
•

•
11⑧⑧⑧
•
11
•
11
•

•
11⑧⑧⑧
•
11
•
11
•

•
11
•
11
•
11
•
Figure 3: Proof that property (c) implies property (a)
31

section, we will solve this dilemma by defining yet another reduction relation ⊲,
with the following properties:
• ⊲ satisfies property (c), and
• the transitive closure of ⊲ is the same as that of →β (or →βη).
4.4 Proof of the Church-Rosser Theorem
In this section, we will prove the Church-Rosser Theorem for βη-reduction. The
proof for β-reduction (without η) is very similar, and in fact slightly simpler, so
we omit it here. The proof presented here is due to Tait and Martin-Löf. We begin
by defining a new relation M ⊲ M′
on terms, called parallel one-step reduction.
We define ⊲ to be the smallest relation satisfying
(1)
x ⊲ x
(2)
P ⊲ P′
N ⊲ N′
PN ⊲ P′
N′
(3)
N ⊲ N′
λx.N ⊲ λx.N′
(4)
Q ⊲ Q′
N ⊲ N′
(λx.Q)N ⊲ Q′
[N′
/x]
(5)
P ⊲ P′
, where x ∈ FV (P)
λx.Px ⊲ P′ .
Lemma 4.6. (a) For all M, M′
, if M →βη M′
then M ⊲ M′
.
(b) For all M, M′
, if M ⊲ M′
then M →→βη M′
.
(c) →→βη is the reflexive, transitive closure of ⊲.
Proof. (a) First note that we have P ⊲ P, for any term P. This is easily shown by
induction on P. We now prove the claim by induction on a derivation of M →βη
M′
. Please refer to pages 18 and 27 for the rules that define →βη. We make a
case distinction based on the last rule used in the derivation of M →βη M′
.
• If the last rule was (β), then M = (λx.Q)N and M′
= Q[N/x], for some
Q and N. But then M ⊲ M′
by (4), using the facts Q ⊲ Q and N ⊲ N.
32

• If the last rule was (η), then M = λx.Px and M′
= P, for some P such
that x ∈ FV (P). Then M ⊲ M′
follows from (5), using P ⊲ P.
• If the last rule was (cong1), then M = PN and M′
= P′
N, for some P,
P′
, and N where P →βη P′
. By induction hypothesis, P ⊲ P′
. From this
and N ⊲ N, it follows immediately that M ⊲ M′
by (2).
• If the last rule was (cong2), we proceed similarly to the last case.
• If the last rule was (ξ), then M = λx.N and M′
= λx.N′
for some N and
N′
such that N →βη N′
. By induction hypothesis, N ⊲ N′
, which implies
M ⊲ M′
by (3).
(b) We prove this by induction on a derivation of M ⊲ M′
. We distinguish several
cases, depending on the last rule used in the derivation.
• If the last rule was (1), then M = M′
= x, and we are done because
x →→βη x.
• If the last rule was (2), then M = PN and M′
= P′
N′
, for some P, P′
,
N, N′
with P ⊲ P′
and N ⊲ N′
. By induction hypothesis, P →→βη P′
and
N →→βη N′
. Since →→βη satisﬁes (cong), it follows that PN →→βη P′
N′
,
hence M →→βη M′
as desired.
• If the last rule was (3), then M = λx.N and M′
= λx.N′
, for some
N, N′
with N ⊲ N′
. By induction hypothesis, N →→βη N′
, hence M =
λx.N →→βη λx.N′
= M′
by (ξ).
• If the last rule was (4), then M = (λx.Q)N and M′
= Q′
[N′
/x], for some
Q, Q′
, N, N′
with Q ⊲ Q′
and N ⊲ N′
. By induction hypothesis, Q →→βη
Q′
and N →→βη N′
. Therefore M = (λx.Q)N →→βη (λx.Q′
)N′
→βη
Q′
[N′
/x] = M′
, as desired.
• If the last rule was (5), then M = λx.Px and M′
= P′
, for some P, P′
with P ⊲ P′
, and x ∈ FV (P). By induction hypothesis, P →→βη P′
, hence
M = λx.Px →βη P →→βη P′
= M′
, as desired.
(c) This follows directly from (a) and (b). Let us write R∗
for the reﬂexive transi-
tive closure of a relation R. By (a), we have →βη ⊆ ⊲, hence →→βη = →βη
∗
⊆
⊲∗
. By (b), we have ⊲ ⊆ →→βη, hence ⊲∗
⊆ →→βη
∗
= →→βη. It follows that
⊲∗
= →→βη.
33

We will soon prove that ⊲ satisﬁes the diamond property. Note that together with
Lemma 4.6(c), this will immediately imply that →→βη satisﬁes the Church-Rosser
property.
Lemma 4.7 (Substitution). If M ⊲ M′
and U ⊲ U′
, then M[U/y] ⊲ M′
[U′
/y].
Proof. We assume without loss of generality that any bound variables of M are
different from y and from the free variables of U. The claim is now proved by
induction on derivations of M ⊲ M′
. We distinguish several cases, depending on
the last rule used in the derivation:
= x, for some variable x. If x = y,
then M[U/y] = U ⊲ U′
= M′
[U′
/y]. If x = y, then by (1), M[U/y] =
x ⊲ x = M′
[U′
/y].
= P′
N′
, for some P, P′
, N,
N′
with P ⊲ P′
and N ⊲ N′
. By induction hypothesis, P[U/y] ⊲ P′
[U′
/y]
and N[U/y] ⊲ N′
[U′
/y], hence by (2), M[U/y] = P[U/y]N[U/y] ⊲
P′
[U′
/y]N′
[U′
/y] = M′
[U′
/y].
= λx.N′
, for some N, N′
with N ⊲ N′
. By induction hypothesis, N[U/y] ⊲ N′
[U′
/y], hence by (3)
M[U/y] = λx.N[U/y] ⊲ λx.N′
[U′
/y] = M′
[U′
/y].
= Q′
[N′
/x], for some
Q, Q′
, N, N′
with Q ⊲ Q′
and N ⊲ N′
. By induction hypothesis, Q[U/y] ⊲
Q′
[U′
/y] and N[U/y] ⊲ N′
[U′
/y], hence by (4), (λx.Q[U/y])N[U/y] ⊲
Q′
[U′
/y][N′
[U′
/y]/x] = Q′
[N′
/x][U′
/y]. Thus M[U/y] ⊲ M′
[U′
/y].
= P′
, for some P, P′
with
P ⊲ P′
, and x ∈ FV (P). By induction hypothesis, P[U/y] ⊲ P′
[U′
/y],
hence by (5), M[U/y] = λx.P[U/y]x ⊲ P′
[U′
/y] = M′
[U′
/y].
A more conceptual way of looking at this proof is the following: consider any
derivation of M ⊲ M′
from axioms (1)–(5). In this derivation, replace any axiom
y ⊲ y by U ⊲ U′
, and propagate the changes (i.e., replace y by U on the left-
hand-side, and by U′
on the right-hand-side of any ⊲). The result is a derivation
of M[U/y] ⊲ M′
[U′
/y]. (The formal proof that the result of this replacement
is indeed a valid derivation requires an induction, and this is the reason why the
proof of the substitution lemma is so long).
34

Our next goal is to prove that ⊲ satisfies the diamond property. Before proving this,
we first define the maximal parallel one-step reduct M∗
of a term M as follows:
1. x∗
= x, for a variable.
2. (PN)∗
= P∗
N∗
, if PN is not a β-redex.
3. ((λx.Q)N)∗
= Q∗
[N∗
/x].
4. (λx.N)∗
= λx.N∗
, if λx.N is not an η-redex.
5. (λx.Px)∗
= P∗
, if x ∈ FV (P).
Note that M∗
depends only on M. The following lemma implies the diamond
property for ⊲.
Lemma 4.8 (Maximal parallel one-step reductions). Whenever M ⊲ M′
, then
M′
⊲ M∗
.
Proof. By induction on the size of M. We distinguish five cases, depending on
the last rule used in the derivation of M ⊲ M′
. As usual, we assume that all bound
variables have been renamed to avoid clashes.
= x, also M∗
= x, and we are done.
= P′
N′
, where P ⊲ P′
and
N ⊲ N′
. By induction hypothesis P′
⊲ P∗
and N′
⊲ N∗
. Two cases:
– If PN is not a β-redex, then M∗
= P∗
N∗
. Thus M′
= P′
N′
⊲
P∗
N∗
= M∗
by (2), and we are done.
– If PN is a β-redex, say P = λx.Q, then M∗
= Q∗
[N∗
/x]. We dis-
tinguish two subcases, depending on the last rule used in the derivation
of P ⊲ P′
:
∗ If the last rule was (3), then P′
= λx.Q′
, where Q ⊲ Q′
. By
induction hypothesis Q′
⊲ Q∗
, and with N′
⊲ N∗
, it follows that
M′
= (λx.Q′
)N′
⊲ Q∗
[N∗
/x] = M∗
by (4).
∗ If the last rule was (5), then P = λx.Rx and P′
= R′
, where
x ∈ FV (R) and R ⊲ R′
. Consider the term Q = Rx. Since
Rx ⊲ R′
x, and Rx is a subterm of M, by induction hypothe-
sis R′
x ⊲ (Rx)∗
. By the substitution lemma, M′
= R′
N′
=
(R′
x)[N′
/x] ⊲ (Rx)∗
[N∗
/x] = M∗
.
35

= λx.N′
, where N ⊲ N′
.
Two cases:
– If M is not an η-redex, then M∗
= λx.N∗
. By induction hypothesis,
N′
⊲ N∗
, hence M′
⊲ M∗
by (3).
– If M is an η-redex, then N = Px, where x ∈ FV (P). In this case,
M∗
= P∗
. We distinguish two subcases, depending on the last rule
used in the derivation of N ⊲ N′
:
∗ If the last rule was (2), then N′
= P′
x, where P ⊲ P′
. By
induction hypothesis P′
⊲ P∗
. Hence M′
= λx.P′
x ⊲ P∗
=
M∗
by (5).
∗ If the last rule was (4), then P = λy.Q and N′
= Q′
[x/y], where
Q ⊲ Q′
. Then M′
= λx.Q′
[x/y] = λy.Q′
(note x ∈ FV (Q′
)).
But P ⊲ λy.Q′
, hence by induction hypothesis, λy.Q′
⊲ P∗
=
M∗
.
= Q′
[N′
/x], where
Q ⊲ Q′
and N ⊲ N′
. Then M∗
= Q∗
[N∗
/x], and M′
⊲ M∗
by the
substitution lemma.
= P′
, where P ⊲ P′
and
x ∈ FV (P). Then M∗
= P∗
. By induction hypothesis, P′
⊲ P∗
, hence
M′
⊲ M∗
.
The previous lemma immediately implies the diamond property for ⊲:
Lemma 4.9 (Diamond property for ⊲). If M ⊲ N and M ⊲ P, then there exists Z
such that N ⊲ Z and P ⊲ Z.
Proof. Take Z = M∗
.
Finally, we have a proof of the Church-Rosser Theorem:
Proof of Theorem 4.2: Since ⊲ satisfies the diamond property, it follows that
its reflexive transitive closure ⊲∗
also satisfies the diamond property, as shown in
Figure 3. But ⊲∗
is the same as →→βη by Lemma 4.6(c), and the diamond property
for →→βη is just the Church-Rosser property for →βη.
36

4.5 Exercises
Exercise 13. Give a detailed proof that property (c) from Section 4.3 implies
property (a).
Exercise 14. Prove that M ⊲ M, for all terms M.
Exercise 15. Without using Lemma 4.8, prove that M ⊲ M∗
for all terms M.
Exercise 16. Let Ω = (λx.xx)(λx.xx). Prove that Ω =βη ΩΩ.
Exercise 17. What changes have to be made to Section 4.4 to get a proof of the
Church-Rosser Theorem for →β, instead of →βη?
Exercise 18. Recall the properties (a)–(c) of binary relations → that were dis-
cussed in Section 4.3. Consider the following similar property, which is some-
times called the “strip property”:
(d) M
11❄❄❄❄❄
⑧⑧⑧⑧⑧
P

N
1111
Z.
Does (d) imply (a)? Does (b) imply (d)? In each case, give either a proof or a
counterexample.
Exercise 19. To every lambda term M, we may associate a directed graph (with
possibly multiple edges and loops) G(M) as follows: (i) the vertices are terms
N such that M →→β N, i.e., all the terms that M can β-reduce to; (ii) the edges
are given by a single-step β-reduction. Note that the same term may have two (or
more) reductions coming from different redexes; each such reduction is a separate
edge. For example, let I = λx.x. Let M = I(Ix). Then
G(M) = I(Ix)
BB
RR Ix GG x .
Note that there are two separate edges from I(Ix) to Ix. We also sometimes
write bullets instead of terms, to get •
@@
TT • GG • . As another example, let
Ω = (λx.xx)(λx.xx). Then
G(Ω) = • dd .
37

(a) Let M = (λx.I(xx))(λx.xx). Find G(M).
(b) For each of the following graphs, find a term M such that G(M) is the given
graph, or explain why no such term exists. (Note: the “starting” vertex need
not always be the leftmost vertex in the picture). Warning: some of these
terms are tricky to find!
(i)
• GG • dd
(ii)
• • ddoo
(iii)
• • GGoo •
(iv)
• •oo @@
•hh
(v)
•XX •
@@oo • GGhh • dd
(vi)
• GG •
ÓÓ✟✟✟✟✟✟
•
‘‘✻✻✻✻✻✻
(vii)
•XX GG • dd
ÓÓ✟✟✟✟✟✟
•
‘‘✻✻✻✻✻✻
5 Combinatory algebras
To give a model of the lambda calculus means to provide a mathematical space
in which the axioms of lambda calculus are satisfied. This usually means that the
elements of the space can be understood as functions, and that certain functions
can be understood as elements.
38

Na¨ıvely, one might try to construct a model of lambda calculus by finding a set
X such that X is in bijective correspondence with the set XX
of all functions
from X to X. This, however, is impossible: for cardinality reason, the equation
X ∼= XX
has no solutions except for a one-element set X = 1. To see this, first
note that the empty set ∅ is not a solution. Also, suppose X is a solution with
|X| 2. Then |XX
| |2X
|, but by Cantor’s argument, |2X
| > |X|, hence XX
is of greater cardinality than X, contradicting X ∼= XX
.
There are two main strategies for constructing models of the lambda calculus, and
both involve a restriction on the class of functions to make it smaller. The first
approach, which will be discussed in this section, uses algebra, and the essential
idea is to replace the set XX
of all function by a smaller, and suitably defined
set of polynomials. The second approach is to equip the set X with additional
structure (such as topology, ordered structure, etc), and to replace XX
by a set
of structure-preserving functions (for example, continuous functions, monotone
functions, etc).
5.1 Applicative structures
Definition. An applicative structure (A, ·) is a set A together with a binary op-
eration “·”.
Note that there are no further assumptions; in particular, we do not assume that
application is an associative operation. We write ab for a · b, and as in the lambda
calculus, we follow the convention of left associativity, i.e., we write abc for (ab)c.
Definition. Let (A, ·) be an applicative structure. A polynomial in a set of vari-
ables x1, . . . , xn and with coefficients in A is a formal expression built from vari-
ables and elements of A by means of the application operation. In other words,
the set of polynomials is given by the following grammar:
t, s ::= x a ts,
where x ranges over variables and a ranges over the elements of A. We write
A{x1, . . . , xn} for the set of polynomials in variables x1, . . . , xn with coefficients
in A.
Here are some examples of polynomials in the variables x, y, z, where a, b ∈ A:
x, xy, axx, (x(y(zb)))(ax).
39

If t(x1, . . . , xn) is a polynomial in the indicated variables, and b1, . . . , bn are el-
ements of A, then we can evaluate the polynomial at the given elements: the
evaluation t(b1, . . . , bn) the element of A obtained by “plugging” xi = bi into the
polynomial, for i = 1, . . . , n, and evaluating the resulting expression in A. Note
that in this way, every polynomial t in n variables can be understood as a function
from An
→ A. This is very similar to the usual polynomials in algebra, which
can also either be understood as formal expressions or as functions.
If t(x1, . . . , xn) and s(x1, . . . , xn) are two polynomials with coefficients in A,
we say that the equation t(x1, . . . , xn) = s(x1, . . . , xn) holds in A if for all
b1, . . . , bn ∈ A, t(b1, . . . , bn) = s(b1, . . . , bn).
5.2 Combinatory completeness
Definition (Combinatory completeness). An applicative structure (A, ·) is com-
binatorially complete if for every polynomial t(x1, . . . , xn) of n 0 variables,
there exists some element a ∈ A such that
ax1 . . . xn = t(x1, . . . , xn)
holds in A.
In other words, combinatory completeness means that every polynomial function
t(x1, . . . , xn) can be represented (in curried form) by some element of A. We
are therefore setting up a correspondence between functions and elements as dis-
cussed in the introduction of this section.
Note that we do not require the element a to be unique in the definition of combi-
natory completeness. This means that we are dealing with an intensional view of
functions, where a given function might in general have several different names
(but see the discussion of extensionality in Section 5.6).
The following theorem characterizes combinatory completeness in terms of a
much simpler algebraic condition.
Theorem 5.1. An applicative structure (A, ·) is combinatorially complete if and
only if there exist two elements s, k ∈ A, such that the following equations are
satisfied for all x, y, z ∈ A:
(1) sxyz = (xz)(yz)
(2) kxy = x
40

Example 5.2. Before we prove this theorem, let us look at a few examples.
(a) The identity function. Can we find an element i ∈ A such that ix = x for
all x? Yes, indeed, we can let i = skk. We check that for all x, skkx =
(kx)(kx) = x.
(b) The boolean “true”. Can we find an element T such that for all x, y, Txy =
x? Yes, this is easy: T = k.
(c) The boolean “false”. Can we find F such that Fxy = y? Yes, what we need
is Fx = i. Therefore a solution is F = ki. And indeed, for all y, we have
kixy = iy = y.
(d) Find a function f such that fx = xx for all x. Solution: let f = sii. Then
siix = (ix)(ix) = xx.
Proof of Theorem 5.1: The “only if” direction is trivial. If A is combinatorially
complete, then consider the polynomial t(x, y, z) = (xz)(yz). By combinatory
completeness, there exists some s ∈ A with sxyz = t(x, y, z), and similarly for
k.
We thus have to prove the “if” direction. Recall that A{x1, . . . , xn} is the set of
polynomials with variables x1, . . . , xn. For each polynomial t ∈ A{x, y1, . . . , yn}
in n + 1 variables, we will define a new polynomial λ∗
x.t ∈ A{y1, . . . , yn} in n
variables, as follows by recursion on t:
λ∗
x.x := i,
λ∗
x.yi := kyi where yi = x is a variable,
λ∗
x.a := ka where a ∈ A,
λ∗
x.pq := s(λ∗
x.p)(λ∗
x.q).
We claim that for all t, the equation (λ∗
x.t)x = t holds in A. Indeed, this is easily
proved by induction on t, using the definition of λ∗
:
(λ∗
x.x)x = ix = x,
(λ∗
x.yi)x = kyix = yi,
(λ∗
x.a)x = kax = a,
(λ∗
x.pq)x = s(λ∗
x.p)(λ∗
x.q)x = ((λ∗
x.p)x)((λ∗
x.q)x) = pq.
Note that the last case uses the induction hypothesis for p and q.
41

Finally, to prove the theorem, assume that A has elements s, k satisfying equations
(1) and (2), and consider a polynomial t ∈ A{x1, . . . , xn}. We must show that
there exists a ∈ A such that ax1 . . . xn = t holds in A. We let
a = λ∗
x1. . . . .λ∗
xn.t.
Note that a is a polynomial in 0 variables, which we may consider as an element
of A. Then from the previous claim, it follows that
ax1 . . . xn = (λ∗
x1.λ∗
x2. . . . .λ∗
xn.t)x1x2 . . . xn
= (λ∗
x2. . . . .λ∗
xn.t)x2 . . . xn
= . . .
= (λ∗
xn.t)xn
= t
holds in A.
5.3 Combinatory algebras
By Theorem 5.1, combinatory completeness is equivalent to the existence of the s
and k operators. We enshrine this in the following definition:
Definition (Combinatory algebra). A combinatory algebra (A, ·, s, k) is an ap-
plicative structure (A, ·) together with elements s, k ∈ A, satisfying the following
two axioms:
(1) sxyz = (xz)(yz)
(2) kxy = x
Remark 5.3. The operation λ∗
, defined in the proof of Theorem 5.1, is defined
on the polynomials of any combinatory algebra. It is called the derived lambda
abstractor, and it satisfies the law of β-equivalence, i.e., (λ∗
x.t)b = t[b/x], for
all b ∈ A.
Finding actual examples of combinatory algebras is not so easy. Here are some
examples:
Example 5.4. The one-element set A = {∗}, with ∗ · ∗ = ∗, s = ∗, and k = ∗, is
a combinatory algebra. It is called the trivial combinatory algebra.
Example 5.5. Recall that Λ is the set of lambda terms. Let A = Λ/=β, the set of
lambda terms modulo β-equivalence. Define M ·N = MN, S = λxyz.(xz)(yz),
and K = λxy.x. Then (Λ, ·, S, K) is a combinatory algebra. Also note that, by
Corollary 4.5, this algebra is non-trivial, i.e., it has more than one element.
42

Similar examples are obtained by replacing =β by =βη, and/or replacing Λ by the
set Λ0 of closed terms.
Example 5.6. We construct a combinatory algebra of SK-terms as follows. Let
V be a given set of variables. The set C of terms of combinatory logic is given by
the grammar:
A, B ::= x S K AB,
where x ranges over the elements of V .
On C, we define combinatory equivalence =c as the smallest equivalence rela-
tion satisfying SABC =c (AC)(BC), KAB =c A, and the rules (cong1) and
(cong2) (see page 18). Then the set C/=c is a combinatory algebra (called the
free combinatory algebra generated by V , or the term algebra). You will prove in
Exercise 20 that it is non-trivial.
Exercise 20. On the set C of combinatory terms, define a notion of single-step
reduction by the following laws:
SABC →c (AC)(BC),
KAB →c A,
together with the usual rules (cong1) and (cong2) (see page 18). As in lambda
calculus, we call a term a normal form if it cannot be reduced. Prove that the
reduction →c satisfies the Church-Rosser property. (Hint: similarly to the lambda
calculus, first define a suitable parallel one-step reduction ⊲ whose reflexive tran-
sitive closure is that of →c. Then show that it satisfies the diamond property.)
Corollary 5.7. It immediately follows from the Church-Rosser Theorem for com-
binatory logic (Exercise 20) that two normal forms are =c-equivalent if and only
if they are equal.
5.4 The failure of soundness for combinatory algebras
A combinatory algebra is almost a model of the lambda calculus. Indeed, given
a combinatory algebra A, we can interpret any lambda term as follows. To each
term M with free variables among x1, . . . , xn, we recursively associate a polyno-
mial [[M]] ∈ A{x1, . . . , xn}:
[[x]] := x,
[[NP]] := [[N]][[P]],
[[λx.M]] := λ∗
x.[[M]].
43

(refl)
M = M
(symm)
M = N
N = M
(trans)
M = N N = P
M = P
(cong)
M = M′
N = N′
MN = M′
N′
(ξ)
M = M′
λx.M = λx.M′
(β)
(λx.M)N = M[N/x]
Table 2: The rules for β-equivalence
Notice that this definition is almost the identity function, except that we have
replaced the ordinary lambda abstractor of lambda calculus by the derived lambda
abstractor of combinatory logic. The result is a polynomial in A{x1, . . . , xn}. In
the particular case where M is a closed term, we can regard [[M]] as an element of
A.
To be able to say that A is a “model” of the lambda calculus, we would like the
following property to be true:
M =β N ⇒ [[M]] = [[N]] holds in A.
This property is called soundness of the interpretation. Unfortunately, it is in
general false for combinatory algebras, as the following example shows.
Example 5.8. Let M = λx.x and N = λx.(λy.y)x. Then clearly M =β N. On
the other hand,
[[M]] = λ∗
x.x = i,
[[N]] = λ∗
x.(λ∗
y.y)x = λ∗
x.ix = s(ki)i.
It follows from Exercise 20 and Corollary 5.7 that the equation i = s(ki)i does
not hold in the combinatory algebra C/=c. In other words, the interpretation is
not sound.
Let us analyze the failure of the soundness property further. Recall that β-equiva-
lence is the smallest equivalence relation on lambda terms satisfying the six rules
in Table 2.
If we define a relation ∼ on lambda terms by
M ∼ N ⇐⇒ [[M]] = [[N]] holds in A,
44

then we may ask which of the six rules of Table 2 the relation ∼ satisfies. Clearly,
not all six rules can be satisfied, or else we would have M =β N ⇒ M ∼ N ⇒
[[M]] = [[N]], i.e., the model would be sound.
Clearly, ∼ is an equivalence relation, and therefore satisfies (refl), (symm), and
(trans). Also, (cong) is satisfied, because whenever p, q, p′
, q′
are polynomials
such that p = p′
and q = q′
holds in A, then clearly pq = p′
q′
holds in A as well.
Finally, we know from Remark 5.3 that the rule (β) is satisfied.
So the rule that fails is the (ξ) rule. Indeed, Example 5.8 illustrates this. Note
that x ∼ (λy.y)x (from the proof of Theorem 5.1), but λx.x ∼ λx.(λy.y)x, and
therefore the (ξ) rule is violated.
5.5 Lambda algebras
A lambda algebra is, by definition, a combinatory algebra that is a sound model
of lambda calculus, and in which s and k have their expected meanings.
Definition (Lambda algebra). A lambda algebra is a combinatory algebra A sat-
isfying the following properties:
(∀M, N ∈ Λ) M =β N ⇒ [[M]] = [[N]] (soundness),
s = λ∗
x.λ∗
y.λ∗
z.(xz)(yz) (s-derived),
k = λ∗
x.λ∗
y.x (k-derived).
The purpose of the remainder of this section is to give an axiomatic description of
lambda algebras.
Lemma 5.9. Recall that Λ0 is the set of closed lambda terms, i.e., lambda terms
without free variables. Soundness is equivalent to the following:
(∀M, N ∈ Λ0) M =β N ⇒ [[M]] = [[N]] (closed soundness)
Proof. Clearly soundness implies closed soundness. For the converse, assume
closed soundness and let M, N ∈ Λ with M =β N. Let FV (M) ∪ FV (N) =
45

{x1, . . . , xn}. Then
M =β N
⇒ λx1 . . . xn.M =β λx1 . . . xn.N by (ξ)
⇒ [[λx1 . . . xn.M]] = [[λx1 . . . xn.N]] by closed soundness
⇒ λ∗
x1 . . . xn.[[M]] = λ∗
x1 . . . xn.[[N]] by def. of [[−]]
⇒ (λ∗
x1 . . . xn.[[M]])x1 . . . xn
= (λ∗
x1 . . . xn.[[N]])x1 . . . xn
⇒ [[M]] = [[N]] by proof of Thm 5.1
This proves soundness.
Definition (Translations between combinatory logic and lambda calculus). Let
A ∈ C be a combinatory term (see Example 5.6). We define its translation to
lambda calculus in the obvious way: the translation Aλ is given recursively by:
Sλ = λxyz.(xz)(yz),
Kλ = λxy.x,
xλ = x,
(AB)λ = AλBλ.
Conversely, given a lambda term M ∈ Λ, we recursively define its translation Mc
to combinatory logic like this:
xc = x,
(MN)c = McNc,
(λx.M)c = λ∗
x.(Mc).
Lemma 5.10. For all lambda terms M, (Mc)λ =β M.
Lemma 5.11. Let A be a combinatory algebra satisfying k = λ∗
x.λ∗
y.x and
s = λ∗
x.λ∗
y.λ∗
z.(xz)(yz). Then for all combinatory terms A, (Aλ)c = A holds
in A.
Exercise 21. Prove Lemmas 5.10 and 5.11.
Let C0 be the set of closed combinatory terms. The following is our first useful
characterization of lambda calculus.
Lemma 5.12. Let A be a combinatory algebra. Then A is a lambda algebra if
and only if it satisfies the following property:
(∀A, B ∈ C0) Aλ =β Bλ ⇒ A = B holds in A. (alt-soundness)
46

Proof. First, assume that A satisfies (alt-soundness). To prove (closed soundness),
let M, N be lambda terms with M =β N. Then (Mc)λ =β M =β N =β (Nc)λ,
hence by (alt-soundness), Mc = Nc holds in A. But this is the definition of
[[M]] = [[N]].
To prove (k-derived), note that
kλ = (λx.λy.x) by definition of (−)λ
= ((λx.λy.x)c)λ by Lemma 5.10
= (λ∗
x.λ∗
y.x)λ by definition of (−)c.
Hence, by (alt-soundness), it follows that k = (λ∗
x.λ∗
y.x) holds in A. Similarly
for (s-derived).
Conversely, assume that A is a lambda algebra. Let A, B ∈ C0 and assume
Aλ =β Bλ. By soundness, [[Aλ]] = [[Bλ]]. By definition of the interpretation,
(Aλ)c = (Bλ)c holds in A. But by (s-derived), (k-derived), and Lemma 5.11,
A = (Aλ)c = (Bλ)c = B holds in A, proving (alt-soundness).
Definition (Homomorphism). Let (A, ·A, sA, kA), (B, ·B, sB, kB) be combina-
tory algebras. A homomorphism of combinatory algebras is a function ϕ : A →
B such that ϕ(sA) = sB, ϕ(kA) = kB, and for all a, b ∈ A, ϕ(a ·A b) =
ϕ(a) ·B ϕ(b).
Any given homomorphism ϕ : A → B can be extended to polynomials in the
obvious way: we define ˆϕ : A{x1, . . . , xn} → B{x1, . . . , xn} by
ˆϕ(a) = ϕ(a) for a ∈ A,
ˆϕ(x) = x if x ∈ {x1, . . . , xn},
ˆϕ(pq) = ˆϕ(p) ˆϕ(q).
Example 5.13. If ϕ(a) = a′
and ϕ(b) = b′
, then ˆϕ((ax)(by)) = (a′
x)(b′
y).
The following is the main technical concept needed in the characterization of
lambda algebras. We say that an equation holds absolutely if it holds in A and in
any homomorphic image of A. If an equation holds only in the previous sense,
then we sometimes say it holds locally.
Definition (Absolute equation). Let p, q ∈ A{x1, . . . , xn} be two polynomials
with coefficients in A. We say that the equation p = q holds absolutely in A if for
all combinatory algebras B and all homomorphisms ϕ : A → B, ˆϕ(p) = ˆϕ(q)
holds in B. If an equation holds absolutely, we write p =abs q.
47

(a) 1k =abs k,
(b) 1s =abs s,
(c) 1(kx) =abs kx,
(d) 1(sx) =abs sx,
(e) 1(sxy) =abs sxy,
(f ) s(s(kk)x)y =abs 1x,
(g) s(s(s(ks)x)y)z =abs s(sxz)(syz),
(h) k(xy) =abs s(kx)(ky),
(i) s(kx)i =abs 1x.
Table 3: An axiomatization of lambda algebras. Here 1 = s(ki).
We can now state the main theorem characterizing lambda algebras. Let 1 =
s(ki).
Theorem 5.14. Let A be a combinatory algebra. Then the following are equiva-
lent:
1. A is a lambda algebra,
2. A satisfies (alt-soundness),
3. for all A, B ∈ C such that Aλ =β Bλ, the equation A = B holds absolutely
in A,
4. A absolutely satisfies the nine axioms in Table 3,
5. A satisfies (s-derived) and (k-derived), and for all p, q ∈ A{y1, . . . , yn}, if
px =abs qx then 1p =abs 1q,
6. A satisfies (s-derived) and (k-derived), and for all p, q ∈ A{x, y1, . . . , yn},
if p =abs q then λ∗
x.p =abs λ∗
y.q.
The proof proceeds via 1 ⇒ 2 ⇒ 3 ⇒ 4 ⇒ 5 ⇒ 6 ⇒ 1.
We have already proven 1 ⇒ 2 in Lemma 5.12.
To prove 2 ⇒ 3, let FV (A) ∪ FV (B) ⊆ {x1, . . . , xn}, and assume Aλ =β
Bλ. Then λx1 . . . xn.(Aλ) =β λx1 . . . xn.(Bλ), hence (λ∗
x1 . . . xn.A)λ =β
(λ∗
x1 . . . xn.B)λ (why?). Since the latter terms are closed, it follows by the rule
(alt-soundness) that λ∗
x1 . . . xn.A = λ∗
x1 . . . xn.B holds in A. Since closed
equations are preserved by homomorphisms, the latter also holds in B for any
48

homomorphism ϕ : A → B. Finally, this implies that A = B holds for any such
B, proving that A = B holds absolutely in A.
Exercise 22. Prove the implication 3 ⇒ 4.
The implication 4 ⇒ 5 is the most difficult part of the theorem. We first dispense
with the easier part:
Exercise 23. Prove that the axioms from Table 3 imply (s-derived) and (k-derived).
The last part of 4 ⇒ 5 needs the following lemma:
Lemma 5.15. Suppose A satisfies the nine axioms from Table 3. Define a struc-
ture (B, •, S, K) by:
B = {a ∈ A | a = 1a},
a • b = sab,
S = ks,
K = kk.
Then B is a well-defined combinatory algebra. Moreover, the function ϕ : A →
B defined by ϕ(a) = ka defines a homomorphism.
Exercise 24. Prove Lemma 5.15.
To prove the implication 4 ⇒ 5, assume ax = bx holds absolutely in A. Then
ˆϕ(ax) = ˆϕ(bx) holds in B by definition of “absolute”. But ˆϕ(ax) = (ϕa)x =
s(ka)x and ˆϕ(bx) = (ϕb)x = s(kb)x. Therefore s(ka)x = s(kb)x holds in A.
We plug in x = i to get s(ka)i = s(kb)i. By axiom (i), 1a = 1b.
To prove 5 ⇒ 6, assume p =abs q. Then (λ∗
x.p)x =abs p =abs q =abs (λ∗
x.q)x
by the proof of Theorem 5.1. Then by 5., (λ∗
x.p) =abs (λ∗
x.q).
Finally, to prove 6 ⇒ 1, note that if 6 holds, then the absolute interpretation
satisfies the ξ-rule, and therefore satisfies all the axioms of lambda calculus.
Exercise 25. Prove 6 ⇒ 1.
Remark 5.16. The axioms in Table 3 are required to hold absolutely. They can
be replaced by local axioms by prefacing each axiom with λ∗
xyz. Note that this
makes the axioms much longer.
5.6 Extensional combinatory algebras
Definition. An applicative structure (A, ·) is extensional if for all a, b ∈ A, if
ac = bc holds for all c ∈ A, then a = b.
49

Proposition 5.17. In an extensional combinatory algebra, the (η) axioms is valid.
Proof. By (β), (λ∗
x.Mx)c = Mc for all c ∈ A. Therefore, by extensionality,
(λ∗
x.Mx) = M.
Proposition 5.18. In an extensional combinatory algebra, an equation holds lo-
cally if and only if it holds absolutely.
Proof. Clearly, if an equation holds absolutely, then it holds locally. Conversely,
assume the equation p = q holds locally in A. Let x1, . . . , xn be the variables
occurring in the equation. By (β),
(λ∗
x1 . . . xn.p)x1 . . . xn = (λ∗
x1 . . . xn.q)x1 . . . xn
holds locally. By extensionality,
λ∗
x1 . . . xn.p = λ∗
x1 . . . xn.q
holds. Since this is a closed equation (no free variables), it automatically holds
absolutely. This implies that (λ∗
x1 . . . xn.p)x1 . . . xn = (λ∗
x1 . . . xn.q)x1 . . . xn
holds absolutely, and finally, by (β) again, that p = q holds absolutely.
Proposition 5.19. Every extensional combinatory algebra is a lambda algebra.
Proof. By Theorem 5.14(6), it suffices to prove (s-derived), (k-derived) and the
(ξ)-rule. Let a, b, c ∈ A be arbitrary. Then
(λ∗
x.λ∗
y.λ∗
z.(xz)(yz))abc = (ac)(bc) = sabc
by (β) and definition of s. Applying extensionality three times (with respect to c,
b, and a), we get
λ∗
x.λ∗
y.λ∗
z.(xz)(yz) = s.
This proves (s-derived). The proof of (k-derived) is similar. Finally, to prove (ξ),
assume that p =abs q. Then by (β), (λ∗
x.p)c = (λ∗
x.q)c for all c ∈ A. By
extensionality, λ∗
x.p = λ∗
x.q holds.
50

6 Simply-typed lambda calculus, propositional logic,
and the Curry-Howard isomorphism
In the untyped lambda calculus, we spoke about functions without speaking about
their domains and codomains. The domain and codomain of any function was the
set of all lambda terms. We now introduce types into the lambda calculus, and thus
a notion of domain and codomain for functions. The difference between types and
sets is that types are syntactic objects, i.e., we can speak of types without having
to speak of their elements. We can think of types as names for sets.
6.1 Simple types and simply-typed terms
We assume a set of basic types. We usually use the Greek letter ι (“iota”) to denote
a basic type. The set of simple types is given by the following BNF:
Simple types: A, B ::= ι A → B A × B 1
The intended meaning of these types is as follows: base types are things like the
type of integers or the type of booleans. The type A → B is the type of functions
from A to B. The type A × B is the type of pairs x, y , where x has type A and
y has type B. The type 1 is a one-element type. You can think of 1 as an abridged
version of the booleans, in which there is only one boolean instead of two. Or you
can think of 1 as the “void” or “unit” type in many programming languages: the
result type of a function that has no real result.
When we write types, we adopt the convention that × binds stronger than →, and
→ associates to the right. Thus, A × B → C is (A × B) → C, and A → B → C
is A → (B → C).
The set of raw typed lambda terms is given by the following BNF:
Raw terms: M, N ::= x MN λxA
.M M, N π1M π2M ∗
Unlike what we did in the untyped lambda calculus, we have added special syntax
here for pairs. Speciﬁcally, M, N is a pair of terms, πiM is a projection, with
the intention that πi M1, M2 = Mi. Also, we have added a term ∗, which is the
unique element of the type 1. One other change from the untyped lambda calculus
is that we now write λxA
.M for a lambda abstraction to indicate that x has type
A. However, we will sometimes omit the superscripts and write λx.M as before.
The notions of free and bound variables and α-conversion are deﬁned as for the
untyped lambda calculus; again we identify α-equivalent terms.
51

(var)
Γ, x:A ⊢ x : A
(app)
Γ ⊢ M : A → B Γ ⊢ N : A
Γ ⊢ MN : B
(abs)
Γ, x:A ⊢ M : B
Γ ⊢ λxA
.M : A → B
(pair)
Γ ⊢ M : A Γ ⊢ N : B
Γ ⊢ M, N : A × B
(π1)
Γ ⊢ M : A × B
Γ ⊢ π1M : A
(π2)
Γ ⊢ M : A × B
Γ ⊢ π2M : B
(∗)
Γ ⊢ ∗ : 1
Table 4: Typing rules for the simply-typed lambda calculus
We call the above terms the raw terms, because we have not yet imposed any
typing discipline on these terms. To avoid meaningless terms such as M, N (P)
or π1(λx.M), we introduce typing rules.
We use the colon notation M : A to mean “M is of type A”. (Similar to the
element notation in set theory). The typing rules are expressed in terms of typing
judgments. A typing judgment is an expression of the form
x1:A1, x2:A2, . . . , xn:An ⊢ M : A.
Its meaning is: “under the assumption that xi is of type Ai, for i = 1 . . . n,
the term M is a well-typed term of type A.” The free variables of M must be
contained in x1, . . . , xn. The idea is that in order to determine the type of M, we
must make some assumptions about the type of its free variables. For instance, the
term xy will have type B if x:A → B and y:A. Clearly, the type of xy depends
on the type of its free variables.
A sequence of assumptions of the form x1:A1, . . . , xn:An, as in the left-hand-side
of a typing judgment, is called a typing context. We always assume that no variable
appears more than once in a typing context, and we allow typing contexts to be re-
ordered implicitly. We often use the Greek letter Γ to stand for an arbitrary typing
context, and we use the notations Γ, Γ′
and Γ, x:A to denote the concatenation of
typing contexts, where it is always assumed that the sets of variables are disjoint.
The symbol ⊢, which appears in a typing judgment, is called the turnstile symbol.
Its purpose is to separate the left-hand side from the right-hand side.
The typing rules for the simply-typed lambda calculus are shown in Table 4. The
rule (var) is a tautology: under the assumption that x has type A, x has type A.
The rule (app) states that a function of type A → B can be applied to an argument
52

of type A to produce a result of type B. The rule (abs) states that if M is a term of
type B with a free variable x of type A, then λxA
.M is a function of type A → B.
The other rules have similar interpretations.
Here is an example of a valid typing derivation:
x:A → A, y:A ⊢ x : A → A
x:A → A, y:A ⊢ x : A → A x:A → A, y:A ⊢ y : A
x:A → A, y:A ⊢ xy : A
x:A → A, y:A ⊢ x(xy) : A
x:A → A ⊢ λyA.x(xy) : A → A
⊢ λxA→A.λyA.x(xy) : (A → A) → A → A
One important property of these typing rules is that there is precisely one rule
for each kind of lambda term. Thus, when we construct typing derivations in a
bottom-up fashion, there is always a unique choice of which rule to apply next.
The only real choice we have is about which types to assign to variables.
Exercise 26. Give a typing derivation of each of the following typing judgments:
(a) ⊢ λx(A→A)→B
.x(λyA
.y) : ((A → A) → B) → B
(b) ⊢ λxA×B
. π2x, π1x : (A × B) → (B × A)
Not all terms are typable. For instance, the terms π1(λx.M) and M, N (P)
cannot be assigned a type, and neither can the term λx.xx. Here, by “assigning
a type” we mean, assigning types to the free and bound variables such that the
corresponding typing judgment is derivable. We say that a term is typable if it can
be assigned a type.
Exercise 27. Show that neither of the three terms mentioned in the previous para-
graph is typable.
Exercise 28. We said that we will identify α-equivalent terms. Show that this
is actually necessary. In particular, show that if we didn’t identify α-equivalent
terms, there would be no valid derivation of the typing judgment
⊢ λxA
.λxB
.x : A → B → B.
Give a derivation of this typing judgment using the bound variable convention.
53

6.2 Connections to propositional logic
Consider the following types:
(1) (A × B) → A
(2) A → B → (A × B)
(3) (A → B) → (B → C) → (A → C)
(4) A → A → A
(5) ((A → A) → B) → B
(6) A → (A × B)
(7) (A → C) → C
Let us ask, in each case, whether it is possible to find a closed term of the given
type. We find the following terms:
(1) λxA×B
.π1x
(2) λxA
.λyB
. x, y
(3) λxA→B
.λyB→C
.λzA
.y(xz)
(4) λxA
.λyA
.x and λxA
.λyA
.y
(5) λx(A→A)→B
.x(λyA
.y)
(6) can’t find a closed term
(7) can’t find a closed term
Can we answer the general question, given a type, whether there exists a closed
term for it?
For a new way to look at the problem, take the types (1)–(7) and make the follow-
ing replacement of symbols: replace “→” by “⇒” and replace “×” by “∧”. We
obtain the following formulas:
(1) (A ∧ B) ⇒ A
(2) A ⇒ B ⇒ (A ∧ B)
(3) (A ⇒ B) ⇒ (B ⇒ C) ⇒ (A ⇒ C)
(4) A ⇒ A ⇒ A
(5) ((A ⇒ A) ⇒ B) ⇒ B
(6) A ⇒ (A ∧ B)
(7) (A ⇒ C) ⇒ C
Note that these are formulas of propositional logic, where “⇒” is implication, and
“∧” is conjunction (“and”). What can we say about the validity of these formulas?
It turns out that (1)–(5) are tautologies, whereas (6)–(7) are not. Thus, the types
54

for which we could find a lambda term turn out to be the ones that are valid when
considered as formulas in propositional logic! This is not entirely coincidental.
Let us consider, for example, how to prove (A∧B) ⇒ A. The proof is very short.
It goes as follows: “Assume A ∧ B. Then, by the first part of that assumption,
A holds. Thus (A ∧ B) ⇒ A.” On the other hand, the lambda term of the
corresponding type is λxA×B
.π1x. You can see that there is a close connection
between the proof and the lambda term. Namely, if one reads λxA×B
as “assume
A ∧ B (call the assumption ‘x’)”, and if one reads π1x as “by the first part of
assumption x”, then this lambda term can be read as a proof of the proposition
(A ∧ B) ⇒ A.
This connection between simply-typed lambda calculus and propositional logic is
known as the “Curry-Howard isomorphism”. Since types of the lambda calculus
correspond to formulas in propositional logic, and terms correspond to proofs, the
concept is also known as the “proofs-as-programs” paradigm, or the “formulas-
as-types” correspondence. We will make the actual correspondence more precise
in the next two sections.
Before we go any further, we must make one important point. When we are
going to make precise the connection between simply-typed lambda calculus and
propositional logic, we will see that the appropriate logic is intuitionistic logic, and
not the ordinary classical logic that we are used to from mathematical practice.
The main difference between intuitionistic and classical logic is that the former
misses the principles of “proof by contradiction” and “excluded middle”. The
principle of proof by contradiction states that if the assumption “not A” leads to
a contradiction then we have proved A. The principle of excluded middle states
that either “A” or “not A” must be true.
Intuitionistic logic is also known as constructive logic, because all proofs in it
are by construction. Thus, in intuitionistic logic, the only way to prove the ex-
istence of some object is by actually constructing the object. This is in contrast
with classical logic, where we may prove the existence of an object simply by
deriving a contradiction from the assumption that the object doesn’t exist. The
disadvantage of constructive logic is that it is generally more difficult to prove
things. The advantage is that once one has a proof, the proof can be transformed
into an algorithm.
55

6.3 Propositional intuitionistic logic
We start by introducing a system for intuitionistic logic that uses only three con-
nectives: “∧”, “→”, and “⊤”. Formulas A, B . . . are built from atomic formulas
α, β, . . . via the BNF
Formulas: A, B ::= α A → B A ∧ B ⊤.
We now need to formalize proofs. The formalized proofs will be called “deriva-
tions”. The system we introduce here is known as natural deduction, and is due
to Gentzen (1935).
In natural deduction, derivations are certain kinds of trees. In general, we will deal
with derivations of a formula A from a set of assumptions Γ = {A1, . . . , An}.
Such a derivation will be written schematically as
x1:A1, . . . , xn:An
...
A .
We simplify the bookkeeping by giving a name to each assumption, and we will
use lower-case letters such as x, y, z for such names. In using the above notation
for schematically writing a derivation of A from assumptions Γ, it is understood
that the derivation may in fact use a given assumption more than once, or zero
times. The rules for constructing derivations are as follows:
1. (Axiom)
(ax)
x:A
A
x
is a derivation of A from assumption A (and possibly other assumptions
that were used zero times). We have written the letter “x” next to the rule,
to indicate precisely which assumption we have used here.
2. (∧-introduction) If
Γ
...
A and
Γ
...
B
56

are derivations of A and B, respectively, then
(∧-I)
Γ
...
A
Γ
...
B
A ∧ B
is a derivation of A ∧ B. In other words, a proof of A ∧ B is a proof of A
and a proof of B.
3. (∧-elimination) If
Γ
...
A ∧ B
is a derivation of A ∧ B, then
(∧-E1)
Γ
...
A ∧ B
A
and (∧-E2)
Γ
...
A ∧ B
B
are derivations of A and B, respectively. In other words, from A ∧ B, we
are allowed to conclude both A and B.
4. (⊤-introduction)
(⊤-I)
⊤
is a derivation of ⊤ (possibly from some assumptions, which were not
used). In other words, ⊤ is always true.
5. (→-introduction) If
Γ, x:A
...
B
is a derivation of B from assumptions Γ and A, then
(→-I)
Γ, [x:A]
...
B
A → B
x
57

is a derivation of A → B from Γ alone. Here, the assumption x:A is no
longer an assumption of the new derivation — we say that it has been “can-
celed”. We indicate canceled assumptions by enclosing them in brackets [ ],
and we indicate the place where the assumption was canceled by writing
the letter x next to the rule where it was canceled.
6. (→-elimination) If
Γ
...
A → B and
Γ
...
A
are derivations of A → B and A, respectively, then
(→-E)
Γ
...
A → B
Γ
...
A
B
is a derivation of B. In other words, from A → B and A, we are allowed
to conclude B. This rule is sometimes called by its Latin name, “modus
ponens”.
This finishes the definition of derivations in natural deduction. Note that, with the
exception of the axiom, each rule belongs to some specific logical connective, and
there are introduction and elimination rules. “∧” and “→” have both introduction
and elimination rules, whereas “⊤” only has an introduction rule.
In natural deduction, like in real mathematical life, assumptions can be made at
any time. The challenge is to get rid of assumptions once they are made. In the
end, we would like to have a derivation of a given formula that depends on as
few assumptions as possible — in fact, we don’t regard the formula as proven
unless we can derive it from no assumptions. The rule (→-I) allows us to discard
temporary assumptions that we might have made during the proof.
Exercise 29. Give a derivation, in natural deduction, for each of the formulas
(1)–(5) from Section 6.2.
6.4 An alternative presentation of natural deduction
The above notation for natural deduction derivations suffers from a problem of
presentation: since assumptions are first written down, later canceled dynamically,
58

it is not easy to see when each assumption in a ﬁnished derivation was canceled.
The following alternate presentation of natural deduction works by deriving entire
judgments, rather than formulas. Rather than keeping track of assumptions as the
leaves of a proof tree, we annotate each formula in a derivation with the entire set
of assumptions that were used in deriving it. In practice, this makes derivations
more verbose, by repeating most assumptions on each line. In theory, however,
such derivations are easier to reason about.
A judgment is a statement of the form x1:A1, . . . , xn:An ⊢ B. It states that the
formula B is a consequence of the (labeled) assumptions A1, . . . , An. The rules
of natural deduction can now be reformulated as rules for deriving judgments:
1. (Axiom)
(axx)
Γ, x:A ⊢ A
2. (∧-introduction)
(∧-I)
Γ ⊢ A Γ ⊢ B
Γ ⊢ A ∧ B
3. (∧-elimination)
(∧-E1)
Γ ⊢ A ∧ B
Γ ⊢ A
(∧-E2)
Γ ⊢ A ∧ B
Γ ⊢ B
4. (⊤-introduction)
(⊤-I)
Γ ⊢ ⊤
5. (→-introduction)
(→-Ix)
Γ, x:A ⊢ B
Γ ⊢ A → B
6. (→-elimination)
(→-E)
Γ ⊢ A → B Γ ⊢ A
Γ ⊢ B
59

6.5 The Curry-Howard Isomorphism
There is an obvious one-to-one correspondencebetween types of the simply-typed
lambda calculus and the formulas of propositional intuitionistic logic introduced
in Section 6.3 (provided that the set of basic types can be identified with the set of
atomic formulas). We will identify formulas and types from now on, where it is
convenient to do so.
Perhaps less obvious is the fact that derivations are in one-to-one correspondence
with simply-typed lambda terms. To be precise, we will give a translation from
derivations to lambda terms, and a translation from lambda terms to derivations,
which are mutually inverse up to α-equivalence.
To any derivation of x1:A1, . . . , xn:An ⊢ B, we will associate a lambda term M
such that x1:A1, . . . , xn:An ⊢ M : B is a valid typing judgment. We define M by
recursion on the definition of derivations. We prove simultaneously, by induction,
that x1:A1, . . . , xn:An ⊢ M : B is indeed a valid typing judgment.
1. (Axiom) If the derivation is
(axx)
Γ, x:A ⊢ A
,
then the lambda term is M = x. Clearly, Γ, x:A ⊢ x : A is a valid typing
judgment by (var).
2. (∧-introduction) If the derivation is
(∧-I)
...
Γ ⊢ A
...
Γ ⊢ B
Γ ⊢ A ∧ B
,
then the lambda term is M = P, Q , where P and Q are the terms as-
sociated to the two respective subderivations. By induction hypothesis,
Γ ⊢ P : A and Γ ⊢ Q : B, thus Γ ⊢ P, Q : A × B by (pair).
3. (∧-elimination) If the derivation is
(∧-E1)
...
Γ ⊢ A ∧ B
Γ ⊢ A
,
60

then we let M = π1P, where P is the term associated to the subderivation.
By induction hypothesis, Γ ⊢ P : A × B, thus Γ ⊢ π1P : A by (π1). The
case of (∧-E2) is entirely symmetric.
4. (⊤-introduction) If the derivation is
(⊤-I)
Γ ⊢ ⊤
,
then let M = ∗. We have ⊢ ∗ : 1 by (∗).
5. (→-introduction) If the derivation is
(→-Ix)
...
Γ, x:A ⊢ B
Γ ⊢ A → B
,
then we let M = λxA
.P, where P is the term associated to the subderiva-
tion. By induction hypothesis, Γ, x:A ⊢ P : B, hence Γ ⊢ λxA
.P : A → B
by (abs).
6. (→-elimination) Finally, if the derivation is
(→-E)
...
Γ ⊢ A → B
...
Γ ⊢ A
Γ ⊢ B
,
then we let M = PQ, where P and Q are the terms associated to the two
respective subderivations. By induction hypothesis, Γ ⊢ P : A → B and
Γ ⊢ Q : A, thus Γ ⊢ PQ : B by (app).
Conversely, given a well-typed lambda term M, with associated typing judgment
Γ ⊢ M : A, then we can construct a derivation of A from assumptions Γ. We
deﬁne this derivation by recursion on the type derivation of Γ ⊢ M : A. The
details are too tedious to spell them out here; we simply go through each of the
rules (var), (abs), (app), (pair), (π1), (π2), (∗) and apply the corresponding rule
(ax), (→-I), (→-E), (∧-I), (∧-E1), (∧-E2), (⊤-I), respectively.
61

6.6 Reductions in the simply-typed lambda calculus
β- and η-reductions in the simply-typed lambda calculus are defined much in the
same way as for the untyped lambda calculus, except that we have introduced
some additional terms (such as pairs and projections), which calls for some addi-
tional reduction rules. We define the following reductions:
(β→) (λxA
.M)N → M[N/x],
(η→) λxA
.Mx → M, where x ∈ FV (M),
(β×,1) π1 M, N → M,
(β×,2) π2 M, N → N,
(η×) π1M, π2M → M,
(η1) M → ∗, if M : 1.
Then single- and multi-step β- and η-reduction are defined as the usual contextual
closure of the above rules, and the definitions of β- and η-equivalence also follow
the usual pattern. In addition to the usual (cong) and (ξ) rules, we now also have
congruence rules that apply to pairs and projections.
We remark that, to be perfectly precise, we should have defined reductions be-
tween typing judgments, and not between terms. This is necessary because some
of the reduction rules, notably (η1), depend on the type of the terms involved.
However, this would be notationally very cumbersome, and we will blur the dis-
tinction, pretending at times that terms appear in some implicit typing context that
we do not write.
An important property of the reduction is the “subject reduction” property, which
states that well-typed terms reduce only to well-typed terms of the same type.
This has an immediate application to programming: subject reduction guarantees
that if we write a program of type “integer”, then the final result of evaluating the
program, if any, will indeed be an integer, and not, say, a boolean.
Theorem 6.1 (Subject Reduction). If Γ ⊢ M : A and M →βη M′
, then Γ ⊢
M′
: A.
Proof. By induction on the derivation of M →βη M′
, and by case distinction on
the last rule used in the derivation of Γ ⊢ M : A. For instance, if M →βη M′
by
(β→), then M = (λxB
.P)Q and M′
= P[Q/x]. If Γ ⊢ M : A, then we must
have Γ, x:B ⊢ P : A and Γ ⊢ Q : B. It follows that Γ ⊢ P[Q/x] : A; the latter
statement can be proved separately (as a “substitution lemma”) by induction on P
and makes crucial use of the fact that x and Q have the same type.
62

The other cases are similar, and we leave them as an exercise. Note that, in par-
ticular, one needs to consider the (cong), (ξ), and other congruence rules as well.
6.7 A word on Church-Rosser
One important theorem that does not hold for βη-reduction in the simply-typed
λ→,×,1
-calculus is the Church-Rosser theorem. The culprit is the rule (η1). For
instance, if x is a variable of type A × 1, then the term M = π1x, π2x reduces
to x by (η×), but also to π1x, ∗ by (η1). Both these terms are normal forms.
Thus, the Church-Rosser property fails.
π1x, π2x
η×
{{✈✈✈✈✈✈✈✈✈✈ η1
88▲▲▲▲▲▲▲▲▲▲
x π1x, ∗
There are several ways around this problem. For instance, if we omit all the η-
reductions and consider only β-reductions, then the Church-Rosser property does
hold. Eliminating η-reductions does not have much of an effect on the lambda
calculus from a computational point of view; already in the untyped lambda cal-
culus, we noticed that all interesting calculations could in fact be carried out with
β-reductions alone. We can say that β-reductions are the engine for computation,
whereas η-reductions only serve to clean up the result. In particular, it can never
happen that some η-reduction inhibits another β-reduction: if M →η M′
, and if
M′
has a β-redex, then it must be the case that M already has a corresponding
β-redex. Also, η-reductions always reduce the size of a term. It follows that if
M is a β-normal form, then M can always be reduced to a βη-normal form (not
necessarily unique) in a ﬁnite sequence of η-reductions.
Exercise 30. Prove the Church-Rosser theorem for β-reductions in the λ→,×,1
-
calculus. Hint: use the same method that we used in the untyped case.
Another solution is to omit the type 1 and the term ∗ from the language. In this
case, the Church-Rosser property holds even for βη-reduction.
Exercise 31. Prove the Church-Rosser theorem for βη-reduction in the λ→,×
-
calculus, i.e., the simply-typed lambda calculus without 1 and ∗.
63

6.8 Reduction as proof simplification
Having made a one-to-one correspondence between simply-typed lambda terms
and derivations in intuitionistic natural deduction, we may now ask what β- and
η-reductions correspond to under this correspondence. It turns out that these re-
ductions can be thought of as “proof simplification steps”.
Consider for example the β-reduction π1 M, N → M. If we translate the left-
hand side and the right-hand side via the Curry-Howard isomorphism (here we
use the first notation for natural deduction), we get
(∧-E1)
(∧-I)
Γ
...
A
Γ
...
B
A ∧ B
A
→
Γ
...
A .
We can see that the left derivation contains an introduction rule immediately fol-
lowed by an elimination rule. This leads to an obvious simplification if we replace
the left derivation by the right one.
In general, β-redexes correspond to situations where an introduction rule is im-
mediately followed by an elimination rule, and η-redexes correspond to situations
where an elimination rule is immediately followed by an introduction rule. For
example, consider the η-reduction π1M, π2M → M. This translates to:
(∧-I)
(∧-E1)
Γ
...
A ∧ B
A
(∧-E2)
Γ
...
A ∧ B
B
A ∧ B
→
Γ
...
A ∧ B
Again, this is an obvious simplification step, but it has a side condition: the left
and right subderivation must be the same! This side condition corresponds to the
fact that in the redex π1M, π2M , the two subterms called M must be equal. It
is another characteristic of η-reductions that they often carry such side conditions.
The reduction M → ∗ translates as follows:
Γ
...
⊤ → (⊤-I)
⊤
64

In other words, any derivation of ⊤ can be replaced by the canonical such deriva-
tion.
More interesting is the case of the (β→) rule. Here, we have (λxA
.M)N →
M[N/x], which can be translated via the Curry-Howard Isomorphism as follows:
(→-E)
(→-I)
Γ, [x:A]
...
B
A → B
x
Γ
...
A
B
→
Γ,
Γ
...
A
...
B .
What is going on here is that we have a derivation M of B from assumptions Γ
and A, and we have another derivation N of A from Γ. We can directly obtain a
derivation of B from Γ by stacking the second derivation on top of the first!
Notice that this last proof “simplification” step may not actually be a simplifica-
tion. Namely, if the hypothesis labeled x is used many times in the derivation
M, then N will have to be copied many times in the right-hand side term. This
corresponds to the fact that if x occurs several times in M, then M[N/x] might
be a longer and more complicated term than (λx.M)N.
Finally, consider the (η→) rule λxA
.Mx → M, where x ∈ FV (M). This trans-
lates to derivations as follows:
(→-I)
(→-E)
Γ
...
A → B (ax)
[x:A]
A
x
B
A → B
x →
Γ
...
A → B
6.9 Getting mileage out of the Curry-Howard isomorphism
The Curry-Howard isomorphism makes a connection between the lambda calculus
and logic. We can think of it as a connection between “programs” and “proofs”.
What is such a connection good for? Like any isomorphism, it allows us to switch
back and forth and think in whichever system suits our intuition in a given situ-
ation. Moreover, we can save a lot of work by transferring theorems that were
proved about the lambda calculus to logic, and vice versa. As an example, we will
65

see in the next section how to add disjunctions to propositional intuitionistic logic,
and then we will explore what we can learn about the lambda calculus from that.
6.10 Disjunction and sum types
To the BNF for formulas of propositional intuitionistic logic from Section 6.3, we
add the following clauses:
Formulas: A, B ::= . . . A ∨ B ⊥.
Here, A ∨ B stands for disjunction, or “or”, and ⊥ stands for falsity, which we
can also think of as zero-ary disjunction. The symbol ⊥ is also known by the
names of “bottom”, “absurdity”, or “contradiction”. The rules for constructing
derivations are extended by the following cases:
7. (∨-introduction)
(∨-I1)
Γ ⊢ A
Γ ⊢ A ∨ B
(∨-I2)
Γ ⊢ B
Γ ⊢ A ∨ B
In other words, if we have proven A or we have proven B, then we may
conclude A ∨ B.
8. (∨-elimination)
(∨-Ex,y)
Γ ⊢ A ∨ B Γ, x:A ⊢ C Γ, y:B ⊢ C
Γ ⊢ C
This is known as the “principle of case distinction”. If we know A∨B, and
we wish to prove some formula C, then we may proceed by cases. In the
ﬁrst case, we assume A holds and prove C. In the second case, we assume
B holds and prove C. In either case, we prove C, which therefore holds
independently.
Note that the ∨-elimination rule differs from all other rules we have consid-
ered so far, because it involves some arbitrary formula C that is not directly
related to the principal formula A ∨ B being eliminated.
9. (⊥-elimination)
(⊥-E)
Γ ⊢ ⊥
Γ ⊢ C
,
for an arbitrary formula C. This rule formalizes the familiar principle “ex
falsum quodlibet”, which means that falsity implies anything.
66

There is no ⊥-introduction rule. This is symmetric to the fact that there is no
⊤-elimination rule.
Having extended our logic with disjunctions, we can now ask what these disjunc-
tions correspond to under the Curry-Howard isomorphism. Naturally, we need to
extend the lambda calculus by as many new terms as we have new rules in the
logic. It turns out that disjunctions correspond to a concept that is quite natural in
programming: “sum” or “union” types.
To the lambda calculus, add type constructors A + B and 0.
Simple types: A, B ::= . . . A + B 0.
Intuitively, A + B is the disjoint union of A and B, as in set theory: an element of
A + B is either an element of A or an element of B, together with an indication
of which one is the case. In particular, if we consider an element of A + A, we
can still tell whether it is in the left or right component, even though the two types
are the same. In programming languages, this is sometimes known as a “union”
or “variant” type. We call it a “sum” type here. The type 0 is simply the empty
type, corresponding to the empty set in set theory.
What should the lambda terms be that go with these new types? We know from
our experience with the Curry-Howard isomorphism that we have to have pre-
cisely one term constructor for each introduction or elimination rule of natural
deduction. Moreover, we know that if such a rule has n subderivations, then our
term constructor has to have n immediate subterms. We also know something
about bound variables: Each time a hypothesis is canceled in a natural deduction
rule, there must be a binder of the corresponding variable in the lambda calculus.
This information more or less uniquely determines what the lambda terms should
be; the only choice that is left is what to call them!
We add four terms to the lambda calculus:
Raw terms: M, N, P ::= . . . in1M in2M
case M of xA
⇒ N | yB
⇒ P AM
The typing rules for these new terms are shown in Table 5. By comparing these
rules to (∨-I1), (∨-I2), (∨-E), and (⊥-E), you can see that they are precisely
analogous.
But what is the meaning of these new terms? The term in1M is simply an element
of the left component of A + B. We can think of in1 as the injection function
A → A + B. Similar for in2. The term (case M of xA
⇒ N | yB
⇒ P) is a
case distinction: evaluate M of type A + B. The answer is either an element of
67

(in1)
Γ ⊢ M : A
Γ ⊢ in1M : A + B
(in2)
Γ ⊢ M : B
Γ ⊢ in2M : A + B
(case)
Γ ⊢ M : A + B Γ, x:A ⊢ N : C Γ, y:B ⊢ P : C
Γ ⊢ (case M of xA
⇒ N | yB
⇒ P) : C
( )
Γ ⊢ M : 0
Γ ⊢ AM : A
Table 5: Typing rules for sums
the left component A or of the right component B. In the first case, assign the
answer to the variable x and evaluate N. In the second case, assign the answer
to the variable y and evaluate P. Since both N and P are of type C, we get a
final result of type C. Note that the case statement is very similar to an if-then-
else; the only difference is that the two alternatives also carry a value. Indeed,
the booleans can be defined as 1 + 1, in which case T = in1∗, F = in2∗, and
if then else MNP = case M of x1
⇒ N | y1
⇒ P, where x and y don’t occur
in N and P, respectively.
Finally, the term AM is a simple type cast, corresponding to the unique function
A : 0 → A from the empty set to any set A.
6.11 Classical logic vs. intuitionistic logic
We have mentioned before that the natural deduction calculus we have presented
corresponds to intuitionistic logic, and not classical logic. But what exactly is the
difference? Well, the difference is that in intuitionistic logic, we have no rule for
proof by contradiction, and we do not have A ∨ ¬A as an axiom.
Let us adopt the following convention for negation: the formula ¬A (“not A”) is
regarded as an abbreviation for A → ⊥. This way, we do not have to introduce
special formulas and rules for negation; we simply use the existing rules for →
and ⊥.
In intuitionistic logic, there is no derivation of A ∨ ¬A, for general A. Or equiv-
alently, in the simply-typed lambda calculus, there is no closed term of type
A + (A → 0). We are not yet in a position to prove this formally, but informally,
the argument goes as follows: If the type A is empty, then there can be no closed
68

term of type A (otherwise A would have that term as an element). On the other
hand, if the type A is non-empty, then there can be no closed term of type A → 0
(or otherwise, if we applied that term to some element of A, we would obtain an
element of 0). But if we were to write a generic term of type A + (A → 0), then
this term would have to work no matter what A is. Thus, the term would have to
decide whether to use the left or right component independently of A. But for any
such term, we can get a contradiction by choosing A either empty or non-empty.
Closely related is the fact that in intuitionistic logic, we do not have a principle of
proof by contradiction. The “proof by contradiction” rule is the following:
(contrax)
Γ, x:¬A ⊢ ⊥
Γ ⊢ A
.
This is not a rule of intuitionistic propositional logic, but we can explore what
would happen if we were to add such a rule. First, we observe that the contradic-
tion rule is very similar to the following:
Γ, x:A ⊢ ⊥
Γ ⊢ ¬A
.
However, since we deﬁned ¬A to be the same as A → ⊥, the latter rule is an
instance of (→-I). The contradiction rule, on the other hand, is not an instance of
(→-I).
If we admit the rule (contra), then A ∨ ¬A can be derived. The following is such
a derivation:
(→-E)
(axy)
y:¬(A ∨ ¬A) ⊢ ¬(A ∨ ¬A)
(→-E)
(axy)
y:¬(A ∨ ¬A), x:A ⊢ ¬(A ∨ ¬A)
(∨-I1 )
(axx)
y:¬(A ∨ ¬A), x:A ⊢ A
y:¬(A ∨ ¬A), x:A ⊢ A ∨ ¬A
(∨-I2 )
(→-Ix)
y:¬(A ∨ ¬A), x:A ⊢ ⊥
y:¬(A ∨ ¬A) ⊢ ¬A
y:¬(A ∨ ¬A) ⊢ A ∨ ¬A
(contray )
y:¬(A ∨ ¬A) ⊢ ⊥
⊢ A ∨ ¬A
Conversely, if we added A ∨ ¬A as an axiom to intuitionistic logic, then this
already implies the (contra) rule. Namely, from any derivation of Γ, x:¬A ⊢ ⊥,
we can obtain a derivation of Γ ⊢ A by using A ∨ ¬A as an axiom. Thus, we can
simulate the (contra) rule, in the presence of A ∨ ¬A.
(∨-Ex,y)
(excluded middle)
Γ ⊢ A ∨ ¬A
(⊥-E)
Γ, x:¬A ⊢ ⊥
Γ, x:¬A ⊢ A
(axy)
Γ, y:A ⊢ A
Γ ⊢ A
69

In this sense, we can say that the rule (contra) and the axiom A ∨ ¬A are equiva-
lent, in the presence of the other axioms and rules of intuitionistic logic.
It turns out that the system of intuitionistic logic plus (contra) is equivalent to
classical logic as we know it. It is in this sense that we can say that intuitionistic
logic is “classical logic without proofs by contradiction”.
Exercise 32. The formula ((A → B) → A) → A is called “Peirce’s law”. It is
valid in classical logic, but not in intuitionistic logic. Give a proof of Peirce’s law
in natural deduction, using the rule (contra).
Conversely, Peirce’s law, when added to intuitionistic logic for all A and B, im-
plies (contra). Here is the proof. Recall that ¬A is an abbreviation for A → ⊥.
(→-E)
(Peirce’s law for B = ⊥)
Γ ⊢ ((A → ⊥) → A) → A
(→-Ix)
(⊥-E)
Γ, x:A → ⊥ ⊢ ⊥
Γ, x:A → ⊥ ⊢ A
Γ ⊢ (A → ⊥) → A
Γ ⊢ A
We summarize the results of this section in terms of a slogan:
intuitionistic logic + (contra)
= intuitionistic logic + “A ∨ ¬A”
= intuitionistic logic + Peirce’s law
= classical logic.
The proof theory of intuitionistic logic is a very interesting subject in its own right,
and an entire course could be taught just on that subject.
6.12 Classical logic and the Curry-Howard isomorphism
To extend the Curry-Howard isomorphism to classical logic, according to the ob-
servations of the previous section, it is sufﬁcient to add to the lambda calculus a
term representing Peirce’s law. All we have to do is to add a term C : ((A →
B) → A) → A, for all types A and B.
Such a term is known as Felleisen’s C, and it has a speciﬁc interpretation in terms
of programming languages. It can be understood as a control operator (similar
to “goto”, “break”, or exception handling in some procedural programming lan-
guages).
70

Specifically, Felleisen’s interpretation requires a term of the form
M = C(λkA→B
.N) : A
to be evaluated as follows. To evaluate M, first evaluate N. Note that both M and
N have type A. If N returns a result, then this immediately becomes the result of
M as well. On the other hand, if during the evaluation of N, the function k is ever
called with some argument x : A, then the further evaluation of N is aborted, and
x immediately becomes the result of M.
In other words, the final result of M can be calculated anywhere inside N, no
matter how deeply nested, by passing it to k as an argument. The function k is
known as a continuation.
There is a lot more to programming with continuations than can be explained in
these lecture notes. For an interesting application of continuations to compiling,
see e.g. [9] from the bibliography (Section 15). The above explanation of what
it means to “evaluate” the term M glosses over several details. In particular, we
have not given a reduction rule for C in the style of β-reduction. To do so is rather
complicated and is beyond the scope of these notes.
7 Weak and strong normalization
7.1 Definitions
As we have seen, computing with lambda terms means reducing lambda terms to
normal form. By the Church-Rosser theorem, such a normal form is guaranteed
to be unique if it exists. But so far, we have paid little attention to the question
whether normal forms exist for a given term, and if so, how we need to reduce the
term to find a normal form.
Definition. Given a notion of term and a reduction relation, we say that a term M
is weakly normalizing if there exists a finite sequence of reductions M → M1 →
. . . → Mn such that Mn is a normal form. We say that M is strongly normalizing
if there does not exist an infinite sequence of reductions starting from M, or in
other words, if every sequence of reductions starting from M is finite.
Recall the following consequence of the Church-Rosser theorem, which we stated
as Corollary 4.2: If M has a normal form N, then M →→ N. It follows that a
term M is weakly normalizing if and only if it has a normal form. This does not
71

imply that every possible way of reducing M leads to a normal form. A term is
strongly normalizing if and only if every way of reducing it leads to a normal form
in finitely many steps.
Consider for example the following terms in the untyped lambda calculus:
1. The term Ω = (λx.xx)(λx.xx) is neither weakly nor strongly normalizing.
It does not have a normal form.
2. The term (λx.y)Ω is weakly normalizing, but not strongly normalizing. It
reduces to the normal form y, but it also has an infinite reduction sequence.
3. The term (λx.y)((λx.x)(λx.x)) is strongly normalizing. While there are
several different ways to reduce this term, they all lead to a normal form in
finitely many steps.
4. The term λx.x is strongly normalizing, since it has no reductions, much
less an infinite reduction sequence. More generally, every normal form is
strongly normalizing.
We see immediately that strongly normalizing implies weakly normalizing. How-
ever, as the above examples show, the converse is not true.
7.2 Weak and strong normalization in typed lambda calculus
We found that the term Ω = (λx.xx)(λx.xx) is not weakly or strongly normaliz-
ing. On the other hand, we also know that this term is not typable in the simply-
typed lambda calculus. This is not a coincidence, as the following theorem shows.
Theorem 7.1 (Weak normalization theorem). In the simply-typed lambda calcu-
lus, all terms are weakly normalizing.
Theorem 7.2 (Strong normalization theorem). In the simply-typed lambda calcu-
lus, all terms are strongly normalizing.
Clearly, the strong normalization theorem implies the weak normalization theo-
rem. However, the weak normalization theorem is much easier to prove, which
is the reason we proved both these theorems in class. In particular, the proof of
the weak normalization theorem gives an explicit measure of the complexity of
a term, in terms of the number of redexes of a certain degree in the term. There
72

is no corresponding complexity measure in the proof of the strong normalization
theorem.
Please refer to Chapters 4 and 6 of “Proofs and Types” by Girard, Lafont, and
Taylor [2] for the proofs of Theorems 7.1 and 7.2, respectively.
8 Polymorphism
The polymorphic lambda calculus, also known as “System F”, is obtained extend-
ing the Curry-Howard isomorphism to the quantiﬁer ∀. For example, consider the
identity function λxA
.x. This function has type A → A. Another identity func-
tion is λxB
.x of type B → B, and so forth for every type. We can thus think of
the identity function as a family of functions, one for each type. In the polymor-
phic lambda calculus, there is a dedicated syntax for such families, and we write
Λα.λxα
.x of type ∀α.α → α.
System F was independently discovered by Jean-Yves Girard and John Reynolds
in the early 1970’s.
8.1 Syntax of System F
The primary difference between System F and simply-typed lambda calculus is
that System F has a new kind of function that takes a type, rather than a term, as
its argument. We can also think of such a function as a family of terms that is
indexed by a type.
Let α, β, γ range over a countable set of type variables. The types of System F
are given by the grammar
Types: A, B ::= α A → B ∀α.A
A type of the form A → B is called a function type, and a type of the form ∀α.A
is called a universal type. The type variable α is bound in ∀α.A, and we identify
types up to renaming of bound variables; thus, ∀α.α → α and ∀β.β → β are
the same type. We write FT V (A) for the set of free type variables of a type A,
deﬁned inductively by:
• FT V (α) = {α},
• FT V (A → B) = FT V (A) ∪ FT V (B),
73

(var)
Γ, x:A ⊢ x : A
(app)
Γ ⊢ M : A → B Γ ⊢ N : A
Γ ⊢ MN : B
(abs)
Γ, x:A ⊢ M : B
Γ ⊢ λxA
.M : A → B
(typeapp)
Γ ⊢ M : ∀α.A
Γ ⊢ MB : A[B/α]
(typeabs)
Γ ⊢ M : A α ∈ FT V (Γ)
Γ ⊢ Λα.M : ∀α.A
Table 6: Typing rules for System F
• FT V (∀α.A) = FT V (A) {α}.
We also write A[B/α] for the result of replacing all free occurrences of α by B in
A. Just like the substitution of terms (see Section 2.3), this type substitution must
be capture-free, i.e., special care must be taken to rename any bound variables of
A so that their names are different from the free variables of B.
The terms of System F are:
Terms: M, N ::= x MN λxA
.M MA Λα.M
Of these, variables x, applications MN, and lambda abstractions λxA
.M are ex-
actly as for the simply-typed lambda calculus. The new terms are type application
MA, which is the application of a type function M to a type A, and type abstrac-
tion Λα.M, which denotes the type function that maps a type α to a term M. The
typing rules for System F are shown in Table 6.
We also write FT V (M) for the set of free type variables in the term M. We need
a ﬁnal notion of substitution: if M is a term, B a type, and α a type variable, we
write M[B/α] for the capture-free substitution of B for α in M.
8.2 Reduction rules
In System F, there are two rules for β-reduction. The ﬁrst one is the familiar rule
for the application of a function to a term. The second one is an analogous rule
74

for the application of a type function to a type.
(β→) (λxA
.M)N → M[N/x],
(β∀) (Λα.M)A → M[A/α],
Similarly, there are two rules for η-reduction.
(η→) λxA
.Mx → M, if x ∈ FV (M),
(η∀) Λα.Mα → M, if α ∈ FT V (M).
The congruence and ξ-rules are as expected:
M → M′
MN → M′
N
N → N′
MN → MN′
M → M′
λxA
M → λxA
M′
M → M′
MA → M′
A
M → M′
ΛαM → ΛαM′
8.3 Examples
Just as in the untyped lambda calculus, many interesting data types and operations
can be encoded in System F.
8.3.1 Booleans
Deﬁne the System F type bool , and terms T, F : bool , as follows:
bool = ∀α.α → α → α,
T = Λα.λxα
.λyα
.x,
F = Λα.λxα
.λyα
.y.
It is easy to see from the typing rules that ⊢ T : bool and ⊢ F : bool are valid
typing judgements. We can deﬁne an if-then-else operation
if then else : ∀β. bool → β → β → β,
if then else = Λβ.λzbool
.zβ.
It is then easy to see that, for any type B and any pair of terms M, N : B, we have
if then else B T MN →→β M,
if then else B F MN →→β N.
75

Once we have if-then-else, it is easy to define other boolean operations, for exam-
ple
and = λabool
.λbbool
. if then else bool a b F,
or = λabool
.λbbool
. if then else bool a T b,
not = λabool
. if then else bool a F T.
Later, in Proposition 8.8, we will show that up to βη equality, T and and F are
the only closed terms of type bool . This, together with the if-then-else operation,
justifies calling this the type of booleans.
Note that the above encodings of the booleans and their if-then-else operation
in System F is exactly the same as the corresponding encodings in the untyped
lambda calculus from Section 3.1, provided that one erases all the types and type
abstractions. However, there is an important difference: in the untyped lambda
calculus, the booleans were just two terms among many, and there was no guar-
antee that the argument of a boolean function (such as and and or ) was actually
a boolean. In System F, the typing guarantees that all closed boolean terms even-
tually reduce to either T or F.
8.3.2 Natural numbers
We can also define a type of Church numerals in System F. We define:
nat = ∀α.(α → α) → α → α,
0 = Λα.λfα→α
.λxα
.x,
1 = Λα.λfα→α
.λxα
.fx,
2 = Λα.λfα→α
.λxα
.f(fx),
3 = Λα.λfα→α
.λxα
.f(f(fx)),
. . .
It is then easy to define simple functions, such as successor, addition, and multi-
plication:
succ = λnnat
.Λα.λfα→α
.λxα
.f(nαfx),
add = λnnat
.λmnat
.Λα.λfα→α
.λxα
.nαf(mαfx),
mult = λnnat
.λmnat
.Λα.λfα→α
.nα(mαf).
Just as for the booleans, these encodings of the Church numerals and functions are
exactly the same as those of the untyped lambda calculus from Section 3.2, if one
erases all the types and type abstractions. We will show in Proposition 8.9 below
that the Church numerals are, up to βη-equivalence, the only closed terms of type
nat .
76

8.3.3 Pairs
You will have noticed that we didn’t include a cartesian product type A× B in the
definition of System F. This is because such a type is definable. Specifically, let
A × B = ∀α.(A → B → α) → α,
M, N = Λα.λfA→B→α
.fMN.
Note that when M : A and N : B, then M, N : A × B. Moreover, for any pair
of types A, B, we have projection functions π1AB : A × B → A and π2AB :
A × B → B, defined by
π1 = Λα.Λβ.λpα×β
.pα(λxα
.λyβ
.x),
π2 = Λα.Λβ.λpα×β
.pβ(λxα
.λyβ
.y).
This satisfies the usual laws
π1AB M, N →→β M,
π2AB M, N →→β N.
Once again, these encodings of pairs and projections are exactly the same as those
we used in the untyped lambda calculus, when one erases all the type-related parts
of the terms. You will show in Exercise 36 that every closed term of type A × B
is βη-equivalent to a term of the form M, N .
Remark 8.1. It is also worth noting that the corresponding η-laws, such as
π1M, π2M = M,
are not derivable in System F. These laws hold whenever M is a closed term, but
not necessarily when M contains free variables.
Exercise 33. Find suitable encodings in System F of the types 1, A + B, and 0,
along with the corresponding terms ∗, in1, in2, case M of xA
⇒ N | yB
⇒ P, and
AM.
8.4 Church-Rosser property and strong normalization
Theorem 8.2 (Church-Rosser). System F satisfies the Church-Rosser property,
both for β-reduction and for βη-reduction.
Theorem 8.3 (Strong normalization). In System F, all terms are strongly normal-
izing.
77

The proof of the Church-Rosser property is similar to that of the simply-typed
lambda calculus, and is left as an exercise. The proof of strong normalization is
much more complex; it can be found in Chapter 14 of “Proofs and Types” [2].
8.5 The Curry-Howard isomorphism
From the point of view of the Curry-Howard isomorphism, ∀α.A is the universally
quantified logical statement “for all α, A is true”. Here α ranges over atomic
propositions. For example, the formula ∀α.∀β.α → (β → α) expresses the valid
fact that the implication α → (β → α) is true for all propositions α and β. Since
this quantifier ranges over propositions, it is called a second-order quantifier, and
the corresponding logic is second-order propositional logic.
Under the Curry-Howard isomorphism, the typing rules for System F become the
following logical rules:
• (Axiom)
(axx)
Γ, x:A ⊢ A
• (→-introduction)
(→-Ix)
Γ, x:A ⊢ B
Γ ⊢ A → B
• (→-elimination)
(→-E)
Γ ⊢ A → B Γ ⊢ A
Γ ⊢ B
• (∀-introduction)
(∀-I)
Γ ⊢ A α ∈ FT V (Γ)
Γ ⊢ ∀α.A
• (∀-elimination)
(∀-E)
Γ ⊢ ∀α.A
Γ ⊢ A[B/α]
The first three of these rules are familiar from propositional logic.
The ∀-introduction rule is also known as universal generalization. It corresponds
to a well-known logical reasoning principle: If a statement A has been proven for
some arbitrary α, then it follows that it holds for all α. The requirement that α is
78

“arbitrary” has been formalized in the logic by requiring that α does not appear in
any of the hypotheses that were used to derive A, or in other words, that α is not
among the free type variables of Γ.
The ∀-elimination rule is also known as universal specialization. It is the simple
principle that if some statement is true for all propositions α, then the same state-
ment is true for any particular proposition B. Note that, unlike the ∀-introduction
rule, this rule does not require a side condition.
Finally, we note that the side condition in the ∀-introduction rule is of course the
same as that of the typing rule (typeabs) of Table 6. From the point of view of
logic, the side condition is justified because it asserts that α is “arbitrary”, i.e.,
no assumptions have been made about it. From a lambda calculus view, the side
condition also makes sense: otherwise, the term λxα
.Λα.x would be well-typed
of type α → ∀α.α, which clearly does not make any sense: there is no way that an
element x of some fixed type α could suddenly become an element of an arbitrary
type.
8.6 Supplying the missing logical connectives
It turns out that a logic with only implication → and a second-order universal
quantifier ∀ is sufficient for expressing all the other usual logical connectives, for
example:
A ∧ B ⇐⇒ ∀α.(A → B → α) → α, (1)
A ∨ B ⇐⇒ ∀α.(A → α) → (B → α) → α, (2)
¬ A ⇐⇒ ∀α.A → α, (3)
⊤ ⇐⇒ ∀α.α → α, (4)
⊥ ⇐⇒ ∀α.α, (5)
∃β.A ⇐⇒ ∀α.(∀β.(A → α)) → α. (6)
Exercise 34. Using informal intuitionistic reasoning, prove that the left-hand side
is logically equivalent to the right-hand side for each of (1)–(6).
Remark 8.4. The definitions (1)–(6) are somewhat reminiscent of De Morgan’s
laws and double negations. Indeed, if we replace the type variable α by the con-
stant F in (1), the right-hand side becomes (A → B → F) → F, which is
intuitionistically equivalent to ¬ ¬(A ∧ B). Similarly, the right-hand side of (2)
becomes (A → F) → (B → F) → F, which is intuitionistically equivalent to
79

¬(¬ A ∧ ¬ B), and similarly for the remaining connectives. However, the ver-
sions of (1), (2), and (6) using F are only classically, but not intuitionistically
equivalent to their respective left-hand sides. On the other hand, it is remarkable
that by the use of ∀α, each right-hand side is intuitionistically equivalent to the
left-hand sides.
Remark 8.5. Note the resemblance between (1) and the definition of A × B given
in Section 8.3.3. Naturally, this is not a coincidence, as logical conjunction A∧B
should correspond to cartesian product A×B under the Curry-Howard correspon-
dence. Indeed, by applying the same principle to the other logical connectives, one
arrives at a good hint for Exercise 33.
Exercise 35. Extend System F with an existential quantifier ∃β.A, not by using
(6), but by adding a new type with explicit introduction and elimination rules to
the language. Justify the resulting rules by comparing them with the usual rules
of mathematical reasoning for “there exists”. Can you explain the meaning of the
type ∃β.A from a programming language or lambda calculus point of view?
8.7 Normal forms and long normal forms
Recall that a β-normal form of System F is, by definition, a term that contains no
β-redex, i.e., no subterm of the form (λxA
.M)N or (Λα.M)A. The following
proposition gives another useful way to characterize the β-normal forms.
Proposition 8.6 (Normal forms). A term of System F is a β-normal form if and
only if it is of the form
Λa1.Λa2 . . . Λan.zQ1Q2 . . . Qk, (7)
where:
• n 0 and k 0;
• Each Λai is either a lambda abstraction λxAi
i or a type abstraction Λαi;
• Each Qj is either a term Mj or a type Bj; and
• Each Qj, when it is a term, is recursively in normal form.
Proof. First, it is clear that every term of the form (7) is in normal form: the term
cannot itself be a redex, and the only place where a redex could occur is inside
one of the Qj, but these are assumed to be normal.
80

For the converse, consider a term M in β-normal form. We show that M is of the
form (7) by induction on M.
• If M = z is a variable, then it is of the form (7) with n = 0 and k = 0.
• If M = NP is normal, then N is normal, so by induction hypothesis, N is
of the form (7). But since NP is normal, N cannot be a lambda abstraction,
so we must have n = 0. It follows that NP = zQ1Q2 . . . QkP is itself of
the form (7).
• If M = λxA
.N is normal, then N is normal, so by induction hypothesis,
N is of the form (7). It follows immediately that λxA
.N is also of the form
(7).
• The case for M = NA is like the case for M = NP.
• The case for M = Λα.N is like the case for M = λxA
.N.
Definition. In a term of the form (7), the variable z is called the head variable of
the term.
Of course, by the Church-Rosser property together with strong normalization, it
follows that every term of System F is β-equivalent to a unique β-normal form,
which must then be of the form (7). On the other hand, the normal forms (7) are
not unique up to η-conversion; for example, λxA→B
.x and λxA→B
.λyA
.xy are
η-equivalent terms and are both of the form (7). In order to achieve uniqueness up
to βη-conversion, we introduce the notion of a long normal form.
Definition. A term of System F is a long normal form if
• it is of the form (7);
• the body zQ1 . . . Qk is of atomic type (i.e., its type is a type variable); and
• each Qj, when it is a term, is recursively in long normal form.
Proposition 8.7. Every term of System F is βη-equivalent to a unique long normal
form.
Proof. By strong normalization and the Church-Rosser property of β-reduction,
we already know that every term is β-equivalent to a unique β-normal form. It
therefore suffices to show that every β-normal form is η-equivalent to a unique
long normal form.
81

We first show that every β-normal form is η-equivalent to some long normal form.
We prove this by induction. Indeed, consider a β-normal form of the form (7).
By induction hypothesis, each of Q1, . . . , Qk can be η-converted to long normal
form. Now we proceed by induction on the type A of zQ1 . . . Qk. If A = α is
atomic, then the normal form is already long, and there is nothing to show. If
A = B → C, then we can η-expand (7) to
Λa1.Λa2 . . . Λan.λwB
.zQ1Q2 . . . Qkw
and proceed by the inner induction hypothesis. If A = ∀α.B, then we can η-
expand (7) to
Λa1.Λa2 . . . Λan.Λα.zQ1Q2 . . . Qkα
and proceed by the inner induction hypothesis.
For uniqueness, we must show that no two different long normal forms can be
βη-equivalent to each other. We leave this as an exercise.
8.8 The structure of closed normal forms
It is a remarkable fact that if M is in long normal form, then a lot of the structure
of M is completely determined by its type. Specifically: if the type of M is
atomic, then M must start with a head variable. If the type of M is of the form
B → C, then M must be, up to α-equivalence, of the form λxB
.N, where N is a
long normal form of type C. And if the type of M is of the form ∀α.C, then M
must be, up to α-equivalence, of the form Λα.N, where N is a long normal form
of type C.
So for example, consider the type
A = B1 → B2 → ∀α3.B4 → ∀α5.β.
We say that this type have five prefixes, where each prefix is of the form “Bi →”
or “∀αi.”. Therefore, every long normal form of type A must also start with five
prefixes; specifically, it must start with
λxB1
1 .λxB2
2 .Λα3.λxB4
4 .Λα5. . . .
The next part of the long normal form is a choice of head variable. If the term is
closed, the head variable must be one of the x1, x2, or x4. Once the head variable
has been chosen, then its type determines how many arguments Q1, . . . , Qk the
head variable must be applied to, and the types of these arguments. The structure
82

of each of Q1, . . . , Qk is then recursively determined by its type, with its own
choice of head variable, which then recursively determines its subterms, and so
on.
In other words, the degree of freedom in a long normal form is a choice of head
variable at each level. This choice of head variables completely determines the
long normal form.
Perhaps the preceding discussion can be made more comprehensible by means of
some concrete examples. The examples take the form of the following proposi-
tions and their proofs.
Proposition 8.8. Every closed term of type bool is βη-equivalent to either T or
F.
Proof. Let M be a closed term of type bool . By Proposition 8.7, we may assume
that M is a long normal form. Since bool = ∀α.α → α → α, every long normal
form of this type must start, up to α-equivalence, with
Λα.λxα
.λyα
. . . .
This must be followed by a head variable, which, since M is closed, can only be
x or y. Since both x and y have atomic type, neither of them can be applied to
further arguments, and therefore, the only two possible long normal forms are:
Λα.λxα
.λyα
.x
Λα.λxα
.λyα
.y,
which are T and F, respectively.
Proposition 8.9. Every closed term of type nat is βη-equivalent to a Church
numeral n, for some n ∈ N.
Proof. Let M be a closed term of type nat . By Proposition 8.7, we may assume
that M is a long normal form. Since nat = ∀α.(α → α) → α → α, every long
normal form of this type must start, up to α-equivalence, with
Λα.λfα→α
.λxα
. . . .
This must be followed by a head variable, which, since M is closed, can only be
x or f. If the head variable is x, then it takes no argument, and we have
M = Λα.λfα→α
.λxα
.x
83

If the head variable is f, then it takes exactly one argument, so M is of the form
M = Λα.λfα→α
.λxα
.fQ1.
Because Q1 has type α, its own long normal form has no prefix; therefore Q1
must start with a head variable, which must again be x or f. If Q1 = x, we have
M = Λα.λfα→α
.λxα
.fx.
If Q1 has head variable f, then we have Q1 = fQ2, and proceeding in this man-
ner, we find that M has to be of the form
M = Λα.λfα→α
.λxα
.f(f(. . . (fx) . . .)),
i.e., a Church numeral.
Exercise 36. Prove that every closed term of type A × B is βη-equivalent to a
term of the form M, N , where M : A and N : B.
8.9 Application: representation of arbitrary data in System F
Let us consider the definition of a long normal form one more time. By definition,
every long normal form is of the form
Λa1.Λa2 . . . Λan.zQ1Q2 . . . Qk, (8)
where zQ1Q2 . . . Qk has atomic type and Q1, . . . , Qk are, recursively, long nor-
mal forms. Instead of writing the long normal form on a single line as in (8), let
us write it in tree form instead:
Λa1.Λa2 . . . Λan.z
✞✞✞✞✞✞✞
✼✼✼✼✼✼✼
❏❏❏❏❏❏❏❏❏❏❏
Q1 Q2 · · · Qk,
where the long normal forms Q1, . . . , Qk are recursively also written as trees. For
example, with this notation, the Church numeral 2 becomes
Λα.λfα→α
.λxα
.f
f
x,
(9)
84

and the pair M, N becomes
Λα.λfA→B→α
.f
✠✠✠ ✺✺✺
M N.
We can use this very idea to encode (almost) arbitrary data structures. For exam-
ple, suppose that the data structure we wish to encode is a binary tree whose leaves
are labelled by natural numbers. Let’s call such a thing a leaf-labelled binary tree.
Here is an example:
•
☛☛ ✸✸✸
5 •
☞☞☞ ✹✹✹
8 7.
(10)
In general, every leaf-labelled binary tree is either a leaf, which is labelled by a
natural number, or else a branch that has exactly two children (a left one and a
right one), each of which is a leaf-labelled binary tree. Written as a BNF, we have
the following grammar for leaf-labelled binary trees:
Tree: T, S ::= leaf (n) branch (T, S).
When translating this as a System F type, we think along the lines of long normal
forms. We need a type variable α to represent leaf-labelled binary trees. We
need two head variables whose type ends in α: The ﬁrst head variable, let’s call
it ℓ, represents a leaf, and takes a single argument that is a natural number. Thus
ℓ : nat → α. The second head variable, let’s call it b, represents a branch, and
takes two arguments that are leaf-labelled binary trees. Thus b : α → α → α. We
end up with the following System F type:
tree = ∀α.(nat → α) → (α → α → α) → α.
A typical long normal form of this type is:
Λα.λℓnat →α
.λbα→α→α
.b
❂❂❂❂
ℓ b
✁✁✁✁ ❃❃❃❃
5 ℓ ℓ
8 7 ,
85

where 5, 7, and 8 denote Church numerals as in (9), here not expanded into long
normal form for brevity. Notice how closely this long normal form follows (10).
Here is the same term written on a single line:
Λα.λℓnat →α
.λbα→α→α
.b(ℓ 5)(b(ℓ 8)(ℓ 7))
Exercise 37. Prove that the closed long normal forms of type tree are in one-to-
one correspondence with leaf-labelled binary trees.
9 Type inference
In Section 6, we introduced the simply-typed lambda calculus, and we discussed
what it means for a term to be well-typed. We have also asked the question, for a
given term, whether it is typable or not.
In this section, we will discuss an algorithm that decides, given a term, whether it
is typable or not, and if the answer is yes, it also outputs a type for the term. Such
an algorithm is known as a type inference algorithm.
A weaker kind of algorithm is a type checking algorithm. A type checking algo-
rithm takes as its input a term with full type annotations, as well as the types of
any free variables, and it decides whether the term is well-typed or not. Thus, a
type checking algorithm does not infer any types; the type must be given to it as
an input and the algorithm merely checks whether the type is legal.
Many compilers of programming languages include a type checker, and programs
that are not well-typed are typically refused. The compilers of some programming
languages, such as ML or Haskell, go one step further and include a type infer-
ence algorithm. This allows programmers to write programs with no or very few
type annotations, and the compiler will ﬁgure out the types automatically. This
makes the programmer’s life much easier, especially in the case of higher-order
languages, where types such as ((A → B) → C) → D are not uncommon and
would be very cumbersome to write down. However, in the event that type in-
ference fails, it is not always easy for the compiler to issue a meaningful error
message that can help the human programmer ﬁx the problem. Often, at least a
basic understanding of how the type inference algorithm works is necessary for
programmers to understand these error messages.
86

9.1 Principal types
A simply-typed lambda term can have more than one possible type. Suppose that
we have three basic types ι1, ι2, ι3 in our type system. Then the following are all
valid typing judgments for the term λx.λy.yx:
⊢ λxι1
.λyι1→ι1
.yx : ι1 → (ι1 → ι1) → ι1,
⊢ λxι2→ι3
.λy(ι2→ι3)→ι3
.yx : (ι2 → ι3) → ((ι2 → ι3) → ι3) → ι3,
⊢ λxι1
.λyι1→ι3
.yx : ι1 → (ι1 → ι3) → ι3,
⊢ λxι1
.λyι1→ι3→ι2
.yx : ι1 → (ι1 → ι3 → ι2) → ι3 → ι2,
⊢ λxι1
.λyι1→ι1→ι1
.yx : ι1 → (ι1 → ι1 → ι1) → ι1 → ι1.
What all these typing judgments have in common is that they are of the form
⊢ λxA
.λyA→B
.yx : A → (A → B) → B,
for certain types A and B. In fact, as we will see, every possible type of the term
λx.λy.yx is of this form. We also say that A → (A → B) → B is the most
general type or the principal type of this term, where A and B are placeholders
for arbitrary types.
The existence of a most general type is not a peculiarity of the term λxy.yx, but
it is true of the simply-typed lambda calculus in general: every typable term has a
most general type. This statement is known as the principal type property.
We will see that our type inference algorithm not only calculates a possible type
for a term, but in fact it calculates the most general type, if any type exists at all.
In fact, we will prove the principal type property by closely examining the type
inference algorithm.
9.2 Type templates and type substitutions
In order to formalize the notion of a most general type, we need to be able to speak
of types with placeholders.
Deﬁnition. Suppose we are given an inﬁnite set of type variables, which we de-
note by upper case letters X, Y, Z etc. A type template is a simple type, built from
type variables and possibly basic types. Formally, type templates are given by the
BNF
Type templates: A, B ::= X ι A → B A × B 1
87

Note that we use the same letters A, B to denote type templates that we previously
used to denote types. In fact, from now on, we will simply regard types as special
type templates that happen to contain no type variables.
The point of type variables is that they are placeholders (just like any other kind of
variables). This means, we can replace type variables by arbitrary types, or even
by type templates. A type substitution is just such a replacement.
Definition. A type substitution σ is a function from type variables to type tem-
plates. We often write [X1 → A1, . . . , Xn → An] for the substitution defined by
σ(Xi) = Ai for i = 1 . . . n, and σ(Y ) = Y if Y ∈ {X1, . . . , Xn}. If σ is a type
substitution, and A is a type template, then we define ¯σA, the application of σ to
A, as follows by recursion on A:
¯σX = σX,
¯σι = ι,
¯σ(A → B) = ¯σA → ¯σB,
¯σ(A × B) = ¯σA × ¯σB,
¯σ1 = 1.
In words, ¯σA is simply the same as A, except that all the type variables have been
replaced according to σ. We are now in a position to formalize what it means for
one type template to be more general than another.
Definition. Suppose A and B are type templates. We say that A is more general
than B if there exists a type substitution σ such that ¯σA = B.
In other words, we consider A to be more general than B if B can be obtained
from A by a substitution. We also say that B is an instance of A. Examples:
• X → Y is more general than X → X.
• X → X is more general than ι → ι.
• X → X is more general than (ι → ι) → (ι → ι).
• Neither of ι → ι and (ι → ι) → (ι → ι) is more general than the other. We
say that these types are incomparable.
• X → Y is more general than W → Z, and vice versa. We say that X → Y
and W → Z are equally general.
88

We can also speak of one substitution being more general than another:
Definition. If τ and ρ are type substitutions, we say that τ is more general than ρ
if there exists a type substitution σ such that ¯σ ◦ τ = ρ.
9.3 Unifiers
We will be concerned with solving equations between type templates. The basic
question is not very different from solving equations in arithmetic: given an equa-
tion between expressions, for instance x + y = x2
, is it possible to find values for
x and y that make the equation true? The answer is yes in this case, for instance
x = 2, y = 2 is one solution, and x = 1, y = 0 is another possible solution. We
can even give the most general solution, which is x = arbitrary, y = x2
− x.
Similarly, for type templates, we might ask whether an equation such as
X → (X → Y ) = (Y → Z) → W
has any solutions. The answer is yes, and one solution, for instance, is X = ι → ι,
Y = ι, Z = ι, W = (ι → ι) → ι. But this is not the most general solution; the
most general solution, in this case, is Y = arbitrary, Z = arbitrary, X = Y → Z,
W = (Y → Z) → Y .
We use substitutions to represent the solutions to such equations. For instance, the
most general solution to the sample equation from the last paragraph is represented
by the substitution
σ = [X → Y → Z, W → (Y → Z) → Y ].
If a substitution σ solves the equation A = B in this way, then we also say that σ
is a unifier of A and B.
To give another example, consider the equation
X × (X → Z) = (Z → Y ) × Y.
This equation does not have any solution, because we would have to have both
X = Z → Y and Y = X → Z, which implies X = Z → (X → Z), which
is impossible to solve in simple types. We also say that X × (X → Z) and
(Z → Y ) × Y cannot be unified.
In general, we will be concerned with solving not just single equations, but sys-
tems of several equations. The formal definition of unifiers and most general
unifiers is as follows:
89

Definition. Given two sequences of type templates ¯A = A1, . . . , An and ¯B =
B1, . . . , Bn, we say that a type substitution σ is a unifier of ¯A and ¯B if ¯σAi =
¯σBi, for all i = 1 . . . n. Moreover, we say that σ is a most general unifier of ¯A
and ¯B if it is a unifier, and if it is more general than any other unifier of ¯A and ¯B.
9.4 The unification algorithm
Unification is the process of determining a most general unifier. More specifically,
unification is an algorithm whose input are two sequences of type templates ¯A =
A1, . . . , An and ¯B = B1, . . . , Bn, and whose output is either “failure”, if no
unifier exists, or else a most general unifier σ. We call this algorithm mgu for
“most general unifier”, and we write mgu( ¯A; ¯B) for the result of applying the
algorithm to ¯A and ¯B.
Before we state the algorithm, let us note that we only use finitely many type
variables, namely, the ones that occur in ¯A and ¯B. In particular, the substitutions
generated by this algorithm are finite objects that can be represented and manipu-
lated by a computer.
The algorithm for calculating mgu( ¯A; ¯B) is as follows. By convention, the al-
gorithm chooses the first applicable clause in the following list. Note that the
algorithm is recursive.
1. mgu(X; X) = id, the identity substitution.
2. mgu(X; B) = [X → B], if X does not occur in B.
3. mgu(X; B) fails, if X occurs in B and B = X.
4. mgu(A; Y ) = [Y → A], if Y does not occur in A.
5. mgu(A; Y ) fails, if Y occurs in A and A = Y .
6. mgu(ι; ι) = id.
7. mgu(A1 → A2; B1 → B2) = mgu(A1, A2; B1, B2).
8. mgu(A1 × A2; B1 × B2) = mgu(A1, A2; B1, B2).
9. mgu(1; 1) = id.
10. mgu(A; B) fails, in all other cases.
90

11. mgu(A, ¯A; B, ¯B) = ¯τ ◦ ρ, where ρ = mgu( ¯A; ¯B) and τ = mgu(¯ρA; ¯ρB).
Note that clauses 1–10 calculate the most general unifier of two type templates,
whereas clause 11 deals with lists of type templates. Clause 10 is a catch-all clause
that fails if none of the earlier clauses apply. In particular, this clause causes the
following to fail: mgu(A1 → A2; B1 × B2), mgu(A1 → A2; ι), etc.
Proposition 9.1. If mgu( ¯A; ¯B) = σ, then σ is a most general unifier of ¯A and ¯B.
If mgu( ¯A; ¯B) fails, then ¯A and ¯B have no unifier.
Proof. First, it is easy to prove by induction on the definition of mgu that if
mgu( ¯A; ¯B) = σ, then σ is a unifier of ¯A and ¯B. This is evident in all cases
except perhaps clause 11: but here, by induction hypothesis, ¯ρ ¯A = ¯ρ ¯B and
¯τ(¯ρA) = ¯τ(¯ρB), hence also ¯τ(¯ρ(A, ¯A)) = ¯τ(¯ρ(B, ¯B)). Here we have used
the evident notation of applying a substitution to a list of type templates.
Second, we prove that if ¯A and ¯B can be unified, then mgu( ¯A; ¯B) returns a most
general unifier. This is again proved by induction. For example, in clause 2, we
have σ = [X → B]. Suppose τ is another unifier of X and B. Then ¯τX = ¯τB.
We claim that ¯τ ◦ σ = τ. But ¯τ(σ(X)) = ¯τ(B) = ¯τ(X) = τ(X), whereas if
Y = X, then ¯τ(σ(Y )) = ¯τ(Y ) = τ(Y ). Hence ¯τ ◦ σ = τ, and it follows that σ is
more general than τ. The clauses 1–10 all follow by similar arguments. For clause
11, suppose that A, ¯A and B, ¯B have some unifier σ′
. Then σ′
is also a unifier for
¯A and ¯B, and thus the recursive call return a most general unifier ρ of ¯A and ¯B.
Since ρ is more general than σ′
, we have ¯κ ◦ ρ = σ′
for some substitution κ. But
then ¯κ(¯ρA) = ¯σ′
A = ¯σ′
B = ¯κ(¯ρB), hence ¯κ is a unifier for ¯ρA and ¯ρB. By
induction hypothesis, τ = mgu(¯ρA; ¯ρB) exists and is a most general unifier for
¯ρA and ¯ρB. It follows that τ is more general than ¯κ, thus ¯κ′
◦ τ = ¯κ, for some
substitution κ′
. Finally we need to show that σ = ¯τ ◦ ρ is more general than σ′
.
But this follows because ¯κ′
◦ σ = ¯κ′
◦ ¯τ ◦ ρ = ¯κ ◦ ρ = σ′
.
Remark 9.2. Proving that the algorithm mgu terminates is tricky. In particular,
termination can’t be proved by induction on the size of the arguments, because
in the second recursive call in clause 11, the application of ¯ρ may well increase
the size of the arguments. To prove termination, note that each substitution σ
generated by the algorithm is either the identity, or else it eliminates at least one
variable. We can use this to prove termination by nested induction on the number
of variables and on the size of the arguments. We leave the details for another
time.
91

9.5 The type inference algorithm
Given the uniﬁcation algorithm, type inference is now relatively easy. We for-
mulate another algorithm, typeinfer, which takes a typing judgment Γ ⊢ M : B
as its input (using templates instead of types, and not necessarily a valid typing
judgment). The algorithm either outputs a most general substitution σ such that
¯σΓ ⊢ M : ¯σB is a valid typing judgment, or if no such σ exists, the algorithm
fails.
In other words, the algorithm calculates the most general substitution that makes
the given typing judgment valid. It is deﬁned as follows:
1. typeinfer(x1:A1, . . . , xn:An ⊢ xi : B) = mgu(Ai; B).
2. typeinfer(Γ ⊢ MN : B) = ¯τ◦σ, where σ = typeinfer(Γ ⊢ M : X → B),
τ = typeinfer(¯σΓ ⊢ N : ¯σX), for a fresh type variable X.
3. typeinfer(Γ ⊢ λxA
.M : B) = ¯τ ◦ σ, where σ = mgu(B; A → X) and
τ = typeinfer(¯σΓ, x:¯σA ⊢ M : ¯σX), for a fresh type variable X.
4. typeinfer(Γ ⊢ M, N : A) = ¯ρ ◦ ¯τ ◦ σ, where σ = mgu(A; X × Y ),
τ = typeinfer(¯σΓ ⊢ M : ¯σX), and ρ = typeinfer(¯τ ¯σΓ ⊢ N : ¯τ ¯σY ), for
fresh type variables X and Y .
5. typeinfer(Γ ⊢ π1M : A) = typeinfer(Γ ⊢ M : A × Y ), for a fresh type
variable Y .
6. typeinfer(Γ ⊢ π2M : B) = typeinfer(Γ ⊢ M : X × B), for a fresh type
variable X.
7. typeinfer(Γ ⊢ ∗ : A) = mgu(A; 1).
Strictly speaking, the algorithm is non-deterministic, because some of the clauses
involve choosing one or more fresh type variables, and the choice is arbitrary.
However, the choice is not essential, since we may regard all fresh type variables
are equivalent. Here, a type variable is called “fresh” if it has never been used.
Note that the algorithm typeinfer can fail; this happens if and only if the call to
mgu fails in steps 1, 3, 4, or 7.
Also note that the algorithm obviously always terminates; this follows by induc-
tion on M, since each recursive call only uses a smaller term M.
92

Proposition 9.3. If there exists a substitution σ such that ¯σΓ ⊢ M : ¯σB is a valid
typing judgment, then typeinfer(Γ ⊢ M : B) will return a most general such
substitution. Otherwise, the algorithm will fail.
Proof. The proof is similar to that of Proposition 9.1.
Finally, the question “is M typable” can be answered by choosing distinct type
variables X1, . . . , Xn, Y and applying the algorithm typeinfer to the typing judg-
ment x1:X1, . . . , xn:Xn ⊢ M : Y . Note that if the algorithm succeeds and returns
a substitution σ, then σY is the most general type of M, and the free variables have
types x1:σX1, . . . , xn:σXn.
10 Denotational semantics
We introduced the lambda calculus as the “theory of functions”. But so far, we
have only spoken of functions in abstract terms. Do lambda terms correspond to
any actual functions, such as, functions in set theory? And what about the notions
of β- and η-equivalence? We intuitively accepted these concepts as expressing
truths about the equality of functions. But do these properties really hold of real
functions? Are there other properties that functions have that that are not captured
by βη-equivalence?
The word “semantics” comes from the Greek word for “meaning”. Denotational
semantics means to give meaning to a language by interpreting its terms as math-
ematical objects. This is done by describing a function that maps syntactic objects
(e.g., types, terms) to semantic objects (e.g., sets, elements). This function is
called an interpretation or meaning function, and we usually denote it by [[−]].
Thus, if M is a term, we will usually write [[M]] for the meaning of M under a
given interpretation.
Any good denotational semantics should be compositional, which means, the in-
terpretation of a term should be given in terms of the interpretations of its sub-
terms. Thus, for example, [[MN]] should be a function of [[M]] and [[N]].
Suppose that we have an axiomatic notion of equality ≃ on terms (for instance,
βη-equivalence in the case of the lambda calculus). With respect to a particular
class of interpretations, soundness is the property
M ≃ N ⇒ [[M]] = [[N]] for all interpretations in the class.
93

Completeness is the property
[[M]] = [[N]] for all interpretations in the class ⇒ M ≃ N.
Depending on our viewpoint, we will either say the axioms are sound (with respect
to a given interpretation), or the interpretation is sound (with respect to a given set
of axioms). Similarly for completeness. Soundness expresses the fact that our ax-
ioms (e.g., β or η) are true with respect to the given interpretation. Completeness
expresses the fact that our axioms are sufﬁcient.
10.1 Set-theoretic interpretation
The simply-typed lambda calculus can be given a straightforward set-theoretic
interpretation as follows. We map types to sets and typing judgments to functions.
For each basic type ι, assume that we have chosen a non-empty set Sι. We can
then associate a set [[A]] to each type A recursively:
[[ι]] = Sι
[[A → B]] = [[B]][[A]]
[[A × B]] = [[A]] × [[B]]
[[1]] = {∗}
Here, for two sets X, Y , we write Y X
for the set of all functions from X to Y ,
i.e., Y X
= {f | f : X → Y }. Of course, X × Y denotes the usual cartesian
product of sets, and {∗} is some singleton set.
We can now interpret lambda terms, or more precisely, typing judgments, as cer-
tain functions. Intuitively, we already know which function a typing judgment
corresponds to. For instance, the typing judgment x:A, f:A → B ⊢ fx : B corre-
sponds to the function that takes an element x ∈ [[A]] and an element f ∈ [[B]][[A]]
,
and that returns f(x) ∈ [[B]]. In general, the interpretation of a typing judgment
x1:A1, . . . , xn:An ⊢ M : B
will be a function
[[A1]] × . . . × [[An]] → [[B]].
Which particular function it is depends of course on the term M. For convenience,
if Γ = x1:A1, . . . , xn:An is a context, let us write [[Γ]] = [[A1]] × . . . × [[An]]. We
now deﬁne [[Γ ⊢ M : B]] by recursion on M.
94

• If M is a variable, we define
[[x1:A1, . . . , xn:An ⊢ xi : Ai]] = πi : [[A1]] × . . . × [[An]] → [[Ai]],
where πi(a1, . . . , an) = ai.
• If M = NP is an application, we recursively calculate
f = [[Γ ⊢ N : A → B]] : [[Γ]] → [[B]][[A]]
,
g = [[Γ ⊢ P : A]] : [[Γ]] → [[A]].
We then define
[[Γ ⊢ NP : B]] = h : [[Γ]] → [[B]]
by h(¯a) = f(¯a)(g(¯a)), for all ¯a ∈ [[Γ]].
• If M = λxA
.N is an abstraction, we recursively calculate
f = [[Γ, x:A ⊢ N : B]] : [[Γ]] × [[A]] → [[B]].
We then define
[[Γ ⊢ λxA
.N : A → B]] = h : [[Γ]] → [[B]][[A]]
by h(¯a)(a) = f(¯a, a), for all ¯a ∈ [[Γ]] and a ∈ [[A]].
• If M = N, P is an pair, we recursively calculate
f = [[Γ ⊢ N : A]] : [[Γ]] → [[A]],
g = [[Γ ⊢ P : B]] : [[Γ]] → [[B]].
We then define
[[Γ ⊢ N, P : A × B]] = h : [[Γ]] → [[A]] × [[B]]
by h(¯a) = (f(¯a), g(¯a)), for all ¯a ∈ [[Γ]].
• If M = πiN is a projection (for i = 1, 2), we recursively calculate
f = [[Γ ⊢ N : B1 × B2]] : [[Γ]] → [[B1]] × [[B2]].
We then define
[[Γ ⊢ πiN : Bi]] = h : [[Γ]] → [[Bi]]
by h(¯a) = πi(f(¯a)), for all ¯a ∈ [[Γ]]. Here πi in the meta-language denotes
the set-theoretic function πi : [[B1]] × [[B2]] → [[Bi]] given by πi(b1, b2) =
bi.
95

• If M = ∗, we deﬁne
[[Γ ⊢ ∗ : 1]] = h : [[Γ]] → {∗}
by h(¯a) = ∗, for all ¯a ∈ [[Γ]].
To minimize notational inconvenience, we will occasionally abuse the notation
and write [[M]] instead of [[Γ ⊢ M : B]], thus pretending that terms are typing
judgments. However, this is only an abbreviation, and it will be understood that
the interpretation really depends on the typing judgment, and not just the term,
even if we use the abbreviated notation.
We also refer to an interpretation as a model.
10.2 Soundness
Lemma 10.1 (Context change). The interpretation behaves as expected under
reordering of contexts and under the addition of dummy variables to contexts.
More precisely, if σ : {1, . . . , n} → {1, . . . , m} is an injective map, and if the
free variables of M are among xσ1, . . . , xσn, then the interpretations of the two
typing judgments,
f = [[x1:A1, . . . , xm:Am ⊢ M : B]] : [[A1]] × . . . × [[Am]] → [[B]],
g = [[xσ1:Aσ1, . . . , xσn:Aσn ⊢ M : B]] : [[Aσ1]] × . . . × [[Aσn]] → [[B]]
are related as follows:
f(a1, . . . , am) = g(aσ1, . . . , aσn),
for all a1 ∈ [[A1]], . . . , am ∈ [[Am]].
Proof. Easy, but tedious, induction on M.
The signiﬁcance of this lemma is that, to a certain extent, the context does not
matter. Thus, if the free variables of M and N are contained in Γ as well as Γ′
,
then we have
[[Γ ⊢ M : B]] = [[Γ ⊢ N : B]] iff [[Γ′
⊢ M : B]] = [[Γ′
⊢ N : B]].
Thus, whether M and N have equal denotations only depends on M and N, and
not on Γ.
96

Lemma 10.2 (Substitution Lemma). If
[[Γ, x:A ⊢ M : B]] = f : [[Γ]] × [[A]] → [[B]] and
[[Γ ⊢ N : A]] = g : [[Γ]] → [[A]],
then
[[Γ ⊢ M[N/x] : B]] = h : [[Γ]] → [[B]],
where h(¯a) = f(¯a, g(¯a)), for all ¯a ∈ [[Γ]].
Proof. Very easy, but very tedious, induction on M.
Proposition 10.3 (Soundness). The set-theoretic interpretation is sound for βη-
reasoning. In other words,
M =βη N ⇒ [[Γ ⊢ M : B]] = [[Γ ⊢ N : B]].
Proof. Let us write M ∼ N if [[Γ ⊢ M : B]] = [[Γ ⊢ N : B]]. By the remark after
Lemma 10.1, this notion is independent of Γ, and thus a well-defined relation on
terms (as opposed to typing judgments). To prove soundness, we must show that
M =βη N implies M ∼ N, for all M and N. It suffices to show that ∼ satisfies
all the axioms of βη-equivalence.
The axioms (refl), (symm), and (trans) hold trivially. Similarly, all the (cong) and
(ξ) rules hold, due to the fact that the meaning of composite terms was defined
solely in terms of the meaning of their subterms. It remains to prove that each of
the various (β) and (η) laws is satisfied (see page 62). We prove the rule (β→) as
an example; the remaining rules are left as an exercise.
Assume Γ is a context such that Γ, x:A ⊢ M : B and Γ ⊢ N : A. Let
f = [[Γ, x:A ⊢ M : B]] : [[Γ]] × [[A]] → [[B]],
g = [[Γ ⊢ N : A]] : [[Γ]] → [[A]],
h = [[Γ ⊢ (λxA
.M) : A → B]] : [[Γ]] → [[B]][[A]]
,
k = [[Γ ⊢ (λxA
.M)N : B]] : [[Γ]] → [[B]],
l = [[Γ ⊢ M[N/x] : B]] : [[Γ]] → [[B]].
We must show k = h. By definition, we have k(¯a) = h(¯a)(g(¯a)) = f(¯a, g(¯a)).
On the other hand, l(¯a) = f(¯a, g(¯a)) by the substitution lemma.
Note that the proof of soundness amounts to a simple calculation; while there are
many details to attend to, no particularly interesting new idea is required. This
is typical of soundness proofs in general. Completeness, on the other hand, is
usually much more difficult to prove and often requires clever ideas.
97

10.3 Completeness
We cite two completeness theorems for the set-theoretic interpretation. The first
one is for the class of all models with finite base type. The second one is for the
single model with one countably infinite base type.
Theorem 10.4 (Completeness, Plotkin, 1973). The class of set-theoretic models
with finite base types is complete for the lambda-βη calculus.
Recall that completeness for a class of models means that if [[M]] = [[N]] holds in
all models of the given class, then M =βη N. This is not the same as complete-
ness for each individual model in the class.
Note that, for each fixed choice of finite sets as the interpretations of the base
types, there are some lambda terms such that [[M]] = [[N]] but M =βη N. For
instance, consider terms of type (ι → ι) → ι → ι. There are infinitely many
βη-distinct terms of this type, namely, the Church numerals. On the other hand,
if Sι is a finite set, then [[(ι → ι) → ι → ι]] is also a finite set. Since a finite
set cannot have infinitely many distinct elements, there must necessarily be two
distinct Church numerals M, N such that [[M]] = [[N]].
Plotkin’s completeness theorem, on the other hand, shows that whenever M and
N are distinct lambda terms, then there exist some set-theoretic model with finite
base types in which M and N are different.
The second completeness theorem is for a single model, namely the one where Sι
is a countably infinite set.
Theorem 10.5 (Completeness, Friedman, 1975). The set-theoretic model with
base type equal to N, the set of natural numbers, is complete for the lambda-βη
calculus.
We omit the proofs.
11 The language PCF
PCF stands for “programming with computable functions”. The language PCF is
an extension of the simply-typed lambda calculus with booleans, natural numbers,
and recursion. It was first introduced by Dana Scott as a simple programming lan-
guage on which to try out techniques for reasoning about programs. Although PCF
is not intended as a “real world” programming language, many real programming
98

languages can be regarded as (syntactic variants of) extensions of PCF, and many
of the reasoning techniques developed for PCF also apply to more complicated
languages.
PCF is a “programming language”, not just a “calculus”. By this we mean, PCF
is equipped with a specific evaluation order, or rules that determine precisely how
terms are to be evaluated. We follow the slogan:
Programming language = syntax + evaluation rules.
After introducing the syntax of PCF, we will look at three different equivalence
relations on terms.
• Axiomatic equivalence =ax will be given by axioms in the spirit of βη-
equivalence.
• Operational equivalence =op will be defined in terms of the operational
behavior of terms. Two terms are operationally equivalent if one can be
substituted for the other in any context without changing the behavior of a
program.
• Denotational equivalence =den is defined via a denotational semantics.
We will develop methods for reasoning about these equivalences, and thus for
reasoning about programs. We will also investigate how the three equivalences
are related to each other.
11.1 Syntax and typing rules
PCF types are simple types over two base types bool and nat .
A, B ::= bool nat A → B A × B 1
The raw terms of PCF are those of the simply-typed lambda calculus, together
with some additional constructs that deal with booleans, natural numbers, and
recursion.
M, N, P ::= x MN λxA
.M M, N π1M π2M ∗
T F zero succ (M) pred (M)
iszero (M) if M then N else P Y(M)
99

(true)
Γ ⊢ T : bool
(false)
Γ ⊢ F : bool
(zero)
Γ ⊢ zero : nat
(succ)
Γ ⊢ M : nat
Γ ⊢ succ (M) : nat
(pred)
Γ ⊢ M : nat
Γ ⊢ pred (M) : nat
(iszero)
Γ ⊢ M : nat
Γ ⊢ iszero (M) : bool
(ﬁx)
Γ ⊢ M : A → A
Γ ⊢ Y(M) : A
(if)
Γ ⊢ M : bool Γ ⊢ N : A Γ ⊢ P : A
Γ ⊢ if M then N else P : A
Table 7: Typing rules for PCF
The intended meaning of these terms is the same as that of the corresponding
terms we used to program in the untyped lambda calculus: T and F are the
boolean constants, zero is the constant zero, succ and pred are the successor
and predecessor functions, iszero tests whether a given number is equal to zero,
if M then N else P is a conditional, and Y(M) is a ﬁxed point of M.
The typing rules for PCF are the same as the typing rules for the simply-typed
lambda calculus, shown in Table 4, plus the additional typing rules shown in Ta-
ble 7.
11.2 Axiomatic equivalence
The axiomatic equivalence of PCF is based on the βη-equivalence of the simply-
typed lambda calculus. The relation =ax is the least relation given by the follow-
ing:
• All the β- and η-axioms of the simply-typed lambda calculus, as shown on
page 62.
• One congruence or ξ-rule for each term constructor. This means, for in-
stance
M =ax M′
N =ax N′
P =ax P′
if M then N else P =ax if M′
then N′
else P′ ,
100

pred (zero ) = zero
pred (succ (n)) = n
iszero (zero ) = T
iszero (succ (n)) = F
if T then N else P = N
if F then N else P = P
Y(M) = M(Y(M))
Table 8: Axiomatic equivalence for PCF
and similar for all the other term constructors.
• The additional axioms shown in Table 8. Here, n stands for a numeral, i.e.,
a term of the form succ (. . . (succ (zero )) . . .).
11.3 Operational semantics
The operational semantics of PCF is commonly given in two different styles: the
small-step or shallow style, and the big-step or deep style. We give the small-step
semantics ﬁrst, because it is closer to the notion of β-reduction that we considered
for the simply-typed lambda calculus.
There are some important differences between an operational semantics, as we
are going to give it here, and the notion of β-reduction in the simply-typed lambda
calculus. Most importantly, the operational semantics is going to be deterministic,
which means, each term can be reduced in at most one way. Thus, there will never
be a choice between more than one redex. Or in other words, it will always be
uniquely speciﬁed which redex to reduce next.
As a consequence of the previous paragraph, we will abandon many of the congru-
ence rules, as well as the (ξ)-rule. We adopt the following informal conventions:
• never reduce the body of a lambda abstraction,
• never reduce the argument of a function (except for primitive functions such
as succ and pred ),
• never reduce the “then” or “else” part of an if-then-else statement,
• never reduce a term inside a pair.
101

Of course, the terms that these rules prevent from being reduced can neverthe-
less become subject to reduction later: the body of a lambda abstraction and the
argument of a function can be reduced after a β-reduction causes the λ to disap-
pear and the argument to be substituted in the body. The “then” or “else” parts
of an if-then-else term can be reduced after the “if” part evaluates to true or false.
And the terms inside a pair can be reduced after the pair has been broken up by a
projection.
An important technical notion is that of a value, which is a term that represents
the result of a computation and cannot be reduced further. Values are given as
follows:
Values: V, W ::= T F zero succ (V ) ∗ M, N λxA
.M
The transition rules for the small-step operational semantics of PCF are shown in
Table 9.
We write M → N if M reduces to N by these rules. We write M → if there
does not exist N such that M → N. The first two important technical properties
of small-step reduction are summarized in the following lemma.
Lemma 11.1. 1. Values are normal forms. If V is a value, then V →.
2. Evaluation is deterministic. If M → N and M → N′
, then N ≡ N′
.
Another important property is subject reduction: a well-typed term reduces only
to another well-typed term of the same type.
Lemma 11.2 (Subject Reduction). If Γ ⊢ M : A and M → N, then Γ ⊢ N : A.
Next, we want to prove that the evaluation of a well-typed term does not get
“stuck”. If M is some term such that M →, but M is not a value, then we
regard this as an error, and we also write M → error . Examples of such terms
are π1(λx.M) and M, N P. The following lemma shows that well-typed closed
terms cannot lead to such errors.
Lemma 11.3 (Progress). If M is a closed, well-typed term, then either M is a
value, or else there exists N such that M → N.
The Progress Lemma is very important, because it implies that a well-typed term
cannot “go wrong”. It guarantees that a well-typed term will either evaluate to a
value in finitely many steps, or else it will reduce infinitely and thus not terminate.
102

M → N
pred (M) → pred (N)
pred (zero ) → zero
pred (succ (V )) → V
M → N
iszero (M) → iszero (N)
iszero (zero ) → T
iszero (succ (V )) → F
M → N
succ (M) → succ (N)
M → N
MP → NP
(λxA
.M)N → M[N/x]
M → M′
πiM → πiM′
π1 M, N → M
π2 M, N → N
M : 1, M = ∗
M → ∗
M → M′
if M then N else P → if M′
then N else P
if T then N else P → N
if F then N else P → P
Y(M) → M(Y(M))
Table 9: Small-step operational semantics of PCF
But a well-typed term can never generate an error. In programming language
terms, a term that type-checks at compile-time cannot generate an error at run-
time.
To express this idea formally, let us write M →∗
N in the usual way if M reduces
to N in zero or more steps, and let us write M →∗
error if M reduces in zero or
more steps to an error.
Proposition 11.4 (Safety). If M is a closed, well-typed term, then M →∗
error.
Exercise 38. Prove Lemmas 11.1–11.3 and Proposition 11.4.
11.4 Big-step semantics
In the small-step semantics, if M →∗
V , we say that M evaluates to V . Note that
by determinacy, for every M, there exists at most one V such that M →∗
V .
103

T ⇓ T
F ⇓ F
zero ⇓ zero
M, N ⇓ M, N
λxA
.M ⇓ λxA
.M
M ⇓ zero
pred (M) ⇓ zero
M ⇓ succ (V )
pred (M) ⇓ V
M ⇓ zero
iszero (M) ⇓ T
M ⇓ succ (V )
iszero (M) ⇓ F
M ⇓ V
succ (M) ⇓ succ (V )
M ⇓ λxA
.M′
M′
[N/x] ⇓ V
MN ⇓ V
M ⇓ M1, M2 M1 ⇓ V
π1M ⇓ V
M ⇓ M1, M2 M2 ⇓ V
π2M ⇓ V
M : 1
M ⇓ ∗
M ⇓ T N ⇓ V
if M then N else P ⇓ V
M ⇓ F P ⇓ V
if M then N else P ⇓ V
M(Y(M)) ⇓ V
Y(M) ⇓ V
Table 10: Big-step operational semantics of PCF
It is also possible to axiomatize the relation “M evaluates to V ” directly. This is
known as the big-step semantics. Here, we write M ⇓ V if M evaluates to V .
The axioms for the big-step semantics are shown in Table 10.
The big-step semantics satisﬁes properties similar to those of the small-step se-
mantics.
Lemma 11.5. 1. Values. For all values V , we have V ⇓ V .
2. Determinacy. If M ⇓ V and M ⇓ V ′
, then V ≡ V ′
.
3. Subject Reduction. If Γ ⊢ M : A and M ⇓ V , then Γ ⊢ V : A.
The analogues of the Progress and Safety properties cannot be as easily stated for
big-step reduction, because we cannot easily talk about a single reduction step or
about inﬁnite reduction sequences. However, some comfort can be taken in the
fact that the big-step semantics and small-step semantics coincide:
104

Proposition 11.6. M →∗
V iff M ⇓ V .
11.5 Operational equivalence
Informally, two terms M and N will be called operationally equivalent if M and
N are interchangeable as part of any larger program, without changing the ob-
servable behavior of the program. This notion of equivalence is also often called
observational equivalence, to emphasize the fact that it concentrates on observable
properties of terms.
What is an observable behavior of a program? Normally, what we observe about a
program is its output, such as the characters it prints to a terminal. Since any such
characters can be converted in principle to natural numbers, we take the point of
view that the observable behavior of a program is a natural number that it evaluates
to. Similarly, if a program computes a boolean, we regard the boolean value as
observable. However, we do not regard abstract values, such as functions, as
being directly observable, on the grounds that a function cannot be observed until
we supply it some arguments and observe the result.
Definition. An observable type is either bool or nat . A result is a closed value
of observable type. Thus, a result is either T, F, or n. A program is a closed term
of observable type.
A context is a term with a hole, written C[−]. Formally, the class of contexts is
defined by a BNF:
C[−] ::= [−] x C[−]N MC[−] λxA
.C[−] . . .
and so on, extending through all the cases in the definition of a PCF term.
Well-typed contexts are defined in the same way as well-typed terms, where it
is understood that the hole also has a type. The free variables of a context are
defined in the same way as for terms. Moreover, we define the captured variables
of a context to be those bound variables whose scope includes the hole. So for
instance, in the context (λx.[−])(λy.z), the variable x is captured, the variable z
is free, and y is neither free nor captured.
If C[−] is a context and M is a term of the appropriate type, we write C[M] for
the result of replacing the hole in the context C[−] by M. Here, we do not α-
rename any bound variables, so that we allow free variables of M to be captured
by C[−].
We are now ready to state the definition of operational equivalence.
105

Definition. Two terms M, N are operationally equivalent, in symbols M =op N,
if for all closed and closing context C[−] of observable type and all values V ,
C[M] ⇓ V ⇐⇒ C[N] ⇓ V.
Here, by a closing context we mean that C[−] should capture all the free variables
of M and N. This is equivalent to requiring that C[M] and C[N] are closed terms
of observable types, i.e., programs. Thus, two terms are equivalent if they can be
used interchangeably in any program.
11.6 Operational approximation
As a refinement of operational equivalence, we can also define a notion of opera-
tional approximation: We say that M operationally approximates N, in symbols
M ⊑op N, if for all closed and closing contexts C[−] of observable type and all
values V ,
C[M] ⇓ V ⇒ C[N] ⇓ V.
Note that this definition includes the case where C[M] diverges, but C[N] con-
verges, for some N. This formalizes the notion that N is “more defined” than M.
Clearly, we have M =op N iff M ⊑op N and N ⊑op M. Thus, we get a partial
order ⊑op on the set of all terms of a given type, modulo operational equivalence.
Also, this partial order has a least element, namely if we let Ω = Y(λx.x), then
Ω ⊑op N for any term N of the appropriate type.
Note that, in general, ⊑op is not a complete partial order, due to missing limits of
ω-chains.
11.7 Discussion of operational equivalence
Operational equivalence is a very useful concept for reasoning about programs,
and particularly for reasoning about program fragments. If M and N are opera-
tionally equivalent, then we know that we can replace M by N in any program
without affecting its behavior. For example, M could be a slow, but simple sub-
routine for sorting a list. The term N could be a replacement that runs much faster.
If we can prove M and N to be operationally equivalent, then this means we can
safely use the faster routine instead of the slower one.
Another example are compiler optimizations. Many compilers will try to optimize
the code that they produce, to eliminate useless instructions, to avoid duplicate
106

calculations, etc. Such an optimization often means replacing a piece of code M
by another piece of code N, without necessarily knowing much about the context
in which M is used. Such a replacement is safe if M and N are operationally
equivalent.
On the other hand, operational equivalence is a somewhat problematic notion. The
problem is that the concept is not stable under adding new language features. It
can happen that two terms, M and N, are operationally equivalent, but when a
new feature is added to the language, they become nonequivalent, even if M and
N do not use the new feature. The reason is the operational equivalence is deﬁned
in terms of contexts. Adding new features to a language also means that there will
be new contexts, and these new contexts might be able to distinguish M and N.
This can be a problem in practice. Certain compiler optimizations might be sound
for a sequential language, but might become unsound if new language features
are added. Code that used to be correct might suddenly become incorrect if used
in a richer environment. For example, many programs and library functions in C
assume that they are executed in a single-threaded environment. If this code is
ported to a multi-threaded environment, it often turns out to be no longer correct,
and in many cases it must be re-written from scratch.
11.8 Operational equivalence and parallel or
Let us now look at a concrete example in PCF. We say that a term POR imple-
ments the parallel or function if it has the following behavior:
POR TP → T, for all P
POR NT → T, for all N
POR FF → F.
Note that this in particular implies POR TΩ = T and POR ΩT = T, where Ω
is some divergent term. It should be clear why POR is called the “parallel” or:
the only way to achieve such behavior is to evaluate both its arguments in parallel,
and to stop as soon as one argument evaluates to T or both evaluate to F.
Proposition 11.7. POR is not deﬁnable in PCF.
We do not give the proof of this fact, but the idea is relatively simple: one proves
by induction that every PCF context C[−, −] with two holes has the following
property: either, there exists a term N such that C[M, M′
] = N for all M, M′
(i.e., the context does not look at M, M′
at all), or else, either C[Ω, M] diverges
107

for all M, or C[M, Ω] diverges for all M. Here, again, Ω is some divergent term
such as Y(λx.x).
Although POR is not definable in PCF, we can define the following term, called
the POR-tester:
POR-test = λx.if xTΩ then
if xΩT then
if xFF then Ω
else T
else Ω
else Ω
The POR-tester has the property that POR-test M = T if M implements the
parallel or function, and in all other cases POR-test M diverges. In particular,
since parallel or is not definable in PCF, we have that POR-test M diverges, for all
PCF terms M. Thus, when applied to any PCF term, POR-test behaves precisely
as the function λx.Ω does. One can make this into a rigorous argument that shows
that POR-test and λx.Ω are operationally equivalent:
POR-test =op λx.Ω (in PCF).
Now, suppose we want to define an extension of PCF called parallel PCF. It
is defined in exactly the same way as PCF, except that we add a new primitive
function POR , and small-step reduction rules
M → M′
N → N′
POR MN → POR M′
N′
POR TN → T
POR MT → T
POR FF → F
Parallel PCF enjoys many of the same properties as PCF, for instance, Lem-
mas 11.1–11.3 and Proposition 11.4 continue to hold for it.
But notice that
POR-test =op λx.Ω (in parallel PCF).
This is because the context C[−] = [−] POR distinguishes the two terms: clearly,
C[POR-test ] ⇓ T, whereas C[λx.Ω] diverges.
108

12 Complete partial orders
12.1 Why are sets not enough, in general?
As we have seen in Section 10, the interpretation of types as plain sets is quite
sufficient for the simply-typed lambda calculus. However, it is insufficient for a
language such as PCF. Specifically, the problem is the fixed point operator Y :
(A → A) → A. It is clear that there are many functions f : A → A from a set
A to itself that do not have a fixed point; thus, there is no chance we are going to
find an interpretation for a fixed point operator in the simple set-theoretic model.
On the other hand, if A and B are types, there are generally many functions f :
[[A]] → [[B]] in the set-theoretic model that are not definable by lambda terms.
For instance, if [[A]] and [[B]] are infinite sets, then there are uncountably many
functions f : [[A]] → [[B]]; however, there are only countably many lambda terms,
and thus there are necessarily going to be functions that are not the denotation of
any lambda term.
The idea is to put additional structure on the sets that interpret types, and to re-
quire functions to preserve that structure. This is going to cut down the size of
the function spaces, decreasing the “slack” between the functions definable in the
lambda calculus and the functions that exist in the model, and simultaneously in-
creasing the chances that additional structure, such as fixed point operators, might
exist in the model.
Complete partial orders are one such structure that is commonly used for this
purpose. The method is originally due to Dana Scott.
12.2 Complete partial orders
Definition. A partially ordered set or poset is a set X together with a binary
relation ⊑ satisfying
• reflexivity: for all x ∈ X, x ⊑ x,
• antisymmetry: for all x, y ∈ X, x ⊑ y and y ⊑ x implies x = y,
• transitivity: for all x, y, z ∈ X, x ⊑ y and y ⊑ z implies x ⊑ z.
The concept of a partial order differs from a total order in that we do not require
that for any x and y, either x ⊑ y or y ⊑ x. Thus, in a partially ordered set it is
109

1 2 3 4 nT F* 0❜ ❜ ❜
❜
❜
❜
❜ ❜ ❜ ❜ ❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜
❜ ❜
❜ ❜ ❜
❜
❜
❜
❜
❏
❏
✡
✡
◗
◗◗
❏
❏✡
✡
✑
✑✑ ✏✏✏✏✏
.........
.........
✧
✧✧
✧
✧✧
❜
❜❜❜
❜❜
.❜
❜❜
✧
✧✧
❛❛❛❛
❡❡ ✪✪✦✦✦✦
. . . . . .
. . . . . .
1 B2 N
ω ω + 1 BB
Figure 4: Some posets
permissible to have incomparable elements.
We can often visualize posets, particularly finite ones, by drawing their line dia-
grams as in Figure 4. In these diagrams, we put one circle for each element of
X, and we draw an edge from x upward to y if x ⊑ y and there is no z with
x ⊑ z ⊑ y. Such line diagrams are also known as Hasse diagrams.
The idea behind using a partial order to denote computational values is that x ⊑ y
means that x is less defined than y. For instance, if a certain term diverges, then
its denotation will be less defined than, or below that of a term that has a definite
value. Similarly, a function is more defined than another if it converges on more
inputs.
Another important idea in using posets for modeling computational value is that
of approximation. We can think of some infinite computational object (such as, an
infinite stream), to be a limit of successive finite approximations (such as, longer
and longer finite streams). Thus we also read x ⊑ y as x approximates y. A
complete partial order is a poset in which every countable chain of increasing
elements approximates something.
Definition. Let X be a poset and let A ⊆ X be a subset. We say that x ∈ X is
an upper bound for A if a ⊑ x for all a ∈ A. We say that x is a least upper bound
for A if x is an upper bound, and whenever y is also an upper bound, then x ⊑ y.
Definition. An ω-chain in a poset X is a sequence of elements x0, x1, x2, . . .
110

such that
x0 ⊑ x1 ⊑ x2 ⊑ . . .
Definition. A complete partial order (cpo) is a poset such that every ω-chain of
elements has a least upper bound.
If x0, x1, x2, . . . is an ω-chain of elements in a cpo, we write ❇❇✂✂✍i∈N xi for the least
upper bound. We also call the least upper bound the limit of the ω-chain.
Not every poset is a cpo. In Figure 4, the poset labeled ω is not a cpo, because the
evident ω-chain does not have a least upper bound (in fact, it has no upper bound
at all). The other posets shown in Figure 4 are cpo’s.
12.3 Properties of limits
Proposition 12.1. 1. Monotonicity. Suppose {xi}i and {yi}i are ω-chains in
a cpo C, such that xi ⊑ yi for all i. Then
❇❇✂✂✍
i
xi ⊑ ❇❇✂✂✍
i
yi.
2. Exchange. Suppose {xij}i,j∈N is a doubly monotone double sequence of
elements of a cpo C, i.e., whenever i i′
and j j′
, then xij ⊑ xi′j′ .
Then
❇❇✂✂✍
i∈N
❇❇✂✂✍
j∈N
xij = ❇❇✂✂✍
j∈N
❇❇✂✂✍
i∈N
xij = ❇❇✂✂✍
k∈N
xkk.
In particular, all limits shown are well-defined.
Exercise 39. Prove Proposition 12.1.
12.4 Continuous functions
If we model data types as cpo’s, it is natural to model algorithms as functions
from cpo’s to cpo’s. These functions are subject to two constraints: they have to
be monotone and continuous.
Definition. A function f : C → D between posets C and D is said to be mono-
tone if for all x, y ∈ C,
x ⊑ y ⇒ f(x) ⊑ f(y).
111

A function f : C → D between cpo’s C and D is said to be continuous if it is
monotone and it preserves least upper bounds of ω-chains, i.e., for all ω-chains
{xi}i∈N in C,
f( ❇❇✂✂✍
i∈N
xi) = ❇❇✂✂✍
i∈N
f(xi).
The intuitive explanation for the monotonicity requirement is that information is
“positive”: more information in the input cannot lead to less information in the
output of an algorithm. The intuitive explanation for the continuity requirement is
that any particular output of an algorithm can only depend on a finite amount of
input.
12.5 Pointed cpo’s and strict functions
Definition. A cpo is said to be pointed if it has a least element. The least element
is usually denoted ⊥ and pronounced “bottom”. All cpo’s shown in Figure 4 are
pointed.
A continuous function between pointed cpo’s is said to be strict if it preserves the
bottom element.
12.6 Products and function spaces
If C and D are cpo’s, then their cartesian product C × D is also a cpo, with the
pointwise order given by (x, y) ⊑ (x′
, y′
) iff x ⊑ x′
and y ⊑ y′
. Least upper
bounds are also given pointwise, thus
❇❇✂✂✍
i
(xi, yi) = (❇❇✂✂✍
i
xi, ❇❇✂✂✍
i
yi).
Proposition 12.2. The first and second projections, π1 : C × D → C and π2 :
C × D → D, are continuous functions. Moreover, if f : E → C and g : E → D
are continuous functions, then so is the function h : E → C × D given by h(z) =
(f(z), g(z)).
If C and D are cpo’s, then the set of continuous functions f : C → D forms a cpo,
denoted DC
. The order is given pointwise: given two functions f, g : C → D,
we say that
f ⊑ g iff for all x ∈ C, f(x) ⊑ g(x).
112

Proposition 12.3. The set DC
of continuous functions from C to D, together with
the order just defined, is a complete partial order.
Proof. Clearly the set DC
is partially ordered. What we must show is that least
upper bounds of ω-chains exist. Given an ω-chain f0, f1, . . . in DC
, we define
g ∈ DC
to be the pointwise limit, i.e.,
g(x) = ❇❇✂✂✍
i∈N
fi(x),
for all x ∈ C. Note that {fi(x)}i does indeed form an ω-chain in C, so that g is a
well-defined function. We claim that g is the least upper bound of {fi}i. First we
need to show that g is indeed an element of DC
. To see that g is monotone, we
use Proposition 12.1(1) and calculate, for any x ⊑ y ∈ C,
g(x) = ❇❇✂✂✍
i∈N
fi(x) ⊑ ❇❇✂✂✍
i∈N
fi(y) = g(y).
To see that g is continuous, we use Proposition 12.1(2) and calculate, for any
ω-chain x0, x1, . . . in C,
g(❇❇✂✂✍
j
xj) = ❇❇✂✂✍
i
❇❇✂✂✍
j
fi(xj) = ❇❇✂✂✍
j
❇❇✂✂✍
i
fi(xj) = ❇❇✂✂✍
j
g(xj).
Finally, we must show that g is the least upper bound of the {fi}i. Clearly, fi ⊑ g
for all i, so that g is an upper bound. Now suppose h ∈ DC
is any other upper
bound of {fi}. Then for all x, fi(x) ⊑ h(x). Since g(x) was defined to be the
least upper bound of {fi(x)}i, we then have g(x) ⊑ h(x). Since this holds for all
x, we have g ⊑ h. Thus g is indeed the least upper bound.
Exercise 40. Recall the cpo B from Figure 4. The cpo BB
is also shown in
Figure 4. Its 11 elements correspond to the 11 continuous functions from B to B.
Label the elements of BB
with the functions they correspond to.
Proposition 12.4. The application function DC
× C → D, which maps (f, x) to
f(x), is continuous.
Proposition 12.5. Continuous functions can be continuously curried and un-
curried. In other words, if f : C × D → E is a continuous function, then
f∗
: C → ED
, defined by f∗
(x)(y) = f(x, y), is well-defined and continuous.
Conversely, if g : C → ED
is a continuous function, then g∗ : C × D → E, de-
fined by g∗(x, y) = g(x)(y), is well-defined and continuous. Moreover, (f∗
)∗ = f
and (g∗)∗
= g.
113

12.7 The interpretation of the simply-typed lambda calculus in
complete partial orders
The interpretation of the simply-typed lambda calculus in cpo’s resembles the set-
theoretic interpretation, except that types are interpreted by cpo’s instead of sets,
and typing judgments are interpreted as continuous functions.
For each basic type ι, assume that we have chosen a pointed cpo Sι. We can then
associate a pointed cpo [[A]] to each type A recursively:
[[ι]] = Sι
[[A → B]] = [[B]][[A]]
[[A × B]] = [[A]] × [[B]]
[[1]] = 1
Typing judgments are now interpreted as continuous functions
[[A1]] × . . . × [[An]] → [[B]]
in precisely the same way as they were defined for the set-theoretic interpretation.
The only thing we need to check, at every step, is that the function defined is
indeed continuous. For variables, this follows from the fact that projections of
cartesian products are continuous (Proposition 12.2). For applications, we use the
fact that the application function of cpo’s is continuous (Proposition 12.4), and for
lambda-abstractions, we use the fact that currying is a well-defined, continuous
operation (Proposition 12.5). Finally, the continuity of the maps associated with
products and projections follows from Proposition 12.2.
Proposition 12.6 (Soundness and Completeness). The interpretation of the simply-
typed lambda calculus in pointed cpo’s is sound and complete with respect to the
lambda-βη calculus.
12.8 Cpo’s and fixed points
One of the reasons, mentioned in the introduction to this section, for using cpo’s
instead of sets for the interpretation of the simply-typed lambda calculus is that
cpo’s admit fixed point, and thus they can be used to interpret an extension of the
lambda calculus with a fixed point operator.
Proposition 12.7. Let C be a pointed cpo and let f : C → C be a continuous
function. Then f has a least fixed point.
114

Proof. Define x0 = ⊥ and xi+1 = f(xi), for all i ∈ N. The resulting sequence
{xi}i is an ω-chain, because clearly x0 ⊑ x1 (since x0 is the least element), and
if xi ⊑ xi+1, then f(xi) ⊑ f(xi+1) by monotonicity, hence xi+1 ⊑ xi+2. It
follows by induction that xi ⊑ xi+1. Let x = ❇❇✂✂✍i xi be the limit of this ω-chain.
Then using continuity of f, we have
f(x) = f(❇❇✂✂✍
i
xi) = ❇❇✂✂✍
i
f(xi) = ❇❇✂✂✍
i
xi+1 = x.
To prove that it is the least fixed point, let y be any other fixed point, i.e., let
f(y) = y. We prove by induction that for all i, xi ⊑ y. For i = 0 this is trivial
because x0 = ⊥. Assume xi ⊑ y, then xi+1 = f(xi) ⊑ f(y) = y. It follows that
y is an upper bound for {xi}i. Since x is, by definition, the least upper bound, we
have x ⊑ y. Since y was arbitrary, x is below any fixed point, hence x is the least
fixed point of f.
If f : C → C is any continuous function, let us write f†
for its least fixed point.
We claim that f†
depends continuously on f, i.e., that † : CC
→ C defines a
continuous function.
Proposition 12.8. The function † : CC
→ C, which assigns to each continuous
function f ∈ CC
its least fixed point f†
∈ C, is continuous.
Exercise 41. Prove Proposition 12.8.
Thus, if we add to the simply-typed lambda calculus a family of fixed point op-
erators YA : (A → A) → A, the resulting extended lambda calculus can then be
interpreted in cpo’s by letting
[[YA]] = † : [[A]][[A]]
→ [[A]].
12.9 Example: Streams
Consider streams of characters from some alphabet A. Let A ω
be the set of finite
or infinite sequences of characters. We order A by the prefix ordering: if s and t
are (finite or infinite) sequences, we say s ⊑ t if s is a prefix of t, i.e., if there exists
a sequence s′
such that t = ss′
. Note that if s ⊑ t and s is an infinite sequence,
then necessarily s = t, i.e., the infinite sequences are the maximal elements with
respect to this order.
Exercise 42. Prove that the set A ω
forms a cpo under the prefix ordering.
115

Exercise 43. Consider an automaton that reads characters from an input stream
and writes characters to an output stream. For each input character read, it can
write zero, one, or more output characters. Discuss how such an automaton gives
rise to a continuous function from A ω
→ A ω
. In particular, explain the mean-
ing of monotonicity and continuity in this context. Give some examples.
13 Denotational semantics of PCF
The denotational semantics of PCF is defined in terms of cpo’s. It extends the cpo
semantics of the simply-typed lambda calculus. Again, we assign a cpo [[A]] to
each PCF type A, and a continuous function
[[Γ ⊢ M : B]] : [[Γ]] → [[B]]
to every PCF typing judgment. The interpretation is defined in precisely the same
way as for the simply-typed lambda calculus. The interpretation for the PCF-
specific terms is shown in Table 11. Recall that B and N are the cpo’s of lifted
booleans and lifted natural numbers, respectively, as shown in Figure 4.
Definition. Two PCF terms M and N of equal types are denotationally equiv-
alent, in symbols M =den N, if [[M]] = [[N]]. We also write M ⊑den N if
[[M]] ⊑ [[N]].
13.1 Soundness and adequacy
We have now defined the three notions of equivalence on terms: =ax, =op, and
=den. In general, one does not expect the three equivalences to coincide. For
example, any two divergent terms are operationally equivalent, but there is no
reason why they should be axiomatically equivalent. Also, the POR-tester and
the term λx.Ω are operationally equivalent in PCF, but they are not denotationally
equivalent (since a function representing POR clearly exists in the cpo semantics).
For general terms M and N, one has the following property:
Theorem 13.1 (Soundness). For PCF terms M and N, the following implications
hold:
M =ax N ⇒ M =den N ⇒ M =op N.
116

Types: [[bool ]] = B
[[nat ]] = N
Terms: [[T]] = T ∈ B
[[F]] = F ∈ B
[[zero ]] = 0 ∈ N
[[succ (M)]] =
⊥ if [[M]] = ⊥,
n + 1 if [[M]] = n
[[pred (M)]] =



⊥ if [[M]] = ⊥,
0 if [[M]] = 0,
n if [[M]] = n + 1
[[iszero (M)]] =



⊥ if [[M]] = ⊥,
T if [[M]] = 0,
F if [[M]] = n + 1
[[if M then N else P]] =



⊥ if [[M]] = ⊥,
[[N]] if [[M]] = F,
[[P]] if [[M]] = T,
[[Y(M)]] = [[M]]†
Table 11: Cpo semantics of PCF
117

Soundness is a very useful property, because M =ax N is in general easier to
prove than M =den N, and M =den N is in turns easier to prove than M =op N.
Thus, soundness gives us a powerful proof method: to prove that two terms are
operationally equivalent, it suffices to show that they are equivalent in the cpo
semantics (if they are), or even that they are axiomatically equivalent.
As the above examples show, the converse implications are not in general true.
However, the converse implications hold if the terms M and N are closed and
of observable type, and if N is a value. This property is called computational
adequacy. Recall that a program is a closed term of observable type, and a result
is a closed value of observable type.
Theorem 13.2 (Computational Adequacy). If M is a program and V is a result,
then
M =ax V ⇐⇒ M =den V ⇐⇒ M =op V.
Proof. First note that the small-step semantics is contained in the axiomatic se-
mantics, i.e., if M → N, then M =ax N. This is easily shown by induction on
derivations of M → N.
To prove the theorem, by soundness, it suffices to show that M =op V implies
M =ax V . So assume M =op V . Since V ⇓ V and V is of observable type, it
follows that M ⇓ V . Therefore M →∗
V by Proposition 11.6. But this already
implies M =ax V , and we are done.
13.2 Full abstraction
We have already seen that the operational and denotational semantics do not co-
incide for PCF, i.e., there are some terms such that M =op N but M =den N.
Examples of such terms are POR-test and λx.Ω.
But of course, the particular denotational semantics that we gave to PCF is not the
only possible denotational semantics. One can ask whether there is a better one.
For instance, instead of cpo’s, we could have used some other kind of mathemati-
cal space, such as a cpo with additional structure or properties, or some other kind
of object altogether. The search for good denotational semantics is a subject of
much research. The following terminology helps in defining precisely what is a
“good” denotational semantics.
Definition. A denotational semantics is called fully abstract if for all terms M
and N,
M =den N ⇐⇒ M =op N.
118

If the denotational semantics involves a partial order (such as a cpo semantics), it
is also called order fully abstract if
M ⊑den N ⇐⇒ M ⊑op N.
The search for a fully abstract denotational semantics for PCF was an open prob-
lem for a very long time. Milner proved that there could be at most one such
fully abstract model in a certain sense. This model has a syntactic description
(essentially the elements of the model are PCF terms), but for a long time, no
satisfactory semantic description was known. The problem has to do with sequen-
tiality: a fully abstract model for PCF must be able to account for the fact that
certain parallel constructs, such as parallel or, are not deﬁnable in PCF. Thus, the
model should consist only of “sequential” functions. Berry and others developed
a theory of “stable domain theory”, which is based on cpo’s with a additional
properties intended to capture sequentiality. This research led to many interesting
results, but the model still failed to be fully abstract.
Finally, in 1992, two competing teams of researchers, Abramsky, Jagadeesan and
Malacaria, and Hyland and Ong, succeeded in giving a fully abstract semantics
for PCF in terms of games and strategies. Games capture the interaction between
a player and an opponent, or between a program and its environment. By consid-
ering certain kinds of “history-free” strategies, it is possible to capture the notion
of sequentiality in just the right way to match PCF. In the last decade, game se-
mantics has been extended to give fully abstract semantics to a variety of other
programming languages, including, for instance, Algol-like languages.
Finally, it is interesting to note that the problem with “parallel or” is essentially
the only obstacle to full abstraction for the cpo semantics. As soon as one adds
“parallel or” to the language, the semantics becomes fully abstract.
Theorem 13.3. The cpo semantics is fully abstract for parallel PCF.
14 Acknowledgements
Thanks to Field Cady, Brendan Gillon, and Francisco Rios for reporting typos.
119

15 Bibliography
Here are some textbooks and other books on the lambda calculus. [1] is a standard
reference handbook on the lambda calculus. [2]–[4] are textbooks on the lambda
calculus. [5]–[7] are textbooks on the semantics of programming languages. Fi-
nally, [8]–[9] are textbooks on writing compilers for functional programming lan-
guages. They show how the lambda calculus can be useful in a more practical
context.
[1] H. P. Barendregt. The Lambda Calculus, its Syntax and Semantics. North-
Holland, 2nd edition, 1984.
[2] J.-Y. Girard, Y. Lafont, and P. Taylor. Proofs and Types. Cambridge University
Press, 1989.
[3] J.-L. Krivine. Lambda-Calculus, Types and Models. Masson, 1993.
[4] G. E. R´ev´esz. Lambda-Calculus, Combinators and Functional Programming.
Cambridge University Press, 1988.
[5] G. Winskel. The Formal Semantics of Programming Languages. An Introduc-
tion. MIT Press, London, 1993.
[6] J. C. Mitchell. Foundations for Programming Languages. MIT Press, London,
1996.
[7] C. A. Gunter. Semantics of Programming Languages. MIT Press, 1992.
[8] S. L. Peyton Jones. The Implementation of Functional Programming Lan-
guages. Prentice-Hall, 1987.
[9] A. W. Appel. Compiling with Continuations. Cambridge University Press,
1992.
120

Cálculo lambda

More Related Content

What's hot (14)

Similar to Cálculo lambda (20)

More from XequeMateShannon (20)

Recently uploaded (20)

Cálculo lambda