1. David Evans http://www.cs.virginia.edu/~evans
Class 34:
Models of Computation
CS200: Computer Science
University of Virginia
Computer Science
David Evans

2. Menu Are complexity classes really meaningful?
How can we model computation?
Turing Machines
Universal Turing Machine
15 April 2002
CS 200 Spring 2002

3. Complexity Classes
We claimed problem complexity doesn’t depend on the language or computer: problems are in class P and NP regardless of what kind of computer you have
In PS7, we saw that if you have a quantum computer you solve a problem that has no known polynomial time solution on a “normal computer” in polynomial time.
This should bother you!
15 April 2002
CS 200 Spring 2002

4. Computability
Does our computer model change whether or not something is undecidable?
No – we proved things we undecidable by showing a
contradiction. It doesn’t depend on how we model computers.
15 April 2002
CS 200 Spring 2002

5. How should we model a Computer?
Colossus (1944)
Cray-1 (1976)
Apollo Guidance Computer (1969)
IBM 5100 (1975)

6. Modeling Computers Input Output Processing Memory
Without it, we can’t describe a problem
Output
Without it, we can’t get an answer
Processing
Need some way of getting from the input to the output
Memory
Need to keep track of what we are doing
15 April 2002
CS 200 Spring 2002

7. Modeling Input Punch Cards Altair BASIC Paper Tape, 1976
Engelbart’s mouse and keypad
15 April 2002
CS 200 Spring 2002

8. Simplest Input Non-interactive: like punch cards and paper tape
One-dimensional: just a single tape of values, pointer to one square on tape 1 1 1
How long should the tape be?
Infinitely long! We are modeling a computer, not building one. Our model should not have silly practical limitations (like a real computer does).
15 April 2002
CS 200 Spring 2002

9. Modeling Output Blinking lights are cool, but hard to model
Output is what is written on the tape at the end of a computation
Connection Machine CM-5, 1993
15 April 2002
CS 200 Spring 2002

10. Modeling Processing Evaluation Rules What do we need:
Given an input on our tape, how do we evaluate to produce the output
What do we need:
Read what is on the tape at the current square
Move the tape one square in either direction
Write into the current square 1 1 1
Is that enough to model a computer?
15 April 2002
CS 200 Spring 2002

11. Modeling Processing Read, write and move is not enough
We also need to keep track of what we are doing:
How do we know whether to read, write or move at each step?
How do we know when we’re done?
What do we need for this?
15 April 2002
CS 200 Spring 2002

12. Finite State Machines 2 1 HALT 1 1 # Start 15 April 20022 1
Start 1 #
HALT
15 April 2002
CS 200 Spring 2002

13. Hmmm…maybe we don’t need those infinite tapes after all?
not a paren (
not a paren 2 1
Start ) )
What if the
next input symbol
is ( in state 2? #
ERROR
HALT
15 April 2002
CS 200 Spring 2002

14. How many states do we need?
not a paren (
not a paren 2
not a paren 1
Start ( ) 3 )
not a paren ) # ( 4
ERROR
HALT ) (
15 April 2002
CS 200 Spring 2002

15. Finite State Machine
There are lots of things we can’t compute with only a finite number of states
Solutions:
Infinite State Machine
Hard to describe and draw
Add a tape to the Finite State Machine
15 April 2002
CS 200 Spring 2002

16. FSM + Infinite Tape Start: Move: Finish: FSM in Start State
Input on Infinite Tape
Pointer to start of input
Move:
Read one input symbol from tape
Follow transition rule from current state
To next state
Write symbol on tape, and move L or R one square
Finish:
Transition to halt state
15 April 2002
CS 200 Spring 2002

17. Matching Parentheses Repeat until halt: Find the leftmost )
If you don’t find one, the parentheses match, write a 1 at the tape head and halt.
Replace it with an X
Look left for the first (
If you find it, replace it with an X (they matched)
If you don’t find it, the parentheses didn’t match – end write a 0 at the tape head and halt
15 April 2002
CS 200 Spring 2002

18. Matching Parentheses 1 HALT Input: ) Write: X ), X, L Move: L X, X, L
X, X, R
2: look for ( 1
Start
(, X, R
#, 1, #
#, 0, #
HALT
Opps! There is a problem
with this as Spencer noticed
in class. It will report the
wrong result for input like (().
Fixing it is left for you.
15 April 2002
CS 200 Spring 2002

19. Turing Machine This is a “Turing Machine”
Alan Turing, On computable numbers: With an application to the Entscheidungsproblem, 1936
Turing developed the machine abstraction to show the halting problem really leads to a contradiction
Our informal argument, depended on assuming we could do if and everything else except halts?
15 April 2002
CS 200 Spring 2002

20. Describing Turing Machinesz z z z z z z z z z z z z z z z z z z z z z
TuringMachine ::= < Alphabet, Tape, FSM >
Alphabet ::= { Symbol* }
Tape ::= < LeftSide, Current, RightSide >
OneSquare ::= Symbol | #
Current ::= OneSquare
LeftSide ::= [ Square* ]
RightSide ::= [ Square* ]
Everything to left of LeftSide is #.
Everything to right of RightSide is #.
), X, L
), #, R
(, #, L 1
2: look for (
Start
(, X, R
HALT
#, 1, -
#, 0, -
Finite State Machine
15 April 2002
CS 200 Spring 2002

21. Describing Finite State Machines
), X, L
), #, R
(, #, L
Describing Finite State Machines 1
2: look for (
Start
(, X, R
#, 1, #
#, 0, #
HALT
TuringMachine ::= < Alphabet, Tape, FSM >
FSM ::= < States, TransitionRules, InitialState, HaltingStates >
States ::= { StateName* }
InitialState ::= StateName must be element of States
HaltingStates ::= { StateName* } all must be elements of States
TransitionRules ::= { TransitionRule* }
TransitionRule ::=
< StateName, ;; Current State
OneSquare, ;; Current square
StateName, ;; Next State
OneSquare, ;; Write on tape
Direction > ;; Move tape
Direction ::= L, R, #
Transition Rule is a procedure:
StateName X OneSquare
 StateName X OneSquare X Direction
15 April 2002
CS 200 Spring 2002

22. Example Turing Machine
), X, L
), #, R
(, #, L
Example Turing Machine 1
2: look for (
Start
(, X, R
#, 1, #
#, 0, #
HALT
TuringMachine ::= < Alphabet, Tape, FSM >
FSM ::= < States, TransitionRules, InitialState, HaltingStates >
Alphabet ::= { (, ), X }
States ::= { 1, 2, HALT }
InitialState ::= 1
HaltingStates ::= { HALT }
TransitionRules ::= { < 1, ), 2, X, L >,
< 1, #, HALT, 1, # >,
< 1, ), #, R >,
< 2, (, 1, X, R >,
< 2, #, HALT, 0, # >,
< 2, ), #, L >,}
15 April 2002
CS 200 Spring 2002

23. Enumerating Turing Machines
Now that we’ve decided how to describe Turing Machines, we can number them
TM = balancing parens
TM = even number of 1s
TM = Photomosaic Program
TM = WindowsXP
Not the real numbers – they would be much bigger!
15 April 2002
CS 200 Spring 2002

24. Universal Turing Machines
15 April 2002
CS 200 Spring 2002

25. Universal Turing Machine
P Number
of TM
Universal
Turing
Machine
Output
Tape
for running
TM-P
in tape I I
Input
Tape
Can we make a Universal Turing Machine?
also, just a number!
15 April 2002
CS 200 Spring 2002

26. Yes!
5,495 bits
Marvin Minsky designed a Universal Turing Machine with 4 symbols and 7 states!
15 April 2002
CS 200 Spring 2002

27. Church-Turing Thesis
Any mechanical computation can be performed by a Turing Machine
There is a TM-n corresponding to every decidable problem
We can simulate one step on any “normal” (classical mechanics) computer with a constant number of steps on a TM:
If a problem is in P on a TM, it is in P on an iMac, CM5, Cray, Palm, etc.
15 April 2002
CS 200 Spring 2002

28. Charge Wednesday, Friday:
Lambda Calculus model of computation
Very different from Turing Machines, but we will show that it is exactly as powerful!
Project Feedback: I will either you before Wednesday, or return comments on Wednesday
15 April 2002
CS 200 Spring 2002