User:Ruud Koot/Computer science/Lambda calculus

In mathematical logic and computer science, the lambda calculus (also written as λ-calculus) is a formal system for expressing computation by way of variable binding and substitution.

(pure) untyped lambda calculus (or type-free lambda calculus) (vs. other lambda calculi)

can be interpreted as:

  1. (inconsistent) proof system (Church vs. types)
  2. programming language

TODO edit

  • term vs. expression
  • intensionality vs. extensionality
  • should we have a separate (techincal) article on the untyped lambda calculus? the proof theoretical properties (normalization, confluence) vary between UTLC, STLC, STLC+fix, STLC+rectypes, Fomega, ...

Outline edit

  • Lambda calculus: high-level overview of both untyped and typed (some, but not too in-depth metatheory: e.g., model theory for untyped, normalization and a few type systems for typed etc.)
  • Untyped lambda calculus: denotation semanatics
  • Typed lambda calculus: Normalization theorems, overview of various type systems

History edit

  • Frege (Begriffschrift, function notation, "currying"), Russel & Whitehead (Principia Mathematica, caret-notation), Gödel's Dialectica interpretation.
  • Developed by Alonzo Church in the 1930's as a formal logic (Church 1932) and formalism for defining computable functions (Church 1936, 1941)
    • As a formal logic: lambda bindings abstract over universal and existential qunatifiers
      • A paradox was found in the untyped system (Kleene & Rosser 1935) which led to the development of typed variants (Church 1940; Henkin 1950)
    • As a formalism for defining computable functions: natural number functions definable in the untyped lambda calculus are the recursive functions (Kleene 1936) and Turing computable functions (Turing 1937)
      • In the 1960's connections with programming languages were found (Landin 1963, 1965, 1966; Böhm 1966; Strachey 1966; Milne & Strachey 1976; Stoy 1977)

Syntax edit

Abstract syntax edit

The abstract syntax of terms (or expressions) M, N, ... in the pure untyped lambda calculus is given in Backus–Naur form (BNF) by:

 

We assume we have an infinite supply of variables V that the metavariables x, y, z, ... range over.

Concrete syntax edit

In the concrete syntax of the lambda calculus the following syntactic conventions are obeyed:

  1. applications associate to the left;
  2. the scope of a binder extends to the right as far as possible;
  3. adjacent binders are merged; and
  4. superfluous parentheses are omitted.

Example The fully parenthesized term (((λx.(λy.(x y))) M) N) is written as (λxy.x y) M N. The final pair of parentheses cannot be omitted as the then resulting term would correspond to the fully parenthesized term (λx.(λy.(((x y) M) N))) instead.

Free and bound variables edit

In an abstraction λx.M the symbol λ is a quantifier or binder that binds all occurrences of the variable x the term M that have not already been bound by a binder inside M. A variable that is not bound is said to be free.

The set of free variables fv(M) occurring in a term M are given by:

 

Example The free variables fv((λxy.x y z) y) of the term (λxy.x y z) y are {y, z}. Note that it is only the second occurrence of the variable y that is free; the first occurrence is bound.

  • Add an image showing the binding structure of a complex expression.

Substitution edit

A substitution [P/x]M is a syntactic operation on lambda terms that replaces all free occurrences of the variable x in the term M with the term P:

Failed to parse (unknown function "\begin{array}"): {\displaystyle \begin{array}{rcll} [P/x]x &=& P \\ [P/x]y &=& y &\text{if $x \not\equiv y$} \\ [P/x](M N) &=& ([P/x]M)([P/x]N) \\ [P/x]\lambda x.M &=& \lambda x.M \\ [P/x]\lambda y.M &=& \lambda y.[P/x]M & \text{if $x \not\equiv y$ and $y \notin fv(P)$} \\ [P/x]\lambda y.M &=& \lambda z.[P/x][z/y]M & \text{where $x \notin fv(M) \cup fv(P)$ and $x \not\equiv y,z$} \end{array} }

Example Applying the substitution [λz.z/x] to the term λy.x yx.x) gives the term λy.(λz.z) (λx.x). Note that neither the second occurrence of x as a binder, nor the third occurrence of x as a bound variable are substituted for, as they are not free variables.

  • capture-avoidance (with some example)
    • Due to alpha-renaming, substitutions are deterministic only up to alpha-equivalance.
    • Barendregt convention

α-equivalence edit

merge this section with Substitutions below?

  • syntactic equivalence (≡ and =α)
  • de Bruijn indices

Semantics edit

Assign meaning to the lambda terms (syntax).

  • fairly technical, move after expressiveness?
  • (in)consistency
    • without types, LC is a system of equalities only
    • Church's original (unsound) logic

Proof systems edit

Syntactic in nature.

Axiomatic semantics edit

An equational proof system.

  • substitution (capture-avoiding)
  • alpha-renaming, beta-equivalence, symmetry, eta equivalence, transitivity, congruence

Operational semantics edit

Reduction rules.

  • beta reduction
  • properties: confluence, but no termination
  • reduction strategies
    • redex
  • eta-reduction and eta-expansion

Properties edit

  • normalization
  • confluence

Model theory edit

Semantic in nature.

Denotational semantics edit

  • (most naturally stated for typed lambda calculi, considering the untyped as a special instance of such...)

Categorical semantics edit

  • (only) make sense in a typed setting

Expressiveness edit

  • probably need to introduce Church numerals before Turing completeness, so we can define lambda-definability of natural number functions

Turing completness edit

Church encodings edit

Extensions and variations edit

Syntax extensions edit

  • let
    • syntactic sugar for application in PULC
    • treated differently in HM
  • fix (term)
    • not needed in PULC
    • needed in STLC

Base types edit

Typed lambda calculi edit

  • simply typed: strong normalization/termination; fix
    • lambda cube
    • Curry-Howard

Combinatory logic edit

Applications edit

Philosophy edit

  • Church-Turing thesis

Mathematics edit

  • foundations
  • Entscheidungsproblem

Computer science edit

  • Landin, programming language theory
  • functional programming

Linguistics edit

See also edit

(Topics that probably need to be mentioned or incorporated somewhere in the running text.)

Further reading edit

Primary / historical edit

Secondary / contemporary edit

  • Henk P. Barendregt (1984). The Lambda Calculus: Its Syntax and Semantics.
  • Henk P. Barendregt (1993). "Lambda calculi with types", in Samson Abramsky, Dov M. Gabbay and Tom Maibaum (eds.), Handbook of Logic in Computer Science, Volume 2, New York: Oxford University Press, pp. 117–309.
  • John C. Mitchell (1996). Foundations for Programming Languages. Foundations of Computing. MIT Press. ISBN 0262133210.
  • J. Roger Hindley and Jonathan P. Seldin (2008). Lambda-Calculus and Combinators: An Introduction. 2nd edition. Cambridge University Press. ISBN 9780521898850.
  • Henk Barendregt, Wil Dekkers, Richard Statman (2010). Lambda Calculus with Types. Cambridge Universty Press. ISBN 9780521766142.

Tertiary edit

External links edit