David Evanshttp://www.cs.virginia.edu/~evans

CS200: Computer ScienceUniversity of VirginiaComputer Science

Lecture 25: Metalinguistics

> (meval '((lambda (x) (* x x)) 4)

the-global-environment)16

25 March 2002 CS 200 Spring 2002 2

Menu• Problem Classification Problems

• Making New Languages

• PS7

25 March 2002 CS 200 Spring 2002 3

Problem ClassificationTo 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)

hard

er to

sho

w, m

ean

s pro

ble

m is e

asier

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 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 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.

25 March 2002 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.

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. Printed by Ottaviano Dei Petrucci in

1501 (first music with movable type)

25 March 2002 CS 200 Spring 2002 13

J S Bach, “Coffee Cantata”, BWV 211 (1732) www.npj.com/homepage/teritowe/jsbhand.html

“Jamais Jamais Jamais” from Harmonice Musices Odhecaton A. (1501)

25 March 2002 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

25 March 2002 CS 200 Spring 2002 15

Is this an exaggeration?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.

(SICP, p. 360)

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 Evaluation1. 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 19

EvalEval

ApplyApply

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:*>))))|33> (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|44

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 email.

• This is powerful: once we have an metacircular evaluator, we can easily make changes to the language!