On Straight Forward Approaches to P vs NP

Transcription

1 On Straight Forward Approaches to P vs NP or: Why complexity theorists aren t as dumb as they look! by Kevin Matulef May 12, 2001 Introduction The infamously unresolved P vs NP question exemplifies the current shortcomings of complexity theory To the uninitiated, the problem feels like one that should be easy to solve In fact, as a practical matter, most computer programmers assume the problem already has been solved in favor of P NPItismuch to the humiliation of complexity theorists that such deap-seated mathematical intuition has been neither validated nor invalidated This paper attempts to illustrate why the distinction between P and NP is more subtle than it appears, and why the straight forward methods used in similar classification problems will not work to show that P = NP or P NP With the exception of the statement of some more advanced theorems at the end of the paper, no prior knowledge is assumed beyond basic familiarity with complexity theory (in particular, the classes P, NP, and PSPACE, and the notion of NP and PSPACE completeness) 1 Diagonalization Since P is a subset of NP, the conjecture that P NP is really a conjecture about strict containment What exactly constitutes a straight forward method for showing that one class is strictly contained in another? This is subjective, to be sure, but historically in computability and complexity theory most such containment proofs seem to follow the same general format, called diagonalization The technique of diagonalization is simple enough To show that a subset is strictly contained in a larger set: Construct a grid, where each row corresponds to an element of the subset, and the columns represent properties of the elements Construct an element that differs from the i th element of the subset in the i th way That is, list each of the elements along the diagonal of the table, change each of them, and construct an element with the resulting list of properties 1

2 Clearly the constructed element is not a member of the subset, since it differs from all of the elements of the subset in at least one spot But, if the element is still a member of the larger set, then that s all that s needed to show the strict containment The reader may be disturbed by this nebulous definition of diagonalization Just what does it mean to differ in the i th way? Indeed, the concept is illdefined, because as we shall see, it turns out to mean different things in different proofs This is best illustrated through some examples of diagonalization in action 11 There are more real numbers than can be enumerated Suppose we have an enumeration r 1,r 2,r 3, of real numbers Construct a grid, where each row corresponds to a real number r k in the enumeration, and the ith column corresponds to the ith digit (after the decimal point) of a number r r r Construct a number whose i th digit is different from the i th digit along the diagonal Diagonal entries: Constructed number: Clearly, the number constructed in part b is a real number, but it also differs from all of the real numbers on the list, because it differs in at least one digit 1 Therefore, the enumeration is a strict subset of the reals 12 There are more recognizable languages than decidable languages Suppose we have an enumeration M 1,M 2,M 3,, of the Turing Machines that decide languages Construct a grid, where each row corresponds to a particular decider M i, and each column corresponds to a particular input M j Entry (i, j) of the grid describes M i s behavior on input M j 1 The astute reader may notice that real numbers can differ in a digit and still be the same, for example = 09 However, we can avoid this complication by not using 0 s or 9 s in the constructed number 2

3 M 1 M 2 M 3 M 1 accept reject accept M 2 reject reject reject M 3 accept accept accept Construct a Turing Machine T that behaves differently from M i on input M i T = On input I 1 Simulate I on I 2 Output the opposite of what that machine outputs If it accepts, reject If it rejects, accept T must recognize some language, but it clearly differs from any decidable machine on at least one input (the diagonal entries above), so it can t itself be decidable Therefore there are more recognizable languages than decidable languages 13 There are more languages in SPACE(n 2 )thanspace(n) Suppose we have an enumeration of the Turing Machines M 1,M 2,M 3, that decide languages in O(n) space Construct a grid, where each row corresponds to a particular O(n) space machine M i, and the columns corresponds to inputs of the form M j 10 k M 1 1 M 1 10 M M 2 1 M 2 10 M M 1 accept reject accept reject reject accept M 2 reject reject reject accept reject reject M 3 accept accept accept accept reject accept Construct a Turing Machine T that behaves differently from M i on inputs of the form M i 10 k for large enough k T = On input w of the form I 10 k 1 Mark off w 2 tape cells In later steps, reject if head tries to go past this mark 2 Simulate I on I 10 k (keeping a counter of the number of steps performed If it ever exceeds 2 w 2, reject) 3 Output the opposite of what that machine outputs If it accepts, reject If it rejects, accept 3

4 Here the constructed machine requires a little bit of explanation First, we note that T uses only n 2 space, since the first step imposes that restriction 2 Second, we note the machine never goes into an infinite loop, because of the counter it keeps in step 2 The primary difference between this proof and 12 is that T is constructed to differ from all the machines that it simulates on a whole family of inputs, rather than just a single input along the diagonal Why is this? Suppose the amount of space that M 1 uses is bounded by the linear function f(n) =51n, and that the size of M 1 1 = 50, so that running M 1 on M 1 1 may require f(50) = 2550 tape cells When T is given M 1 1, in step 1 it marks off only 50 2 = 2500 tape cells before proceeding to simulate M 1 on M 1 1 Since 2550 tape cells are required, the simulation will be cut off prematurely However, note that on inputs M 1 10, M 1 100, M , T will have no trouble performing the simulation with these input n 2 begins to exceed 51n In general, for any O(n) space machine M i, the space bound f( M i 10 k ) will always be less than M i 10 k 2 for large enough k But, since the value of f(k) varies for every machine, we must construct T to differ from M i on a whole family of inputs to insure the simulation succeeds Of course, in the proof above, the functions n 2 and n were chosen arbitrarily, and it works equally well with any pair of functions f and g where f o(g(n)), and g is space constructible As a corollary, we get NL PSPACE EXPSPACE 14 There are more languages in TIME(n 2 )thantime(n) The proof of this theorem is left as an exercise for the reader It follows the same method as that of the space hierachy theorem, however the simulating machine T keeps a counter of the amount of time used, rather than marking off tape to track the amount of space used Updating the counter for every step of the simulation, and moving the counter so that it remains near the tape head, introduces an extra log factor for the simulation Thus the Time Hierarchy Theorem is a little more complicated to state: for any pair of functions f and g where f o(g(n)/ log g(n)), and g is time constructible, TIME(f) TIME(g) 3 As a corrollary to the Time Hierarchy Theorem, P EXPTIME 15 There are more languages in NP than P? From the previous two examples, it seems like the path to showing that P NP should be clear Suppose we have an enumeration of the Turing Machines M 1,M 2,M 3, that decide languages in polynomial time Construct a grid, where each row corresponds to a particular polynomial time machine M k, and the columns corresponds to inputs that are some variant of M i 2 We also must point out that it is crucial that the computation of n 2 itself avoids using more than O(n 2 ) space In general, a function f(n) log n is said to be space constructible if f(1 n ) is computable in O(f(n)) space 3 A function g(n) n log n is time constructible if g(1 n ) is computable in O(g(n)) time 4

5 Construct an NP machine that when given an input w like M i, simulates M i on w and does the opposite Even though it s not entirely clear how the above strategy might be implemented, it certainly feels plausible given the same strategy s success at proving P EXPTIME Unfortunately, it is not a plausible strategy for showing P NP, as we will soon see 2 Relativization The diagonalization method is surprisingly robust For instance, consider the earlier use of the diagonalization method to show that there are some languages, like the halting problem, which are recognizable but not decidable One might reasonably wonder what would happen if Turing Machines had the power to solve the halting problem instantly Formally, we can define a Turing machine with oracle language A as one which has a special tape on which it can write a string, and in one computation step receive an answer for whether or not the string is in A Are all the languages that are recognizable by Turing machines with halting problem oracles decidable by them as well? Unfortunately, the answer is no, and the proof is the exact same proof given in 12 When T is simulating I on I, if I ever asks whether or not a particular machine halts, T can simulate by asking asking its oracle Thus we obtain the result: for any oracle A, there are languages that are recognizable by machines with oracle A, but not decidable by machines with oracle A A quick inspection of 14 reveals that it is still valid as well when using an oracle machine That is, there are more languages decidable in O(n 2 ) time by machines with oracle A than in O(n) time by machines with oracle A Because all of these proofs still hold up in the oracle case, the technique of diagonalization is said to relativize The ability for a proof technique to relativize is both a blessing and a curse In some sense, it means the technique is very powerful However, in another sense it means the technique may be too powerful when the distinctions between classes are fine For example, suppose we were to prove that P NPvia techniques similar to proofs 12-4 Then we would also prove that for any oracle A, P A NP A However, this is false 21 An oracle for which P A = NP A In fact, this is not too hard to see Consider the class of Turing machines augmented with a PSPACE complete language such as TQBF Clearly, any language in PSPACE can be decided in polynomial time by one of these supermachines The super-machine simply performs a polynomial time reduction to TQBF, and queries the oracle We know such a reduction exists because TQBF is complete Thus, PSPACE P TQBP At the same time, consider a nondeteterminic polynomial machine that has access to a TQBF oracle If all of the oracle queries are replaced by a bruteforce deterministic PSPACE computation, then the resulting machine decides 5

6 the same language, and any one branch uses at most polynomial space Thus, NP TQBF NPSPACE But by Savitch s theorem, PSPACE = NPSPACE, so we get the inclusion NP TQBF P TQBP Of course, the reverse inclusion is trivial (P TQBF NP TQBP because a deterministic polynomial machine with the ability to query oracles is just a nondeterministic machine with the same ability that never branches) Therefore, P TQBF =NP TQBF In some sense, this is not too surprising It s as if giving Turing machines the ability to solve TQBF in one step makes them so much more powerful, the difference beween P and NP becomes negligible To make a very rough analogy, a weight-lifter may have more power than a layman, but when you give them both a gun, they re equally deadly! The existence of an oracle which makes P equal to NP might lead one to conjecture that maybe P does equal NP Unfortunately, the chance of proving this via simple simulation is just as slim This is because there exists an oracle which makes P and NP provably different If an NP machine could be simulated efficiently by a P machine in a straightforward way (such as the simulation used to show PSPACE=NPSPACE), then giving both machines an oracle shouldn t change much, because the simulating machine can use its own oracle whenever the simulated machine makes a query 22 An oracle for which P A NP A The trick to finding such an oracle is to construct it in just such a way that an associated language systematically differs from every P A machine, but still leaves that language well within the realm of NP A machines Given a language A, we can construct an associated language that consists the strings in A plus all of the strings with the same length as those in A SAME-LENGTH-STRINGS A = {w there is a string of length w in A} For example, consider A = {1, 101} Then SAME-LENGTH-STRINGS A = {1, 0, 000, 001, 010, 011, 100, 101, 110, 111} Now suppose that we have the ability to determine very quickly if a string is in A How could we write an algorithm to decide SAME-LENGTH-STRINGS A? The most straightforward approach would be to generate all possible strings that are the same size as the input, and if any of them are in A, accept Of course, this isn t particularly efficent, since generating all possible strings of length w takes exponential time Fortunately, using nondeterminism, there is a better way; this is just the sort of problem that nondeterministic machines are good at In fact, for any A, it is clear that HAS-EQUAL-LENGTH-STRING A NP A The following algorithm works: On input w 1 Nondeterministically select a string of length w 6

7 2 If the string is in A, accept, otherwisereject So for any possible oracle language A, we ve succeeded at finding an associated language that the nondeterministic oracle machines are really good at solving We just need to choose a particular A that prevents every deterministic polynomial oracle machine from solving SAME-LENGTH-STRINGS A Let M 1,M 2,M 3, be all of the deterministic polynomial time oracle machines We will construct the language A through a series of stages, where in each stage we make sure that the next M i is unable to solve SAME-LENGTH- STRINGS A Here we go: Start by envisioning a list of all the strings in Σ Initially, it is unkown if any string is in A As we proceed through the following steps, we will cross some strings off of the list and circle other strings until the status of every string is determined We start by making sure that M 1 does not decide SAME-LENGTH- STRINGS A To do this, we run M 1 on a string 1 k,wherek is chosen to be large enough such that the number of strings of length k is larger than the running time of the machine on 1 k (note that k is guaranteed to exists, because the number of strings of length k is 2 k, while the running time of the machine grows only polynomially) While M 1 is running on 1 k, we make sure that all of the strings that it queries are not in A That is, we cross those strings off of the list If M 1 ends up accepting 1 k, we cross off all the strings of length k, thus making sure 1 k is not in SAME-LENGTH-STRINGS A If M 1 rejects 1 k, then we circle some other string of length k that M i didn t query the oracle about, thus making sure 1 k is in SAME-LENGTH-STRINGS A (Note that there is guaranteed to be at least one unqueried string of length k, because there are more strings of length k than the entire running time of the machine) In this manner, we insure that M 1 does not decide SAME-LENGTH-STRINGS A, because it behaves differently on input 1 k Now we just continue this process to insure that every deterministic polynomial time oracle machine does not decide SAME-LENGTH-STRINGS A For each M i : 1 Choose a k large enough so that 1 k is both longer than any string whose status has not yet been decided upon, and so that the number of strings of length k is larger than the running time of M i 2 Run M i on 1 k If it queries a string whose status has not yet been determined, cross that string off of the list If it queries a string whose status has been determined, do nothing further Finally, if M i ends up accepting 1 k, cross off all strings of length k, but if M i ends up rejecting 1 k, find one other string of length k that hasn t been crossed off yet and declare it to be in A 7

8 By the same logic as above, this insures that M i does not decide SAME-LENGTH-STRINGS A, because it behaves differently on input 1 k The above construction shows how to make an A such that SAME-LENGTH- STRINGS A is not in P A, and SAME-LENGTH-STRINGS A is in NP A Therefore P A NP A It is tempting to conclude that P NP simply because P A NP A However the reader is warned against this, because the former is not a logical implication of the latter It is entirely possible that the power of nondeterminism does not give NP machines much advantage over P machines, but that the power of nondeterminism combined with the power of an oracle augments the power of NP more than the oracle alone augments the power of P The reader may also note that the proof of this theorem does have a diagonal feel to it It may even be considered diagonalization, though I think this illustrates the difficulty of coming up with a formal definition of a proof technique The pair of oracle results discussed here is often given as an argument against the use of diagonalization to prove P NP However I think it s more accurate to say that it s an argument against simple simulate and do the opposite proofs, rather than diagonalization in all its forms 3 Where to go from here? The simultaneous existence of oracles that make P = NP and P NP opens up a host of interesting questions Is it possible that the oracle A which makes P A NP A is itself in P? Then this would prove P NP! Unfortunately, the language A is so contrived that the possibility of proving that it s in P seems very small Still, it s possible that some variation of the oracle is in P and has same effect In fact, there are a lot of oracle languages with the effect that P L NP L (the complentary set of languages has measure 0, see paper by Jarod Alper) Is there any way to show that two classes are equal without using a proof that relativizes? Indeed there is The best example of a nonrelativing proof is that which shows the class of interactive proofs (IP) is equal to PSPACE (see paper by BJ Maress) In fact, a non-relativing technique is needed for the proof, because there exists an oracle which separates the two classes Is there any way to show that two classes are different without using a proof that relativizes? As it turns out, yes there is, but progress in this areas has come only very recently In 1998, Burhman, Fortnow, and Thierauf gave the first non-relativing separation proof, showing that the class MA EXP (languages proven by an interactive proof system where the 8

9 prover sends a single message to the probabilistic exponential time verifier) is not equal to the class of languages with polynomial sized circuits, even though there is an oracle which makes the two classes the same To prove this, they made use of a previous non-relativizing equality result 4 Conclusion The distinction between P and NP is much finer than it first appears, and fragile enough to hold up in some worlds and not others Consequently, the straight-forward methods of the past are not readily adaptable to the P vs NP question, and new techniques which are just beginning to be understood must be employed References This paper was based on a lecture (fragments of which can be found at given in the spring term of 2001 in a course at Brown University on Advanced Topics in the Theory of Computation The presentation primarily follows that in The Theory of Computation, by Michael Sipser, and Computational Complexity by Christos Papadimitriou Additional information can be found in the gs019 papers by Jarod Alper and BJ Mares, and in the following original articles: 1 H Burhman, L Fortnow, and T Thierauf Nonrelativizing separations In Proceedings of the 13th IEEE Conference on Computational Complexity, pages 8-12 IEEE, New York, T Baker, J Gill, R Solovay Relativizations of the P = NP question SIAM Journal of Computing 4(4): L Fortnow Diagonalization In The Computational Complexity Column, July