Computer
Sciences
Department
A New Time-Space Lower Bound for Nondeterministic
Algorithms Solving Tautologies
Scott Diehl
Dieter van Melkebeek
Ryan Williams
Technical Report #1601
October 2007
Prepare for your exams
Study with the several resources on Docsity
Earn points to download
Earn points by helping other students or get them with a premium plan
Guidelines and tips
Prepare for your exams
Study with the several resources on Docsity
Earn points to download
Earn points by helping other students or get them with a premium plan
New Time-Space Lower Bound for Nondeterministic Algorithms Solving Tautologies, Papers of Engineering
A new time-space lower bound for nondeterministic algorithms solving tautologies, boosting the time lower bound for subpolynomial space algorithms to 3√4−o(1). The result is stated in the less restrictive setting of small-polynomial space bounds.
Typology: Papers
Pre 2010
1 / 12
This page cannot be seen from the preview
Don't miss anything!
Related documents
Partial preview of the text
Download New Time-Space Lower Bound for Nondeterministic Algorithms Solving Tautologies and more Papers Engineering in PDF only on Docsity!
Computer
Sciences
Department
A New Time-Space Lower Bound for Nondeterministic
Algorithms Solving Tautologies
Scott Diehl Dieter van Melkebeek Ryan Williams
Technical Report #
October 2007
A New Time-Space Lower Bound for Nondeterministic Algorithms
Solving Tautologies
Scott Diehl ∗
University of Wisconsin-Madison
[email protected]
Dieter van Melkebeek †
University of Wisconsin-Madison
[email protected]
Ryan Williams
Carnegie Mellon University
[email protected]
October 6, 2007
Abstract We show that for all reals c and d such that c^2 d < 4 there exists a positive real e such that tautologies cannot be decided by both a nondeterministic algorithm that runs in time nc, and a nondeterministic algorithm that runs in time nd^ and space ne. In particular, for every real d < 3
√ 4 there exists a positive real e such that tautologies cannot be decided by a nondeterministic algorithm that runs in time nd^ and space ne.
1 Introduction
Tautologies is the set of Boolean formulas that are satisfied by every assignment to their variables. Lower bounds for nondeterministic algorithms deciding tautologies relate to the fundamental ques- tion of NP versus coNP. Although we expect that NP 6 = coNP, the best lower bound we have to date only shows that conondeterministic time t is not contained in nondeterministic time o(t), and we cannot rule out even a linear-time nondeterministic algorithm for tautologies. One way to approach this shortcoming is to show lower bounds within specific families of propositional proof systems, such as resolution. This corresponds to establishing time lower bounds for the nondeterministic algorithms that solve tautologies within those proof systems. Although the lower bounds achieved in this manner are often quantitatively very strong (see [1] for a survey), they only apply to these specific algorithms. A different direction that has been successful at proving lower bounds focuses on nondetermin- istic algorithms that are only restricted in the amount of space they use. For example, one result along these lines gives a time lower bound of n
√ 2 −o(1) ≈ n^1.^414 for nondeterministic algorithms that solve tautologies while using a subpolynomial amount of space, i.e., space no(1)^ [4]. In this report, we present a new time-space lower bound for nondeterministic algorithms solving tautolo- gies, boosting the time lower bound for subpolynomial space algorithms to n
√ (^34) −o(1) ≈ n^1.^587. We state the result in the less restrictive setting of small-polynomial space bounds: ∗Supported by NSF Career award CCR-0133693 and Cisco Systems Distinguished Graduate Fellowship. †Partially supported by NSF Career award CCR-0133693.
In the remainder of the report, we focus on proving the condition c^2 d < 4 given in Theorem
- To do so, we first present some essential techniques and lemmas in Section 2 before proving the result in Section 3.
2 Preliminaries
In this section, we describe some conventions and definitions that we follow throughout the report, as well as describe some techniques and results that are crucial to our proofs.
2.1 Machine Model
All of our results are robust with respect to choice of machine model. For concreteness, we use the random-access machine model throughout the report. We refer to [6] for a description of this model. Our arguments skim over the details regarding the constructibility of functions involved— in the end, the functions we are interested in are polynomials, which are sufficiently constructible for our purposes. We take this opportunity to point out an important limitation that space restrictions impose on a nondeterministic machine: although a nondeterministic machine can guess one bit per unit of running time, it does not have two-way access to these bits unless it explicitly writes them down on its worktapes. Such a machine can only remember as many of its guess bits at one time as its space bound allows. Thus, a space-bounded nondeterministic machine cannot necessarily follow the typical behavior of writing down its guess in full (say, an assignment to Boolean variables) and then verifying if this guess has a certain property (say, satisfies a given formula) while enjoying two-way access to the guess.
2.2 Notation
Much of our notation is standard, although we adopt some nonstandard abbreviations to be concise. For functions t and s, we denote NT(t) to be the class of languages recognized by nondeterministic machines running in time O(t) and NTS(t, s) to be those recognized by nondeterministic machines running in simultaneous time O(t) and space O(s). We prefix “co” to either to represent their complementary class. We often use the same notation to refer to classes of machines rather than classes of languages; where the interpretation isn’t clear from context, either should work. In our arguments, it is often necessary to describe an alternating computation where the number of guess bits in a given phase is explicit. To this end, we adopt the following notation (see [2] for more discussion).
Definition 1. Given a complexity class C and a function f , we define the class ∃f^ C to be the set of languages that can be described as
{x|∃y ∈ { 0 , 1 }O(f^ (|x|))P (x, y)},
where P is a predicate accepting a language in the class C when its complexity is measured in terms of |x| (not |x| + |y|). We analogously define ∀f^ C.
2.3 Conondeterministic Linear Time Versus Tautologies
One result that we use (as with every known time-space lower bound for satisfiability or tautologies) is a tight connection between the tautologies problem and the class of languages recognized by conondeterministic linear-time machines, coNT(n). The Cook-Levin Theorem, the seminal result showing that satisfiability is NP-complete, can be interpreted as saying that satisfiability captures the time complexity of all of NP up to polynomial factors; the complement of this statement applies to the tautologies problem and coNP. Fortnow et al. [4] formulated a sufficiently strong version of this statement which shows that tautologies tightly captures the time and space complexity of conondeterministic linear time in a way that allows lower bounds for the latter to transfer with little loss in parameters to the former (and vice-versa).
Lemma 3 ([4]). For positive reals d and e, if
coNT(n) * NTS(nd, ne),
then for any reals d′^ < d and e′^ < e,
Tautologies ∈/ NTS(nd ′ , ne ′ ).
Since a lower bound for coNT(n) yields essentially the same lower bound for tautologies by Lemma 3, we focus on proving lower bounds of the former type for the remainder of the report.
2.4 Indirect Diagonalization
Our proofs follow the now-standard technique used to prove time-space lower bounds for satisfia- bility or tautologies known as indirect diagonalization. This is a proof by contradiction wherein we begin by assuming that the desired lower bound does not hold, which in the case of Theorem 2 is that coNT(n) ⊆ NT(nc) ∩ NTS(nd, ne). (1)
We then use this unlikely assumption to derive a series of more and more unlikely inclusions. The argument concludes when we derive an inclusion so unlikely that it contradicts a known diagonalization result. Most of the challenge in formulating an indirect diagonalization argument is in the step of deriving new inclusions from the hypothesis (1). The main two tools we use towards this end go in opposite directions:
(a) Speed up nondeterministic space-bounded computations by adding alternations, and (b) Eliminate these alternations at a moderate increase in running time via the hypothesis (1). To envision the utility of these items, notice that the hypothesis allows the simulation of a conondeterministic machine by a space-bounded nondeterministic machine. Item (a) allows us to simulate the latter machine by an alternating machine that runs in less time. Item (b) eliminates the alternations from this simulation, increasing the running time modestly. In this way, we end up back at a nondeterministic computation, so that overall we have derived a simulation of a conondeterministic machine by a nondeterministic one. The complexity class inclusion that this simulation yields is a complementation of the form
coNT(t) ⊆ NT(f (t)),
out an issue that arises in this context due to the necessity of treating the guess bits of previous alternating stages as input to the final stage: The running-time of the final stage must be linear in the original input and the guess bits of the previous alternating stages in order to apply the hypothesis. An example of accounting for this effect is as follows:
Proposition 5. Suppose that coNT(n) ⊆ NT(nc)
for some real c ≥ 1. Then for any time functions t and t′,
∃t ′ coNT(t) ⊆ NT((t + t′^ + n)c).
Proof. Consider a machine M recognizing a language in ∃t ′ coNT(t). Its acceptance condition on input x can be written as ∃y ∈ { 0 , 1 }O(t ′ (^) ) P (x, y),
where P (·, ·) is a predicate recognized by a conondeterministic machine running in time O(t) on input 〈x, y〉. Since P takes input of size O(n + t′), the hypothesis allows P to be recognized by a nondeterministic machine running in time O((t + t′^ + n)c) by a padding argument. In this way, we can characterize the acceptance of M by two consecutive existential guesses. Thus, M can be simulated by a nondeterministic machine that requires time O(t′) for its guess of y and O((t + t′^ + n)c) for the part recognizing P , for a total of O((t + t′^ + n)c) since c ≥ 1.
In a typical setting of t = t′^ = n1+Ω(1), Proposition 5 allows us to go from the second level of the polynomial-time hierarchy to the first at the cost of increasing the running-time to the power of c, as described above. The finer point to make is that although the argument only applies the hypothesis to the final conondeterministic phase, Proposition 5 indicates that, in general, the t′ guess bits of the initial phase factor into the cost of eliminating the alternation as much as the running time of the final phase does, even when the latter is much smaller. This point is where the special property of the speedup (2) becomes important, since the input to the final stage is only a small portion of the bits guessed in the initial stage, dramatically reducing the effect just described. We now have all the tools we need to carry out our indirect diagonalization argument to proof Theorem 2.
3 Proof of the Lower Bound
We prove Theorem 2 in this section, beginning with a brief discussion of the techniques required to prove the (c^2 − 1)d < c condition of [4]. We then show how to build on these techniques to arrive at the c^2 d < 4 condition. The relevant technical lemma from [4] can be thought of as trading space for time within NP under the hypothesis (1). More precisely, it tries to establish
NTS(t, s) ⊆ NT(f (t, s)) (3)
for the smallest possible functions f , with the hope that f (t, s) ≪ t. In particular, for subpolynomial space bounds, s = to(1), [4] achieves f = tc−^1 /c+o(1), which is smaller than t when c < φ ≈ 1 .618. As an example of the utility of the space-for-time statement, let us sketch the n
√ 2 −o(1) (^) lower
bound for subpolynomial-space nondeterministic algorithms solving tautologies mentioned in the
introduction. We assume, by way of contradiction, that coNT(n) ⊆ NTS(nc, no(1)). Then we have that: coNT(n) ⊆ NTS(nc, no(1)) [by hypothesis of indirect diagonalization] ⊆ NT(nc (^2) −1+o(1) ) [by trading space for time using (3).]
This is a contradiction with Lemma 4 when c <
2, yielding the desired lower bound. The space-for-time statement is shown by an inductive argument that derives statements of the type (3) for a sequence of smaller and smaller functions fℓ. The idea can be summarized as follows: We start with a space-bounded nondeterministic machine and apply the speedup (2).
NTS(t, s) ⊆ ∃bs^ ∀log^ b^ NTS(t/b, s) ︸ ︷︷ ︸ (∗) ︸ ︷︷ ︸ (∗∗)
We then use the inductive hypothesis to trade the space bound of the final stage (∗) of this Σ 3 - simulation for time: NTS(t, s) ⊆ ∃bs∀log^ bNT(fℓ− 1 (t/b, s)).
We conclude the inductive argument by using the assumption that coNT(n) ⊆ NT(nc) to eliminate the two alternations in this simulation, ending up with another statement of the form
NTS(t, s) ⊆ NT(fℓ(t, s)).
Our main modification to this argument comes by noticing that it uses only the time-bounded half of the hypothesis of the indirect diagonalization argument (1). By replacing (∗) in the above using the time and space bounded half of the hypothesis, that coNT(n) ⊆ NTS(nd, ne), we eliminate an alternation at the same time as re-introducing a space-bound. This allows us to apply the inductive hypothesis for a second time in the argument to trade this space bound for a speedup in time. Provided that the space-bounded half of the hypothesis is not too expensive, i.e., that d is not too much larger than c, the net effect is to eliminate the alternation in (∗∗) even more efficiently, yielding a smaller fℓ after completing the argument. That this approach works better than the previous when d is close to c makes plausible the behavior as illustrated in Figure 1. Two key ingredients that allow the above idea to yield a quantitative improvement for certain values of c and d are (i) that the conondeterministic guess at the beginning of stage (∗∗) is only over log b bits and (ii) the fact mentioned in Section 2 that (∗) has input size only O(n + s). Because of (i), the running time of (∗∗) is dominated by that of (∗), allowing us to reduce the cost of simulating (∗∗) without an alternation only by reducing the cost of simulating (∗) in coNT. Item (ii) is important for the latter task, as per the discussion of Proposition 5, because the input size of (∗) is much smaller than the O(n + bs) bits taken by (∗∗); in particular, it does not increase with b. Now that we have sketched the important ideas, we present the details.
Lemma 6. If coNT(n) ⊆ NT(nc) ∩ NTS(nd, ne)
for some reals c, d, and e then for every nonnegative integer ℓ, time function t, and space function s ≤ t,
NTS(t, s) ⊆ NT
(tsℓ)αℓ^ + (n + s)aℓ
lines of Proposition 5. Specifically, since (∗∗) takes input of size O(n+bs), this places the simulation in ∃bsNT
(( t b sℓ)αℓ^ μℓ^ + (n + s)aℓμℓ^ + (n + s)aℓ^ + (bs + n))c
⊆ NT(((
t b
sℓ)αℓ^ μℓ ︸ ︷︷ ︸ (ց)
+(n + s)aℓ^ μℓ^ + (n + s)aℓ^ + (^) ︸︷︷︸bs (ր)
)c), (^) (12)
where the inclusion holds by collapsing the adjacent existential phases (and the time required to guess the O(bs) configuration bits is accounted for by the observation that c ≥ 1). Therefore, we have arrived at a simulation that gives rise to an inclusion of NTS(t, s) in NT(·); all that remains is to choose b to optimize the running-time. Notice that the running time of the simulation in (12) has one term, (ր), that increases with b and one term, (ց), that decreases with b. The running-time is optimized up to a constant factor by choosing b to equate the two terms, resulting in a choice of
b∗^ =
(tsℓ)αℓ^ μℓ s
) 1 /(1+αℓ μℓ) .
When this value is at least 1, the running-time of the nondeterministic simulation (12) is
O
(tsℓ+1)cαℓμℓ/(1+αℓ^ μℓ)^ + (n + s)caℓμℓ^ + (n + s)caℓ
resulting in the recurrences (5) and (6). If b∗^ < 1, then b = 1 is the best we can do; the desired bound still holds since in this case (ր) + (ց) = O(s), which is dominated by the (n + s)aℓ+1^ term.
Under the hypothesis of Lemma 6, we can further deduce that for a sufficiently large polynomial τ , coNT(τ ) ⊆ NTS(τ d, τ e) ⊆ NT(τ (d+eℓ)αℓ^ + τ eaℓ^ ) = NT(τ μℓ+1^ ), (13)
which is a contradiction with Lemma 4 when μℓ+1 < 1. Therefore, the key question is for what values of c, d, and e does μℓ+1 take on a value less than 1. Our analysis focuses on small values of e and shows how such a setting allows us to exhibit the desired behavior in μℓ.
Theorem 7. For all reals c and d such that c^2 d < 4 there exists a positive real e such that
coNT(n) * NT(nc) ∩ NTS(nd, ne).
Proof. The case where either c < 1 or d < 1 is ruled out by Lemma 4. For c ≥ 1 and d ≥ 1, assume (by way of contradiction) that
coNT(n) ⊆ NT(nc) ∩ NTS(nd, ne)
for a value of e to be determined later. As noted above, the hypothesis in conjunction with Lemma 6 yields the complementation (13) for any integer ℓ ≥ 0 and sufficiently large polynomial bound τ. Our goal is now to characterize the behavior of μℓ in terms of c, d, and e. This task is facilitated by focusing on values of e that are small enough to smooth out the complex behavior of μℓ caused by (i) the appearance of the nonconstant term eℓ in the recurrence and (ii) its definition via the maximum of two functions.
We first handle item (i) by introducing a related, nicer sequence by substituting a real β (to be determined) as an upper bound for eℓ: Let
μ′ ℓ = max(α′ ℓ(d + β), ea′ ℓ), (14)
where α′ 0 = 1, a′ 0 = 1 and α′ ℓ+1 = cα′ ℓμ′ ℓ/(1 + α′ ℓμ′ ℓ), (15)
and a′ ℓ+1 = ca′ ℓ · max(1, μ′ ℓ). (16)
As long as β behaves as intended, i.e., that eℓ ≤ β, we can show by induction that αℓ ≤ α′ ℓ, aℓ ≤ a′ ℓ, and μℓ ≤ μ′ ℓ. Therefore, μ′ ℓ upper bounds μℓ up to a value of ℓ that depends on e, and this ℓ-value becomes large when e is very small. This allows us to use μ′ ℓ as a proxy for μℓ in our analysis. To smooth out the behavior caused by issue (ii), we point out that the first term in the definition (14) of μ′ ℓ is larger than the second when e is very small. Provided that this is the case, μ′ ℓ follows the sequence νℓ defined as follows:
ν 0 = d + β νℓ+1 = ν ℓ^2 c(d + β)/((d + β) + ν ℓ^2 ).
This delivers a simpler sequence to analyze. Notice that because the underlying transformation, η → η^2 c(d + β)/((d + β) + η^2 ), is increasing over the reals, the sequence νℓ is monotone. It is decreasing if and only if ν 1 < ν 0 , which is equivalent to (c − 1)(d + β) < 1. Furthermore, when c^2 (d + β) < 4, the transformation has a unique real fixed point at 0. Since the underlying transformation is also bounded and starts positively, the sequence νℓ must decrease monotonically to 0 in this case. Therefore, when c^2 d < 4 we can choose a positive β such that νℓ becomes as small as we want for large ℓ. Provided that β, e, and ℓ satisfy the assumptions required to smooth out items (i) and (ii), this also gives us that μℓ is small. More formally, let ℓ∗^ be the first value of ℓ such that νℓ+1 < 1. Then to satisfy item (i), we require that
e(ℓ∗^ + 1) ≤ β. (18)
For item (ii), we require that the first term in the definition (14) of μ′ ℓ dominates the second up to this point, namely, α′ ℓ(d + β) ≥ er′ ℓ for all ℓ ≤ ℓ∗^ + 1. (19)
When all of these conditions are satisfied, we have that
μℓ∗+1 ≤ μ′ ℓ∗+1 = νℓ∗+1 < 1 ,
and the running-time of the conondeterministic simulation represented by (13) for ℓ = ℓ∗^ runs in time O(τ μℓ∗+1^ ) = O(τ μ
′ ℓ∗ (^) + ) = O(τ νℓ∗+1^ ). (20) Therefore, by choosing a small enough positive e to satisfy the finite number of constraints in (18) and (19), we arrive at our goal of exhibiting an exponent cost in the complementation of (13) that is smaller than 1. This is a contradiction, which proves the desired lower bound.