Downloaded 16 times
![Operational Semantics -- Evaluation
t1 t1'
/* congruence rule 1 */
t1 t2 t1' t2
t2 t2'
/* congruence rule 2 */
v1 t2 v1 t2'
(λx.t) v [x ↦ v]t /* computation rule */](https://image.slidesharecdn.com/introductiontothelambdacalculus-170119234004/85/Introduction-to-the-lambda-calculus-3-320.jpg)
![Applying not
(λa. a false true) true
(λa. a false true) (λt. λf. t)
(λt. λf. t) false true
false
(λx.t) v [x ↦ v]t
(from operational semantic rules)](https://image.slidesharecdn.com/introductiontothelambdacalculus-170119234004/85/Introduction-to-the-lambda-calculus-8-320.jpg)
![Operational Semantics -- Evaluation
t1 t1'
/* congruence rule 1 */
t1 t2 t1' t2
t2 t2'
/* congruence rule 2 */
v1 t2 v1 t2'
(λx.t) v [x ↦ v]t /* computation rule */](https://image.slidesharecdn.com/introductiontothelambdacalculus-170119234004/75/Introduction-to-the-lambda-calculus-3-2048.jpg)
![Applying not
(λa. a false true) true
(λa. a false true) (λt. λf. t)
(λt. λf. t) false true
false
(λx.t) v [x ↦ v]t
(from operational semantic rules)](https://image.slidesharecdn.com/introductiontothelambdacalculus-170119234004/75/Introduction-to-the-lambda-calculus-8-2048.jpg)
Uploaded byJack Fox
Introduction to the lambda calculus
This document introduces the lambda calculus through its history and key concepts. It describes Alonzo Church's development of the untyped and simply typed lambda calculus in the 1930s and 1940s as a foundation for logic and computation. It then explains the basic syntax and evaluation rules of the lambda calculus, how to represent data like booleans and numbers, and how to define common operations and recursion without built-in types or control structures.
More Related Content
Similar to Introduction to the lambda calculus
![[FLOLAC'14][scm] Functional Programming Using Haskell](https://cdn.slidesharecdn.com/ss_thumbnails/slides-140630030216-phpapp01-thumbnail.jpg?width=600ounds&width=560&fit=bounds)
Introduction to the lambda calculus
- 1. Introduction to theLambda Calculus Alonzo Church 1932, “A set of postulates for the foundation of logic”, a formal system with the aim of providing a foundation for logic which would be more natural than Russell’s type theory or Zermelo’s set theory, and would not contain free variables 1936 Church isolated and published just the portion relevant to computation, what is now called the untyped lambda calculus 1940, he also introduced a computationally weaker, but logically consistent system, known as the simply typed lambda calculus Re-discovered as a versatile tool in Computer Science by people like McCarthy, et al. in the 1960s
- 2. Operational Semantics --Syntax t ::= x /* variable */ λx.t /* abstraction */ t t /* application */ v ::= λx.t /* abstraction value */
- 3. Operational Semantics --Evaluation t1 t1' /* congruence rule 1 */ t1 t2 t1' t2 t2 t2' /* congruence rule 2 */ v1 t2 v1 t2' (λx.t) v [x ↦ v]t /* computation rule */
- 4. That’s it! No datastructures No control flow statements No strings, numbers, or even booleans Any questions?
- 5. Any questions? Like, howdo you do anything?
- 6. Church encoding representing dataand operators in the lambda calculus
- 7. Let’s start withthe booleans true = λt. λf. t false = λt. λf. f not = λa. a false true
- 8. Applying not (λa. afalse true) true (λa. a false true) (λt. λf. t) (λt. λf. t) false true false (λx.t) v [x ↦ v]t (from operational semantic rules)
- 9. β-reduction applying functions totheir arguments Normal order reduction – most well-known languages work from the leftmost, outermost, redex and work in, halting when the outermost argument can no longer be applied Redex – reducible expression Full β-reduction – reduce available redexes in any desired order
- 10. Full β-reduction λs.λz. (λs'.λz'.(λb. b) s' ((λt.λb. b) s' z')) s ((λs'.λz'. (λs''.λz''. (λb. b) s'' ((λt.λb. b) s'' z'')) s' ((λt.λb. b) s' z')) s z)
- 11. Full β-reduction λs.λz. (λs'.λz'.s' z') s ((λs'.λz'. (λs''.λz''. s'' z'') s' z') s z)
- 12. Full β-reduction λs.λz. s((λs'.λz'. (λs''.λz''. s'' z'') s' z') s z)
- 13. Full β-reduction λs.λz. s((λs'.λz'. s' z') s z)
- 14.
- 15. Back to thebooleans and = λa. λb. a b fls or = λa. λb. a tru b nand = λa. λb. not (and a b) xor = λa. λb. and (nand a b) (or a b) cond = λp. λt. λf. p t f /* i.e. if else */
- 16. and (λa. λb. ab fls) tru fls (λt. λf. t) (λt. λf. f) (λt. λf. f) λt. λf. f (λa. λb. a b fls) tru tru (λt. λf. t) (λt. λf. t) (λt. λf. f) λt. λf. t
- 17. Hooray! xnor = λa.λb. not (xor a b)
- 18. Now we haveassertions! xnor = λa. λb. not (xor a b) xnor tru (cond fls fls tru) xnor fls (cond fls tru fls)
- 19. Tuples pair = λf.λs. λb. b f s fst = λp. p tru snd = λp. p fls
- 20. Numbers c0 = λs.λz. z c1 = λs. λz. s z c2 = λs. λz. s (s z) c3 = λs. λz. s (s (s z)) … Just like Peano arithmetic
- 21. Operations on numbers iszro= λm. m (λx. fls) tru plus = λm. λn. λs. λz. m s (n s z) mult = λm. λn. m (plus n) c0 exp = λm. λn. n (mult m) c1 scc = λn. λs. λz. s (n s z) /* number successor */ /* number predecessor */ prd = λm. fst (m (λp. pair (snd p) (plus c1 (snd p))) (pair c0 c0)) eql = λm. λn. and (iszro (m prd n)) (iszro (n prd m))
- 22. Automating assertions /* itis true that ... */ xnor tru (eql c1 (exp c1 c1)) xnor tru (eql c6 (plus c2 c4)) xnor tru (eql c1 (fst (pair c1 tru)))
- 23. Lists Lists follow fromtuples and numbers (more on that another time)
- 24. Recursion fix (a.k.a theY-combinator) = λf. (λx. f (λy. x x y)) (λx. f (λy. x x y)) takes recursive abstraction λf. λx. __f__ Haskell Curry
- 25. Recursion (λf. (λx. f(λy. x x y)) (λx. f (λy. x x y))) (λf. λx. __) (bar) (λx. (λf. λx'. __) (λy. x x y)) (λx. (λf. λx'. __) (λy. x x y)) (bar) (foo) (λf. λx'. __) (λy. foo foo y) (bar) λx'. __ (bar)
- 26. Recursion fact = λf.λx. cond (iszro x) c1 (mult x (f (prd x))) (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) fact c3 /* successive interations */ (λy. (λx. f (λy'.x x y')) (λx. f (λy'.x x y')) y) (/* prev recurs*/)