Abstract. This paper deals with balanced leaf language complexity classes, introduced independently in [1] and [14]. We propose the seed concept for leaf languages, which allows us to give “short” representations for leaf words. We then use seeds to show that leaf languages A with N P ⊆ BLeaf P (A) cannot be polylog-sparse (i.e. censusA ∈ O(log O(1) )), unless P H collapses. We also generalize balanced ≤P,bit -reductions, which were introduced m in [6], to other bit-reductions, for example (balanced) truth-table- and Turing-bit-reductions. Then, similarly to above, we prove that N P and Σ2P cannot have polylog-sparse hard sets under those balanced truthtable- and Turing-bit-reductions, if the polynomial-time hierarchy is infinite. Keywords Computational Complexity, Leaf Languages, Seeds, Sparseness

1

Introduction

The leaf language formalism, introduced in [1] and independently in [14], can be used to describe polynomial-time complexity classes in the following way: Let M be some non-determistic polynomial-time Turing machine (short: NPTM). For input x let each path in the computation tree of M (x) be marked with a word from {0, 1}∗ , characterizing the nondeterministic choices on that path. M (x) produces output bit 0 or 1 on each path. If we concatenate all output bits of M (x) in the lexicographical order of their path marks, we get the leaf word leaf M (x). For a given leaf language A we define the complexity class Leaf P (A) as the set of all languages L for which there is an NPTM M such that for all inputs x it holds: x ∈ L ↔ leaf M (x) ∈ A. In this paper we additionally require M to be balanced. An NPTM is balanced if for any input its computation tree is balanced. A computation tree is balanced if there is a maximal path mark y with the property that all path marks x with |x| = |y| and x ≤lex y exist and further no other path marks exist in that computation tree. BLeaf P is defined analogously to Leaf P with the only difference that now M has to be balanced. See Section 2.1 for further details. This formalism allows to define many known complexity classes in a uniform way. If we set A = Σ ∗ {1}Σ ∗ and B = {0}∗ we get for example N P = BLeaf P (A) = Leaf P (A), coN P = BLeaf P (B) = Leaf P (B).

For these particular leaf languages the balanced leaf language classes are the same as the non-balanced ones. In general that does not need to be the case (see [7] and [8]). It is well-known that SAT contains exponentially many instances of each size, that is censusSAT (n) ∈ Ω(2cn ) for some c > 0. In this paper we tackle the question whether NPTMs can reduce the exponentially many instances of SAT to less than exponentially many words, or more precisely: How many words are necessary in a leaf language A with N P ⊆ BLeaf P (A)? We first show that sparse sets are sufficient, i.e. N P ⊆ BLeaf P (SP ARSE) (see Proposition 1). This yields an upper bound. In our main result we then give a lower bound by showing that no polylog-sparse leaf language A can satisfy N P ∈ BLeaf P (A), unless P H collapses. We call a leaf language A polylog-sparse if there is a polynomial p such that censusA (n) ≤ p(log n). Thus, leaf languages for N P can probably not be arbitrarily “empty”.

1.1

Generalized Bit-reductions and Seeds

In [6] the notation L ≤P,bit A was introduced for L ∈ BLeaf P (A). m This is very intuitive, since L ∈ BLeaf P (A) means that there is some balanced NPTM M such that leaf M is a reduction from L to A, i.e. x ∈ L ↔ leaf M (x) ∈ A. However, we prefer the notation L ≤P,Bbit A m to emphasize the fact that the reduction is carried out by a balanced P,Bbit NPTM. Later in 2.3 we will generalize this to ≤tt , ≤TP,Bbit and other balanced bit-reductions. Similar to our main result we then show in Sections 4 and 5 the following: There are no polylog-sparse leaf languages which are hard for N P or Σ2P P,Bbit P,Bbit -, ≤TP,Bbit - or ≤btt -reductions, unless P H collapses. An under ≤m overview of our results is given in Section 3. In the proofs and for the definition of general ≤P,Bbit -reductions we need seeds. A set S is called a seed set of a leaf language A if there is a balanced NPTM M such that leaf M (S) = A. The crucial feature of seeds is that they can be much smaller than the corresponding leaf words they induce.

1.2

Relation to Other Work

Our work is related to the following results about sparse hard sets for N P from [10], [9], [11] and [2]. For S ∈ SP ARSE it holds [10] [9] N P [11] [2]

N P ≤P m S ≤P T S ∧ S ∈ NP N P ≤P btt S N P ≤P T S

=⇒ P =N P =⇒ P H=Θ2P =⇒ P =N P =⇒ P H=S2P .

Let us look at the theorem from [10]. It implies that there is probably no deterministic polynomial-time Turing-machine that can manyone-reduce the Ω(2cn ) satisfiable boolean formulae of size n to only a polynomial number of words. Our main result implies the same conclusion for nondeterministic polynomial-time machines: If P H does not collapse, then

P,Bbit there is no NPTM that can manyone-reduce (i.e. ≤m ) all satisfiable boolean formulae of size n to only a polynomial number of words. Thus, in this respect non-determinism does not seem to be more powerful than determinism. We also use similar ideas as in [10]. The main new ingredient in our proof is the use of seeds. Our other results relate similarly to the other theorems above.

2

Notation and Definitions

Before we start, let us agree on the following conventions: We fix the alphabet Σ = {0, 1} and add symbols (e.g. delimiters) when necessary. Furthermore, weSextend a function f : A → B to f : 2A → 2B by setting f (X) = x∈X {f (x)}. Let ≤lex be the lexicographical ordering of words and v the W prefix relation, that is: For x, y ∈ Σ ∗ we write x v y if and only if z∈Σ ∗ xz = y. For a set A its census function is defined as censusA (n) := |{w : w ∈ A ∧ |w| ≤ n}|. Call a set A sparse if censusA ∈ O(nO(1) ) and let SP ARSE be the set of all sparse sets. Analogously, a set A is called polylog-sparse if censusA ∈ O(log O(1) ). Let P ol be the set of all polynomials. F P is the class of all functions computable by polynomial-time Turing-machines. The class Θ2P = P N P [log] consists of all languages that can be accepted by a polynomial-time Turing-machine with at most O(log n) adaptive queries to an N P -oracle. The complexity class S2P was introduced in [3] and [13]. A language L is in S2P iff there is a polynomial-time predicate P such that: If x ∈ L then there exists a y, such that for all z the predicate P (x, y, z) is true. Conversely, if x 6∈ L then there exists a z, such that for all y the predicate P (x, y, z) is false. The lengths of y and z are in both cases polynomially bounded in the length of x. From [13] it is known that P N P ⊆ S2P .

2.1

Leaf Language Complexity Classes

We first formalize balanced NPTMs. Definition 1. BFP is the set of all functions f such that there exist f1 , f2 ∈ F P with f1 : Σ ∗ × N → Σ, f2 : Σ ∗ → N and for all x ∈ Σ ∗ f (x) = f1 (x, 1) . . . f1 (x, f2 (x)). Such functions f are called polynomial-time bit-computable. If in the following we are given a function f ∈ BF P , we always assume that f1 and f2 denote the respective F P -functions as in Definition 1. For f ∈ BF P we say: f produces leaf word f (x) on input x. It is easy to see that BF P = {leaf M : M is a balanced NPTM}. The inclusion ⊆ is trivial and the inclusion ⊇ follows by noting that if M is balanced, the i-th bit of leaf M (x) can be computed in polynomial time: Let b ∈ {0, 1}∗ be the binary representation of i. First compute the maximal path mark y in the computation of leaf M (x). The i-th bit exists

iff |b| ≤ |y| and 0|y|−|b| b ≤lex y. It can then be computed by following the path with mark 0|y|−|b| b. Note that the same procedure cannot be applied for unbalanced M , since the path computing the i-th bit does not necessarily have mark 0|y|−|b| b. In fact, computing the i-th bit if M is unbalanced seems to be much harder. See [7] for more on balanced vs. unbalanced computation trees. However, in this paper we are only concerned with balanced computations. We now formally define balanced leaf language complexity classes. Definition 2. For A ⊆ Σ ∗ we define: L ∈ BLeaf P (A) ↔def

_

[x ∈ L ↔ f (x) ∈ A]

f ∈BF P

For A, R ⊆ Σ ∗ , A ∩ R = ∅ we also define promise classes: L ∈ BLeaf P (A, R) ↔def _ ˆ f ∈BF P

2.2

˜ (x ∈ L → f (x) ∈ A) ∧ (x 6∈ L → f (x) ∈ R) .

Seeds

We now introduce the notion of seeds. Definition 3. For S, A ⊆ Σ ∗ we say that S is a seed set of the leaf language A, if there is a function f ∈ BF P —the generating function or simply generator— with f (S) = A. We say further: x is the seed of f (x) and f (x) is the f -expansion of seed x. The crucial feature of seeds is that they are (often) much smaller than the leaf word they represent. If we know the seed s of a leaf word b we can compute each bit of b in polynomial time in |s| whenever needed. If S is a seed set for A with generator f ∈ BF P then B is, in a way, effectively constructible from S via f .

2.3

Balanced Bit-reductions

In [6] it was pointed out, that we can interpret L ∈ BLeaf P (A) as a bit reduction from L to A. Recall from Definition 2 that L ∈ BLeaf P (A) means, that there is some r ∈ BF P such that x ∈ L ↔ r(x) ∈ A. This resembles very much the definition of ≤P m -reductions with the only difference that now r is in BF P and not in F P . That is why the notation L ≤P,bit A was introduced. Instead of ≤P,bit as in [6] we rather use m m P,Bbit to emphasize that the reduction must be realized by a balanced ≤m NPTM. Using seeds, we now define tt-, T - and other bit-reductions.

Definition 4. If for X = L, N L, P, N P, RP, . . . and Y = m, tt, T, . . . ∗ the reduction ≤X Y is already defined, we define for L, A ⊆ Σ _ _ ¯ ⊆A ¯ ∧ L ≤X L ≤X,Bbit A ↔def [f (S) ⊆ A ∧ f (S) Y S.] (1) Y S⊆Σ ∗ f ∈BF P

For such ≤X,Bbit -reductions we call the ≤X Y -reduction from A to S the Y corresponding seed reduction, S the corresponding seed oracle, f the access function and A the leaf oracle. For L, A, R ⊆ Σ ∗ with A ∩ R = ∅ we also define promise reductions L ≤X,Bbit (A, R) ↔def Y h _ _

f (S1 ) ⊆ A ∧ f (S2 ) ⊆ R ∧ L ≤X Y (S1 , S2 )

S1 ,S2 ⊆Σ ∗ f ∈BF P

i

X where L ≤X Y (S1 , S2 ) means, that there is a ≤Y -reduction r from L to S1 with the promise that r only asks queries from S1 ∪ S2 . Analogously we call (S1 , S2 ) the seed oracle with accepting/ rejecting parts S1 /S2 and (B1 , B2 ) the leaf oracle with accepting/ rejecting parts B1 /B2 . P,Bbit Our ≤m coincides with ≤P,bit in [6]. m Note that the answer of a ≤X,Bbit -oracle A on a query x is not χA (x) (as Y for a ≤X Y -oracle) but rather χA (f (x)), where f is the access function to A and χA is the characteristic function of A. It is obvious how to extend Definition 4 to unbalanced bit-reductions, but in this paper we do not need that. Access functions in the context of bit-reductions are quite similar to generating functions in the context of seed sets. We have deliberately chosen a different name to reflect the different approach: Whereas a generating function “generates” a leaf language from a given seed set, an access function is used to check whether the expansion of some seed yields a leaf that is contained in some given leaf language. Thus, an access function “gives access” to a leaf oracle. X,Bbit A. This is Now, the following fact is easy to see: L ≤X Y A → L ≤Y X because if r is a ≤Y -reduction from L to A, then the same r with access function f = id is a ≤X,Bbit -reduction from L to A. That means that Y -reductions can be seen as extensions of ≤X ≤X,Bbit Y -reductions. Y

3

Overview of Results

In the next sections we show the following results for polylog-sparse sets K: P,Bbit Theorem 1 N P ≤m K =⇒ P H=Θ2P P,Bbit Theorem 3 N P ≤T (K, 0∗ ) =⇒ P H=S2P P,Bbit P K =⇒ P H=∆P Theorem 4 Σ2 ≤btt 2 P,Bbit P K =⇒ P H=Σ4P Theorem 5 Σ 2 ≤T In the following interpretation of the theorems we assume that P H does not collapse to Σ4P . Theorem 1 then suggests that there are no polylogP,Bbit sparse ≤m -hard leaf languages for N P .

P,Bbit In the other theorems we try to relax the ≤m -reduction in the supP,Bbit P,Bbit position to ≤tt - and ≤T -reductions. But then we can prove a collapse of P H only under some other additional assumptions. In Theorem 3 for example, we additionally require that the ≤P,Bbit T reduction is a particular promise reduction. Theorem 3 can be interpreted as saying that N P does probably not have polylog-sparse leaf languages which are N P -typical, i.e. accepting leaf words contain at least one 1 and rejecting leaf words contain only 0’s. Theorems 4 and 5, on the other hand, require additionally that not only N P but also Σ2P can be reduced to some polylog-sparse leaf language. These theorems suggest that there are no polylog-sparse ≤P,Bbit btt or ≤TP,Bbit -hard leaf languages for Σ2P . Looking at the related results about sparse hard sets (see Section 1.2), some readers might wonder why we sometimes have to require that Σ2P and not merely N P reduces to K and also why the resulting collapse of P H is on a higher level. Informally, the reason is that in order to check that two seeds y1 and y2 yield the same leaf word can only be checked by expanding them and checking if f (y1 ) = f (y2 ), which requires a coN P computation.

4

Lower Bounds for N P -hard Leaf Languages

In this section we demonstrate, that no polylog-sparse leaf language A P,Bbit can be ≤m -hard for N P , unless P H collapses. This clearly suggests a lower bound for the number of words needed in leaf languages which characterize N P . Nevertheless, we first give an upper bound, by showing P,Bbit that every set has a ≤m -hard, sparse leaf language. Proposition 1. For all L ⊆ Σ ∗ it holds P,Bbit SP ARSE. L ≤m

Proof. Assume L ⊆ Σ ∗ . Define padding function f ∈ BF P as f (x) = W |x| 02 x. Define the set A by a ∈ A ↔ x∈L f (x) = a. Clearly, A is sparse. Then obviously x ∈ L ↔ f (x) ∈ A and thus L ∈ BLeaf P (A). t u P,Bbit Now, what are the lower bounds for ≤m -hard leaf languages? In this section we tackle that question for the class N P . Firstly, it is obvious that P,Bbit -hard for N P , unless P = N P . Assuming finite sets cannot be ≤m that P H does not collapse the following theorem gives a better bound:

Theorem 1. For a polylog-sparse set K it holds P,Bbit K =⇒ P H = Θ2P . N P ≤m

Proof. Choose arbitrary L ∈ Π2P . We will show L ∈ Θ2P . L ∈ Π2P means that there must be polynomials p, q and r ∈ F P with x∈L↔

p ^ y

r(x, y) ∈ SAT

(2)

V and py |r(x, y)| ≤ q(|x|). By assumption, there is an f ∈ BF P and a polylog-sparse K such that for all boolean formulae φ φ ∈ SAT ↔ f (φ) ∈ K.

(3)

Choose a polynomial t such that censusK (n) ≤ t(log n) for all n. We now construct a Θ2P -machine ML that decides L. On input x with |x| = n it first uses oracle A 8 9 |y1 |≤q(n) |ym |≤q(n) < = _ _ ^ A := (0n , 1m ) : ··· f (yi ) 6= f (yj ) : ; y1 ∈SAT

ym ∈SAT 1≤i

to compute the number of leaves in K that have seeds of length ≤ q(n). We call that number m(n). ˆ Clearly, to compute m(|x|) ˆ at most 2dlog m(|x|)e ˆ ≤ 2dlog t(log f2 (q(|x|)))e ∈ O(log |x|) queries to A are needed. Note that A is in N P since an A-accepting machine MA only needs to guess y1 , . . . , ym and paths pij,1≤i,j≤m ∈ Σ O(P ol(n)) such that for all i 6= j it holds f1 (yi , pij ) 6= f1 (yj , pij ) or f2 (yi ) 6= f2 (yj ). After having computed m(n), ˆ ML makes one last query (x, m(n)) ˆ to another coN P -machine MB , which will accept iff x ∈ L. We finish the proof by showing how such a coN P -machine MB works. ˆ MB on input (x, m(n)) ˆ starts like MA on input (0n , 1m(n) ). On nonaccepting MA -paths MB stops and rejects, too. Note that on accepting paths of the MA -computation MB knows seeds y1 , . . . , ym(n) for all leaves ˆ in K which can be constructed from seeds of length ≤ q(n). With (3) this means that for all boolean formulae φ with |φ| ≤ q(n) it therefore holds i≤m(n) ˆ

φ ∈ SAT ↔

_

f (yi ) = f (φ).

(4)

i

On accepting MA -paths MB then checks whether ˆ p i≤m(n) _ ^ y

f (yi ) = f (r(x, y)).

(5)

i

By (2) and (4) this is equivalent to x ∈ L. Thus, the rest of the construction of MB is straightforward if we show that (5) is a coN P -predicate. But this is true because (5) is equivalent to 2 3 ˆ v≤f2 (r(x,y)) p i≤m(n) ^ _ ^ 4f2 (r(x, y)) = f2 (yi ) ∧ f1 (yi , v) = f1 (r(x, y), v)5(6) , y

i

v

W which is a coN P -predicate since i quantifies only over polynomially many elements. Thus, ML is a Θ2P -machine deciding L. t u P,Bbit P,Bbit K instead of N P ≤m K in Theorem 1, If we require N P ≤dtt P almost the same proof establishes P H = Θ2 .

In the next Theorem 3 we will achieve a collapse of P H by assuming that N P is only ≤TP,Bbit -reducible to some polylog-sparse leaf oracle (K, {0}∗ ). In order to do so we additionally require the leaf reduction to be “N P -typical”, that is positive queries produce leaf words containing at least one 1 and negative queries produce leaf words from {0}∗ . In the proof we need a result from Cai. Theorem 2. [2] For S ∈ SP ARSE P N P ≤P T S =⇒ P H = S2 .

Theorem 3. For polylog-sparse K it holds N P ≤TP,Bbit (K, {0}∗ ) =⇒ P H = S2P . Proof. Let K be given as in the assumption with censusK (n) ≤ t(log n) for some polynomial t. Let M be a deterministic polynomial-time oracle Turing machine (short: DPOM) that can decide SAT with the help of the ≤TP,Bbit -oracle (K, {0}∗ ). Let f ∈ BF P be the access function of that reduction and (S1 , S2 ) the corresponding seed oracle, that is f (S1 ) ⊆ K and f (S2 ) ⊆ {0}∗ . Let the computation time of M be bounded by the polynomial p. Because of Theorem 2 it suffices to construct a sparse oracle P ath with N P ⊆ P P ath . We first define an auxiliary oracle P ath0 that contains all (0n , w) ˆ for which 3 2 |s|=n w0 ≤w _ ^ˆ 0 4w f1 (s, w ) = 05 . (7) ˆ ≤ f2 (s) ∧ f1 (s, w) ˆ =1∧ s∈S1

w0

Note that for each possible query s with f (s) ∈ K, the smallest w ˆ with f1 (s, w) ˆ = 1 is in P ath0 (0|s| ). Hence, if P ath0 (0|s| ) is known, it can be decided in polynomial time whether a given formula s is in SAT . We extend P ath0 to _ P ath := {(0n , w) : w v w}. ˆ (8) w∈P ˆ ath0 (0n )

P ath(0n ) contains all prefixes of P ath0 (0n ). Using the oracle P ath it is possible to compute P ath0 (0n ) in polynomial time in n. Since K is polylog-sparse it is clear that |P ath0 (0n )| ∈ O(nO(1) ). Hence P ath0 ∈ SP ARSE and also P ath ∈ SP ARSE. A SAT -deciding DPOM M 0 with oracle P ath could basically work like M with the only difference: Whenever M asks the leaf oracle K if f (s) ∈ K, M 0 computes P ath0 (0|s| ) and then checks whether f1 (s, w) ˆ = 1 for some w ˆ ∈ P ath0 (0|s| ). If that is the case, M 0 proceeds as M on answer “Yes”. Otherwise M 0 proceeds as M on answer “No”. Thus, SAT ≤P T P ath, which together with Theorem 2 establishes the result. t u Note that in [13] it was proven that P N P ⊆ S2P . Looking at Theorems 1 and 3 a natural question is whether it is possible to conclude something stronger than P H = S2P by combining both assumptions (i.e. P,Bbit N P ≤m (K, {0}∗ )). That is still open. We now want to see if similar results are possible for coN P .

Proposition 2. There is a polylog-sparse set K with P,Bbit coN P ≤m K. n

For example K = {02 : n ∈ N } proves this proposition. Thus, a theorem that is analogous to Theorem 1 for coN P would immediately imply a collapse of P H, which is assumed to be highly unlikely. Similarly, we P,Bbit also see why Theorem 1 can (probably) not be extended to ≤btt/tt/T reductions, since that would also imply a collapse of P H. The relaxation to ≤TP,Bbit -reductions in Theorem 3 was only possible because we additionally required the leaf oracle to be “N P -typical”.

5

Lower Bounds for Σ2P -hard Leaf Languages

Following on from what was said at the end of the previous section P,Bbit there is another way of extending Theorem 1 to ≤btt - and ≤P,Bbit T reductions. But again, we also have to accept an additional requirement, which now is that Σ2P (and not only N P ) must be balanced bit-reducible to some polylog-sparse leaf language K. In this section we show two theorems of that kind. The first of them is an adaption of a result by Ogihara-Watanabe (see [11]), which originally stated, that there cannot be sparse ≤P btt -hard sets for N P , unless P = N P . Theorem 4. For polylog-sparse K it holds P,Bbit Σ2P ≤btt K =⇒ P H = P N P = ∆P 2 .

The proof is quite long and technical. Due to space restrictions it is deferred to the final journal version. However, for readers knowing the original proof from [11] the following lines might give some idea of how it works. We also use the left-set technique. The main difference is the following: In the original proof it is easy to check whether two queries y1 and y2 to the oracle are the same (which is the case iff y1 = y2 ). Now, in our case that is more difficult. Even for queries y1 and y2 with y1 6= y2 it is still possible that they are in fact the same question, namely if f (y1 ) = f (y2 ). So, checking whether two queries ask for the same leaf word now requires a coN P -oracle. Since that test already needs a coN P P,Bbit oracle, it is not sufficient to require N P ≤btt K in the assumption P,Bbit P but rather Σ2 ≤btt K. Our last theorem assumes only the weaker supposition Σ2P ≤TP,Bbit K but then P H only collapses to Σ4P . Theorem 5. For polylog-sparse K it holds Σ2P ≤TP,Bbit K → P H = Σ4P . Proof. Assume L ∈ Π4P . We show L ∈ Σ4P . Suppose K as in the assumption and let t be a polynomial such that censusK (n) ≤ t(log n). Choose Q ∈ P and polynomials p1 , . . . , p4 such that p1 p4 ^ _ x∈L↔ · · · Q(x, x1 , . . . , x4 ). x1

x4

We define L0 as the set containing all (x, x1 , x2 ) with

|x1 | ≤ p1 (|x|) ∧ |x2 | ≤ p2 (|x|) ∧

p3 p4 ^ _

Q(x, x1 , . . . , x4 ).

(9)

x3 x4

Obviously, L0 ∈ Π2P and thus by the assumption L0 ≤TP,Bbit K. But then also L0 ≤TP,Bbit K, since ≤TP,Bbit is a deterministic Turing-reduction. Hence, there must be a DPOM M , with associated access function f ∈ BF P , which realizes a ≤TP,Bbit -reduction from L0 to V K. Choose polynomial q with |f (x)| ≤ 2q(|x|) . Because of the constraint i=1,2 |xi | ≤ pi (|x|) in (9), we can also bound the computation time of M (x, x1 , x2 ) by a polynomial in |x|, instead of |(x, x1 , x2 )|. Let r be such a polynomial. We now define a predicate O, that is true for given n ∈ N and S = {s1 , . . . , sm } iff: M decides with ≤TP,Bbit -leaf oracle f (S) for all inputs (x, x1 , x2 ), |x| ≤ n, correctly whether (x, x1 , x2 ) ∈ L0 . |x|≤n p1 p2

O(S, 0n ) ↔

^ ^^

0≤c≤r(|x|)

i=1,...,c

i=1,...,c

_

_

_

c∈N

"

(10)

x1 x2

x

li ∈Σ ≤r(|x|)

(11)

oi ∈Σ

M (x, x1 , x2 ) makes queries l1 , . . . , lc

and gets answers o1 , . . . , oc "1≤i≤c # ^ _ ∧ oi = 1 ↔ f (li ) = f (u) i

(12)

(13)

u∈S

2

∧ 4M (x, x1 , x2 ) rejects → 2

#

6 ∧ 4M (x, x1 , x2 ) accepts →

p3 p4 ^ _ x03 x4

¬Q(x, x1 , x2 , x03 , x4 )5(14)

p3 p4 ^ _ x3

3

x4

3

7 . Q(x, x1 , x2 , x3 , x4 )5(15)

(For the time being ignore the arrow.) Let us have a closer look at a each line. Line (10) is clear: We want to know if M gives correct answers for all (x, x1 , x2 ) with |x| ≤ n, |x1 | ≤ p1 (|x|) and |x2 | ≤ p2 (|x|). In line (11) it is guessed, how many queries (= c) and which queries (= {l1 , . . . , lc }) are made by M (x, x1 , x2 ) and what the answers to these queries are (= {o1 , . . . , oc }). In (12) it is checked whether the queries were guessed correctly: Is l1 the first query of M (x, x1 , x2 )? If M gets answer o1 on that query, is the next query l2 ? And so on. In line (13) it is tested, if the guessed answers oi are correct with respect to f (S). In lines (14)-(15) it is checked, if M (x, x1 , x2 ) actually computes the correct answer.

Now let us see what the complexity of O is. Line (12) can be decided in P . Line (13) can be rewritten as 3 2 v≤f2 (li ) i≤c ^ ^ 4 oi = 1 → f2 (li ) = f2 (u) ∧ f1 (li , v) = f1 (u, v)5 (16) v

i

2

∧4

i≤c

^

oi = 0 →

i

^ h

v≤f2 (li )

_

f2 (li ) 6= f2 (u) ∨

v

u∈S

i

3

f1 (li , v) 6= f1 (u, v) 5(17) .

Line (16) checked in coN P . Line (17) can be decided in N P V can be V since 1≤i≤c and i u∈S quantify only over polynomially many choices. P Lines (14) and (15) are in Σ2P and The longest chain of W V W V Π2 respectively. alternating quantifiers is thus x,x1 ,x2 c,li ,oi x3 x4 from lines (10), (11) and (15). Therefore, O seems to be a Π4P -predicate. V But we can improve that to Π3P . Just move the px33 -quantifier from line (15) to the beginning of line (11), as is indicated by the arrow. Certainly, the resulting predicate is in Π3P . Since the computation M (x, x1 , x2 ) implicitly depends on the values oi , this shift seems to change the semantics of O. The following V argument shows that it does not: If we move the x3 -quantifier from line (15) to the end of line (11) the semantics are not changed since x3 does not occur in between. Now, the crucial observation is that for fixed S, n, x, x1 , x2 there is exactly one choice for c, li , oi that makes lines (12) and (13) true. We call them c(S, n, x, x1 , x2 ), li (S, n, x, x1 , x2 ),WandW oi (S, W n, x, x1 , x2 ). Thus, we can replace the existential quantifiers c , li , oi in line (11) with

c = c(S, n, x, x1 , x2 ), oi = oi (S, n, x, x1 , x2 ), li = li (S, n, x, x1 , x2 ). (18) V Since that term does not depend on x3 we can further move the x3 quantifier past it, i.e. from its current position W the W end of line (11) W at to the beginning of that line. Substituting c , li , oi back for (18) establishes that O is indeed a Π3P -predicate. Since K is polylog-sparse and the computation time of M is bounded by V r, we conclude: For each input length n there must be a set S, s∈S |s| ≤ r(n) and |S| ≤ t(q((r(n))), such that O(S, 0n ) is satisfied. Thus, sets S with O(S, 0n ) can be non-deterministically guessed in polynomial time. We get |si |≤r(|x|)

x∈L↔

_

O(S, 0|x| )

S={s1 ,...,st(q(r(|x|))) }

∧

p1 p2 ^ _ˆ

lines (11) − (13)

x1 x2

which proves L ∈ Σ4P .

˜ ∧ M (x, x1 , x2 ) accepts ,

t u

It is conceivable that a different approach in the proof collapses the polynomial hierarchy to a lower level than Σ4P .

6

Acknowledgements

I would like to thank Gerd Wechsung for supervising my Diploma Thesis on leaf languages and Harry Buhrman for hints on this paper.

References [1] D. P. Bovet, P. Crescenzi, R. Silvestri, A Uniform Approach to Define Complexity Classes, Theoretical Computer Science 104, 1992, pp. 263-283. [2] J.-Y. Cai, S2P ⊆ ZP P N P , FOCS 2001, pp. 620-629 [3] R. Canetti, More on BPP and the polynomial-time hierarchy, Information Processing Letters 57, 1996, pp. 237-241 [4] J.-Y. Cai, M. Ogihara, Sparse Sets versus Complexity Classes, Complexity Theory Retrospective II by L.A. Hemaspaandra, A.L. Selman (Eds.), 1997, pp. 53-80 [5] S. Homer, L. Longpr´e On reductions of NP sets to sparse sets, Journal of Computer and System Sciences 48(2), 1994, pp. 324-336 [6] U. Hertrampf, C. Lautemann, T. Schwentick, H. Vollmer, K. Wagner, On the Power of Polynomial Time Bit-Reductions, Proc. 8th Structure in Complexity Theory Conference, 1993, pp. 200-207. [7] U. Hertrampf, H. Vollmer, K. Wagner, On Balanced vs. Unbalanced Computation Trees, Mathematical Systems Theory 29, 1996, pp. 411-421. [8] B. Jenner, P. McKenzie, D. Therien, Logspace and Logtime Leaf Languages, Information and Computation 141, 1996, pp. 21-33 [9] J. Kadin P N P [log n] and sparse Turing-complete sets for N P , Journal of Computer and System Sciences 39, 1989, pp. 282-298 [10] S. Mahaney, Sparse complete sets for NP: Solution of a conjecture of Berman and Hartmanis, Journal of Computer and System Sciences 25(2), 1982, pp. 130-143 [11] M. Ogiwara, O. Watanabe, On polynomial time bounded truth-table reducibility of NP sets to sparse sets, SIAM JC 20 1991, 471-483 [12] C. H. Papadimitriou, Computational Complexity, Addison Wesley 1994 [13] A. Russell, R. Sundaram, Symmetric alternation captures BPP, Computational Complexity 7(2), 1998, pp. 152-162 [14] N. Vereshchagin, Relativizable and Nonrelativizable Theorems in the Polynomial Theory of Algorithms, Russian Acad. Sci. Izv. Math. 42, 1994, pp. 261-298