1. Lecture 6: Lambda Calculus
God created the integers – all else is the result of man.
Leopold Kronecker
God created application – all else is the result of man.
Alonzo Church (not really)
Background
just got here last week
finished degree at MIT week before
Philosophy of advising students
don’t come to grad school to implement someone else’s idea
can get paid more to do that in industry
learn to be a researcher
important part of that is deciding what problems and ideas are worth spending time on
grad students should have their own project
looking for students who can come up with their own ideas for research
will take good students interested in things I’m interested in – systems, programming languages & compilers, security
rest of talk – give you a flavor of the kinds of things I am interested in
meant to give you ideas (hopefully even inspiration!) but not meant to suggest what you should work on
CS655: Programming Languages
University of Virginia
Computer Science
David Evans

2. Language Complexity and Brain Cell Decay
English
(OED: 500,000 words)
C++
(680 pages)
(Number of Morphemes)
Language Complexity
Scheme
(50 pages)
??? (.5 page)
Years Spent in School
6 Feb 2001
CS 655: Lecture 6

3. Complexity in Scheme Special Forms Primitives Evaluation Complexity
if, cond, define, etc.
Primitives
Numbers (infinitely many)
Booleans: #t, #f
Functions (+, -, and, or, etc.)
Evaluation Complexity
Environments (more than ½ of our interpreter)
If we have lazy evaluation,
(and don’t care about abstraction) we don’t need these.
Hard to get rid of?
Can we get rid of all this and still have a useful language?
6 Feb 2001
CS 655: Lecture 6

4. -calculus Alonzo Church, 1940 term = variable | term term | (term)
(LISP was developed from -calculus, not the other way round.)
term = variable
| term term
| (term)
|  variable . term
6 Feb 2001
CS 655: Lecture 6

5. Mystery Function (Teaser)
p  xy.  pca.pca (x.x xy.x) x) y
(p ((x.x xy.y) x) (x. z.z (xy.y) y)
m  xy.  pca.pca (x.x xy.x) x) x.x
(p y (m ((x.x xy.y) x) y))
f  x.
 pca.pca ((x.x xy.x) x)
(z.z (xy.y) (x.x))
(m x (f ((x.x xy.y) x))) if
x = 0 1
x * f (x – 1)
6 Feb 2001
CS 655: Lecture 6

6. Evaluation Rules -reduction (renaming) y. M  v. (M [y v])
where v does not occur in M.
-reduction (substitution)
(x. M)N   M [ x N ]
6 Feb 2001
CS 655: Lecture 6

7. Identity () x  y if x and y are same name
M1 M2  N1 N if M1  N1  M2  N2
(M)  (N) if M  N
x. M  y. N if x  y  M  N
6 Feb 2001
CS 655: Lecture 6

8. Defining Substitution ( )
x [x N]  N
y [x N]  y where x  y
M1 M2 [x N]  M1 [x N] M2 [x N]
(x. M) [x N]  x. M
6 Feb 2001
CS 655: Lecture 6

9. Defining Substitution ( )
(y. M) [x N]  y. (M [x N])
where x  y and y does not appear free in N or x does not appear free in M.
(y. M) [x N]  z. (M [y z]) [x N]
where x  y, z  x and z  y and z does not appear in M or N, x does occur free in M and y does occur free in N.
6 Feb 2001
CS 655: Lecture 6

10. Reduction (Uninteresting Rules)
y. M  v. (M [y v])
where v does not occur in M.
M  M
M  N  PM  PN
M  N  MP  NP
M  N  x. M  x. N
M  N and N  P  M  P
6 Feb 2001
CS 655: Lecture 6

11. -Reduction (the source of all computation)
(x. M)N  M [ x N ]
6 Feb 2001
CS 655: Lecture 6

12. Recall Apply in Scheme
“To apply a procedure to a list of arguments, evaluate the procedure in a new environment that binds the formal parameters of the procedure to the arguments it is applied to.”
We’ve replaced environments with substitution.
We’ve replaced eval with reduction.
6 Feb 2001
CS 655: Lecture 6

13. Some Simple Functions I  x.x C  xy.yx Abbreviation for x.(y. yx)
CII = (x.(y. yx)) (x.x) (x.x)
 (y. y (x.x)) (x.x)
 x.x (x.x)
 x.x
= I
6 Feb 2001
CS 655: Lecture 6

14. Evaluating Lambda Expressions
redex: Term of the form (x. M)N
Something that can be -reduced
An expression is in normal form if it contains no redexes (redices).
To evaluate a lambda expression, keep doing reductions until you get to normal form.
6 Feb 2001
CS 655: Lecture 6

15.  f. (( x.f (xx)) ( x. f (xx)))
Example
 f. (( x.f (xx)) ( x. f (xx)))
6 Feb 2001
CS 655: Lecture 6

16. Alyssa P. Hacker’s Answer
( f. (( x.f (xx)) ( x. f (xx)))) (z.z)
 (x.(z.z)(xx)) ( x. (z.z)(xx))
 (z.z) ( x.(z.z)(xx)) ( x.(z.z)(xx))
 (x.(z.z)(xx)) ( x.(z.z)(xx))
 ...
6 Feb 2001
CS 655: Lecture 6

17. Ben Bitdiddle’s Answer
( f. (( x.f (xx)) ( x. f (xx)))) (z.z)
 (x.(z.z)(xx)) ( x. (z.z)(xx))
 (x.xx) (x.(z.z)(xx))
 (x.xx) (x.xx)
 ...
6 Feb 2001
CS 655: Lecture 6

18. Be Very Afraid! Some -calculus terms can be -reduced forever!
The order in which you choose to do the reductions might change the result!
6 Feb 2001
CS 655: Lecture 6

19. Take on Faith (for now)
All ways of choosing reductions that reduce a lambda expression to normal form will produce the same normal form (but some might never produce a normal form).
If we always apply the outermost lambda first, we will find the normal form is there is one.
This is normal order reduction – corresponds to normal order (lazy) evaluation
6 Feb 2001
CS 655: Lecture 6

20. T  xy. x F  xy. y if  pca . pca Who needs primitives? 6 Feb 2001
CS 655: Lecture 6

21. Evaluation if T M N T  xy. x F  xy. y if  pca . pca
((pca . pca) (xy. x)) M N
 (ca . (x.(y. x)) ca)) M N
   (x.(y. x)) M N
 (y. M )) N   M
6 Feb 2001
CS 655: Lecture 6

22. Who needs primitives? and  xy. if x y F or  xy. if x T y
6 Feb 2001
CS 655: Lecture 6

23. Coupling [M, N]  z.z M N first  p.p T second  p.p F first [M, N]
= p.p T (z.z M N)   (z.z M N) T
= (z.z M N) xy. x   (xy. x) M N   M
6 Feb 2001
CS 655: Lecture 6

24. Tupling n-tuple: [M] = M
[M0,..., Mn-1, Mn] = [M0, [M1 ,..., [Mn-1, Mn ]... ]
n-tuple direct:
[M0,..., Mn-1, Mn] = z.z M0,..., Mn-1, Mn
Pi,n = x.x Ui,n
Ui,n = x0... xn. xi
What is P1,2?
6 Feb 2001
CS 655: Lecture 6

25. Primitives What about all those pesky numbers? 6 Feb 2001
CS 655: Lecture 6

26. What are numbers? We need three (?) functions:
succ: n  n + 1
pred: n  n – 1
zero?: n  (n = 0)
Is that enough to define add?
6 Feb 2001
CS 655: Lecture 6

27. Adding for Post-Docs add  xy.if (zero? x) y (add (pred x) (succ y)
6 Feb 2001
CS 655: Lecture 6

28. Counting 0  I 1  [F, I] 2  [F, [F, I]] 3  [F, [F [F, I]] ...
n + 1  [F, n]
6 Feb 2001
CS 655: Lecture 6

29. Arithmetic Zero?  x.x T Zero? 0 = (x.x T) I = T
Zero? 1 = (x.x T) [F, I] = F
succ  x.[F, x]
pred  x.x F
pred 1 = (x.x F) [F, I] = [F, I]F = I = 0
pred 0 = (x.x F) I = IF = F
6 Feb 2001
CS 655: Lecture 6

30. Factorial mult  xy. if (zero? x) 0 (add y (mult (pred x) y)) fact 
x. if (zero? x) 1
(mult x (fact (pred x)))
Recursive definitions should make you uncomfortable.
Need for definitions should also bother you.
6 Feb 2001
CS 655: Lecture 6

31. Summary
All you need is application and abstraction and you can compute anything
This is just one way of representing numbers, booleans, etc. – many others are possible
Integers, booleans, if, while, +, *, =, <, subtyping, multiple inheritance, etc. are for wimps! Real programmers only use .
6 Feb 2001
CS 655: Lecture 6

32. Charge Problem Set 2 out today Read Prakash’s Notes
Make a quantum scheme interpreter
Longer and harder than PS1
New teams assigned
Read Prakash’s Notes
Be uncomfortable about recursive definitions
6 Feb 2001
CS 655: Lecture 6