Explicit substitution

In computer science, Explicit substitution is an umbrella term used to describe several calculi based on the Lambda calculus that pay special attention to the formalization of the process of substitution. The concept of explicit substitutions has become notorious not just because of a large number of published calculi of explicit substitutions in the literature with quite different characteristics but also because the notion often turns up (implicitly and explicitly) in formal descriptions and implementation of all the mathematical forms of substitution involving variables such as in abstract machines, predicate logic, and symbolic computation.

Basics

A simple example of a lambda calculus with explicit substitution is "λx", which adds one new form of term to the lambda calculus, namely the form M⟨x:=N⟩, which reads "M where x will be substituted by N". (The meaning of the new term is the same as the common idiom let x:=N in M from many programming languages.) λx can be written with the following rewriting rules:
# (λx.M) N → M⟨x:=N⟩
# x⟨x:=N⟩ → N
# x⟨y:=N⟩ → x (x≠y)
# (M₁M₂) ⟨x:=N⟩ → (M₁⟨x:=N⟩) (M₂⟨x:=N⟩)
# (λx.M) ⟨y:=N⟩ → λx.(M⟨x:=N⟩) (x≠y)While making substitution explicit, this formulation still retains the complexity of the lambda calculus "variable convention", requiring arbitrary renaming of variables during reduction to ensure that the "(x≠y) condition on the last rule is always satisfied before applying the rule. Therefore many calculi of explicit substitution avoid variable names altogether by using a so-called "name-free" De Bruijn index notation.

History

Explicit substitutions grew out of an ‘implementation trick’ used, for example, by AUTOMATH, and became a respectable syntactic theory in lambda calculus and rewriting theory. The idea of a specific calculus where substitutions are part of the object language, and not of the informal meta-theory, is credited to Abadi, Cardelli, Curien, and Levy. Their seminal paper [M. Abadi, L. Cardelli, P-L. Curien and J-J. Levy, Explicit Substitutions, Journal of Functional Programming 1, 4 (October 1991), 375-416.] on the λσ calculus explains that implementations of Lambda calculus need to be very careful when dealing with substitutions. Without sophisticated mechanisms for structure-sharing, substitutions can cause a size explosion, and therefore, in practice, substitutions are delayed and explicitly recorded. This makes the correspondence between the theory and the implementation highly non-trivial and correctness of implementations can be hard to establish. One solution is to make the substitutions part of the calculus, that is, to have a calculus of explicit substitutions.

Once substitution has been made explicit, however, the basic properties of substitution change from being semantic to syntactic properties. One most important example is the "substitution lemma", which with the notation of λx becomes
* (M⟨x:=N⟩)⟨y:=P⟩ = (M⟨y:=P⟩)⟨x:=(N⟨y:=P⟩)⟩ (x≠y)A surprising counterexample, due to Melliès, [P-A. Melliès: Typed lambda-calculi with explicit substitutions may not terminate. TLCA 1995: 328-334] shows that the way this rule is encoded in the original calculus of explicit substitutions is not strongly normalizing. Following this, a multitude of calculi were described trying to offer the best compromise between syntactic properties of explicit substitution calculi. [P. Lescanne, From λσ to λν:a journey through calculi of explicit substitutions, POPL 1994, pp. 60-69.] [K. H. Rose, Explicit Substitution – Tutorial & Survey, BRICS LS-96-3, September 1996 ( [http://www.brics.dk/LS/96/3/BRICS-LS-96-3.ps.gz ps.gz] ).]

See also

* Substitution instance

References

----