- 1932: Alonzo Church develops the (type-free) Lambda Calculus as part of a general theory of functions and logic, intended as a foundation for mathematics. The whole system was proved inconsistent by Kleene and Rosser (1935), but the Lambda Calculus (taken alone) was proved consistent by Chuch and Rosser (as a consequence of the Church-Rosser property of the Lambda Calculus).
- 1936: Kleene proves that all Recursive functions (defined by Gödel in 1931) can be represented in the Lambda Calculus.
- 1937: Turing proves that every function computable by a Turing machine can be represented in the Lambda Calculus, and viceversa.
- In the same years, Church formulates the statement which is
known as
*Church's Thesis*:

Namely every function which can ever be computed algoritmically can be expressed in the Lambda Calculus. This statement cannot be proved formally, of course, because the notion of "algoritmic computability" is not defined formally. But, as a matter of fact, this "conjecture" has never been "disproved": not even the most sophisticated modern machines and programming languages can define more functions than those defined by the lambda calculus (or any of the other equivalent formalisms: Recursive functions, Turing machines, etc.).*Every computable function can be defined in the Lambda Calculus* - Based on the Lambda Calculus, a class of programming languages have been developed: the so-called Functional Languages (Lisp, Scheme, ML, Haskell, ...)

- Abstraction: if M = M[x] is an expression depending on x,
then \x.M[x] denotes the mapping x |-> M[x].
Namely the function that, for each term x, gives the term M[x].
The symbol "\" stands for the Greek letter lambda.
Example (assuming a language enriched with numerical constant and primitive operations): (\x. x+1) represents the function which, on input x, outputs x+1.

- Application: M N represents the function M applied to the argument N.

Variables: V ::= x | y | z | ...

Lambda-Terms: M ::= V | (\V M) | (M M)

M_{1}M_{2}... M_{k}stands for ( ... (M_{1}M_{2}) ... M_{k})

\x_{1}x_{2}... x_{k}.M stands for (\x_{1}(\x_{2}... (\x_{k}M) ... ))

This theory defines a semantics for lambda-terms in the sense that it defines the
meaning of a
term` M `as the
(equivalence) class of all terms lambda-convertible to ` M`.

It will be useful to introduce some preliminary notions.

These concepts of binder and scope are similar to the concepts of declaration and scope in programming langauges like for instance C, Pascal, or ML.

For example, consider the term

+++ (\x. ... (\x. --- ) *** ) ^^^The parts ... and *** are in the scope of the outermost \x. The part --- is in the scope of the innermost \x. The parts +++ and ^^^ are out of the scope of both \x.

An occurrence of x is* free *in M
if it is not in the scope of any binder for x.

For example, consider the term

(\x. x y (\x.\y. y z x ) x ) y xWe have 4 occurrences of x, of which only the last is free. The first and the third are bound by the outermost \x and the second is bound by the innermost \x. As for the other variables, we have 3 occurrences of y, of which the first and the last are free, and we have only one occurrence of z, free.

The free variables of M are all the variables which occur free in M. Formally:

FV(x) = {x}

FV(\x.M) = FV(M) - {x}

FV(M N) = FV(M) union FV(N)

x[N/x] = N

y[N/x] = y

(\y.M)[N/x] = \y.(M[N/x])

(\x.M)[N/x] = \x.M

(M P)[N/x] = (M[N/x])(P[N/x])

The condition "N does not contain free variables which are bound in M" is meant to avoid "variable capture". For example, given M = \y.zx, and N = y, if we simply replaced x by N in M, we would obtain the term \y.zy, which is intuitively incorrect since y, which was free in N, would become bound in M[N/x]. (Or in other words, M was constant on y and would become not constant.)

\x.M =provided that y is neither free nor bound in M._{alpha}\y.M[y/x]

(\x.M) N =provided that N does not contain free variables which is bound in M (in a subterm containing x), so to avoid variable capture._{beta}M[N/x]

Example: (\x. x+1) 5 =_{beta} 5+1 = 6

Variable assumption: To avoid the "variable capture" problem, and more in general, confusion with names, we will assume that all variables that occur free have names different from those of the bound variables, and that all bound variables have different names as well. Note that this assumption is not restrictive since we can always alpha-rename the bound variables.

For example, when we have a term like

x (\x.x(\x.x)x)we will write, instead

x (\y.y(\z.z)y)

Another solution would be to define the notion of substitution so that it renames the variables automatically when needed. For this approach see for instance Hindley and Seldin, Definition 1.1.

- M = N => M P = N P (Congruence 1)
- M = N => P M = P N (Congruence 2)
- M = N => \x.M = \x.N (Xi rule)