A Representation of Terms of the Lambda-Calculus in Standard ML

Transcription

1 A Representation of Terms of the Lambda-Calculus in Standard ML Matthew Wahab April 30, 2006 Abstract Representing terms of the λ-calculus is complicated by the need to uniquely associate bound variables with their binding terms. Using Standard ML, a representation of λ-terms based on the name-carrying notation can use reference values to identify the variable bound by a binding term. This approach preserves the simplicity of the name-carrying notation while improving its efficiency. 1 Introduction The λ-calculus (Church, 1941) is used in many theorem provers and automated proof tools. Representing and manipulating λ-terms in such tools is complicated by the need to avoid the name-capture problem which occurs with binding terms and bound variables. A binding term, written λx.t for some name x and λ-term T, denotes an anonymous function and any variable named x occurring in T is bound to that term, to represent the function parameter. Name-capture occurs if there is another term binding x in T : it is unclear to which term variable x is meant to be bound. There are two main approaches to representing λ-terms. The name-carrying notation is that used by Church (1941), its implementation is described by Gordon (1988). In this notation, a variable is represented by its name and name-capture is avoided by ensuring that bound variables are always uniquely named, renaming variables and their binding terms whenever necessary. This approach makes terms easy to examine but difficult to manipulate since renaming involves gathering the names already in use, to ensure that a replacement is unique. The second approach is the namefree notation of de Bruijn (1972). A bound variable is represented by an index giving the number of binding terms between the variable and its binding term, the term λx.λy.x is represented λx.λy.1. Because bound variables are always uniquely associated with their binding term, name-capture does not occur. Implementations of this notation are efficient but complicated by the need to take into account, when examining a term, of the changing indices of a bound variable. This also makes it difficult to treat subterms of a term indepently of the term. The approach to representing λ-terms described here is the name-carrying notation with the names of bound variables represented by the reference values of Standard ML (Milner et al., 1990). A reference is generated by the Standard ML runtime system and is guaranteed to be unique: if two references are created at different times then they are distinct. Terms must still be renamed with this approach but this can be done without testing the newly generated names for uniqueness. This Copyright c 2006 Matthew Wahab 1

2 preserves the simplicity of the name-carrying notation while removing a major source of inefficiency in its implementation. The name-carrying representation using references (which will be called reference-carrying for brevity) will be described through an implementation of the λ-calculus. The features of Standard ML used in the description are summarised in Section 2 and the implementation of the λ-calculus and term representation is given in Section 3. Some practical issues are discussed in Section 4 and Section 5 concludes the paper. 2 Standard ML Milner et al. (1990) give a formal definition of Standard ML. A tutorial description is given by Paulson (1991). Standard ML types include the integers, int, booleans bool, strings, string and the type of n-tuples ( a 1 * * a n ) where a i is a type variable. Expression (e 1,..., e n ) is the n-tuple of expressions e 1,..., e n. The empty list is [] and x::y is the list constructed from element x and list y. Type T 1 is defined as an alias for type T 2 by type T 1 = T 2. An abstract type T is defined datatype T = C 1... C n for n 1 where C i is a constructor for T. If C i is in the form C i of T 1 then it takes an argument of type T 1. An exception e is declared with exception e, thrown with raise e and caught, when it occurs in f, by f handle e => g. Exception Fail s, for string s, is usually used to indicate failure. The conditional expression is if b then e 1 else e 2 for test b and expressions e 1, e 2. The pattern matching expression case f of P 1 => e 1... P n => e n selects e i such that P i is the first pattern (beginning with P 1 ) to match the result of evaluating f. The sequential evaluation of e 1 followed by e 2 is e 1 ; e 2 and returns the result of e 2. Identifier x is defined as the value of expression e by val x =e and a function definition has the form fun f a 1... a n =e where a 1,..., a n are the parameters. Functions can also be defined by pattern matching on the parameters. The anonymous function with argument x and body e is fn x => e. The forms let val x =y in e and let fun f a 1... a n =g in e define variable x and function f respectively as local to expression e. A reference to data item x of type T is created by ref x, has type T ref and!r is x. Type T will be called the base type of type T ref. The assignment of e to reference x is x:=e. Each invocation of function ref creates a unique reference and references can be compared by the equality function =. The expression ref x =ref x is false and the expression let val t=ref x in t=t is true for any x. 3 Implementing the λ-calculus The implementation of the λ-calculus consists of an abstract type representing λ-terms and functions implementing the rules of the calculus. A λ-term is either a free variable which is not bound by a binding term, the application of a term f to term a, fa, a binding term or a bound variable. The rules of the λ-calculus describe conversions defined by textual substitution and the substitution of r for t in T will be written T [r/t]. Renaming is by α-conversion, defined λx.t α λy.t [y/x] where y is a name that doesn t occur in T. An application is reduced by β-conversion, defined (λx.t )E β T [E/x]. The η-conversion of a term is λx.(t x) η T, provided that x doesn t occur in T. The name-capture problem occurs with β-conversion when a binding term with name x is substituted into a term in which x is already bound. For example, if (λy.λx.yx)(λx.x) is reduced to (λx.(λx.x)x), it becomes unclear to which binding term the innermost occurrence of x is bound. 2

3 type binder = string ref fun binder s = ref s fun destbinder q =!q datatype term = Free of string App of term * term Bound of binder Lambda of binder * term fun mem x [] = false mem x (y::ys) = if x=y then true else mem x ys fun isclosedfulltrm sb = case trm of App(f, a) => if (isclosedfull f sb) then (isclosedfull a sb) else false Lambda(q, b) => isclosedfull b (Bound(q)::sb) Bound(q) => mem(bound(q)) sb => true fun isclosed trm = isclosedfull trm [] Figure 1: Representation of λ-terms Terms The reference-carrying representation of λ-terms is given in Figure 1 as the abstract type term. Constructors Free and App represent free variables (which are named with strings) and the application of terms respectively. Constructors Bound and Lambda represent bound variables and binding terms respectively. In both, the name of the bound variable is represented by an element of type binder which is an alias for references to strings. Function binder constructs a unique binder and function destbinder returns the string referred to by a binder. Bound variables are associated with binding terms having the same binder, term Lambda(q, b) binds all terms Bound(q) occurring in b. As with the standard name-carrying notation, binder q of a term Lambda(q, b) must be unique to avoid the name-capture problem. An element T of type term is closed (and represents a well-formed λ-term) if every bound variable Bound(q) in T occurs only as a subterm of a binding term with binder q. Function isclosed tests whether a term T is closed, using function isclosedfull to desc through the structure of T. For each binding term Lambda(q, b), bound variable Bound(q) is added to the (initially empty) list sb. If a bound variable occurring in T does not appear in sb then it must be outside its binding term and T is not closed. Substitution The implementation of substitution given here renames terms each time they are used as replacements, replacing the binder in each binding term Lambda(q, b) and bound variable Bound(q) occuring in b. This is necessary so that, when a substitution T [r/t] is carried out, the binders of binding terms in each instance of r which is substituted into T are unique. 3

4 type substitution = (term * term) list exception NotFound fun add x y sb = (x, y)::sb fun get x [] = raise NotFound get x ((t, r)::ls) = if(x=t) then r else get x ls fun renamefull sb t = case t of Free(s) => Free(s) App(l, r) => App(renameFull sb l, renamefull sb r) Lambda(q, b) => let val nq = binder(destbinder q) in let val nsb = add(bound q) (Bound nq) sb in Lambda(nq, renamefull nsb b) Bound(q) => (get(bound q) sb) handle NotFound => (Bound q) fun rename t = renamefull [] t fun lookup t sb = rename(get t sb) fun subst trm sb = let fun substaux (Free s) = Free s substaux (App(l, r)) = App(subst l sb, subst r sb) substaux (Lambda(q, b)) = Lambda(q, subst b sb) substaux (Bound q) = (Bound q) in (lookup trm sb) handle NotFound => substaux trm Figure 2: Implementation of Substitution The substitution operation is implemented as function subst of Figure 2 using a number of utility types and functions. An element of type substitution stores the list of term-replacement pairs to be used in a substitution. Functions add and get are the basic operations on substitution lists, to respectively add or get a term-replacement pair. Renaming of terms is carried out by function rename, using function renamefull. This descs through a term creating a new, unique binder q for each subterm Lambda(q, b) and replacing bound variable Bound(q) with Bound(q ) in b to obtain a new body b. The subterm is then replaced with Lambda(q, b ). A bound variable appearing outside its binding term is not renamed, allowing the substitution of bound variables for terms. Function lookup is used to get and then rename a replacement term from a substitution list. The expression subst T (add t r []) replaces each occurrence of t in T with a term obtained by renaming r. Because r differs from r only in the binders appearing in binding terms and bound variables, term r is equivalent to r in the λ-calculus (the terms are α-convertible, see Barregt, 1984) and is a valid replacement for t. Function subst is an implementation of textual substitution, any part of a term can be replaced. In the standard name-carrying notation and the namefree notation, substitution is usually specialised 4

5 fun alphaconv (Lambda(q, b)) = let val nq=binder(destbinder q) in Lambda(nq, subst b (add (Bound q) (Bound nq) [])) alphaconv t = raise Fail "Not an alpha-redex" fun betaconv (App(Lambda(q, b), t)) = subst b (add (Bound q) t []) betaconv t = raise Fail "Not a beta-redex" fun etaconv (Lambda(q, App(b, Bound(x)))) = if(q=x) then if(isclosed b) then b else raise Fail "Not an eta-redex" else raise Fail "Not an eta-redex" etaconv t = raise Fail "Not an eta-redex" Figure 3: Implementation of λ-calculus Rules to the replacement of variables, which is all that is needed to define the rules of the λ-calculus (de Bruijn, 1972; Barregt, 1984). To implement the textual substitution T [r/t] in the name-carrying notation, the variable names used in T must be recorded and compared with those occurring in r and those generated when renaming r. Using references, names already in use can be ignored, since reference creation always generates a unique name. In the namefree notation, textual substitution is difficult because of the different indices that represent a bound variable in different parts of a term. For example, the substitution (λx.t )[y/(fx)], where x is inted to be the variable bound by λx.t, involves examining (fx) to identify the occurrences of x and taking into account the changes to the indices of x, as the substitution descs through T, when comparing (fx) with the subterms of T. In a name-carrying notation, only textual equality is needed to compare terms involving bound variables. Rules The rules of the λ-calculus are implemented in terms of the substitution function subst. Function alphaconv carries out α-conversion of the term Lambda(q, b), creating a new binder q and forming a new body b by replacing Bound(q) with Bound(q ) in b to give the new term Lambda(q, b ). Note that function rename provides generalised α-conversion, renaming all binding terms occurring in its argument. Function betaconv implements β-conversion, applied to the term App(Lambda(q, b), t) it substitutes t for Bound(q) wherever it occurs in b. Finally, η-conversion is implemented by function etaconv which, applied to an initially closed term Lambda(q, App(b, Bound(q))), returns b after testing isclosed(b) to ensure that Bound(q) doesn t occur in b. The functions implementing the rules of the λ-calculus always return a closed term if their arguments are closed. Function alphaconv doesn t remove binding terms. Function betaconv collapses a binding term, replacing its bound variable with a given term t. If t is closed then so is the result of betaconv. With function etaconv, both the argument and the result must be closed for the function to succeed. 5

6 fun alphaequals trm1 trm2 = let fun aeql t1 t2 sb = case (t1, t2) of (Free(s1), Free(s2)) => s1=s2 (Bound(b1), Bound(b2)) => let val qv1 = (get t1 sb) handle NotFound => t1 in qv1=t2 (App(f1, a1), App(f2, a2)) => if aeql f1 f2 sb then aeql a1 a2 sb else false (Lambda(q1, b1), Lambda(q2, b2)) => aeql b1 b2 (add (Bound(q1)) (Bound(q2)) sb) => false in aeql trm1 trm2 [] Figure 4: Equality Under α-conversion Comparing Terms In the λ-calculus, terms t 1 and t 2 are considered equivalent if they are equal or can be made equal by renaming bound variables, the terms are α-convertible. In the namefree notation, the equivalence of terms can be determined using textual equality. In name-carrying notations, an α-equality operation must be defined to match bound variables in the two terms. This is implemented as function alphaequals, of Figure 4. The function descs through the structure of terms t 1 and t 2. If binding term λq 1.b 1 in t 1 matches the binding term λq 2.b 2 in t 2, the bound variable Bound(q 1 ) must appear t 1 wherever Bound(q 2 ) appears in t 2, with all other subterms matching exactly. Examples For the examples, the following values will be assumed: val x=binder "x" val y=binder "y" The Standard ML interpreter prints references in terms of their contents which means that it may not be obvious when references are distinct. To make clear the result of operations on terms, function displayrename of Figure 5 is used in the examples to replace the strings referred to by binders. It uses function inttoname to create a string from an integer. For example, the result of evaluating expression displayrename(lambda(x, Bound(x))) is Lambda(ref "a", Bound(ref "a")). α-conversion Renaming with α-conversion constructs a term distinct from its argument. val ac1=lambda(x, (Lambda(y, (App(Bound y, Bound x))))) val ac2=alphaconv ac1 Value ac1 represents the term (λx.λy.yx) and value ac2 is ac1 after renaming. Expression ac1=ac1 is true and ac1=ac2 is false, the terms are distinct under textual equality. The two terms are α-equal, alphaequals ac1 a2 is true. 6

7 fun inttoname i nm= let val numchars = 26 in let val ld = nmˆ(str (chr ((ord #"a")+(i mod numchars)))) and rm = i div numchars in if (rm=0) then ld else inttoname (i-numchars) ld fun displayrenamefull t i sb = case t of (Free( )) => t (App(f, a)) => App(displayRenameFull f i sb, displayrenamefull a i sb) (Bound(q)) => ((get t sb) handle NotFound => t) Lambda(q, b) => let val nq = binder (inttoname (!i) "") in i:=(!i)+1; Lambda(nq, displayrenamefull b i (add (Bound(q)) (Bound(nq)) sb)) fun displayrename t = displayrenamefull t (ref 0) [] Figure 5: Displaying Terms β-conversion β-conversion deps on function subst to ensure that name-capture is avoided. That this happens can be seen by constructing a λ-term, λx.λy.(yx), which is applied to itself: val bc1=lambda(x, (Lambda(y, (App (Bound y, Bound x))))) val bc2=app(bc1, bc1) val bc3=betaconv bc2 Value bc2 represents the term (λx.λy.(yx))(λx.λy.(yx)) and value bc3 is the result of applying β-conversion to reduce bc2 : Lambda(ref "y", App(Bound(ref "y"), Lambda(ref "x", Lambda(ref "y", App(Bound(ref "y"), Bound(ref "x")))))) Although this appears to show that the same binder is used by more than one binding term, evaluating displayrename bc3 makes clear that the bound variables are distinct and represent the term λa.a(λb.λc.(cb)): Lambda(ref "a", App(Bound(ref "a"), Lambda(ref "b", Lambda(ref "c", App(Bound(ref "c"), Bound(ref "b")))))) η-conversion η-conversion removes the outermost binding term if the bound variable is unused. val ec1=lambda(x, App(Lambda(y, Bound(y)), Bound(x))) val ec2=etaconv(ec1) 7

8 Value ec1 represents the term (λx.(λy.y)x) and value ec2 is the η-conversion of ec1, the term (λy.y): Lambda(ref "y", Bound(ref "y")) 4 Practical Issues The approach to representing λ-terms described here deps on the uniqueness of the binders appearing in terms. In a system using the λ-calculus, a term may persist for some time and have several copies. This means that the uniqueness of binders must be maintained as part of the system design, by renaming terms as necessary to ensure that each instance of a term is distinct from any other. This is the reverse of the situation with the namefree notation, where terms can be copied freely. Any type can be used as the base type referred to by binders. With the typed λ-calculus, for example, binders would be references to pairs which record variable names and types. However, a drawback of using references is that they are specific to a particular execution of a program and cannot be used in a subsequent program execution. Instead, translation to and from the namefree notation is necessary to allow terms to be stored for reuse. The main cost of using references is the need to rename terms in which binders occur. In the implementation of substitution given in Figure 2, replacement terms are always renamed and a straightforward optimisation is to test and memoise whether this renaming is necessary. This can be combined with the renaming operation so that that if rename does not make any changes to a term t, a flag is set to prevent a second attempt to rename t. Since the manipulation of terms is mainly carried out in terms of substitution, this optimisation should improve the performance of the term operations. 5 Conclusion Using references as the names in the name-carrying notation provides a representation of λ-terms which is simple to use. The implementation of a term operation can deal with subterms of a term individually while the name-capture problem is avoided by using the Standard ML runtime system to generate unique names. For most term operations, reference-carrying is more efficient than the standard name-carrying notation. An exception is the abstraction from a term T, to give a term λx.t [x/v] where v is a free variable in T. This can be significant for systems such as theorem provers where abstraction is one of the operations used to manipulate terms. In the name-carrying notation, it is enough to construct the abstraction λv.t, without performing the substitution, since free and bound variables have the same representation. In both the namefree notation and the reference-carrying notation, free and bound variables are distinct and the substitution of x for v must be carried out. However, this advantage is offset by the difficulty of maintaining unique names which makes operations involving the structure of a term, such as substitution, complicated and inefficient in the name-carrying notation. Both the namefree and the reference-carrying notation treat a term T as an instance of a set of terms which are equivalent to T. In the namefree notation, term T represents all terms equivalent to T and T is used directly in operations. In the reference-carrying notation, term T is used to generate an equivalent term T and it is T which is used in an operation. The need to generate an equivalent term makes reference-carrying less efficient than the namefree notation. However, a term operation in the namefree notation must take into account the different representations of a bound variable occurring in a term, complicating its implementation. This is avoided in name-carrying notations, including reference-carrying, where a bound variable has the same representation throughout a term. 8

9 The principal benefit of the reference-carrying notation is to preserve the advantages of a namecarrying notation while reducing the cost of manipulating terms. This should lead to term operations which approach the efficiency of those in the namefree notation while being simpler to implement. References Barregt, H. P. (1984). The Lambda Calculus: Its Syntax and Semantics. North-Holland. Church, A. (1941). The Calculi of Lambda Conversion. Princeton University Press. de Bruijn, N. G. (1972). Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation with application to the Church-Rosser theorem. Indagationes Mathematicae 34, Reprinted in: Selected Papers on Automath, edited by R.P. Nederpelt, J.H. Geuvers and R.C. de Vrijer, Studies in Logic, vol. 133, pp North-Holland Gordon, M. J. C. (1988). Progamming Language Theory and its Implementation. Prentice-Hall. Milner, R., Tofte, M. and Harper, R. (1990). The Definition of Standard ML. MIT Press. Paulson, L. C. (1991). ML for the Working Programmer. Cambridge University Press. 9