Bounded Queries to SAT and the Boolean Hierarchy - Semantic Scholar

Bounded Queries to SAT and the Boolean Hierarchy Richard Beigel Department of Computer Science The Johns Hopkins University Baltimore, MD 21218 To appear in TCS Abstract

We study the complexity of decision problems that can be solved by a polynomial-time Turing machine that makes a bounded number of queries to an NP oracle. Depending on whether we allow some queries to depend on the results of other queries, we obtain two (probably) dierent hierarchies. We present several results relating the bounded NP query hierarchies to each other and to the Boolean hierarchy. We also consider the similarly-de ned hierarchies of functions that can be computed by a polynomial-time Turing machine that makes a bounded number of queries to an NP oracle. We present relations among these two hierarchies and the Boolean hierarchy. In particular we show for all k that there are functions computable with 2k parallel queries to an NP set that are not computable in polynomial time with k serial queries to any oracle, unless P = NP. As a corollary k + 1 parallel queries to an NP set allow us to compute more functions than are computable with only k parallel queries to an NP set, unless P = NP; the same is true of serial queries. Similar results hold for all tt-self-reducible sets. Using a \mind-change" technique, we show that 2k ? 1 parallel queries to an NP set allow us to accept in polynomial time exactly the same sets as can be accepted in polynomial time with k serial queries to an NP set. (In fact, the same is true for any class in place of NP that is closed under polynomial-time positive-bounded-truth-table reductions.) This contrasts with the expected result for function computations with an NP oracle [6]. In addition we show that the Boolean hierarchy and the bounded query hierarchies (of languages) either stand or collapse together. Finally we show that if the Boolean hierarchy collapses to any level but the zeroth (deterministic polynomial time), then for all k there are functions computable in polynomial  Research supported by a Fannie and John Hertz Foundation fellowship and by NSF grant CCR8808949. Part of this work was done while the author was a graduate student at Stanford University.

1

time with k parallel queries to an NP set that are not computable in polynomial time with k ? 1 serial queries to any set (NP-complete sets are p-superterse).

1. Introduction We de ne four bounded query hierarchies, which consist of functions and sets that can be computed with a bounded number of queries to an NP oracle, where we distinguish between serial queries (as in a Turing reduction) and parallel queries (as in a truth-table reduction). (In [11] serial queries are called adaptive, and parallel queries are called nonadaptive. For additional background, see [1, 2, 8, 5].) We adopt the following notation from [3]:

Notation 1 Let A be a set, C a class of sets, and r a reduction.  PAr is the class of all sets that are polynomial-time r-reducible to A.  PFAr is the class of all functions that are polynomial-time r-reducible to A.  PCr = [A2C PAr .  PFCr = [A2C PFAr. We write k-tt to denote truth-table reducibility of norm k and k-T to denote Turing reducibility with only k queries. (See [3] for de nitions of standard concepts in complexity theory.) Thus, PAk-tt is the class of all sets that are accepted by a polynomial-time algorithm that makes k parallel queries to A, and PAk-T is the class of all sets that are accepted by a polynomial-time algorithm that makes k serial queries to A. The hierarchy PA1-T ; PA2-T ; PA3-T; : : : is called the bounded query hierarchy of sets relative to A. The hierarchy PFA1-T ; PFA2-T ; PFA3-T; : : : is called the bounded query hierarchy of functions relative to A. The other two hierarchies are called the bounded parallel query hierarchies. When no confusion is possible, we refer to all four of these hierarchies collectively as the bounded query hierarchies. Each element of a bounded query hierarchy is called a bounded query class. See [9, 10] for more on bounded query classes relative to nonrecursive oracles. NP NP NP We are most interested in the classes PFNP k-T , PFk-tt , Pk-T , and Pk-tt. Note that if NP A NP A is NP-complete then PFk-T = PFk-T , etc. The PFk-T hierarchy has been studied previously by Krentel in [18] (he considers a non-constant query bound), because it provides a natural measure of the complexity of NP-hard functions. In a similar way, the two bounded query hierarchies of sets provide natural measures of the complexity of NP-hard decision problems. Those two hierarchies are 2

closely related to the Boolean hierarchy, which has been studied by many people including Cai, Hemachandra, Kobler, Schoning, and Wagner [14, 17]. The second level of the Boolean hierarchy was studied by Papadimitriou and Yannakakis [22]. In Section 4., we determine how the bounded NP query hierarchies of sets interleave with the Boolean hierarchy, and then we show that either all three hierarchies of sets collapse at some level, or else all three hierarchies of sets are proper. (Some of these results were obtained previously in [17].) The idea of alternations was rst used by Markov in [19] to minimize the number of not-gates in a circuit. It was later used by Putnam in [24] to show that every consistent formula of quanti cation theory has a model in the Boolean algebra over the r.e. sets. Putnam's term for alternations is \mind changes." Mind changes have been applied to the further study of that Boolean algebra in [10]. In this paper, we use mind changes in order to re-derive a theorem of [29], obtaining as a corollary that NP NP NP PFNP (2k ?1)-tt = PFk-T . Based on this, Buss and Hay were able to show that Ptt = Pbf [12], thus disproving a conjecture of Kobler, Schoning, and Wagner. (Wagner has also independently disproved his conjecture [28].) The mind change technique also yields a new proof of Hemachandra's surprising result that PNE = NPNE . In Section 5., we examine a tradeo between serial queries and parallel queries to general oracles (this is related to p-terseness). We de ne k-cheatable sets and prove an important technical result, the Weak Nonspeedup Theorem, which says that an arbitrarily large number of parallel queries to a k-cheatable set can be answered in polynomial time by making only 2k ? 1 of the same queries (to the same set) in parallel. This enables us to show, for example, that the bounded query hierarchies NP PFNP k-T and PFk-tt are proper unless P = NP. A similar result holds for all tt-selfreducible oracles. In Section 6., we prove that if P 6= NP and the Boolean hierarchy collapses, then A PFNP k-tt 6 PF(k?1)-T for any A; in other words k parallel queries to an NP oracle allow us to compute functions that cannot be computed by making k ? 1 serial queries to any oracle. This is surprising because we assume a collapse in order to conclude a separation.

2. Preliminaries Let A(x) = 1 if x 2 A, 0 if x 2= A. The function FAk de ned below is a convenient notation for the results of k parallel queries to A. The function FA! de ned below returns the answers to any number of parallel queries to A. De nition 2 We de ne functions FAk and FA! by ( A(x1); : : :; A(xr)) if r = k A Fk (x1; : : :; xr ) = (unde ned otherwise FA! (x1; : : :; xr ) = (A(x1); : : :; A(xr)): A Note that PFF1-kT = PFAk-tt, where we abuse notation slightly by allowing a function as an oracle. We will usually allow only sets as oracles. 3

We write f  g to denote the composition of the functions f and g. We de ne the composition of sets of functions by lifting the ordinary composition operator: De nition 3 If C1 and C2 are two sets of functions then C1  C2 = ff1  f2 : f1 2 C1 and f2 2 C2g: We de ne a companion operation to the composition of two functions. If x and y are two lists (we also treat scalars as singleton lists) then we write x k y to denote the concatenation of x and y as lists (not as strings).

De nition 4  If f1 and f2 are two functions, then (f1 k f2)(x) = f1(x) k f2(x):  If C1 and C2 are two sets of functions then C1 k C2 = ff1 k f2 : f1 2 C1 and f2 2 C2g: Note that the k operator is associative. The following obvious results show the connections between the bounded query classes and the  and k operators.

Observation 5

i. PFX(j+k)-T = PFXj-T  PFXk-T .

ii. PFX(j+k)-tt = PF  (PFXj-tt k PFXk-tt).

Proof:

i. It is obvious that PFXj-T  PFXk-T  PFX(j+k)-T. For the reverse containment, let h 2 PFX(j+k)-T . We de ne a function g 2 PFXk-T that returns the entire internal state of the machine computing h after the rst k queries have been made to X . Then we de ne a function f 2 PFXj-T that completes h's computation by making j additional queries to X . h = f  g. ii. It is obvious that PF  (PFXj-tt k PFXk-tt)  PFX(j+k)-tt. For the reverse containment, let h 2 PFX(j+k)-tt. We de ne a function g 2 PFXk-tt that returns the input and the answers to the rst k oracle queries made to X in the computation of h. We de ne a function f 2 PFXj-tt that returns the answers to the last j queries made to X . This information is sucient to simulate h in polynomial time without any further oracle queries.

4

The preceding observation is proved in greater detail and generality in [4]. The following observation is quite handy, because it allows us to propagate collapses.

Observation 6

i. If PFB(k+1)-T = PFBk-T then

(8j  k)[PFBj-T = PFBk-T ]: ii. If PFB(k+1)-tt = PFBk-tt then

(8j  k)[PFBj-tt = PFBk-tt]:

Proof:

i. Assume that PFBk-T = PFB(k+1)-T . For all t  0, PFB(k+m+1)-T = = = =

PFB(k+1+m)-T PFB(k+1)-T  PFBm-T by Observation 5(i) PFBk-T  PFBm-T by assumption PFB(k+m)-T by Observation 5(i): Thus PFB(k+m+1)-T = PFB(k+m)-T for all m  0. By transitivity, PFBj-T = PFBk-T for all j  k. ii. Assume that PFBk-tt = PFB(k+1)-tt. For all m  0, PFB(k+m+1)-tt = = = =

PFB(k+1+m)-tt PF  (PFB(k+1)-tt k PFBm-tt) by Observation 5(ii) PF  (PFBk-tt k PFBt-tt) by assumption PFB(k+m)-tt by Observation 5(ii): Thus PFB(k+m+1)-tt = PFB(k+m)-tt for all m  0. By transitivity, PFBj-tt = PFBk-tt for all j  k. The following is a convenient extension of the de nition of pm reducibility on sets.

De nition 7 f pm g if there exists a polynomial-time computable function h such that f = g  h. We nish this section by de ning two kinds of reductions between sets. Many of the results in this paper are valid not only for NP, but for any class that is closed under the following reductions: 5

De nition 8  A isp polynomial-time positive-bounded-truth-table reducible to B (denoted A pbtt B ) if there exists a constant k, polynomial-time computable functions q1; : : : ; qk, and a polynomial-time computable Boolean function f such that f is a nondecreasing function of its last k arguments and x 2 A () f (x; q1(x); : : : ; qk(x)):

 A is nondeterministically polynomial-time reducible to B (denoted A NP m B ) if there exists a polynomial-time computable function f and a polynomial p such that x 2 A () (9y:jyj  p(jxj))[f (x; y) 2 B ]:

3. The Boolean Hierarchy Several papers [23, 25, 29] have discussed the Boolean Hierarchy. Cai and Hemachandra studied it extensively, and they proved that several de nitions of the Boolean Hierarchy are equivalent [14]. We prefer the following: De nition 9 The ith level of the Boolean Hierarchy is NP(i), where NP(0) = P; NP(i + 1) = fL1 ? L2 : L1 2 NP; L2 2 NP(i):g The function #Ak de ned below determines how many of k strings are elements of A. De nition 10 We de ne an integer-valued function #Ak by X #Ak(x1; : : : ; xk ) = A(xi): 1ik

The predicate GEQA de ned below determines whether at least t strings are elements of A, where t is a parameter. De nition 11 We de ne a predicate GEQA by GEQA = f(t; x1; : : :; xn ) : #An(x1; : : : ; xn)  tg: The predicate PARITYAk, de ned below, determines whether an odd number of k strings are elements of A. De nition 12 We de ne predicates PARITYAk and PARITYA! by ( A (#k (x1; : : :; xk ) mod 2) if r = k A PARITYk (x1; : : : ; xr) = unde ned otherwise PARITYA! (x1; : : : ; xr) = (#Ar(x1; : : :; xr ) mod 2) 6

Since PARITYAk is a 0,1-valued function we will frequently write PARITYAk to mean the set having that characteristic function.

Observation 13 i. If A 2 NP then GEQA 2 NP. ii. If A 2 NP then #A2k ?1 2 PFNP k-T . iii. If A 2 NP then PARITYA2k ?1 2 PNP k-T .

iv. If A is NP-complete then PARITYAk is pm -complete for NP(k). v. NP(2k ? 1)  PNP k-T .

Proof: i. We can nondeterministically guess witnesses for membership of t strings in A and check them in polynomial time. (For xed t, we could produce a monotone Boolean formula expressing GEQA (t; ) in terms of A, so for xed t the observation depends only on the eective closure of NP under union and intersection.) ii. By (i), a single NP query tells us if at least j of the 2k ? 1 input strings are elements of A. A binary search tells us how many. iii. Follows from (ii). iv. (This has also been proved previously in [17] using the equivalent of Theorem 14(i) from the next section.) To see that every language in NP(k) is pmreducible to PARITYAk, let L = L1 ? (L2 ?


? (Lk?1 ? Lk )


) 2 NP(k). For 1  i  k de ne L0i = \1ti Lt. Then x belongs to L if and only if x belongs to L0i for an odd number of values of i. Since NP is eectively closed under intersection, L0i 2 NP. Therefore, since A is NP-complete, we can de ne fi so that x 2 L0i () fi(x) 2 A. Then

x 2 L () (f1(x); : : :; fk (x)) 2 PARITYAk: Thus L pm PARITYAk. To see that PARITYAk 2 NP(k), let Li(~x) = GEQA (i; ~x). Then PARITYAk = L1 ? (L2 ?


? (Lk?1 ? Lk )


). Since Li 2 NP by (i), PARITYAk 2 NP(k). Thus, PARITYAk is polynomial-time m-complete for NP(k). v. Follows from (iii) and (iv).

7

4. Bounded Queries vs. Boolean Hierarchy It is known that all time-bounded oracle computations can be turned into truth-table computations, because we can simulate the computation for all possible sequences of oracle answers. If we are, in addition, computing with a bounded number of queries, then the computation is a bounded-truth-table computation. Thus all languages in the bounded query classes are polynomial-time bounded-truth-table reducible to an NP language; by a theorem of [14], those languages must belong to the Boolean hierarchy. We address the question of where the class PNP k-T lies in the Boolean hierarchy. k+1 Amir and Gasarch [2] have previously shown that NP(2k ? 1)  PNP k-T  NP(2 ). A result due to Wagner and Wechsung allows us to determine, within one level, where NP NP PNP k-T and Pk-tt lie in the Boolean hierarchy. (The question for Pk-tt was answered previously by Kobler, Schoning, and Wagner [17].)

Theorem 14

A

PARITY k i. If A is NP-complete then PNP . k-tt = P1-T

NP ii. PNP k-T = P(2k ?1)-tt . iii. NP(k) [ co-NP(k)  PNP k-tt  NP(k + 1) \ co-NP(k + 1).

k k iv. NP(2k ? 1) [ co-NP(2k ? 1)  PNP k-T  NP(2 ) \ co-NP(2 ).

Proof: i. This was stated by Wagner and Wechsung in [29]. We present our own formal proof below, but rst we give some intuition. Suppose that L k-tt B , for some B 2 NP. We could simulate the truth-table reduction as follows: We determine the truth table and its entries q1; : : :; qk . Then we compute the value of the truth-table under the assumption that all oracle answers are 0. Next we enumerate (in canonical order) all possible witnesses of qi 2 B for all i. Whenever we discover a witness to qi 2 B where qi was not previously known to belong to B , we update the value of the truth table, using the corrected assumption. If the new information changes the value of the truth table, then we say that the truth table has \changed its mind." The nal value of the truth table will be the correct value, because we will have correctly determined which formulas are satis able. The nal value is the exclusive-or of the initial value and the low-order bit of the number of mind changes. There is no obvious way to discover exactly when a mind change occurs (even nondeterministically); however, we can nondeterministically test whether at least m mind changes could occur (for some ordering of the oracle answers, potentially dierent from the canonical order), in the following way: We guess m sequences of k oracle answers. Then we check that each yes in the ith sequence is also a yes in the (i + 1)st sequence; and we check that the truth table's value 8

given the ith sequence of answers is dierent from its value given the (i + 1)st sequence of answers. Then we guess witnesses to the queries corresponding to the yes answers in the mth sequence. Finally we check those witnesses. Thus, a single NP query can determine whether at least m mind changes could occur. Since A is NP-complete and m  k, a single query to PARITYAk determines whether the maximum number of mind changes that could occur is odd. In polynomial time we determine the initial Avalue of the truth table, then we exclusive-or the two bits. Thus, L 2 P1PARITY -T k . Formally, suppose that L 2 PNP k-tt. Then there exists a set B in NP, polynomialtime computable functions q1; : : :; qk , and a polynomial-time computable 0,1valued function f such that

x 2 L () f (x; (B (q1(x)); : : :; B (qk(x)))) = 1: In what follows, let ~v denote the vector (v1; : : : ; vk ) of length k. Let ~v0 denote the zero-vector. We write ~v  w~ to indicate that (8i)[vi  wi] and (9i)[vi < wi]: Let

T = f(x; m) : (9~v1; : : : ;~vm) (8i  k)[vim = 1 =) qi(x) 2 B ]; (8j  m)[~vj?1  ~vj ]; and (8j  m)[f (x; ~vj?1) 6= f (x; ~vj )]g: The set T is in NP, because we can guess ~v1; : : : ;~vm, check that qi(x) 2 B nondeterministically in polynomial time, check that ~vj?1  ~vj deterministically in time O(k), and evaluate f (x; ~vj ) deterministically in polynomial time. Let M (x) be the largest m such that (x; m) 2 T , and take ~vM (x) from some witness to that fact. Let ~ denote the vector of correct oracle answers. Then f (x; ~vM (x)) = f (x; ~ ); for otherwise (~v1; : : : ;~vM (x); ~) would be a witness to (x; M (x) + 1) 2 T . Furthermore, f (x; ~vM (x))  f (x; ~v0) + M (x) (mod 2)); because f (x; ~vj )  f (x; ~vj?1) + 1 (mod 2) for each j . Therefore

L(x) = f (x; ~v0)  (M (x) mod 2): Since k + 1 is the length of the longest increasing chain of vectors ordered by , it follows that M (x)  k. By construction, therefore,

M (x) =

X

1mk

9

T (x; m);

so (since A is NP-complete) the function M is pm-reducible to #Ak. Therefore the function (x)[M (x) mod 2] is pm-reducible to PARITYAk. Thus A

L 2 P1PARITY -T k :

We establish the reverse containment by noting that PARITYAk 2 PAk-tt for all A. ii. PXk-T  PX(2k ?1)-tt for all X because we can simulate the PXk-T computation for all possible sequences of oracle answers without making any queries. This simulation is guaranteed to terminate in polynomial time because we can impose a polynomial-time clock on each possible computation path. At most 2k ? 1 dierent queries could occur on all paths combined. We make them simultaneously, thus determining which is the correct path. For the reverse containment, let A be any NP-complete set. We have PNP (2k ?1)-tt

=



PARITY A2k ?1 P1-T by PNP k-T

by (i) Observation 13(iii):

iii. (This was proved previously in [17].) The rst containment follows from the de nitions. Let A be any NP-complete set. To show the second containment A p it is sucient to show that every set L in PNP k-tt is m -reducible to PARITYk+1 and is also pm reducible to the complement of PARITYAk+1 . We prove the rst half of this statement. Since PNP k-tt is closed under complement the second half follows automatically. PARITY Ak Let L 2 PNP . By (i), L 2 P . Therefore, there exist polynomial-time k-tt 1-T computable functions q1; : : : ; qk and a 0,1-valued function f such that

x 2 L () f (x)  PARITYAk(q1(x); : : :; qk (x)) = 1: Fix w1 2 A and w0 2= A. Let q0(x) = w1 if f (x) = 1, w0 otherwise. Then

x 2 L () PARITYAk+1(q0(x); q1(x); : : :; qk (x)) = 1: iv. Follows from (ii) and (iii). It is interesting to note what properties of the class NP are actually required in the proof of part (i). These properties are used only in order to show that the set T belongs to NP. Since k is a constant and m  k, all quanti ers in the de nition of T range over a nite set of possible values. Therefore they could be replaced by conjunctions and disjunctions (ands and ors). Thus the only property required of the class NP is closure under ppbtt-reductions de ned at the end of Section 2.. (This 10

is a machine-independent way of saying that NP is eectively closed under union, intersection and polynomial-time many-one reductions.) Note that the theorem can be rephrased slightly so as not to require the fact that NP contains a pm-complete set. It is easily seen that part (ii) is valid under the same assumptions. We will return to this point in the next Section 4.1.. In particular, parts (i) and (ii) hold for all p-invariant nondeterministic time classes. Now, let us assume only that k is bounded by a polynomial in the proof of part (i). Then the universal quanti ers range over a polynomial-size set of possible values and the existential quanti er ranges over an exponential-size set of possible values. Thus, in this case, the proof requires closure under ppbtt-reducibility and closure under NP m -reducibility. Buss and Hay were the rst to note that our proof of parts (i) and (iii) yields the following corollary [12]:

Corollary 15 Let A be NP-complete. L Ptt A if and only if L pm PARITYA! . Thus, for NP-complete sets A the set PARITYA! is pm-complete for PAtt. Kobler, Schoning, and Wagner [17] had previously proved the weaker result that PARITYA! is pm-complete for PAbf , where \bf" denotes Boolean-formula reduction. (The dierence

between tt-reductions and bf-reductions is that tt-reductions are allowed arbitrary polynomial-time bounded computation after the simultaneous queries, whereas bfreductions are required to pre-compute a polynomial-size Boolean formula and then to plug the oracle answers into that formula.) Since the two classes have a pmcomplete problem in common (and are closed under pm-reductions), they are equal. Kobler, Schoning, and Wagner had conjectured that these two classes were unequal, because it seemed that a proof would hinge on nding a polynomial-time algorithm to convert Boolean circuits into equivalent Boolean formulas. We note that Wagner also disproved his conjecture independently of Buss and Hay [28]. The conjecture can NP also be disproved as a corollary to Hemachandra's result [16] that PNP tt = PO(log n)-T . We say that a hierarchy is proper if all levels are distinct. We say that a hierarchy collapses at the kth level if the rst k levels are distinct, but all levels after the kth are equal to the kth level. We say that a hierarchy collapses if it collapses at some level, not necessarily the rst.

Theorem 16 The following are equivalent: i. The PNP k-T hierarchy is proper.

ii. The PNP k-tt hierarchy is proper. iii. The Boolean hierarchy is proper. iv. The PNP k-T hierarchy does not collapse.

v. The PNP k-tt hierarchy does not collapse.

vi. The Boolean hierarchy does not collapse.

11

Proof: (i) ) (iv), (ii) ) (v), (iii) ) (vi): By de nition. (iv) () (v) () (vi): Theorem 14 shows that all languages from each hierarchy

belong to the other two hierarchies. Therefore, if one hierarchy collapses, they all collapse. (vi) ) (iii): By contradiction. Suppose that NP(k + 1) = NP(k). Since NP(i) is the dierence of i NP languages, NP(t + k + 1) = NP(t + k), for all t. By transitivity, for all j  k, NP(j ) = NP(k). (vi) ) (ii): Let A be NP-complete. Proof by contradiction. Suppose that A A NP NP NP PNP (k+1)-tt = Pk-tt. Then PARITYk+1 2 Pk-tt. Therefore PARITYk+2 2 P(k+1)-tt = NP NP PNP k-tt by assumption. So, by Theorem 14(i), P(k+2)-tt = Pk-tt . Since NP PNP k-tt  NP(k + 1)  NP(k + 2)  P(k+2)-tt NP(k + 1) must be equal to NP(k + 2). Therefore the Boolean hierarchy collapses. NP (ii) ) (i): By Theorem 14(ii), the PNP k-tt hierarchy is a re nement of the Pk-T hierarchy. We note in passing that the bounded query class PNP k-T can be relativized to an X oracle X | we replace NP by NP and we also allow the k-Turing reduction unlimited access to the oracle X . PNP k-tt can be relativized similarly. Because Cai [13] has shown that the Boolean hierarchy is proper under almost all relativizations, it follows that NP the PNP k-T hierarchy and the Pk-tt hierarchy are proper under almost all relativizations. Because Cai and Hemachandra [14] have constructed for each k an oracle relative to which the Boolean hierarchy collapses at exactly the kth level, it follows that there exists an oracle relativize to which PNP k-tt hierarchy collapses at exactly the k th level, and another oracle relative to which the PNP k-T hierarchy collapses at exactly the k th level.

4.1. General Bounded Query and Dierence Hierarchies

In the preceding section we considered the bounded query hierarchies over NP and their relationships with the Boolean hierarchy, which is the same as the dierence hierarchy over NP. In this section we will consider bounded query hierarchies and dierence hierarchies over an arbitrary class of languages C . This will help us to further isolate the properties of NP that are needed for some of the previous results. Some of the proof techniques will be dierent. We begin by de ning dierence hierarchies. De nition 17 The ith level of the dierence hierarchy over the class C is denoted C by DIFF (i), where DIFFC (0) = P; DIFFC (i + 1) = fL1 ? L2 : L1 2 C ; L2 2 DIFFC (i):g We also de ne co-DIFFC (i) = fL : L 2 DIFFC (i)g: 12

Note that DIFFNP(i) = NP(i). We will show how the dierence hierarchy and the bounded query hierarchies interleave.

Theorem 18 i. If C is any class of languages then PCk-tt  PCk-T  PC(2k?1)-tt: ii. If C is any class of languages then

DIFFC (k) [ co-DIFFC (k)  PCk-tt: iii. If C is closed under ppbtt-reductions then

DIFFC (k) [ co-DIFFC (k)  PCk-tt  DIFFC (k + 1) \ co-DIFFC (k + 1): iv. If C is closed under ppbtt-reductions then

PC(2k ?1)-tt = PCk-T:

Proof: i. The rst containment is obvious. For the second containment, see the rst half of the proof of Theorem 14(ii). ii. This is obvious. iii. This follows from the proof of Theorem 14(iii) and the note that follows the proof of the theorem. iv. The proof is similar to the proof of Theorem 14(ii). The interleaving results above allow us to provide conditions under which the bounded query hierarchies over must C collapse.

Theorem 19

i. The DIFFC (k) hierarchy either collapses or is proper.

ii. The PCk-T hierarchy either collapses or is proper.

iii. Either PCk-tt  PC(2k+1)-tt or the PCk-tt hierarchy collapses to its kth level.

iv. If C is closed under ppbtt-reductions, then the PCk-tt hierarchy either collapses or is proper.

13

v. If C is closed under ppbtt-reductions, then the PCk-tt hierarchy collapses i the PCk-T hierarchy collapses i the DIFFC (k) hierarchy collapses.

Proof:

i. This could be proved in the same way as Theorem 16((vi) ) (iii)). However, the following nonconstructive proof demonstrates a more useful technique. Assume that the DIFFC (k) hierarchy does not collapse. Then choose the largest u such that DIFFC (u)  DIFFC (k). It is easily seen that DIFFC (u +1)  DIFFC (k +1), because every language in the former class is the dierence of a language in C and a language in DIFFC (u) = DIFFC (k). On the other hand, we chose u so that DIFFC (u + 1) 6 DIFFC (k), so DIFFC (k + 1) 6= DIFFC (k). Thus the DIFFC (k) hierarchy is proper. ii. Assume that the PCk-T hierarchy does not collapse. Choose the largest u such that PCu-T  PCk-T. It is easily seen that PC(u+1)-T  PC(k+1)-T , because every language in the former class can be computed by making one query to a language in C followed by the computation of a predicate in PCu-T = PCk-T. On the other hand, we chose u so that PC(u+1)-T 6 PCk-T , so PC(k+1)-T 6= PCk-T. Thus the PCk-T hierarchy is proper. iii. Assume that the PCk-tt hierarchy does not collapse to its kth level. Choose the largest u such that PCu-tt  PCk-tt. Then PC(u+1)-tt  PC(2k+1)-tt, because every language in the former class can be computed by making one query to a language in C and evaluating either of two predicates belonging to PCu-tt = PCk-tt, depending on the answer to the rst query (with 2k + 1 parallel queries we can ask the rst query and evaluate both possible predicates). On the other hand, we chose u so that PC(u+1)-tt 6 PCk-tt, so PC(2k+1)-tt 6= PCk-tt. iv. This proof diers from the preceding proofs, because we use the fact that two dierent hierarchies interleave in order to prove that one of them is proper. Assume that the PCk-tt hierarchy does not collapse. By Theorem 18(iv) the PCk-tt hierarchy and the DIFFC (k) hierarchy interleave, so we can choose the largest u such that DIFFC (u)  PCk-tt. It is easily seen that DIFFC (u + 1)  PC(k+1)-tt because every language in the former class can be expressed as the dierence of a language in C and a language in DIFFC (u)  PCk-tt. On the other hand, we chose u so that DIFFC (u + 1) 6 PCk-tt. Therefore PC(k+1)-tt 6= PCk-tt so the PCk-tt hierarchy is proper. v. These hierarchies interleave by Theorem 18. If one of them collapses then they must all collapse.

14

Note that in the proof of part (iii), we did not use the fact that the DIFFC (k) hierarchy interleaves the PCk-tt hierarchy level for level. This proof technique is applicable whenever the DIFFC (k) hierarchy interleaves the PCk-tt hierarchy in any fashion. (See [7] for applications of this technique to bounded query classes in a recursion-theoretic setting.)

4.2. Several Rounds of Queries

In this section we nd a normal form for computations that solve decision problems by making several rounds of queries to an NP set. As in the proof of Observation 5(i), it is easy to see that PFAnr -tt 


 PFAn -tt is the class of problems that can be solved in polynomial time by making n1 parallel queries to A, followed by n2 parallel queries to A, : : : ; followed by nr parallel queries to A. (See [4] for formalities and generalizations.) The following theorem was proved in [10] for computation without time bound; however the proof also establishes the result for polynomial time. The technique is a generalization of the binary search strategy used in the proof of Observation 13(ii). Theorem 20 For all A, 1

A

A

GEQ #A(n +1)




(nr +1)?1 2 PFGEQ nr -tt 


 PFn -tt 1

1

Corollary 21 If A 2 NP then NP PARITYA(n +1)




(nr +1)?1 2 P  PFNP nr -tt 


 PFn -tt 1

1

Proof: Theorem 20 and Observation 13(i) imply that NP #A(n +1)




(nr +1)?1 2 PFNP nr -tt 


 PFn -tt : 1

1

The result follows because PARITYAn (x1; : : :; xn) = #An(x1; : : :; xn) mod 2: Now we are ready to apply the mind-change technique to computations that make several rounds of NP queries.

Theorem 22 If A is NP-complete then PARITY A(n1 +1)




(nr +1)?1

P1-T

NP = P  PFNP nr -tt 


 PFn -tt: 1

15

Proof: Assume that L 2 P  PFBnr -tt 


 PFBn -tt for some NP language B . We

use the mind-change technique of Theorem 14(i). The intuition is similar, except that when we obtain new information about the answers to queries made at round j we must recompute the queries made at later rounds. We might as well assume that all queries made at rounds greater than j change. Then we assume that none of those queries belongs to B until we nd a witness for its membership. This leads to a slightly more complicated precedence relation among vectors of oracle answers. Formally, let ~v denote a sequence of r vectors such that the ith vector has length ni. That is, ~v = (~v1; : : :;~vr ) = ((v1;1; : : : ; v1;n ); : : : (vr;1; : : :; vr;nr )): NP Let L 2 P  PFNP nr -tt 


 PFn -tt. Then there exist a set B in NP and polynomial-time computable functions qi;j with 1  i  r and 1  j  nr such that qi;j (x; ~v) produces the j th query to be asked in the ith round, assuming that ~v provides correct answers to queries made in earlier rounds. There also exists a polynomial-time computable 0,1-valued function f such that x 2 L () f (x; ~v) = 1; 0 assuming that ~v provides correct answers to queries made in all rounds. Let ~v denote the zero-vector. We write ~v  w~ if ~v precedes w~ lexically when we apply the ordering  to individual components, that is, if (9j )[~vj  w~ j and (8i < j )[~vi = w~ i]]: Let 1 m T = f(x; m) : (9~v ; : : : ; ~v ) j = 1 =) q (x; ~v j ) 2 B ]; (8j  m)(8i  k)(8h  ni)[vi;h i;h j ?1  ~ j ~ (8j  m)[v  v ]; j ?1 j and (8j  m)[f (x; ~v ) 6= f (x; ~v )]g: 1 m j The set T is in NP, because we can guess ~v ; : : :; ~v , check that qi;h(x; ~v ) 2 B j ?1 j nondeterministically in polynomial time, check that ~v  ~v deterministically in j time O(n1 +


+ nr ), and evaluate f (x; ~~v ) deterministically in polynomial time. M (x) Let M (x) be the largest m such that (x; m) 2 T , and take ~v from some witness ~ to that fact. Let  denote the vector of correct oracle answers. Then M (x) f (x; ~v ) = f (x; ~); 1 M (x) for otherwise (~v ; : : :; ~v ; ~) would be a witness to (x; M (x)+1) 2 T . Furthermore, 1

1

1

M (x) 0 f (x; ~v )  f (x; ~v ) + M (x) (mod 2));

16

j j ?1 because f (x; ~v )  f (x; ~v ) + 1 (mod 2) for each j . Therefore

0

L(x) = f (x; ~v )  (M (x) mod 2): Let N = (n1 + 1)


(nr + 1). Since N is the length of the longest increasing chain of vectors ordered by , it follows that M (x)  N ? 1. By construction, therefore,

M (x) =

X

1mN ?1

T (x; m);

so (since A is NP-complete) the function M is pm-reducible to #AN ?1. Therefore the function (x)[M (x) mod 2] is pm-reducible to PARITYAN ?1. Thus A

N? : L 2 PPARITY 1-T 1

The reverse containment follows from Corollary 21.

Corollary 23 NP NP P  PFNP nr -tt 


 PFn -tt  Pdlog (n +1)


(nr +1)e-T : 1

1

Proof: Follows from Theorem 22 and Observation 13(iii).

As in Theorem 14, this proof goes through if NP is replaced by a class C that is closed under ppbtt-reductions. If we make the stronger assumption that C is closed under NP m -reductions then the result holds even when the number of queries and the number of rounds are not constant. (See [12] for similar results.) Next we will apply our techniques to oracles for nondeterministic exponential time.

De nition 24 i. E = [c1DTIME(cn ). ii. EXP = [k1 DTIME(2nk ). iii. NE = [c1 NTIME(cn ). iv. NEXP = [k1 NTIME(2nk ). Corollary 25 NE NE P  PFNE nr -tt 


 PFn -tt  Pdlog (n +1)


(nr +1)e-T : 1

1

Similar techniques yield a beautiful result due to Hemachandra that rst appeared in [16]. A simple proof of that result also appears in [27]. 17

Corollary 26 NPNE = PNE :

Proof:

Let L 2 NPNE, so that L is accepted by an NTIME(nk ) algorithm with oracle NE. We can simulate that algorithm on all possible paths, making the queries from dierent paths in parallel. Thus NE NE L 2 EXPNE (2nk )-T  EXP(2nk ? )-T 


 EXP1-T ; 1

where EXPAr is de ned by analogy to PAr. The number of queries made at each round is a function of the input length. By modifying the proof of Theorem 22, it is not hard to see that PARITY NE NP L 2 P  (P1-T k EXP1-T 2O(n2k ) ): ~0

The NP query is needed in order to evaluate f (x; ~v ). Each component of the query to PARITYNE 2O n k can be computed in polynomial time. We only need EXP because there are exponentially many components. Thus we can perform binary search in polynomial time, using O(n2k ) queries to an oracle that belongs to NEXP. Since every set in NEXP is pm-reducible to a set in NE (by padding), it follows that ( 2 )

NE L 2 PNEXP O(n k )-T  P : 2

5. Separating the Hierarchies of Functions NP In this section, we ask if the PFNP k-T and PFk-tt hierarchies are proper. Determining the NP relation between the PFk-T hierarchy and the PFNP k-tt hierarchy is helpful in showing that they are indeed proper (assuming P 6= NP). For that reason, we begin by examining the tradeo between serial queries and parallel queries in a general setting.

De nition 27 i. ii. iii. iv.

A set A is k-query p-terse if FAk 2= PFA(k?1)-T. A set A is p-terse if A is k-query p-terse for all k. A set A is k-query p-superterse if (8X )[FAk 2= PFX(k?1)-T]. A set A is p-superterse if A is k-query p-superterse for all k.

The origins of the name terse are explained in [9]. P-terseness is also studied in [2] and [5]. 18

De nition 28

i. An oracle A is k-cheatable if (9X )[FA2k 2 PFXk-T]. ii. An oracle A is cheatable if A is k-cheatable for some k.

We observe that p-superterseness and non-cheatability are transferred upwards under 1-tt reductions.

Observation 29 Suppose that A 1-tt B . i. If A is p-superterse then B is p-superterse. ii. If A is not cheatable then B is not cheatable.

Proof: (By contradiction.)

i. Suppose that B is not p-superterse, so that FBk 2 PFX(k?1)-T for some X . Since A 1-tt B , FAk 2 PFBk-tt  PFX(k?1)-T; so A is not p-superterse, which is a contradiction. ii. Suppose that B is cheatable, so that FB2k 2 PFXk-T for some X . Since A 1-tt B , FA2k 2 PFB2k -tt  PFXk-T ;

so A is cheatable, which is a contradiction. If FA2k can be computed by asking k queries to some oracle X in unbounded computation time, then we say that A is recursively cheatable. In [9] we proved the Nonspeedup Theorem, which states that all recursively cheatable sets are recursive. This might lead us to conjecture, by analogy, that all cheatable sets are in P. However, Amir and Gasarch [2] have constructed oracles A of arbitrarily great complexity such that (8k)[FAk 2 PFA1-T]. Nonetheless, we can prove a Weak Nonspeedup Theorem for polynomial-time computation; this theorem will have several interesting applications.

Theorem 30 If FA2k 2 PFBk-T then i. for every n  2k , any n parallel queries to A can be answered by a polynomial time algorithm that asks only 2k ? 1 of the same queries (to A) in parallel. ii. for every n, FAn 2 PFBk-T . This theorem originally appeared in [4]. The most elegant proof uses a combinatorial lemma due to Owings [21], which we present below. Before proving the theorem, we review the concept of computability by a set of polynomial-time functions. 19

De nition 31 The total function h is computable by a set of k polynomial-time computable functions if there exist k polynomial time computable functions g1 ; : : :; gk such that (8x)[h(x) 2 fgi(x) : 1  i  kg]:

Equivalently, the function h is computable by a set of k polynomial-time computable functions if, for each x, we can compute in polynomial time a length-k list that includes h(x). When h is computable by a set of k polynomial-time computable functions, we say informally that there are only k possible values for h(x). The following theorem [5] provides an equivalence between bounded query reducibility to an oracle and computability by a set of polynomial-time computable functions.

Theorem 32 i. If (9B )[h 2 PFBk-T ] then h is computable by a set of 2k polynomial-time computable functions.

ii. If h is computable by a set of 2k polynomial-time computable functions then (9B 2 Ph1-T )[h 2 PFBk-tt].

The following de nition is used in proving Owings's Separation Lemma.

De nition 33 If C is a collection of sets and X is a set, then X separates C if for all S; S 0 in C S= 6 S 0 ) S \ X =6 S 0 \ X: This section's main result will follow from the following combinatorial lemma, which says that k ? 1 points are sucient to separate k sets. The lemma appears in [21]. We present Owings's proof.

Lemma 34 (Owings) If jCj = k  1 then there exists a set X that separates C such that jX j  k ? 1. Proof: By induction on k. The base case (k = 1) is trivial. Assume that the lemma is true for some value of k  1. Let S1, S2 be distinct elements of C , and let x 2 (S1 ? S2) [ (S2 ? S1). Let C1 = fS 2 C : x 2 S g and C2 = fS 2 C : x 2= S g: Let k1 = jC1j and k2 = jC2j. By the induction hypothesis, there exists a set X1 that separates C1 such that jX1j  k1 ? 1, and there exists a set X2 that separates C2 such that jX2j  k2 ? 1. Let X = X1 [ X2 [ fxg. Then X separates C and jX j  k1 ? 1 + k2 ? 1 + 1 = k1 + k2 ? 1 = k ? 1. 20

Lemma 35 If FAk is computable by a set of k polynomial time functions, then any k queries to A can be answered by a polynomial time algorithm that asks only k ? 1 of the same queries in parallel.

Proof: that

By assumption, there exist k polynomial time functions g1; : : :; gk such

(8x1; : : : ; xk)[FAk(x1; : : :; xk ) 2 fgi(x1; : : :; xk ) : 1  i  kg]: Without loss of generality, assume that if i 6= j then gi(x1; : : :; xk ) 6= gj (x1; : : :; xk ) for all x1; : : :; xk . Let ~x = (x1; : : : ; xk ) and let X = fx1; : : :; xk g. For i = 1; : : :; k let

Si = fxj 2 X : the j th component of gi(~x) is 1g  X: We say that the set S agrees with the set A on X if S \ X = A \ X . Because FAn is computed by g1; : : :; gk , one of the sets S1; : : :; Sk agrees with A on X . Thus we can determine FAk(~x) by computing a natural number i such that Si agrees with A on X . Because the functions g1; : : : ; gk produce distinct outputs, the sets S1; : : : ; Sk are distinct. By Lemma 34, there is a (k ? 1)-element set X 0 = fx01; : : : ; x0k?1g that separates fS1; : : :; Sk g. Since S1; : : : ; Sk are subsets of X , points outside of X cannot help to separate fS1; : : :; Sk g; therefore, without loss of generality, we may assume that X 0 is a subset of X . Because one of the sets S1; : : : ; Sk agrees with A on X , at least one of the sets S1; : : : ; Sk agrees with A on X 0. Because X 0 separates fS1; : : :; Sk g, exactly one of the sets S1; : : :; Sk agrees with A on X 0. This set must also agree with A on X . Thus we can determine FAk(~x) by computing the unique i such that Si agrees with A on X 0. The following algorithm computes FAk: Step 1: Input x1; : : :; xk . Step 2: Compute S1; : : : ; Sk as above. Step 3: By using the construction implicit in Lemma 34 (or by trying all k possibilities) nd a set of k ? 1 points fx01; : : :; x0k?1g  fx1; : : :; xk g that separates fS1; : : :; Sk g. Step 4: Compute FAk?1(x01; : : : ; x0k?1). Step 5: Find i such that FAk?1 (x01; : : :; x0k?1) = FSk?i 1(x01; : : :; x0k?1):

Step 6: Output gi(x1; : : :; xk ). Proof of Theorem 30: Assume that FA2k 2 PFBk-T . 21

i. By Theorem 32(i), FA2k is computable by a set of 2k polynomial time functions. Thus by Lemma 35, the answers to 2k parallel queries to A can be determined in polynomial time by making (in parallel) only 2k ? 1 of the same 2k queries to A. If n > 2k then we can replace 2k of the n parallel queries with only 2k ? 1 of them, thereby eliminating one of the n queries. We keep eliminating queries in this way until we are left with only 2k ? 1 of the original n parallel queries. ii. This is obvious if n < 2k . If n  2k then FAn 2 PFA(2k?1)-tt by (i)  PFA(2k)-tt  PFBk-T by assumption: Thus, it would not be a good idea to use a cheatable oracle to generate questions on a true/false test. A student would only need to copy a bounded number of answers in order to determine them all. In [1], we have extended this theorem to apply not only to FAn but to all functions in PFA .

Corollary 36 If P 6= NP then the set of all satis able Boolean formulas ( SAT) is not cheatable.

Proof:

Assume that SAT is k-cheatable. Given an instance of SAT, we divide it into 2k subproblems (by trying all possible assignments to k variables); each subproblem is k variables smaller than the original. Theorem 30 allows us to eliminate one subproblem. We divide each of these 2k ? 1 problems in two by eliminating one variable, and Theorem 30 allows us to reduce these 2k+1 ? 2 problems to just 2k ? 1 of them. Continuing in this way, we can eliminate all of the variables and solve the instance of SAT in polynomial time, a contradiction. The special case k = 1 of the preceding corollary was obtained independently by Amir and Gasarch [2]. The result above follows for all sets that are NP-hard under 1-tt reductions, by Observation 29(ii). Below, we see that the same method of proof applies to all ttself-reducible sets. In [26], Schnorr de ned self-reducibility. De nition 37 A set A is self-reducible if there is a polynomial time bounded oracle Turing machine M such that  All strings queried by M are strictly shorter than the input string.  The language accepted by M A (machine M computing with oracle A) is A. 22

We say that a set A is tt-self-reducible if A is self-reducible via a machine M that computes a truth-table reduction. More formally, we have

De nition 38 The set A is tt-self-reducible if there exist polynomial time computable functions f and ~q such that for every string x

A(x) = f (x; FA!(~q(x))); and each component of ~q(x) is shorter than x.

Theorem 39 If A is tt-self-reducible and cheatable, then A 2 P. Proof: Since A is tt-self-reducible, there exist polynomial time computable functions f and ~q such that for every string x

A(x) = f (x; FA!(~q(x))); and each component of ~q(x) is shorter than x. Assume that A is k-cheatable. The following recursive algorithm computes FA2k?1: Step 1: Input ~x = (x1; : : : ; x2k?1). Step 2: If each component of ~x is equal to the empty string, then compute FA2k?1(~x) by table lookup, and return the value. Step 3: Let ~y = ~q(x1) k


k ~q(x2k?1). If ~y has fewer than 2k components then pad ~y with an empty string, so that the length of ~y at least 2k . Step 4: As in the proof of Theorem 30(i), we can compute FA! (~y) in polynomial time by determining the answers to only 2k ? 1 of the same queries. Let ~z = (z1; : : : ; z2k?1) be those queries. Recursively compute FA2k?1 (~z), and use the answer in order to compute FA!(~y). Step 5: Return the value of (f (x1; FA!(~q(x1))) k


k f (x2k?1; FA! (~q(x2k?1 )))). Since each component of ~q(xi) is shorter than xi, the depth of the recursion is bounded by the length of the longest component of ~x. Each recursive call runs in polynomial time, so the algorithm runs in polynomial time. Since FA2k ?1 is computable in polynomial time, the set A is computable in polynomial time. Theorem 39 has been extended to all Turing self-reducible sets in [1, 15].

Corollary 40 If A is tt-self-reducible and A 2= P then i. PFAk-T  PFA(k+1)-T . ii. PFAk-tt  PFA(k+1)-tt . 23

Proof: Let A be a tt-self-reducible set that is not in P. i. By contradiction. Assume that PFAk-T = PFA(k+1)-T . By Observation 6(i), A is cheatable. By assumption, A is tt-self-reducible and A 2= P. This contradicts Theorem 39. ii. Similar to (i). A more general (and more useful) kind of self-reducibility can been de ned in terms of an arbitrary partial order (instead of string length) [20].

De nition 41 A set A is self-reducible if there exists a polynomial-time computable partial order  such that  there exists a polynomial p such that whenever xm  xm?1 


 x1; we have m  p(jx1j) and jxmj  p(jx1j); and there exists a polynomial time bounded oracle Turing machine M such that  all strings queried by M precede the input string in the ordering , and  the language accepted by M A (machine M computing with oracle A) is A. We note that the proofs given above all go through for this more general de nition of self-reducibility. Corollary 40 yields:

Corollary 42 If P 6= NP then NP i. PFNP k-tt  PF(k+1)-tt . NP ii. PFNP k-T  PF(k+1)-T . Part (ii) of Corollary 42 was proved rst by Krentel; his result is true even if k  (1 ? ) log n is a function of the input length [18].

6. A Relation Between The Boolean Hierarchy and PTerseness It is not currently known whether NP-complete sets are p-terse, assuming that P 6= NP. One might try to prove that NP-complete sets are p-terse, assuming the stronger hypothesis that the Boolean hierarchy is proper. In this context, the following theorem is surprising. 24

Theorem 43 If P 6= NP and the Boolean hierarchy is not proper then NP-complete

sets are p-superterse. Proof: (By contradiction.) Suppose that NP-complete sets are not p-superterse, so there exists k and B such that B PFNP (k+1)-tt  PFk-T :

Then, by [5, Corollary 5.3], for all m there exists an oracle C 2 PNP m-tt such that C PFNP m-tt  PF(k log m)-tt: Suppose that the Boolean hierarchy is not proper. Then the PNP k-tt hierarchy collapses NP , so for some j by Theorem 16. Thus, C 2 P to PNP j -tt j -tt NP PFNP m-tt  PF(jk log m)-tt : Choose m large enough so that jk log m  m ? 1. Then NP PFNP m-tt  PF(m?1)-tt ; which contradicts Theorem 42(i) unless P = NP. This contradiction proves the lemma. Note that the only fact we used about NP is that NP contains a non-cheatable set unless P = NP, so a more general theorem is possible [4]. Note also that the conclusion of the theorem automatically applies to all sets that are NP-hard under 1-tt reductions, by Observation 29(i). While we are considering functions that are bounded query reducible to an NP set, we prove a companion to Observation 13. Part (i) below is not quite obvious. Theorem 44 Let A be an NP-complete set. #A2

k? i. PFNP k-T = PF1-T A

1

#A2

k? ii. PF#1-kT  PFNP k-tt  PF1-T NP iii. PFNP k-T  PF(2k ?1)-tt

Proof:

#A2

1

i. PF1-Tk ?  PFNP k-T by Observation 13(ii). #Ak ? Now we show that PFNP  PF 1-T . Suppose that A is an algorithm that k-T computes with k serial queries to A. We interpret the sequence of oracle answers as a binary integer m between 0 and 2k ? 1; the result of the rst query is the high-order bit. In order to determine if m  j , we guess any integer j 0  j ; for each 1-bit in j 0 we guess a satisfying assignment to the corresponding query. Since that is an NP computation, a single query to A suces. Thus we can determine m with a single query to #A2k?1 . 1

2

1

25

ii. The rst inclusion follows from the de nition of #Ak. The second inclusion follows from (i). iii. Simulate the PFk-T computation for all possible sequences of oracle answers. There are only 2k ? 1 queries that could be made. Also follows from (i). Theorem 44.iii expresses a partial tradeo between serial queries to an NP set and parallel queries to an NP set. Especially in light of Theorem 14.ii, we might NP wonder whether the converse is true. Namely, is PFNP (2k ?1)-tt  PFk-T ? Since this would imply that NP-complete sets are not p-superterse, we expect that the answer is no. In fact, we have shown [6] that all NP-hard sets (under truth-table reductions) are p-superterse unless P = UP and R = NP. For the same reason, we do not expect that the second containment in part (ii) can be tightened. Can the rst containment in (ii) be tightened?

7. Discussion For decision problems, we have shown that k serial queries to an NP set have the same computational power as 2k ? 1 parallel queries to an NP set. This contrasts sharply with the expected situation for function computation [6]. NP We have shown that either the PNP k-T , Pk-tt, and Boolean hierarchies are all proper or they all collapse. There are oracles relative to which they display either behavior. NP We have shown that the PFNP k-T and PFk-tt hierarchies are proper unless P = NP. It is natural to extend these hierarchies by allowing the number of queries to depend on the input length. Some separation results for the extended PFNP k-T hierarchy are in [6, 18]. Some open problems are stated in [6, 5, 18]. In particular, we know that NPcomplete sets are not cheatable unless P = NP. We also know from [6] that NPcomplete sets are p-terse unless P = UP and R = NP. What can we say about the tradeo between parallel and serial queries to NP-complete sets, predicated only on the assumption that P 6= NP?

8. Acknowledgments My sincere thanks go to my thesis advisor, John Gill, who supervised some of this work. I am also indebted to Sam Buss, Bill Gasarch, Louise Hay, Lane Hemachandra, and Jim Owings for very helpful discussions, and in addition to Bill Gasarch, Cathy Schevon and Dwight Wilson for proofreading. Finally, I thank the editor, Ron Book, for suggesting better terminology; and the referees for generally helpful comments and for suggesting a better organization of the material.

26

References [1] A. Amir, R. Beigel, and W. I. Gasarch. Some connections between bounded query classes and nonuniform complexity. In Proceedings of the 5th Annual Conference on Structure in Complexity Theory, pages 232{243, 1990. [2] A. Amir and W. I. Gasarch. Polynomial terse sets. Inf. & Comp., 77:37{56, Apr. 1988. [3] J. L. Balcazar, J. Daz, and J. Gabarro. Structural Complexity I, volume 11 of EATCS Monographs on Theoretical Computer Science. Springer-Verlag, New York, 1988. [4] R. Beigel. Query-Limited Reducibilities. PhD thesis, Stanford University, 1987. Also available as Report No. STAN-CS-88-1221. [5] R. Beigel. A structural theorem that depends quantitatively on the complexity of SAT. In Proceedings of the 2nd Annual Conference on Structure in Complexity Theory, pages 28{32. IEEE Computer Society Press, June 1987. [6] R. Beigel. NP-hard sets are p-superterse unless R = NP. TR 88-04, The Johns Hopkins University, Dept. of Computer Science, 1988. [7] R. Beigel. When are k + 1 queries better than k? TR 88-06, The Johns Hopkins University, Dept. of Computer Science, 1988. [8] R. Beigel. Bi-immunity results for cheatable sets. Theoretical Computer Science, 73(3):249{263, 1990. [9] R. Beigel, W. I. Gasarch, J. T. Gill, and J. C. Owings. Terse, superterse, and verbose sets. Inf. & Comp., 103:68{85, 1993. [10] R. Beigel, W. I. Gasarch, and L. Hay. Bounded query classes and the dierence hierarchy. Archive for Mathematical Logic, 29(2):69{84, Dec. 1989. [11] R. V. Book and K.-I. Ko. On sets truth-table reducible to sparse sets. SICOMP, 17:903{919, 1988. [12] S. R. Buss and L. E. Hay. On truth table reducibility to SAT. Inf. & Comp., 91(1):86{102, Mar. 1991. [13] J. Cai. On Some Most Probable Separations of Complexity Classes. PhD thesis, Cornell University, Ithaca, NY, 1986. [14] J. Cai and L. A. Hemachandra. The Boolean hierarchy: Hardware over NP. In A. L. Selman, editor, Structure in Complexity Theory, pages 105{124. SpringerVerlag, June 1986. Lecture Notes in Computer Science 223. 27

[15] J. Goldsmith, D. Joseph, and P. Young. Using self-reducibilities to characterize polynomial time. TR 87-11-11, Dept. of Computer Science, University of Washington, Seattle, Nov. 1987. To appear in Information and Computation. [16] L. A. Hemachandra. The strong exponential hierarchy collapses. In Proceedings of the 19th Annual ACM Symposium on Theory of Computing, 1987. [17] J. Kobler, U. Schoning, and K. W. Wagner. The dierence and truth-table hierarchies for NP. RAIRO Theoretical Informatics and Applications, 21:419{ 435, 1987. [18] M. W. Krentel. The complexity of optimization problems. JCSS, 36(3):490{509, 1988. [19] A. A. Markov. On the inversion complexity of a system of functions. J. ACM, 6:331{334, 1958. [20] A. Meyer and M. Paterson. With what frequency are apparently intractable problems dicult? TR MIT/LCS/TM-126, M. I. T., 1979. [21] J. C. Owings, Jr. A cardinality version of Beigel's Nonspeedup Theorem. JSL, 54(3):761{767, Sept. 1989. [22] C. H. Papadimitriou and M. Yannakakis. The complexity of facets (and some facets of complexity). JCSS, 28:244{259, 1984. [23] C. H. Papadimitriou and S. K. Zachos. Two remarks on the complexity of counting. In Proceedings of the 6th GI Conference on Theoretical Computer Science, pages 269{276. Springer-Verlag, 1983. Volume 145 of Lecture Notes in Computer Science. [24] H. Putnam. Trial and error predicates and the solution to a problem of Mostowski. JSL, 30(1):49{57, Mar. 1965. [25] D. A. Russo. Structural Properties of Complexity Classes. PhD thesis, University of California at Santa Barbara, Mar. 1985. [26] C. P. Schnorr. Optimal algorithms for self-reducible problems. In Proceedings of the 3rd International Colloquium on Automata, Languages, and Programming, pages 322{337, 1976. [27] U. Schoning and K. W. Wagner. Collapsing oracle hierarchies, census functions, and logarithmically many queries. TR 140, Universitat Augsburg, Institut fur Mathematik, 1987. [28] K. W. Wagner. Bounded query classes. SICOMP, 19(5):833{846, Oct. 1990. 28

[29] G. Wechsung and K. Wagner. On the Boolean closure of NP. In Proceedings of the 1985 International Conference on Fundamentals of Computation Theory, pages 485{493. Springer-Verlag, 1985. Volume 199 of Lecture Notes in Computer Science.

29