Lecture 5:  Lambda Calculus                                                                      See lambda calculus cheat 
                                                CSC 131                                                                sheet on “links” page of 
                                               Fall, 2011                                                                      course web page!
                                              Kim Bruce
                           Pure Lambda Calculus                                                                                   Computability
                    • Terms of pure lambda calculus
                       - M ::= v | (M M) | λv. M
                       - Provide theoretical foundations for functional                                          • Can encode all computable functions in pure 
                         languages.                                                                                 untyped lambda calculus.
                       - Turing-complete                                                                             - true = λ u. λ v. u 
                    • Reduction rules for lambda calculus:                                                           - false = λ u. λ v. v
                        (α) λx. M  → λy. ([y/x] M), if y ̸∉ FV(M).                                                   - cond = λ u. λ v. λ w. u v w
                        (β) (λx. M) N → [N/x] M. 
                        (η) λx. (M x)  → M.     Optional rule
                                Lambda Encoding                                                                              Encoding Integers
                                                                                                                 • Integers:
                    • Pairing:                                                                                       - 0 = λ s. λ z. z. 
                         Pair = λ m. λ n. λ b. cond b m n.                                                           - 1 = λ s. λ z. s z. 
                       -                                                                                             - 2 = λ s. λ z. s (s z). 
                       - fst = λp. p true 
                       - snd = λp. p false                                                                       • Integers encode repetition:
                                                                                                                     - 2 f x = f (f x)
                                                                                                                                (n)
                                                                                                                     - n f x = f   (x)
                                         Arithmetic                                                                                      Predecessor
                    • Succ = λ n. λ s. λ z. s (n s z)                                                                • PZero = <0,0> = Pair 0 0
                        - Succ n = λ s. λ z. s (n s z) = λ s. λ z. s (s(n) z) = n+1                                  • PSucc = λ n. Pair (snd n) (Succ (snd n))
                    • Plus = λ n. λ m. λ s. λ z. m s (n s z).                                                           - PSucc PZero = 
                    • Mult = λ n. λ m. (m ( Plus n) 0).                                                                 - n PSucc PZero =  for n > 0
                    • isZero = λ n. n (λ x. false) true                                                              • Pred = λ n. fst (n PSucc PZero)
                                                                                                                        - Pred n = n - 1, for n > 0, 
                    • Subtraction is hard!!                                                                             - Pred 0 = 0
                                           Recursion                                                                                    Fixed Points
                    • Recursive definitions are handy                                                                 • Several fixed point operators:
                        - fact = λn. cond (isZero n) 1 (Mult n (fact (Pred n)))                                         - Ex:  Y = λf . (λx. f (xx))(λx. f (xx)) 
                        - Not a definition because can’t name functions!                                              • Claim for all g,   Y g = g (Y g)
                    • Let F stand for the closed term:                                                                     Y g = λf . (λx. f (xx))(λx. f (xx)) g 
                        - λf. λn. cond (isZero n) 1 (Mult n (f (Pred n)))                                                         = (λx. g(xx))(λx. g(xx)) 
                        - Notice F(fact) = fact.                                                                                  = g((λx. g(xx))(λx. g(xx))) 
                        - fact is a fixed point of F                                                                               = g (Y g)
                        - To find fact, need only find fixed point of F!                                                  If let x  = Y g, then g (x ) = x .
                                                                                                                     •           0                      0       0
                                            Factorial                                                                        Computing Factorials
                    • Recursive definition:                                                                           fact 1 = (F (fact)) 1    because fact is a fixed point of F 
                  - let F = λf. λn. cond (isZero n) 1 (Mult n (f (Pred n)))                                                   = (λn. cond (isZero n) 1 (Mult n (fact (Pred n)))) 1        
                  - let fact  = Y F                                                                                                                                                                                 expanding F
                  - then F(fact) = fact                                                                                       = cond (isZero 1) 1 (Mult 1 (fact (Pred 1))) applying it
                    • Compute:                                                                                                = Mult 1 (fact (Pred 1)) by the definition of cond 
                     fact 0 = (F (fact)) 0    because fact is a fixed point of F                                               = fact 0              by the definition of Mult and Pred 
                                 = cond (isZero 0) 1 (Mult 0 (fact (Pred 0)))                                                 = 1                       by the above calculation 
                                 = 1 by the definition of cond
                                                                                                        Lambda Calculus
                                                                                             • λ-calculus invented in 1928 by Church in 
                                                                                               Princeton & first published in 1932.
                              Some History                                                   • Goal to provide a foundation for logic
                                                                                             • First to state explicit conversion rules.
                                                                                             • Original version inconsistent, but corrected
                                                                                             • 1933, definition of natural numbers
                              Collaborators                                                               Undecidability
                • 1931-1934: Grad students:  
                   - J. Barkley Rosser and Stephen Kleene                                    • Convertibility problem for λ-calculus 
                   - Church-Rosser confluence theorem ensured                                   undecidable.
                     consistency (earlier version inconsistent)                              • Validity in first-order predicate logic 
                   - Kleene showed λ-definable functions very rich                              undecidable.
                      • Equivalent to Herbrand-Gödel recursive functions
                      • Equivalent to Turing-computable functions.                           • Proved independently year later by Turing.
                      • Founder of recursion theory, invented regular expressions               - First showed halting problem undecidable
                • Church’s thesis: 
                   - λ-definability ≡ effectively computable
                                Alan Turing                                                          Combinatory Logic
                • Turing                                                                     • Schönfinkel - get rid of bound variables
                   - 1936, in Cambridge, England, definition of Turing                        • Combinators K, S sufficient to write all 
                     machine                                                                   computable functions:
                   - 1936-38, in Princeton to get Ph.D. under Church.                           - K x y = x
                   - 1937, first published fixed point combinator                                 - S x y z = (x y)(x z)
                   - Kleene did not use fixed-point operator in defining a%                      CL terms include K, S, variables and all terms 
                     recursive functions on natural numbers!                                 •
                   - Broke German enigma code in WW2, Turing test AI                           created by function application.
                   - Persecuted as homosexual, committed suicide in 1954                     • All computable fcns, equivalent to λ-calculus
                                                                                                                                        Types
                                                                                                              • Start with base type e and build up types and 
                                                                                                                 terms:
                        Typed Lambda Calculus                                                                     - Type ::= e | Type → Type
                                                                                                                  - M ::= v | (M M) | λv : Type. M
                                                                                                              • Examples:
                                                                                                                  - Types: e, e → e, e → e → e, (e → e) → e, ...
                                                                                                                  - Terms:  λx: e. x,    λf: e → e. λz: e. f(f(z))
                                       Definitions                                                                         Totally Awesome!!
                   • Earlier definitions generalize over types t:
                              t                                                                               • Theorem:  If M is a term of the typed lambda 
                       - true  = λx:t. λy:u. x                                                                   calculus, then M has a unique normal form.  
                          t                    (n)
                       - n  = λs: t→t. λz: t. s  (z)                                                             I.e., every term of the typed lambda calculus is total.
                   • Some untyped terms can’t be typed:                                                       • Corollary:  The typed lambda calculus does not 
                       - Ω = (λx. (x x))(λx. (x x))                                                              include all computable functions.
                       - Y = λf . (λx. f (x x))(λx. f (x x))