The λ-calculus and Curry s Paradox Drew McDermott , revised

Transcription

1 The λ-calculus and Curry s Paradox Drew McDermott drew.mcdermott@yale.edu , revised The λ-calculus was invented by Alonzo Church, building on earlier work by Gottlob Frege and Moses Schönfinkel. It can be considered from several vantage points: 1. As a model of computation 2. As a way to add computation to formal logic 3. As a tool for understanding the foundations of mathematics Church was interested in all three, but we ll focus on the second topic, following the lead of Richard Montague, who used a complex modal logic with λ-conversion in his extremely influential work on the semantics of natural language. This will be our focus for much of the course. For now, let s just think about the predicate calculus; we won t even need quantifiers. In propositional logic, letters denote arbitrary truth-valued propositions, which are then combined into familiar constructions: P ( not P ), P Q ( P and Q ), and P Q ( P or Q or both ). P Q is a useful abbreviation for P Q, usually read as if P then Q or P only if Q. In predicate calculus, we add structure to propositions. An atomic formula is a proposition of the form p(t 1,..., t k ), where p is a predicate symbol and each t i is a term. In the simplest formulation, terms are just variables or constants, as in q(x, a). (Items in this font are vocabulary items from a particular theory. Variables, such as x, are usually bound by quantifiers, which we re not focusing on.) For many purposes, we begin to need more complex terms, of the form f(t 1,..., t k ), such as cons, as in heirs(henry viii, cons(mary i, cons(edward vi, cons(elizabeth i, nil)))) The term cons(x, l) denotes the list l but with one more element, x, tacked onto the front. It s important for computer-science students to realize that that s all there is to it: the term does not denote a computation wherein a procedure called cons is called to do something to the results of computation x and computation l. (Similarly, married(henry viii, catherine of aragon) 1

2 denotes T or F, not a procedure for checking whether Henvry VIII was actually married to his first wife, or if the marriage didn t count, as Henry eventually claimed.) We introduce computation into the system by providing axioms concerning the equality relation, =(x, y), but syntactically sugared as x = y. (One such axiom is that x = x, but we re missing the For all x part until we have quantifiers.) Whether we need special inference rules for equality depends on exactly how we organize things, but it will be convenient to introduce the rule of substitution of equals for equals: If you can infer t = u from premises Γ, where t and u are arbitrry terms, and you can infer α[t] from Γ, where α[t] is an arbitrary formula with an occurrence of t as a term, then you can infer α[u], where α[u] has that occurrence replaced by u. Symbolically: Γ t = u Γ α[t] Γ α[u] where Γ... means that... can be inferred using premises Γ. This is where the λ-calculus comes in. It s a way of describing functions in a computational sense, as transformations of terms into other terms. It introduces a new kind of term, called a λ-expression, whose abstract syntax is λvt, where v is a variable and t is a term. There are several possible ways to write this in surface syntax. I ll write it with a dot after the v and often put parentheses around it. We already have terms of the form f(t,...), but in the λ-calculus all functions have exactly one variable, so the application of f to t is written f t. This sort of function application associates to the left, so fa 1 a 2 means (f a 1 ) a 2. For this to make sense, f must be the sort of thing denoted by a λ-expression of the form (λx 1.λx 2.e), that is, a function of one argument whose value is itself a function of one argument. 1 Such a function is said to be curried, implying that one has a two-argument function in mind that it really is. 2 1 Why resort to the clumsy phrase must be the sort of thing denoted by? Why not just say f must be a λ-expression? Because f might be a variable that might eventually be replaced by a λ-expression; or a function application that might reduce to a λ-expression (see below). 2 Because we started with n-argument functions and now have functions that take just one, it looks like we re allowing two different notations for function application into the language? That s probably a bad idea, so what follows may be seen as a digression into a version of predicate calculus in which everything is curried. Or you can put parentheses around every argument in the λ-calculus, writing f 1f 2 t as f 1(f 2)(t). (This actually what a curried-function application looks like in Scala.) Another possible tactic is to treat 2

3 The main rule of the λ-calculus is β-conversion: Some subterm (λv.t)t is transformed to t[t /v], that is, every occurrence of v replaced by t (sometimes written t[v:=t ]). This may seem like a fairly trivial thing to do, but, because every occurrence of v is replaced by t, it allows for the proliferation of occurrences of t. An occurrence of a term of the form (λv.t)t is called a redex (for reducible expression ). When a redex is β-converted, the new term replaces it in the λ term it s a subterm of. Several caveats are in order. The only occurrences of v that are actually replaced are those that are free in t. An occurrence of a variable v is free in a term if it doesn t occur inside the scope of a binding of v. Currently the only variable binder we have is λ. More subtly, in making the replacement, one must be careful that no occurrence of a variable free in t becomes bound. See the textbook for examples. If necessary, variables in t are renamed to avoid such collisions (a process Church called α-conversion, in case you re keeping score). We connect the λ-calculus to the predicate calculus by interpreting β- convertibility as a form of equality. That is, if term t 1 can be converted to t 2 via a series of β-conversions, then we can infer t 1 = t 2 : t 1 β t 2 t 1 = t 2 (t 1 β t 2 is read, t 1 is β-reducible to t 2.) We can use the conclusion of this rule as a premise to our equality-substitution rule. There s a lot more to be said about logic and about the λ-calculus, but we re already in trouble. We need two more inference rules, modus ponens: and reductio ad absurdum: α α β β Γ, α α Γ α If from the assumption that something is false you can derive a contradiction, then you can infer that it is true. functions that really take n > 1 arguments as a function of one argument, an n-tuple. Then f(x 1,..., x n) is syntactic sugar that saves us from actually having to deconstruct tuples. (This is how Haskell and ML construe uncurried multi-argument functions on the rare occasions when they indulge in them.) Of course, this idea requires us to introduce tuples into our ontology, which we have no other reason to do. 3

4 The trouble that arises is called Curry s Paradox, after Haskell B. Curry, an American logician who studied with David Hilbert and Paul Bernays. 3 We start by assuming the term ((λx.(xx) 0 = 1)(λx.(xx) 0 = 1)) in order to derive a contradiction from it. Use the β-equality-substitution rule to infer (((λx.(xx) 0 = 1)(λx.(xx) 0 = 1)) 0 = 1) which, by the rules of propositional logic, is the same as ((λx.(xx) 0 = 1)(λx(xx) 0 = 1)) (0 = 1) But the first conjunct is the negation of our assumption! reductio ad absurdum, we may conclude Hence, by Then, by β-conversion: ((λx.(xx) 0 = 1)(λx(xx) 0 = 1)) ((λx.(xx) 0 = 1)(λx.(xx) 0 = 1)) 0 = 1 Fianlly, by modus ponens: 0 = 1 Got that? It helps if we introduce the abbreviation R to stand for the key term (λx.(xx) 0 = 1). Then RR β ((RR) 0 = 1). The first phase was to assume (RR) and derive ((RR) 0 = 1), which is equivalent to (RR) (0 = 1), a contradiction. Hence, RR. But β-converting again, we can infer (RR) 0 = 1, and hence (via modus ponens) 0 = 1. Clearly, there is something wrong with a term X that is equivalent to X A, where A is some arbitrary proposition. (Replace 0=1 by any proposition you like.) The usual diagnosis is that R contains the subterm (xx), that is, that the term x is applied to itself. The cure is type theory. 3 Curry worked in the area of combinatory logic rather than the λ-calculus, although the two are closely related. The programming language Haskell perhaps should have been called Alonzo. By the way, currying was also named after Curry, but by programminglanguage researchers, decades after the idea was employed by Schönfinkel, Church, and, eventually, Curry, whose name apparently lends itself to term coinage better than most. 4

5 Type theory was invented by Bertrand Russell in order to cure Russell s Paradox, a similar problem in set theory. The idea is to label terms with types, and allow the term f t only if f has type a b and t has type a (in which case f t itself has typed b). There s no way for the variable x to have both the type a b and the type a for any a or b, so xx is untypeable 4 and hence the paradox cannot get started. 5 Sources: Wikipedia URL = paradox and J.C. Beall 2013 Curry s Paradox, in Edward N. Zalta (ed.) The Stanford Encyclopedia of Philosophy, (Spring 2013 Edition), URL = 4 Okay, this is too simple. But it ll do for now. But what does untypeable mean? Does it mean that xx is syntactically ill-formed? Or does it mean that xx is syntactically okay, but meaningless? It s safer to go with the first alternative, but the second will work, too. 5 Of course, making theories consistent by removing bugs as they pop up works no better than making programs bug-free using the same method. 5