This preview has intentionally blurred sections. Sign up to view the full version.View Full Document
Unformatted text preview: ECS 120 Lesson 27 – Intractability, Hierarchy Theorems Oliver Kreylos Monday, June 4th, 2001 In our discussion of time complexity and the classes P and NP , we isolated the NP-complete ones as the hardest problems in NP . We also said that, for practical purposes, NP-complete problems can be treated as intractable – as problems where all but the smallest input sizes require a prohibitive amount of running-time. But, since the question “ P = NP ?” is still undecided, there might be efficient, polynomial algorithms for NP- complete problems after all. Today we are going to develop the tools to prove one practical problem to be intractable, by showing that any algorithm solving it needs exponential time. 1 Hierarchy Theorems Intuition tells us that, if a Turing Machine is given more time or space to compute, it should be able to decide more languages. The next two theorems show that this intuition is true – up to some technicalities. Since it is simpler, we start by looking at how an increase of memory increases the amount of problems that can be solved. 1.1 Space Hierarchies To start, we need to define by how much we have to increase a Turing Ma- chine’s available memory in order to make a difference. Some very small increases might not be useful to a machine. 1 Definition 1 (Space-constructible Functions) A function f : N → N is called space-constructible , if there exists a Turing Machine M that, on in- put 1 n , writes f ( n ) in binary onto its tape, and uses only O ( f ( n ) ) space. Space constructible functions are useful in the following way: If a Turing Machine is supposed to be running in O ( f ( n ) ) space, where f ( n ) is space- constructible, it can scan its input to determine its length n , and can compute the amount of space f ( n ) it has available to do its computation. If f ( n ) were not space-constructible, just checking the length of the input and finding out how much space is left would already make the machine exceed its space limit – functions like that are hardly useful. Luckily, every “reasonable” function is also space-constructible. For ex- ample, f ( n ) = n 2 is space constructible: Given input 1 n , a machine could count the number of ones using binary notation, using only log n additional space, and could then calculate n 2 by multiplying the binary notation of n with itself. The standard written multiplication algorithm needs only O ( k ) space to multiply two k-bit numbers; therefore the additional space needed is another O (log n ). In total, 1 n can be converted to n 2 in binary using only O ( n + log n ) = O ( n ) = O ( n 2 ) space. Using space-constructible functions, we can state the following hierarchy theorem: Theorem 1 (Space Hierarchy Theorem) Let f : N → N be a space-con- structible function. Then there exists a language A that can be decided in space O ( f ( n ) ) , but not in space o ( f ( n ) ) ....
View Full Document
- Spring '07
- Space, Computational complexity theory, Turing Machines, Time hierarchy theorem