David Evans cs.virginia/~evans

1. Lecture 25: Metalinguistics David Evans http://www.cs.virginia.edu/~evans > (meval '((lambda (x) (* x x)) 4) the-global-environment) 16 CS200: Computer Science University of Virginia Computer Science

2. Menu • Problem Classification Problems • Making New Languages • PS7 CS 200 Spring 2002

3. Problem Classification To show a problem is decidable/in NP/in P, you need to show it is easy enough to be solved with a procedure in that class: • Decidable: it is easy enough to be solved by some procedure that always terminates • NP: it is easy enough to be solved by a procedure that tries an exponential number of guesses, but takes only P-time to check one if correct • P: it is easy enough to be solved by a polynomial time procedure – O (nk) harder to show, means problem is easier CS 200 Spring 2002

4. To show a problem is undecidable or NP-complete, you need to show it is as hard as a problem you know enough to be solved with a procedure in that class: • Undecidable: if you had a procedure that solves this problem, you could use it to solve a known undecidable problem (e.g., the halting problem) • NP-Complete: if you had a procedure that solves this problem, you could use it to solve a known NP-Complete problem (e.g., the travelling salesman problem) • Subtlety: the transformation of the problem and answer must be in P CS 200 Spring 2002

5. Virus Detection Problem Problem 7. Melissa Problem Input: A Word macro (like a program, but embedded in an email message) Output: true if the macro will forward the message to people in your address book; false otherwise. How can we show it is undecidable? CS 200 Spring 2002

6. Undecidability Proof Suppose we could define is-virus? that decides the Melissa problem. Then: (define (halts? P) (if (is-virus? ‘(begin P virus-code)) #t #f)) Since it is a virus, we know virus-code was evaluated, and P must halt (assuming P wasn’t a virus). Its not a virus, so the virus-code never executed. Hence, P must not halt. CS 200 Spring 2002

7. Undecidability Proof Suppose we could define is-virus? that decides the Melissa problem. Then: (define (halts? P) (is-virus? ‘(begin (vaccinate P) virus-code)) Where (vaccinate P) evaluates to P with all mail commands replaced with print commands (to make sure (is-virus? P) is false. CS 200 Spring 2002

8. Proof • If we had is-virus? we could define halts? • We know halts? is undecidable • Hence, we can’t have is-virus? • Thus, we know is-virus? is undecidable Practice the other problems from Friday. I won’t hand out solutions, but will answer questions about them. CS 200 Spring 2002

9. Metalinguistic Abstraction CS 200 Spring 2002

10. Solving Problems: Recap • PS1-4: • Divide a problem into procedures that can be combined to solve it • PS5: • Divide a problem into procedures and state that can be combined to solve it • PS6: • Divide a problem into objects that can be used to model it CS 200 Spring 2002

11. Solving Problems • PS7: • Divide a problem into creating a good language for solving the problem, and defining a solution using that language Languages change the way we think. Sometimes the best way to solve a problem is to invent a new language first. CS 200 Spring 2002

12. “Jamais Jamais Jamais” from Harmonice Musices Odhecaton A. Printed by Ottaviano Dei Petrucci in 1501 (first music with movable type) CS 200 Spring 2002

13. “Jamais Jamais Jamais” from Harmonice Musices Odhecaton A. (1501) J S Bach, “Coffee Cantata”, BWV 211 (1732) www.npj.com/homepage/teritowe/jsbhand.html CS 200 Spring 2002

14. Inventing a Language • Design the grammar • What strings are in the language? • Use BNF to describe all the strings in the language • Make up the evaluation rules • Describe what everything the grammar can produce means • Build an evaluator • A procedure that evaluates expressions in the language CS 200 Spring 2002

15. Is this an exaggeration? (SICP, p. 360) It is no exaggeration to regard this as the most fundamental idea in programming: The evaluator, which determines the meaning of expressions in the programming language, is just another program. To appreciate this point is to change our images of ourselves as programmers. We come to see ourselves as designers of languages, rather than only users of languages designed by others. CS 200 Spring 2002

16. Programming an Evaluator If a language is just a program, what language should we program the language in? CS 200 Spring 2002

17. The Metacircular Evaluator CS 200 Spring 2002

18. Environmental Model of Evaluation • To evaluate a combination, evaluate all the subexpressions and apply the value of the first subexpression to the values of the other subexpressions. • To apply a compound procedure to a set of arguments, evaluate the body of the procedure in a new environment. To construct this environment, make a new frame with an environment pointer that is the environment of the procedure that contains places with the formal parameters bound to the arguments. CS 200 Spring 2002

19. Eval Eval and Apply are defined in terms of each other. Apply CS 200 Spring 2002

20. meval (define (meval expr env) (cond ((self-evaluating? expr) expr) ((variable? expr) (environment-lookup-name expr env)) ((lambda? expr) (make-procedure (lambda-parameters expr) (lambda-body expr) env)) ((application? expr) (mapply (meval (application-operator expr) env) (map (lambda (subexpr) (meval subexpr env)) (application-operands expr)))) (else (error "Unknown expression: " exp)))) CS 200 Spring 2002

21. mapply (define (mapply procedure operands) (cond ((primitive-procedure? procedure) (apply-primitive procedure operands)) ((compound-procedure? procedure) (meval-sequence (procedure-body procedure) (extend-environment (procedure-parameters procedure) operands (procedure-environment procedure)))) (else (error “Can’t apply: " procedure)))) CS 200 Spring 2002

22. > (meval 3 the-global-environment) |(meval 3 (((+ primitive-procedure #<primitive:+>) (* primitive-procedure #<primitive:*>)))) |3 3 > (meval '(+ 2 2) the-global-environment) |(meval (+ 2 2) the-global-environment) | (meval + the-global-environment) | (primitive-procedure #<primitive:+>) | (meval 2 the-global-environment) | 2 | (meval 2 the-global-environment) | 2 | (mapply (primitive-procedure #<primitive:+>) (2 2)) | 4 |4 4 CS 200 Spring 2002

23. Charge • Defining eval and apply is the guts of it • Wednesday we will see the details • PS7 out Wednesday • If you’ve done the reading and want to start it before then, send me email. • This is powerful: once we have an metacircular evaluator, we can easily make changes to the language! CS 200 Spring 2002