Apropos of an errata in ÜB 10 exercise 3

Transcription

1 Apropos of an errata in ÜB 10 exercise 3 Komplexität von Algorithmen SS13 The last exercise of the last exercise sheet was incorrectly formulated and could not be properly solved. Since no one spotted the error and the semester is already over, we provide these notes hoping that they will be of help to students preparing for for the final exam. What the exercise asked The goal of the exercise was to prove that Krom-SAT, the set of all satisfiable Krom formulas is in NL, by way of a logspace reduction. That is, the idea was to find a problem P, known to be in NL and define a function f such that: 1. for all x, x KS f(x) P 2. f can be computed by a deterministic Turing machine using (auxiliary) space bounded by a function O(log n) on the input size n. The notation for this is Krom-SAT logspace P and we recall that the existence of such an f would guarantee that Krom-SAT is in NL since since, if M P (y) is a Turing machine witnessing that P NL, then M(x) := M P (f(x)) would be a Turing machine that decides Krom-SAT and, because Turing machines running in logarithmic space can be composed in a way such that the space usage is also logarithmically bound (shown in class), it would do so using only logarithmic space. The statement of the exercise also hinted that one could exploit the fact that if A and B are problems in NL, then deciding whether x A and y B, for any given (x, y) is also in NL (formally written as A B NL). The general idea being that perhaps there wasn t a single problem A to which we could easily reduce Krom-SAT, but two problems A and B such that we can reduce it to A B. As we will confirm by the end of this notes, Krom-SAT is in NL, so by the very fact that PATH is NL-complete, Krom-SAT logspace PATH, so some f as above reducing Krom-SAT to PATH must exist. The problem is that no simple reduction seems to be available. Of course, one could simply show that Krom-SAT NL by exhibiting a suitable Turing machine, but the point of the exercise was to practice complexity proofs by reductions which many times can be simpler. The construction of the last section will give us a general method to construct NL problems to which we can reduce some given one. A variation of the exercise that had a simple solution Let us first consider a small variation of this exercise that could have been easily solved. Instead of looking at all the Krom formulas, let s assume that the number of available propositions is 1

2 arbitrary but fixed. We can then define, for each k N: Krom-SAT k := {α α is a Krom formula built using only propositions p 1, p 2,... p k }. The statement of the exercise tells us that it is known that a Krom formula α is unsatisfiable whenever there is a proposition p i occurring in α such that there are reasoning chains over α from p i to p i and from p i to p i. The definition of a reasoning chain looks very much like a path on a graph G α that has literals (p and p are called literals) as nodes; and an edge from node x to y iff there is either a clause (x y) or (y x) in α, where x is the complement of literal x (i.e., p = p and p = p). For example, if α contained the clause (p 2 p 37 ), G α would contain an edge from p 2 to p 37 and another one from p 37 to p 2. We then conclude that the existence of a reasoning chain over α from p i to p i and from p i to p i is equivalent to the existence of a path on G α from p i to p i and another from p i to p i. Checking for the existence of a path between two nodes in a graph is known to be in NL, but what about the existence of two paths? The latter is just the problem PATH PATH, which we already know is in NL as well! And since NL is closed by complements, the fact that no two such reasoning chains for p i / p i exist, which correspond to a query on PATH PATH, is in NL as well. Summing up, deciding that α Krom-SAT k corresponds to checking the following k problems: ((G α, p 1, p 1 ), (G α, p 1, p 1 )) PATH PATH ((G α, p 2, p 2 ), (G α, p 2, p 2 )) PATH PATH. ((G α, p k, p k ), (G α, p k, p k )) PATH PATH But since k is fixed, we can use k times and therefore, α Krom-SAT k corresponds to checking whether the tuple: (((G α, p 1, p 1 ), (G α, p 1, p 1 )), ((G α, p 2, p 2 ), (G α, p 2, p 2 )),... ((G α, p k, p k ), (G α, p k, p k ))) is an element of the problem: (PATH PATH) (PATH PATH) (PATH PATH) }{{} k times The latter, which we shall call P k for brevity, is in NL by construction. We can then have a reduction from Krom-SAT k to P k by way of the function f k such that f k (α) is the large tuple above. What we still need to verify is that f k (α) can be computed using space logarithmic in the length of α. The key step is to show that G α can be built this way, but this is not hard: compute_graph k (α) // NB. in t h i s program k i s a constant, not a v a r i a b l e! // We assume nodes are numbered 1, 2,... k, k + 1, k + 2,... k + k // From 1 to k, they correspond to p 1, p 2,... p k // From k + 1 to k + k, to p 1, p 2,... p k // We assume l i t (i) r e t u r n s p i i f i k and p i k o t h e r w i s e // S i m i l a r l y neg (i) r e t u r n s p i i f i k and p i k o t h e r w i s e // We w i l l output the adjacency matrix, b i t by b i t. We 2

3 fo r i := 1 to 2 k fo r j := 1 to 2 k // we need to output the b i t corresponding // to c e l l ( i, j ) o f the adjacency matrix i f ( l i t ( i ) l i t ( j ) ) occurs in α or ( neg ( j ) neg ( i ) ) occurs in α then output ( 1 ) else output ( 0 ) Since k is a constant, i and j take constant space (log k bits each). The check at the guard needs to traverse α searching for the two given clauses, if the input is simple enough, it can even be done with no space overhead (in the worst case, pointers that delimit the clauses suffice, in which case we would have space proportional to the logarithm of the length of the input). We may conclude that compute_graph_k runs in logarithmic space. Finally, we compute f k as follows (we use indentation to clarify the structure of the output): f k (α) for i :=1 to k compute_graph k (α) compute_graph k (α) Again, variable i takes constant space (since k is constant) and each call to compute_graph k requires logarithmic space. We have then established that, for each k N, Krom-SAT k logspace P k, and since P k was easily seen to be in NL, the former is in NL as well. Unfortunately, this doesn t give us a reduction for Krom-SAT, since for each k we are reducing to a different problem (i.e. P 1, P 2, P 3 are all different problems). In order to use this same idea as a reduction that works for all Krom-SAT, we would need to show that the problem i=1 P i is also in NL. This will be the topic of the final section, but before, that... An aside: isn t it obvious now that Krom-SAT is in NL? Given that we have shown that Krom-SAT k NL for every k, some may wonder if it is not completely obvious that Krom-SAT has to be in NL as well and regard the following section as, perhaps, pedantic and 3

4 unnecessary. Obviousness lies in the eye of the beholder, so if that is the case, we cannot really challenge that, but let us consider a very similar problem: SAT k = {α α is a satisfiable propositional formula built from propositions p 1, p 2,... p k } Intuitively, SAT k is to SAT as Krom-SAT k is to Krom-SAT. The following deterministic program decides SAT k following a brute-force approach: it just tries every possible valuation. brute_force_sat k (α) // In what f o l l o w s v i i s to be t h o u g h t as a // t r u t h v a l u e (0 = f a l s e or 1 = t r u e ) f o r p r o p o s i t i o n p i for v 1 := 0 to 1 for v 2 := 0 to 1 for v 3 := 0 to 1... return for v k := 0 to 1 i f (v 1, v 2, v 3,... v k ) s a t i s f i e s α then return true f a l s e For each k, brute_force_sat k contains k nested for-loops. Now, for a fixed k, what is the time complexity of this program? It is not hard to verify that checking whether (v 1, v 2, v 3,... v k ) satisfies α can be done in polynomial time, so let s say it takes time at most n c for some constant c. This check is run at most 2 k times, so the overall complexity is at most 2 k n c. Now, 2 k is a very large constant but a constant (since k is fixed), so SAT k PTIME for all k. If it is also completely obvious that SAT has to be in PTIME, we would be quite interested in listening to the argument for that in detail! Incidentally, given that SAT k is probably simpler 1 than SAT, couldn t it be the case that Krom-SAT k is also simpler than Krom-SAT? The answer is YES!, and constitutes a nice exercise for idle times: show that Krom-SAT k SPACE(0), that is, it can be solved without using any working tape whatsoever! 2 (hint: the same argument works for SAT k if formulas are assumed to be in CNF). The problem of querying an unbounded number of times We can summarize the situation as follows. We know that for a fixed k, checking k instances of a problem A in NL is in NL, as witnessed by the fact the A A A }{{} k times is in NL, but we would need to verify that checking an unbounded number of instances is in NL as well. That is, given A NL, we want to show that: A := {l ({0, 1} ) k st. l = [x 1, x 2,... x k ] and 1 i k, x i A} 1 Probably, since, of course, PTIME = NPTIME may end up being the case contrary to expectations. 2 Having this, we do know for sure that Krom-SAT k is simpler than Krom-SAT since the latter is known to be NL-complete and the space hierarchy theorem tells us that there are problems in NL that are not solvable in SPACE(0) 4

5 is in NL as well. Intuitively, the input to A is a list (of unbounded length) of inputs to A, and it accepts only those lists such that all its elements are accepted. Assume that M A (x) is a Turing machine that decides A. Moreover, let idx : (({0, 1} ) N) {0, 1} be the list index function such that: { x i if l = [x 1, x 2... x n ] and 1 i n idx(l, i) := ɛ otherwise where ɛ denotes the empty string. It is clear that idx can be computed by a non-deterministic Turing machine in logarithmic space (we only need space for a counter that goes from 0 to the length of the input). Using these two functions we define: M A (l) // Unlike before, k depends on the input here k := l e ngth of l fo r i := 1 to k assert M A ( idx (l, i ) ) It is clear that M A decides A, we only need to verify that it requires space O(log n), where n is the length (in bits) of the input. Clearly i can hold at most k which is always l, so we need log l log n bits for it. The only question is whether the call to M A (idx(l,i)) uses logarithmic space. Here we need to pay attention to an implementation detail, namely, the way in which M A is called. Clearly, we cannot compute idx(l,i) and save it in an auxiliary tape, since the space usage for that tape would be linear on n (e.g., when l = 1). Instead, we can assume that idx is implemented in such a way that l is read from the input tape while i is read from an auxiliary tape (which it will consider read-only). Now we can repeat the same construction that was used to show that logspace computations are closed by composition to argue that there exists another Turing machine M (l, i) that computes the same as M A (idx(l,i)) (also reading i from the secondary tape) and requiring only logarithmic space. If we use this M in implementing M A, then it clearly runs in logspace. ( Finally, reusing ) the ideas from before we can define a function f that reduces Krom-SAT to : PATH PATH f (α) k := count p r o p o s i t i o n s in α for i :=1 to k compute_graph ( α) 5

6 compute_graph ( α) compute_graph ( α) k := count p r o p o s i t i o n s in α // We assume nodes are numbered 1, 2,... k, k + 1, k + 2,... k + k // From 1 to k, they correspond to p 1, p 2,... p k // From k + 1 to k + k, to p 1, p 2,... p k // We assume l i t (i) r e t u r n s p i i f i k and p i k o t h e r w i s e // S i m i l a r l y neg (i) r e t u r n s p i i f i k and p i k o t h e r w i s e // We w i l l output the adjacency matrix, b i t by b i t. We fo r i := 1 to 2 k fo r j := 1 to 2 k // we need to output the b i t corresponding // to c e l l ( i, j ) o f the adjacency matrix i f ( l i t ( i ) l i t ( j ) ) occurs in α or ( neg ( j ) neg ( i ) ) occurs in α then output ( 1 ) else output ( 0 ) If α requires n bits to be represented, then certainly the number of propositions occurring in it is no larger than n. That means that, in both procedures, k requires at most log n bits of space, and therefore i and the result of i+k in f, and i and j in compute_graph need O(log n) bits of space as well, since in the worst case, they can hold the value 2 k. We conclude, then, that Krom-SAT logspace ( PATH PATH ) and, consequently, Krom-SAT NL. 6