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

2. Menu Problem Classification Problems Making New Languages PS7
25 March 2002
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
25 March 2002
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
25 March 2002
CS 200 Spring 2002

5. Virus Detection Problem
Problem 7. Melissa Problem
Input: A Word macro (like a program, but embedded in an 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?
25 March 2002
CS 200 Spring 2002

6. Undecidability Proof (define (halts? P)
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.
25 March 2002
CS 200 Spring 2002

7. Undecidability Proof (define (halts? P)
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.
25 March 2002
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.
25 March 2002
CS 200 Spring 2002

9. Metalinguistic Abstraction
25 March 2002
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
25 March 2002
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.
25 March 2002
CS 200 Spring 2002

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

13. “Jamais Jamais Jamais” from Harmonice Musices Odhecaton A. (1501)
J S Bach, “Coffee Cantata”, BWV 211 (1732)
25 March 2002
CS 200 Spring 2002

14. Inventing a Language Design the grammar Make up the evaluation rules
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
25 March 2002
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.
25 March 2002
CS 200 Spring 2002

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

17. The Metacircular Evaluator
25 March 2002
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.
25 March 2002
CS 200 Spring 2002

19. Eval Apply Eval and Apply are defined in terms of each other.
25 March 2002
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))))
25 March 2002
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))))
25 March 2002
CS 200 Spring 2002

22. > (meval 3 the-global-environment) |(meval 3
(((+ primitive-procedure #<primitive:+>)
(* primitive-procedure #<primitive:*>)))) |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
| (mapply (primitive-procedure #<primitive:+>) (2 2))
| 4 |4 4
25 March 2002
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 .
This is powerful: once we have an metacircular evaluator, we can easily make changes to the language!
25 March 2002
CS 200 Spring 2002