Lambda Calculus Revisited Lecture 7: Lambda Calculus Revisited 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 http://www.cs.virginia.edu/~evans

Menu Review last time Building Primitives Real reason for Lambda Calculus Substitution Rules Building Primitives 6 Feb 2001 CS 655: Lecture 6

What is Calculus? In High School: d/dx xn = nxn-1 [Power Rule] d/dx (f + g) = d/dx f + d/dx g [Sum Rule] Calculus is a branch of mathematics that deals with limits and the differentiation and integration of functions of one or more variables... 6 Feb 2001 CS 655: Lecture 6

Real Definition A calculus is just a bunch of rules for manipulating symbols. People can give meaning to those symbols, but that’s not part of the calculus. Differential calculus is a bunch of rules for manipulating symbols. There is an interpretation of those symbols corresponds with physics, slopes, etc. 6 Feb 2001 CS 655: Lecture 6

Lambda Calculus Rules for manipulating strings of symbols in the language: term = variable | term term | (term) |  variable . term Humans can give meaning to those symbols in a way that corresponds to computations. 6 Feb 2001 CS 655: Lecture 6

Why? Once we have precise and formal rules for manipulating symbols, we can use it to reason with. Since we can interpret the symbols as representing computations, we can use it to reason about programs. 6 Feb 2001 CS 655: Lecture 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

Defining Substitution (|) 1. y [x | N] = N where x  y 2. y [x | N] = y where x  y 3. M1 M2 [x | N] = M1 [x | N] M2 [x | N] 4. (x. M) [x | N] = x. M 6 Feb 2001 CS 655: Lecture 6

Defining Substitution (|) 5a. (y. M) [x | N] = y. (M [x | N]) where x  y and y does not appear free in N and x appears free in M. 5b. (y. M) [x | N] = y. M where x  y and y does or does not appear free in N and x does not appear free in M. 6 Feb 2001 CS 655: Lecture 6

Defining Substitution (|) 5. (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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Charge Read Mocking Mockingbirds Read as much of Smullyan’s chapters as you can, but don’t feel you have to work out every puzzle (that could take many weeks...) Read and understand all of Keenan’s paper Be uncomfortable about recursive definitions 6 Feb 2001 CS 655: Lecture 6