1. CSCI 2670 Introduction to Theory of Computing
November 18, 2004

2. Announcement
No quiz next week
November 18, 2004

3. Machine-dependent complexity
Example, let L={w | w is a palindrome}
How long will it take us to decide L on a standard TM?
Go back and forth crossing off matching symbols at beginning and end
O(n2)
How long will it take us to decide L on a 2-tape TM?
Copy string
Compare symbols reading forward on tape 1 and backward on tape 2
O(n)
November 18, 2004

4. Complexity relationships
Theorem: Let t(n) be a function, where t(n)  n. Then every t(n) time multitape TM has an equivalent O(t2(n)) time single-tape TM
Proof idea: Consider structure of equivalent single-tape TM. Analyzing behavior shows each step on multi-tape machine takes O(t(n)) on single tape machine
November 18, 2004

5. Equivalent machines M 0 1 ~ ~ ~ ~ ~ ~ a a a ~ ~ ~ ~ ~ a b ~ ~ ~ ~ ~ ~
0 1 ~ ~ ~ ~ ~ ~
a a a ~ ~ ~ ~ ~
a b ~ ~ ~ ~ ~ ~
# # a a a # a b # ~ ~ S
November 18, 2004

6. Simulating k-tape behavior
Single tape start string is
#w#~#...#~#
Each move proceeds as follows:
Start at leftmost slot
Scan right to (k+1)st # to find symbol at each virtual tape head
Make second pass making updates indicated by k-tape transition function
When a virtual head moves onto a #, shift string to right
November 18, 2004

7. Proof of theorem Analyzing simulation of k-tape machine
Each step on single-tape machine has two phases
Scan tape
Perform operations
How long does first phase take?
Length of string on tape
Each portion has O(t(n)) length (this occurs if tape heads only move right)
November 18, 2004

8. Proof of theorem (cont.)
How long does second phase take?
Perform k steps
Each step may require a right shift
Each step takes O(t(n)) time
Total of k steps is O(t(n)) because k is a constant
What’s the total time?
O(t(n)) steps each take O(t(n)) time
Total time is O(t2(n))
November 18, 2004

9. Determinism vs. non-determinism
Definition: Let P be a non-deterministic Turing machine. The running time of P is the function f:N→N, where f(n) is the maximum number of steps that P uses on any branch of its computation in any input of length n.
November 18, 2004

10. Non-deterministic tree…
reject
accept
Non-deterministic
f(n)
accept/reject
Deterministic
November 18, 2004

11. Complexity relationship
Theorem: Let t(n) be a function where t(n)n. Then every t(n) time non-deterministic single-tape Turing machine has an equivalent 2O(t(n)) time deterministic single-tape Turing machine.
November 18, 2004

12. Complexity relationship proof
Proof: Given a non-deterministic TM, P, running in t(n) time, construct a 3-tape deterministic TM that simulates P.
The height of the tree is at most t(n). Assume the maximum number of branches in the tree is b. Therefore, the number of leaves in the tree is O(bt(n)).
Total number of nodes is less than twice the number of leaves – i.e. O(bt(n)).
November 18, 2004

13. Complexity relationship proof (cont.)
Deterministic TM does a breadth-first search of the non-deterministic TM’s tree.
Total time to search tree is O(t(n)) to travel from the root to a leaf × O(bt(n)), the number of leaves.
O(t(n)bt(n)) = O(2log_2 t(n) 2(log_2 b)t(n)) = O(2O(t(n)))
November 18, 2004

14. Complexity relationship proof (cont.)
Are we done?
No! We constructed a 3-tape TM with running time O(2O(t(n)))
Single-tape TM will take O((2O(t(n)))2)=O(22O(t(n)))=O(2O(t(n)))
Yes!
November 18, 2004

15. Polynomial vs. exponential time
We distinguish between algorithms that have polynomial running time and those that have exponential running time
Polynomial functions – even ones with large exponents – grow less quickly than exponential functions
We can only process large data sets with polynomial running time algorithms
November 18, 2004

16. Polynomial equivalence
Two algorithms A1 and A2 are polynomially equivalent if we can simulate A2 using A1 with only a polynomial increase in running time
November 18, 2004

17. The class P
P is the class of languages that are decidable in polynomial time on a single-tape Turing machine
P = k TIME(nk)
P “roughly corresponds” to the problems that are realistically solvable on a computer
November 18, 2004

18. Size of input: Important consideration
The running time is measured in terms of the size of the input
If we increase the input size can that make the problem seem more efficient
E.g., if we represent integers in unary instead of binary
We consider only reasonable encodings
November 18, 2004

19. A problem in class P Binary tree query
Given a binary search tree T and a key k, find the node in T with key(node) = k
How do we show this problem is in class P?
Write an algorithm and show that the algorithm has running time O(nk) for some k
November 18, 2004

20. Binary search M = “On input <G,k> Let node = root(G)
Do while key(node) <> k
If key(node) < k
If right(node) == NIL
return NIL
Else
node = right(node)
If left(node) == NIL
node = left(node)
Return node
November 18, 2004

21. Execution time Worst case running time? O(|nodes|)
Occurs if tree is unbalanced
Is this O(n)?
Yes … any reasonable encoding will have an entry for each node
November 18, 2004

22. Have a wonderful weekend
November 18, 2004