1 / 32

Lecture 7: Lambda Calculus Revisited

Lecture 7: Lambda Calculus Revisited. CS655: Programming Languages University of Virginia Computer Science. David Evans http://www.cs.virginia.edu/~evans. Menu. Review last time Real reason for Lambda Calculus Substitution Rules Building Primitives. What is Calculus?. In High School:

kennethlawrence
Download Presentation

Lecture 7: Lambda Calculus Revisited

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 7: Lambda Calculus Revisited CS655: Programming Languages University of Virginia Computer Science David Evans http://www.cs.virginia.edu/~evans

  2. Menu • Review last time • Real reason for Lambda Calculus • Substitution Rules • Building Primitives CS 655: Lecture 6

  3. What is Calculus? • In High School: d/dxxn = 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... CS 655: Lecture 6

  4. 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. CS 655: Lecture 6

  5. 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. CS 655: Lecture 6

  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. CS 655: Lecture 6

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

  8. 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 CS 655: Lecture 6

  9. Defining Substitution (|) 5a. (y. M) [x |N] =y. (M [x|N]) where x  y and ydoes 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 xdoes not appear free in M. CS 655: Lecture 6

  10. Defining Substitution (|) 5. (y. M) [x |N] =y. (M [x|N]) where x  y and ydoes not appear free in Norx 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. CS 655: Lecture 6

  11. Reduction (Uninteresting Rules) y. M v. (M [yv]) 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 CS 655: Lecture 6

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

  13. 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. CS 655: Lecture 6

  14. 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 CS 655: Lecture 6

  15. 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. CS 655: Lecture 6

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

  17. 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))  (z.z) ( x.(z.z)(xx)) ( x.(z.z)(xx))  (x.(z.z)(xx)) ( x.(z.z)(xx)) ... CS 655: Lecture 6

  18. 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)  (x.xx)(x.xx) ... CS 655: Lecture 6

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

  20. 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 CS 655: Lecture 6

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

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

  23. Who needs primitives? and xy. ifxyF or xy. ifxTy CS 655: Lecture 6

  24. 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 CS 655: Lecture 6

  25. 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 isP1,2? 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? CS 655: Lecture 6

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

  28. Counting 0 I 1 [F, I] 2 [F, [F, I]] 3 [F, [F [F, I]] ... n + 1 [F, n] 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 CS 655: Lecture 6

  30. Factorial mult  xy.if (zero?x) 0 (addy (mult (predx) y)) fact x. if (zero?x) 1 (multx (fact (predx))) Recursive definitions should make you uncomfortable. Need for definitions should also bother you. 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 . CS 655: Lecture 6

  32. 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 CS 655: Lecture 6

More Related