Polynomial-time Hierarchy Research Articles

The complexity of learning concept classes with polynomial general dimension

The general dimension is a combinatorial measure that characterizes the number of queries needed to learn a concept class. We use this notion to show that any p-evaluatable concept class with polynomial query complexity can be learned in polynomial time with the help of an oracle in the polynomial hierarchy, where the complexity of the required oracle depends on the query-types used by the learning algorithm. In particular, we show that for subset and superset queries an oracle in Σ 3 P suffices. Since the concept class of DNF formulas has polynomial query complexity with respect to subset and superset queries with DNF formulas as hypotheses, it follows that DNF formulas are properly learnable in polynomial time with subset and superset queries and the help of an oracle in Σ 3 P . We also show that the required oracle in our main theorem cannot be replaced by an oracle in a lower level of the polynomial-time hierarchy, unless the hierarchy collapses.

The complexity of constructing pseudorandom generators from hard functions

We study the complexity of constructing pseudorandom generators (PRGs) from hard functions, focussing on constant-depth circuits. We show that, starting from a function $$f:\{ 0,1\} ^l \to \{ 0,1\} $$ computable in alternating time O(l) with O(1) alternations that is hard on average (i.e. there is a constant $$\epsilon > 0$$ such that every circuit of size $$2^{\epsilon l} $$ fails to compute f on at least a 1/poly(l) fraction of inputs) we can construct a $${\text{PRG}}:\{ 0,1\} ^{O(\log n)} \to \{ 0,1\} ^n $$ computable by DLOGTIME-uniform constant-depth circuits of size polynomial in n. Such a PRG implies $$BP \cdot AC^0 = AC^0 $$ under DLOGTIME-uniformity. On the negative side, we prove that starting from a worst-case hard function $$f:\{ 0,1\} ^l \to \{ 0,1\} $$ (i.e. there is a constant $$\epsilon > 0$$ such that every circuit of size $$2^{\epsilon l} $$ fails to compute f on some input) for every positive constant $$\delta < 1$$ there is no black-box construction of a $${\text{PRG}}:\{ 0,1\} ^{\delta n} \to \{ 0,1\} ^n $$ computable by constant-depth circuits of size polynomial in n. We also study worst-case hardness amplification, which is the related problem of producing an average-case hard function starting from a worst-case hard one. In particular, we deduce that there is no blackbox worst-case hardness amplification within the polynomial time hierarchy. These negative results are obtained by showing that polynomialsize constant-depth circuits cannot compute good extractors and listdecodable codes.

On the Complexity of Finding Paths in a Two-Dimensional Domain II: Piecewise Straight-Line Paths

The problem of finding a piecewise straight-line path, with a constant number of line segments, in a two-dimensional domain is studied in the Turing machine-based computational model and in the discrete complexity theory. It is proved that, for polynomial-time recognizable domains associated with polynomial-time computable distance functions, the complexity of this problem is equivalent to a discrete problem which is complete for ∑2P, the second level of the polynomial-time hierarchy.

The size of SPP

Derandomization techniques are used to show that at least one of the following holds regarding the size of the counting complexity class SPP: 1. μ p (SPP)=0. 2. PH ⊆ SPP . In other words, SPP is small by being a negligible subset of exponential time or large by containing the entire polynomial-time hierarchy. This addresses an open problem about the complexity of the graph isomorphism problem: it is not weakly complete for exponential time unless PH is contained in SPP. It is also shown that the polynomial-time hierarchy is contained in SPP NP if NP does not have p-measure 0.

The size of SPP

Derandomization techniques are used to show that at least one of the following holds regarding the size of the counting complexity class SPP: 1. μ p(SPP)=0. 2. PH ⊆ SPP . In other words, SPP is small by being a negligible subset of exponential time or large by containing the entire polynomial-time hierarchy. This addresses an open problem about the complexity of the graph isomorphism problem: it is not weakly complete for exponential time unless PH is contained in SPP. It is also shown that the polynomial-time hierarchy is contained in SPP NP if NP does not have p-measure 0.

Locally Determined Logic Programs and Recursive Stable Models

In general, the set of stable models of a recursive logic program can be quite complex. For example, it follows from results of Marek, Nerode, and Remmel [Ann. Pure and Appl. Logic (1992)] that there exists finite predicate logic programs and recursive propositional logic programs which have stable models but no hyperarithmetic stable models. In this paper, we shall define several conditions which ensure that recursive logic program P has a stable model which is of low complexity, e.g., a recursive stable model, a polynomial time stable model, or a stable model which lies in a low level of the polynomial time hierarchy.

ON HIGHER ARTHUR-MERLIN CLASSES

We study higher Arthur-Merlin classes defined via several natural probabilistic operators BP, R and coR. We investigate the complexity classes they define, and a number of interactions between these operators and the standard polynomial time hierarchy. We prove a hierarchy theorem for these higher Arthur-Merlin classes involving interleaving operators, and a theorem giving non-trivial upper bounds to the intersection of the complementary classes in the hierarchy.

Average-case intractability vs. worst-case intractability

We show that not all sets in NP (or other levels of the polynomial-time hierarchy) have efficient average-case algorithms unless the Arthur-Merlin classes MA and AM can be derandomized to NP and various subclasses of P /poly collapse to P . Furthermore, other complexity classes like P ( PP ) and PSPACE are shown to be intractable on average unless they are easy in the worst case.

On Proving Circuit Lower Bounds against the Polynomial-Time Hierarchy

We consider the problem of proving circuit lower bounds against the polynomial-time hierarchy. We give both positive and negative results. For the positive side, for any fixed integer k>>0, we give an explicit $\Sigma^{\rm p}_2$ language, acceptable by a $\Sigma^{\rm p}_2$ machine with running time O(nk2+k ), that requires circuit size >nk. This provides a constructive version of an existence theorem of R. Kannan [Inform. and Control, 55 (1982), pp. 40--56]. Our main theorem is on the negative side. We give evidence that it is infeasible to give relativizable proofs that any single language in the polynomial-time hierarchy requires superpolynomial circuit size. Our proof techniques are based on the decision tree version of the Switching Lemma for constant depth circuits and the Nisan--Wigderson pseudorandom generator. We also take this opportunity to publish some previously unpublished older results of the first author on constant depth circuits, both straight lower bounds and inapproximability results based on decision tree--type Switching Lemmas.

SIGACT news complexity theory column 35

I was surprised and delighted at a recent conference when the complexity class Θ 2 p suddenly popped up in a talk (by Markus Holzer on work by him and Pierre McKenzie) where it is was not exactly something one would have before-hand expected to come into play. After hearing the rest of Markus's remarkable talk (which he illustrated using toys from his daughter), I was much hoping that the authors would be so kind as to write a guest column; they very generously agreed to, and that column appears below.So, what is Θ 2 p ? Θ 2 p is the class of languages acceptable via parallel access to NP, and has many equivalent alternate definitions and characterizations (see [KSW87, Hem89, Wag90]), such as the one used in the paper below. This class was first studied by Papadimitriou and and Zachos in 1983 [PZ83] (though in a form that at that time was not known to be equivalent to the definition just mentioned), and has played an important role in complexity theory, e.g., Kadin [Kad89] proved that the polynomial-time hierarchy collapses to Θ 2 p if NP has sparse Turing-complete sets. Recently, the class has turned out to play other surprising roles, such as in analyzing the complexity of electoral systems (see the survey [HH00]) and in understanding the performance of greedy algorithms [HR98, HRS01]. In fact, a survey column a few years ago was devoted to overviewing such raised-to-Θ 2 p lower bounds [HHR97]. Bill Gasarch and SIGACT News need YOU! That is, the next issue will contain a guest column edited by Bill Gasarch, which will collection opinions on the future of the P-versus-NP question. Bill very much wants a broad range of opinions, and will be setting up a web page (http://www.cs.umd.edu/~gasarch/pnp/) describing how you can get your opinions to him. He may even put up a series of polling questions there, so please go there, vote early, and vote often!And in the issues following that will be articles by M. Schaeffer and C. Umans on complete sets at and beyond the polynomial hierarchy's second level, by A. Nickelsen and T. Tantau on partial information classes, and by R. Paturi on the complexity of k -SAT.

On the Knowledge Complexity of ${\cal{N}P}$

We show that if a language has an interactive proof of logarithmic statistical knowledge-complexity, then it belongs to the class . Thus, if the polynomial time hierarchy does not collapse, then -complete languages do not have logarithmic knowledge complexity. Prior to this work, there was no indication that would contradict languages being proven with even one bit of knowledge. Our result is a common generalization of two previous results: The first asserts that statistical zero knowledge is contained in [11, 2], while the second asserts that the languages recognizable in logarithmic statistical knowledge complexity are in [19]. Next, we consider the relation between the error probability and the knowledge complexity of an interactive proof. Note that reducing the error probability via repetition is not free: it may increase the knowledge complexity. We show that if the negligible error probability is less than (where k(n) is the knowledge complexity) then the language proven is in the third level of the polynomial time hierarchy (specifically, it is in ). In the standard setting of negligible error probability, there exist PSPACE-complete languages which have sub-linear knowledge complexity. However, if we insist, for example, that the error probability is less than , then PSPACE-complete languages do not have sub-quadratic knowledge complexity, unless . In order to prove our main result, we develop an AM protocol for checking that a samplable distribution D has a given entropy h. For any fractions , the verifier runs in time polynomial in and and fails with probability at most to detect an additive error in the entropy. We believe that this protocol is of independent interest. Subsequent to our work Goldreich and Vadhan [16] established that the problem of comparing the entropies of two samplable distributions if they are noticeably different is a natural complete promise problem for the class of statistical zero knowledge ( ).

Graph Nonisomorphism Has Subexponential Size Proofs Unless the Polynomial-Time Hierarchy Collapses

Traditional hardness versus randomness results focus on time-efficient randomized decision procedures. We generalize these trade-offs to a much wider class of randomized processes. We work out various applications, most notably to derandomizing Arthur-Merlin games. We show that every language with a bounded round Arthur-Merlin game has subexponential size membership proofs for infinitely many input lengths unless exponential time coincides with the third level of the polynomial-time hierarchy (and hence the polynomial-time hierarchy collapses). Since the graph nonisomorphism problem has a bounded round Arthur-Merlin game, this provides the first strong evidence that graph nonisomorphism has subexponential size proofs. We also establish hardness versus randomness trade-offs for space bounded computation.

Relating Automata-theoretic Hierarchies to Complexity-theoretic Hierarchies

We show that some natural refinements of the Straubing and Brzozowski hierarchies correspond (via the so called leaf-languages) step by step to similar refinements of the polynomial-time hierarchy. This extends a result of Burtschik and Vollmer on relationship between the Straubing and the polynomial hierarchies. In particular, this applies to the Boolean hierarchy and the plus-hierarchy.

PSPACE has constant-round quantum interactive proof systems

In this paper we introduce quantum interactive proof systems, which are interactive proof systems in which the prover and verifier may perform quantum computations and exchange quantum messages. It is proved that every language in PSPACE has a quantum interactive proof system that requires a total of only three messages to be sent between the prover and verifier and has exponentially small (one-sided) probability of error. It follows that quantum interactive proof systems are strictly more powerful than classical interactive proof systems in the constant-round case unless the polynomial time hierarchy collapses to the second level.

Theory of computational complexity

UNIFORM COMPLEXITY. Models of Computation and Complexity Classes. NP-Completeness. The Polynomial-Time Hierarchy and Polynomial Space. Structure of NP. NONUNIFORM COMPLEXITY. Decision Trees. Circuit Complexity. Polynomial-Time Isomorphism. PROBABILISTIC COMPLEXITY. Probabilistic Machines and Complexity Classes. Complexity of Counting. Interactive Proof Systems. Probabilistically Checkable Proofs and NP-Hard Optimization Problems. Bibliography. Index.

On boolean lowness and boolean highness

The concepts of lowness and highness originate from recursion theory and were introduced into the complexity theory by Schöning (Lecture Notes in Computer Science, Vol. 211, Springer, Berlin, 1985). Informally, a set is low (high resp.) for a relativizable class K of languages if it does not add (adds maximal resp.) power to K when used as an oracle. In this paper, we introduce the notions of boolean lowness and boolean highness. Informally, a set is boolean low (boolean high resp.) for a class K of languages if it does not add (adds maximal resp.) power to K when combined with K by boolean operations. We prove properties of boolean lowness and boolean highness which show a lot of similarities with the notions of lowness and highness. Using Kadin's technique of hard strings (see Kadin, SIAM J. Comput 17(6) (1988) 1263–1282; Wagner, Number-of-query hierachies, TR 158, University of Augsburg, 1987; Chang and Kadin SIAM J. Comput. 25(2) (1996) 340; Beigel et al. Math. Systems Theory 26 (1993) 293–310) we show that the sets which are boolean low for the classes of the boolean hierarchy are low for the boolean closure of Σ 2 p . Furthermore, we prove a result on boolean lowness which has as a corollary the best known result (see Beigel, ( 1993); in fact even a bit better) on the connection of the collapses of the boolean hierarchy and the polynomial-time hierarchy if BH = NP(k) then PH = Σ 2 k−1⊕NP(k) .

Time–Space Tradeoffs for Satisfiability

We give the first nontrivial model-independent time–space tradeoffs for satisfiability. Namely, we show that SAT cannot be solved in n1+o(1) time and n1−ε space for any ε>0 general random-access nondeterministic Turing machines. In particular, SAT cannot be solved deterministically by a Turing machine using quasilinear time and n space. We also give lower bounds for log-space uniform NC1 circuits and branching programs. Our proof uses two basic ideas. First we show that if SAT can be solved nondeterministically with a small amount of time then we can collapse a nonconstant number of levels of the polynomial-time hierarchy. We combine this work with a result of Nepomnjaščiı that shows that a nondeterministic computation of superlinear time and sublinear space can be simulated in alternating linear time. A simple diagonalization yields our main result. We discuss how these bounds lead to a new approach to separating the complexity classes NL and NP. We give some possibilities and limitations of this approach.

Separating Complexity Classes Using Autoreducibility

A set is autoreducible if it can be reduced to itself by a Turing machine that does not ask its own input to the oracle. We use autoreducibility to separate the polynomial-time hierarchy from exponential space by showing that all Turing complete sets for certain levels of the exponential-time hierarchy are autoreducible but there exists some Turing complete set for doubly exponential space that is not. Although we already knew how to separate these classes using diagonalization, our proofs separate classes solely by showing they have different structural properties, thus applying Post's program to complexity theory. We feel such techniques may prove unknown separations in the future. In particular, if we could settle the question as to whether all Turing complete sets for doubly exponential time are autoreducible, we would separate either polynomial time from polynomial space, and nondeterministic logarithmic space from nondeterministic polynomial time, or else the polynomial-time hierarchy from exponential time. We also look at the autoreducibility of complete sets under nonadaptive, bounded query, probabilistic, and nonuniform reductions. We show how settling some of these autoreducibility questions will also lead to new complexity class separations.

Jan Krajíček, Pavel Pudlák, and Gaisi Takeuti. Bounded arithmetic and the polynomial hierarchy. Ibid., vol. 52 (1991), pp. 143–153. - Samuel R. Buss. Relating the bounded arithmetic and polynomial time hierarchies. Ibid., vol. 75 (1995), pp. 67–77. - Domenico Zambella. Notes on polynomially bounded arithmetic. The journal of symbolic logic, vol. 61 (1996), pp. 942–966.

Jan Krajíček, Pavel Pudlák, and Gaisi Takeuti. Bounded arithmetic and the polynomial hierarchy. Ibid., vol. 52 (1991), pp. 143–153. - Samuel R. Buss. Relating the bounded arithmetic and polynomial time hierarchies. Ibid., vol. 75 (1995), pp. 67–77. - Domenico Zambella. Notes on polynomially bounded arithmetic. The journal of symbolic logic, vol. 61 (1996), pp. 942–966.

Determining acceptance possibility for a quantum computation is hard for the polynomial hierarchy

Abstract It is shown that determining whether a quantum computation has a non-zero probability of accepting is at least as hard as the polynomial time hierarchy. This hardness result also applies to determining in general whether a given quantum basis state appears with nonzero amplitude in a superposition, or whether a given quantum bit has positive expectation value at the end of a quantum computation. This result is achieved by showing that the complexity class NQP of Adleman, Demarrais, and Huang, a quantum analog of NP, is equal to the counting class $co-C equals P$.