As we have seen in Chapter 10, the main property of typed systems not possessed by untyped systems is that all reductions are finite, and hence every typed term has a normal form. In this appendix we shall prove this theorem for the simply typed systems in Chapter 10, and for an extended system from which the consistency of first-order arithmetic can be deduced.

The proofs will be variations on a method due to W. Tait, [Tai67]. (See also [TS00, Sections 6.8, 6.12.2] or [SU06, Sections 5.3.2–5.3.6].) Simpler methods are known for pure λ and CL, but Tait's is the easiest to extend to more complex type-systems.

We begin with two definitions which have meaning for any reduction concept defined by sequences of replacements. The first is a repetition of Definition 10.14. The second is the key to Tait's method.

Definition A3.1 (Normalizable terms) A typed or untyped CL-or λ-term X is called normalizable or weakly normalizable or WN with respect to a given reduction concept, iff it reduces to a normal form. It is called strongly normalizable (SN) iff all reductions starting at X are finite.

As noted in Chapter 10, SN implies WN. Also the concept of SN involves the distinction between finite and infinite reductions, whereas WN does not, so SN is a fundamentally more complex concept than WN.

Introduction

In this chapter, a sequence of pure terms will be chosen to represent the natural numbers. It is then reasonable to expect that some of the other terms will represent functions of natural numbers, in some sense. This sense will be defined precisely below. The functions so representable will turn out to be exactly those computable by Turing machines.

In the 1930s, three concepts of computability arose independently: ‘Turing-computable function’, ‘recursive function’ and ‘λ-definable function’. The inventors of these three concepts soon discovered that all three gave the same set of functions. Most logicians took this as strong evidence that the informal notion of ‘computable function’ had been captured exactly by these three formally-defined concepts.

Here we shall look at the recursive functions, and prove that all these functions can be represented in λ and CL. (We shall not work with the Turing-computable functions because their representability-proof is longer.)

An outline definition of the recursive functions will be given here; more details and background can be found in many textbooks on computability or textbooks on logic which include computability, for example [Coh87], [Men97] or the old but thorough [Kle52].

Notation 4.1 This chapter is written in the same neutral notation as the last one, and its results will hold for both λ and CL unless explicitly stated otherwise.

The λ-calculus and combinatory logic are two systems of logic which can also serve as abstract programming languages. They both aim to describe some very general properties of programs that can modify other programs, in an abstract setting not cluttered by details. In some ways they are rivals, in others they support each other.

The λ-calculus was invented around 1930 by an American logician Alonzo Church, as part of a comprehensive logical system which included higher-order operators (operators which act on other operators). In fact the language of λ-calculus, or some other essentially equivalent notation, is a key part of most higher-order languages, whether for logic or for computer programming. Indeed, the first uncomputable problems to be discovered were originally described, not in terms of idealized computers such as Turing machines, but in λ-calculus.

Combinatory logic has the same aims as λ-calculus, and can express the same computational concepts, but its grammar is much simpler. Its basic idea is due to two people: Moses Schönfinkel, who first thought of it in 1920, and Haskell Curry, who independently re-discovered it seven years later and turned it into a workable technique.

The purpose of this book is to introduce the reader to the basic methods and results in both fields.

The reader is assumed to have no previous knowledge of these fields, but to know a little about propositional and predicate logic and recursive functions, and to have some experience with mathematical induction.

Applicative structures

In first-order logic, a common question to ask about a formal theory is ‘what are its models like?’. For the theories λβ and CLw the first person to ask this was Dana Scott in the 1960s, while he was working on extending the concept of ‘computable’ from functions of numbers to functions of functions. The first non-trivial model, D∞, was constructed by Scott in 1969.

Since then many other models have been made. The present chapter will set the scene by introducing a few basic general properties of models of CLw, and the next will do the same for λβ, whose concept of model is more complicated. Then Chapter 16 will describe the model D∞ in detail and give outlines and references for some other models. Scott's D∞ is not the simplest model known, but it is a good introduction, as the concepts used in building it are also involved in discussions of other models.

But first, a comment: although λ-calculus and combinatory logic were invented as long ago as the 1920s, there was a 40-year gap before their first model was constructed; why was there this long delay?

There are two main reasons. The first is the origin of λβ and CLw. Both Church and Curry viewed these theories, not from within the semantics that most post-1950 logicians were trained in, but from the alternative viewpoint described in Discussion 3.27.

In Chapter 1 the technicalities of bound variables, substitution and α-conversion were merely outlined. This is the best approach at the beginning. Indeed, most accounts of λ omit details of these, and simply assume that clashes between bound and free variables can always be avoided without problems; see, for example, the ‘variable convention’ in [Bar84, Section 2.1.13]. The purpose of this appendix is to show how that assumption can be justified.

Before starting, it is worth mentioning two points. First, there is a notation for λ-calculus that avoids bound variables completely. It was invented by N. G. de Bruijn, see [Bru72], and in it each bound variable-occurrence is replaced by a number showing its ‘distance’ from its binding λ, in a certain sense. De Bruijn's notation has been found useful when coding λ-terms for machine manipulation; examples are in [Alt93, Hue94, KR95]. But, as remarked in [Pol93, pp. 314–315], it does not lead to a particularly simple definition of substitution, and most human workers still find the classical notation easier to read.

For such workers, the details of α-conversion would not be avoided by de Bruijn's notation, but would simply be moved from the stage of manipulating terms to that of translating between the two notations.

The second point to note is shown by the following two examples: if we simply deleted ≡α from the rules of λ-calculus, we would lose the confluence of both ⊳βη and ⊳β.

Simple types

In mathematics the definition of a particular function usually includes a statement of the kind of inputs it will accept, and the kind of outputs it will produce. For example, the squaring function accepts integers n as inputs and produces integers n2 as outputs, and the zero-test function accepts integers and produces Boolean values (‘true’ or ‘false’ according as the input is zero or not).

Corresponding to this way of defining functions, λ and CL can be modified by attaching expressions called ‘types’ to terms, like labels to denote their intended input and output sets. In fact almost all programming languages that use λ and CL use versions with types.

This chapter and the next two will describe two different approaches to attaching types to terms: (i) called Church-style or sometimes explicit or rigid, and (ii) called Curry-style or sometimes implicit. Both are used extensively in programming.

The Church-style approach originated in [Chu40], and is described in the present chapter. In it, a term's type is a built-in part of the term itself, rather like a person's fingerprint or eye-colour is a built-in part of the person's body. (In Curry's approach a term's type will be assigned after the term has been built, like a passport or identity-card may be given to a person some time after birth.)

Introduction: complete partial orders

Having looked at the abstract definition of ‘model’ in the last two chapters, let us now study one particular model in detail. It will be a variant of Dana Scott's D∞, which was the first non-trivial model invented, and has been a dominant influence on the semantics of λ-calculus and programming languages ever since.

Actually, D∞ came as quite a surprise to all workers in λ − even to Scott. In autumn 1969 he wrote a paper which argued vigorously that an interpretation of all untyped λ-terms in set theory was highly unlikely, and that those who were interested in making models of λ should limit themselves to the typed version. (For that paper, see [Sco93].) The paper included a sketch of a new interpretation of typed terms. Then, only a month later, Scott realized that, by altering this new interpretation only slightly, he could make it into a model of untyped λ; this was D∞.

D∞ is a model of both CLw and λβ, and is also extensional. The description below will owe much to accounts by Dana Scott and Gordon Plotkin, and to the well-presented account in [Bar84], but it will give more details than these and will assume the reader has a less mathematical background.

The construction of D∞ involves notions from topology. These will be defined below. They are very different from the syntactical techniques used in this book so far, but they are standard tools in the semantics of programming languages.