lecture 17 lambda calculus [0.5em] (origin of programming...
TRANSCRIPT
![Page 1: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/1.jpg)
ENE4014: Programming Languages
Lecture 17 — Lambda Calculus
(Origin of Programming Languages)
Woosuk Lee2020 Spring
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 1 / 38
![Page 2: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/2.jpg)
Questions
Programming languages look very differentI C, C++, Java, OCaml, Haskell, Scala, JavaScript, etc
Are they different fundamentally?
Is there core mechanism underlying all programming languages?
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 2 / 38
![Page 3: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/3.jpg)
Syntactic Sugar
Syntactic sugar is syntax that makes a language “sweet”: it does notadd expressiveness but makes programs easier to read and write.
For example, we can “desugar” the let expression:
let x = E1 in E2desugar=⇒ (proc x E2) E1
Exercise) Desugar the program:
let x = 1 in
let y = 2 in
x + y
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 3 / 38
![Page 4: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/4.jpg)
Syntactic Sugar
Q) Identify all syntactic sugars of the language:
E → n| x| E + E| E − E| iszero E| if E then E else E| let x = E in E| letrec f(x) = E in E| proc x E| E E
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 4 / 38
![Page 5: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/5.jpg)
Lambda Calculus (λ-Calculus)
By removing all syntactic sugars from the language, we obtain aminimal language, called lambda calculus:
e → x variables| λx.e abstraction| e e application
Programming language = Lambda calculus + Syntactic sugars
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 5 / 38
![Page 6: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/6.jpg)
Origins of Programming Languages and Computer
In 1935, Church developed λ-calculus as a formal system for mathematicallogic and argued that any computable function on natural numbers can becomputed with λ-calculus (the model of programming languages).
In 1936, Turing independently developed Turing machine and argued thatany computable function on natural numbers can be computed with themachine (the model of computers)1.
Turing machine and lambda calculus appeared as byproducts of a
mathematicians dream.1http://ropas.snu.ac.kr/~kwang/4190.310/15/book-ch2.pdf (in Korean)
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 6 / 38
![Page 7: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/7.jpg)
What Mathematicians Dreamed About
Hillberts Entscheidungsproblem (1928 @ICM):
“Is there an algorithm to decide whether a given first-order statementis provable from the axioms using the inference rules? ”
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 7 / 38
![Page 8: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/8.jpg)
cf) Peano Arithmetic
Vocabulary:Σ = {0, 1,+, ·,=}
Axioms:
∀x. ¬(x+ 1 = 0)
∀x, y. x+ 1 = y + 1 =⇒ x = y
∀x. x+ 0 = x
∀x, y. x+ (y + 1) = (x+ y) + 1
∀x. x · 0 = 0
∀x, y. x · (y + 1) = x · y + x...
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 8 / 38
![Page 9: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/9.jpg)
cf) Peano Arithmetic
Theorem (Fermats Last Theorem)
∀x, y, z, n. x 6= 0 ∧ y 6= 0 ∧ z 6= 0 ∧ n > 2 =⇒ xn + yn 6= zn
Proposed by Fermat in 1637.
Completely proved by Wiles in 1995.
Can we automate the proof search? (Hillberts problem)
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 9 / 38
![Page 10: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/10.jpg)
Godels Incompleteness Theorems (1931)
A complete and consistent set of axioms for all mathematics is impossible.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 10 / 38
![Page 11: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/11.jpg)
Direct Proofs by Turing and Church
In 1936, Alonzo Church and Alan Turing directly showed that a generalsolution to the decision problem is impossible.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 11 / 38
![Page 12: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/12.jpg)
Overview of Turing Machines (Turings Definition of Computation)
Examples:
A machine to write the sequence 001011011101111011111 . . .
A machine to add 2 and 3: given a tape “*11*111*”, writes“*11*111*11111*”.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 12 / 38
![Page 13: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/13.jpg)
Overview of Turing Machines
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 13 / 38
![Page 14: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/14.jpg)
Universal Turing Machine
The culmination of Turings work.
UTM is a Turing machine that can simulate an arbitrary Turing machineon an arbitrary input.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 14 / 38
![Page 15: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/15.jpg)
Turing’s Proof
Turing reduced the halting problem for Turing machines to thedecision problem.
H: the Turing machine that solves the halting problem
A: the Turing machine that solves the decision problem
A =⇒ H
H is logically impossible.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 15 / 38
![Page 16: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/16.jpg)
Church’s Proof
Church proved that there is no function which decides for two givenlambda calculus expressions whether they are equivalent or not.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 16 / 38
![Page 17: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/17.jpg)
Church-Turing Thesis
A surprising fact is that the classes of λ-calculus and Turing machinescan compute coincide even though they were developed independently.
Church and Turing proved that the classes of computable functionsdefined by λ-calculus and Turing machine are equivalent.
In other words, Turing machine and lambda calculus are equallypowerful.
A function is λ-computable if and only if Turing computable.
This equivalence has led mathematicians and computer scientists tobelieve that these models are “universal”: A function is computable ifand only if λ-computable if and only if Turing computable.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 17 / 38
![Page 18: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/18.jpg)
Impact of λ-Calculus
λ-calculus had immense impacts on programming languages.
It has been the core of functional programming languages (e.g., Lisp,ML, Haskell, Scala, etc).
Lambdas in other languages:I Java8
(int n, int m) -> n + m
I C++11[](int x, int y) { return x + y; }
I Python(lambda x, y: x + y)
I JavaScriptfunction (a, b) { return a + b }
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 18 / 38
![Page 19: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/19.jpg)
Syntax of Lambda Calculus
e → x variables| λx.e abstraction| e e application
Examples:
x y zλx.x λx.y λx.λy.x
x y (λx.x) z x λy.z ((λx.x) λx.x)
Conventions when writing λ-expressions:1 Application associates to the left, e.g., s t u = (s t) u2 The body of an abstraction extends as far to the right as possible, e.g.,λx.λy.x y x = λx.(λy.((x y) x))
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 19 / 38
![Page 20: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/20.jpg)
Bound and Free Variables
An occurrence of variable x is said to be bound when it occurs insideλx, otherwise said to be free.
I λy.(x y)I λx.xI λz.λx.λx.(y z)I (λx.x) x
Expressions without free variables is said to be closed expressions orcombinators.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 20 / 38
![Page 21: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/21.jpg)
Evaluation
To evaluate λ-expression e,
1 Find a sub-expression of the form:
(λx.e1) e2
Expressions of this form are called “redex” (reducible expression).
2 Rewrite the expression by substituting the e2 for every freeoccurrence of x in e1:
(λx.e1) e2 → [x 7→ e2]e1
This rewriting is called β-reduction
Repeat the above two steps until there are no redexes.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 21 / 38
![Page 22: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/22.jpg)
Evaluation
λx.x
(λx.x) y
(λx.x y)
(λx.x y) z
(λx.(λy.x)) z
(λx.(λx.x)) z
(λx.(λy.x)) y
(λx.(λy.x y)) (λx.x) z
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 22 / 38
![Page 23: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/23.jpg)
Substitution
The definition of [x 7→ e1]e2:
[x 7→ e1]x = e1[x 7→ e1]y = y
[x 7→ e1](λy.e2) = λz.[x 7→ e1]([y 7→ z]e2) (new z)[x 7→ e1](e2 e3) = ([x 7→ e1]e2 [x 7→ e1]e3)
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 23 / 38
![Page 24: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/24.jpg)
Evaluation Strategy
In a lambda expression, multiple redexes may exist. Which redex toreduce next?
λx.x (λx.x (λz.(λx.x) z)) = id (id (λz.id z))
redexes:id (id (λz.id z))
id (id (λz.id z))
id (id (λz.id z))
Evaluation strategies:I Normal orderI Call-by-nameI Call-by-value
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 24 / 38
![Page 25: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/25.jpg)
Normal order strategy
Reduce the leftmost, outermost redex first:
id (id (λz.id z))
→ id (λz.id z))
→ λz.id z→ λz.z6→
The evaluation is deterministic.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 25 / 38
![Page 26: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/26.jpg)
Call-by-name strategy
Follow the normal order reduction, not allowing reductions insideabstractions:
id (id (λz.id z))
→ id (λz.id z))
→ λz.id z6→
The call-by-name strategy is non-strict (or lazy) in that it evaluatesarguments that are actually used.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 26 / 38
![Page 27: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/27.jpg)
Call-by-value strategy
Reduce the outermost redex whose right-hand side has a value (a termthat cannot be reduced any further):
id (id (λz.id z))
→ id (λz.id z))
→ λz.id z6→
The call-by-name strategy is strict in that it always evaluates arguments,whether or not they are used in the body.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 27 / 38
![Page 28: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/28.jpg)
Compiling to Lambda Calculus (with Normal Order Strategy)
Consider the source language:
E → true| false| n| x| E + E| iszero E| if E then E else E| let x = E in E| letrec f(x) = E in E| proc x E| E E
Define the translation procedure from E to λ-calculus.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 28 / 38
![Page 29: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/29.jpg)
Compiling to Lambda Calculus (with Normal Order Strategy)
E: the translation result of E in λ-calculus
true = λt.λf.tfalse = λt.λf.f
0 = λs.λz.z1 = λs.λz.(s z)n = λs.λz.(sn z)x = x
E1 + E2 = (λn.λm.λs.λz.m s (n s z)) E1 E2
iszero E = (λm.m (λx.false) true) E
if E1 then E2 else E3 = E1 E2 E3
let x = E1 in E2 = (λx.E2) E1
letrec f(x) = E1 in E2 = let f = Y (λf.λx.E1) in E2
proc x E = λx.E
E1 E2 = E1 E2
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 29 / 38
![Page 30: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/30.jpg)
Correctness of Compilation
Theorem
For any expression E,[[E]] = [[E]]
where [[E]] denotes the value that results from evaluating E.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 30 / 38
![Page 31: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/31.jpg)
Examples: Booleans
if true then 0 else 1 = true 0 1= (λt.λf.t) 0 1= 0= λs.λz.z
Note that
[[if true then 0 else 1]] = [[if true then 0 else 1]]
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 31 / 38
![Page 32: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/32.jpg)
Church Booleans
Logical “and”:and = λb.λc.(b c false)
and true true = trueand true false = falseand false true = falseand false false = false
Logical “or”:or = λb.λc.(b true c)
or true true = trueor true false = trueor false true = trueor false false = false
Logical “not”:not = λb.(b false true)
not true = falsenot false = true
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 32 / 38
![Page 33: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/33.jpg)
Pairs
Using booleans, we can encode pairs of values.
pair v w : create a pair of v and wfst p : select the first component of p
snd p : select the second component of p
Definition:pair = λf.λs.λb.b f s
fst = λp.p truesnd = λp.p false
Example:
fst (pair v w) = fst ((λf.λs.λb.b f s) v w)= fst (λb.b v w)= (λp.p true) (λb.b v w)= (λb.b v w) true= true v w= v
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 33 / 38
![Page 34: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/34.jpg)
Church Numerals
1 + 2 = (λn.λm.λs.λz.m s (n s z)) 1 2= λs.λz.(2 s (1 s z))= λs.λz.(2 s (λs.λz.(s z) s z))= λs.λz.(2 s (s z))= λs.λz.((λs.λz.(s (s z))) s (s z))= λs.λz.(s (s (s z)))= 3
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 34 / 38
![Page 35: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/35.jpg)
Church Numerals
Multiplication:
E1 × E2 = (λm.λn.m (+ n) 0 E1 E2
Example:1× 2 = (λm.λn.m (+ n) 0) 1 2
= 1 (+ 2) 0= (λs.λz. s z) (+ 2) 0= (+ 2) 0= (λm.λs.λz.m s (2 s z)) 0= λs.λz.(0 s (2 s z))= λs.λz.((λs.λz.z) s (2 s z))= λs.λz.2 s z= λs.λz.((λs.λz.s (s z)) s z)= λs.λz.s (s z) = 2
Power (nm):λm.λn.m (× n) 1
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 35 / 38
![Page 36: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/36.jpg)
Recursion
For example, the factorial function
f(n) = if n = 0 then 1 else n ∗ f(n− 1)
is encoded by
fact = Y (λf.λn.if n = 0 then 1 else n ∗ f(n− 1))
where Y is the Y-combinator (or fixed point combinator):
Y = λf.(λx.f (x x))(λx.f (x x))
Then, fact n computes n!.
Recursive functions can be encoded by composing non-recursivefunctions!
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 36 / 38
![Page 37: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/37.jpg)
Recursion
Let F = λf.λn.if n = 0 then 1 else n ∗ f(n− 1) andG = λx.F (x x).
fact 1= (Y F ) 1= (λf.((λx.f(x x))(λx.f(x x))) F ) 1= ((λx.F (x x))(λx.F (x x))) 1= (G G) 1= (F (G G)) 1= (λn.if n = 0 then 1 else n ∗ (G G)(n− 1)) 1= if 1 = 0 then 1 else 1 ∗ (G G)(1− 1))= if false then 1 else 1 ∗ (G G)(1− 1))= 1 ∗ (G G)(1− 1)= 1 ∗ (F (G G))(1− 1)= 1 ∗ (λn.if n = 0 then 1 else n ∗ (G G)(n− 1))(1− 1)= 1 ∗ if (1− 1) = 0 then 1 else (1− 1) ∗ (G G)((1− 1)− 1)= 1 ∗ 1
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 37 / 38
![Page 38: Lecture 17 Lambda Calculus [0.5em] (Origin of Programming …psl.hanyang.ac.kr/~wslee/courses/ene4014/lec17.pdf · 2020-03-30 · Lecture 17 | Lambda Calculus (Origin of Programming](https://reader033.vdocuments.mx/reader033/viewer/2022060301/5f085d967e708231d421a6be/html5/thumbnails/38.jpg)
Summary
Programming language = Lambda calculus + Syntactic sugars
λ-calculus is a minimal programming language.I Syntax: e→ x | λx.e | e eI Semantics: β-reduction
Yet, λ-calculus is Turing-complete.
Woosuk Lee ENE4014 2020 Spring, Lecture 17 March 30, 2020 38 / 38