Transcript slides

Lecture 25:
Metalinguistics
> (meval '((lambda (x) (* x x)) 4)
the-global-environment)
16
CS200: Computer Science
University of Virginia
Computer Science
David Evans
http://www.cs.virginia.edu/~evans
Menu
• Problem Classification Problems
• Making New Languages
• PS7
25 March 2002
CS 200 Spring 2002
2
Problem Classification
harder to show, means problem is easier
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)
25 March 2002
CS 200 Spring 2002
3
To show a problem is undecidable or
NPcomplete, 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
4
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?
25 March 2002
CS 200 Spring 2002
5
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 Since it is a virus, we know virus-code was
evaluated, and P must halt (assuming P wasn’t a virus).
#f))
25 March 2002
Its not a virus, so the virus-code never executed.
Hence, P must not halt.
CS 200 Spring 2002
6
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.
25 March 2002
CS 200 Spring 2002
7
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
8
Metalinguistic
Abstraction
25 March 2002
CS 200 Spring 2002
9
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
10
• PS7:
Solving Problems
–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
11
“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
12
“Jamais Jamais Jamais” from
Harmonice Musices Odhecaton A.
(1501)
25 March 2002
J S Bach, “Coffee Cantata”,
BWV 211 (1732)
www.npj.com/homepage/teritowe/jsbhand.html
CS 200 Spring 2002
13
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
25 March 2002
CS 200 Spring 2002
14
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
15
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
16
The Metacircular Evaluator
25 March 2002
CS 200 Spring 2002
17
Environmental Model of Evaluation
1. To evaluate a combination, evaluate all the
subexpressions and apply the value of the first
subexpression to the values of the other
subexpressions.
2. 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
18
Eval
Eval and Apply
are defined in
terms of each
other.
25 March 2002
Apply
CS 200 Spring 2002
19
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
20
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
21
> (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
25 March 2002
CS 200 Spring 2002
22
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!
25 March 2002
CS 200 Spring 2002
23