Qwiki http://qwiki.stanford.edu/index.php/Main_Page MediaWiki 1.15.3 first-letter Media Special Talk User User talk Qwiki Qwiki talk File File talk MediaWiki MediaWiki talk Template Template talk Help Help talk Category Category talk Complexity Dojo 3646 12365 2009-08-11T05:27:56Z MartinSchwarz 1970 {{CD-Menu}} In complexity theory, it isn't enough to say that something is impossible; you have to ''prove'' it. So here in the '''Complexity Dojo''', we introduce several major theorems and proof techniques that will go a long way. Of course, there are going to be disagreements as to what a "major theorem" is, so this is all in the opinion of the [[Christopher Granade|Tour Guide]] and any other contributors. The main focus, though, will be on theorems that illustrate important concepts more than on theorems which have a direct impact. If you feel that the list of theorems is somehow terribly deficient for the lack of a specific theorem, please add it! For those of you not used to mathematical proofs in general, here's some resources that may help: * One of the various textbooks on the subject, such as that by [http://books.google.com/books?id=j7xcHwAACAAJ Maddox]. * [[Wikibooks:Mathematical Proof|Mathematical Proof]], a book on [[WikiBooks:Main Page|WikiBooks]]. (As of the time of this writing, it is woefully incomplete, but it should improve.) * Wikipedia entry on [[Wikipedia:Mathematical proof|Mathematical proof]]. * [http://mathworld.wolfram.com/ MathWorld]'s definitions of [http://mathworld.wolfram.com/Proof.html Proof] and [http://mathworld.wolfram.com/Theorem.html Theorem]. Also good is the page on [http://mathworld.wolfram.com/ReductioadAbsurdum.html proof by contradiction]. Of course, none of these resources can compare with taking a class that requires proofs (real analysis or complexity theory make good candidates), or a class directly about proofs. == Major Theorems == * [[Complexity Dojo/Cook-Levin Theorem|Cook-Levin Theorem]]: [[Complexity Garden#SAT|SAT]] &isin; {{zcls|n|npc|NP-complete}}. * [[Complexity Dojo/Savitch's Theorem|Savitch's Theorem]]: {{zcls|n|nspace}}(f(n)) &sube; {{zcls|d|dspace}}(f&sup2;(n)), {{zcls|p|pspace}} = {{zcls|n|npspace}} * [[Complexity Dojo/Ladner's Theorem|Ladner's Theorem]] {{zcls|p|p}} &ne; {{zcls|n|np}} implies that {{zcls|n|npi|NP-intermediate}} problems exist. * [[Complexity Dojo/Blum Speedup Theorem|Blum Speedup Theorem]]: Some problems do not have optimal solutions. * [[Complexity Dojo/Impagliazzo-Widgerson Theorem|Impagliazzo-Widgerson Theorem]]: {{zcls|p|p}} = {{zcls|b|bpp}} unless {{zcls|e|e}} has sub-exponential circuits. * [[Complexity Dojo/Toda's Theorem|Toda's Theorem]]: {{zcls|p|ph}} &sube; {{zcls|p|p}}<sup>{{zcls|symbols|sharpp|#P}}</sup>. * [[Complexity Dojo/Natural Proofs|Natural Proofs]] == Proof Techniques == * {{ns|Christopher Granade:Complexity Dojo|Diagonalization}}: Method of showing that an enumeration of a set is incomplete. Complexity Dojo/Cook-Levin Theorem 3653 11448 2008-07-25T15:26:56Z Christopher Granade 1266 [[Christopher Granade:Complexity Dojo:Cook-Levin Theorem]] moved to [[Complexity Dojo/Cook-Levin Theorem]]: Moving out of [[User:Christopher Granade]] and fixing namespace separator. {{CD-Menu}} The '''Cook-Levin Theorem''' shows that ''any'' problem in {{zcls|n|np}} is [[Complexity Zoo Glossary#reduction|reducible]] to [[Complexity Garden#sat|SAT]] in polynomial time. Thus, SAT is at least as hard as every other problem in NP (we call this property NP-hardness). Being in NP itself, this implies that SAT somehow encapsulates ''why'' problems in NP are hard. It is important enough that we say that SAT is {{zcls|n|npc|NP-complete}}. The Cook-Levin Theorem also lets us show that other problems are NP-complete by reducing SAT to them in polynomial time, since polynomials are closed under composition. Thus, the theorem acts as a starting point for further study of NP-completeness. There are actually many versions of the proof of Cook-Levin Theorem. Some versions, such as the one presented by {{zcite|Pap94}} reduce NP problems to the Circuit-SAT problem (a variant of SAT), then use as a lemma that Circuit-SAT is reducible to SAT. In doing so, they prove a slightly stronger result that Circuit-SAT is also NP-complete. Other versions of the proof, such as the [[Wikipedia:Cook's theorem|one given by Wikipedia]], employ a gaggle of variables to represent the NP machine being reduced to SAT. In either case, however, what remains is that the satisfiablity instance constructed by the proof simulates an NP machine, and thus solving it gives you the ability to solve arbitrary NP problems for which an NP machine has been devised (as opposed to those problems that we place in NP non-constructively). Moreover, most (if not every) version of the proof relies on the ''locality'' of a Turing machine. That is, we shall rely upon the fact that since the transition function for a Turing machine depends only on the symbols under each read head and the machine state, we can describe the Turing machine as the combination of a series of local descriptions. This is a commonly enough covered theorem that we shall not give a proof here, but rather shall be content to direct the reader to one of the proofs given elsewhere (please expand this list if you find a good proof somewhere): * {{zcite|Pap94}} * [[Wikipedia:Cook's theorem|Wikipedia]] Complexity Dojo/Diagonalization 3648 11456 2008-07-25T15:30:36Z Christopher Granade 1266 [[Christopher Granade:Complexity Dojo:Diagonalization]] moved to [[Complexity Dojo/Diagonalization]]: Moving out of [[User:Christopher Granade]] and fixing namespace separator. {{CD-Menu}} '''Diagonalization''' refers to a method of proving that some enumeration $\{s_1, s_2,\dots\}$ of an infinite set misses at least one element. == Example == Perhaps the best way to introduce the idea is in a context other than complexity theory. [[Wikipedia:Georg Cantor|Georg Cantor]] famously applied diagonalization to show that the set of real numbers is strictly larger than the set of integers, despite that they are both infinite. We shall show here a seemingly weaker version, where we show that $\left\vert\mathbb{R}\right\vert > \left\vert\mathbb{N}\right\vert$, but it is easy to show that the integers and natural numbers have the same cardinality. {{Theorem |Cantor's Diagonalization Argument|statement=The set of real numbers $\mathbb{R}$ is strictly larger than the set of natural numbers $\mathbb{N}$. That is, there exists an injection (one-to-one function) $f : \mathbb{N}\to\mathbb{R}$, but that any such $f$ fails to be surjective (onto). |proof=Showing that an injective function $f : \mathbb{N}\to\mathbb{R}$ exists is trivial; consider $f(n) = n$. On the other hand, suppose for the sake of contradiction that there exists some $f$ of the same form which is bijective (one-to-one and onto). Then, we can enumerate the real numbers: $\{f(1), f(2), f(3), \dots\}$. In particular, if we write out the decimal expansion of $f(i)$ as $f(i) = f_{i1} f_{i2} \dots$, where each $f_{ij} \in {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}$, then we can make a table as follows: <center> <table> <tr><td>$f(1)$</td><td>=</td><td>$f_{11}$</td><td>$f_{12}$</td><td>$f_{13}$</td><td>$f_{14}$</td><td>$f_{15}$</td><td>$\cdots$</td></tr> <tr><td>$f(2)$</td><td>=</td><td>$f_{21}$</td><td>$f_{22}$</td><td>$f_{23}$</td><td>$f_{24}$</td><td>$f_{25}$</td><td>$\cdots$</td></tr> <tr><td>$f(3)$</td><td>=</td><td>$f_{31}$</td><td>$f_{32}$</td><td>$f_{33}$</td><td>$f_{34}$</td><td>$f_{35}$</td><td>$\cdots$</td></tr> <tr><td>$f(4)$</td><td>=</td><td>$f_{41}$</td><td>$f_{42}$</td><td>$f_{43}$</td><td>$f_{44}$</td><td>$f_{45}$</td><td>$\cdots$</td></tr> <tr><td>$f(5)$</td><td>=</td><td>$f_{51}$</td><td>$f_{52}$</td><td>$f_{53}$</td><td>$f_{54}$</td><td>$f_{55}$</td><td>$\cdots$</td></tr> </table> </center> Now, consider $g=g_1 g_2 g_3 \dots$, where each $g_i = f_{ii} + 1 \bmod 10$. For example, if $f_{22} = 9$, then $g_2 = 0$. Intuitively, we construct $g$ by selecting digits from the diagonal of the table above, and shifting each by one. But then, we claim that for any $i\in\mathbb{N}$, $g\ne f(i)$. To see this, note that $f(i)$ and $g$ must differ in at least one digit&ndash;the $i^{\mathrm{th}}$ digit&ndash;by construction. (Note that there is a slight technicality that we're sweeping under the rug here: 0.999.... = 1.0000, but they differ in every digit. I say that this technicality is slight, however, as we could deal with this as a special case.) Therefore, $g$ is not in our enumeration and so $f$ is not surjective. }} == Applications == This is the most clean and intuitive example of how diagonalization arguments go, and shows the general pattern by which the method works. If we want to show that an enumeration is incomplete, then we construct a new element that is different from every single other item in that enumeration by construction. Though we have given a very specific example here, the argument generalizes to show that the cardinality of a set is always strictly less than that of its power set (see [http://mathworld.wolfram.com/CantorDiagonalMethod.html this article on MathWorld] for more details). Many very important proofs in complexity theory work by diagonalization arguments, including: * [[Christopher Granade:Complexity Dojo:Ladner's Theorem|Ladner's Theorem]]. * The Time Hierarchy Theorem. == Limits of Diagonalization == There are limits to the power of diagonalization, however. To see this, we need to take a brief detour into oracle land. We define an [[Zoo Glossary#oracle|oracle]] Turing machine (OTM) for some problem $O$ to be a Turing machine which has a special tape, called the ''oracle tape'', and three special states $q_{?}, q_{\mbox{yes}}, q_{\mbox{no}}$. Whenever an OTM enters the special state $q_?$, in the next step its new state shall be either $q_{\mbox{yes}}$ or $q_{\mbox{no}}$, depending on whether the contents $w$ of satisfy $w\in O$. Given the set of Turing machines in a class $A$, we write that the class $A^O$ is the set of oracle Turing machines, where the oracle is for the problem $O$. Thus, P<sup>3SAT</sup> is the set of polynomial-time deterministic Turing machines with oracles for 3SAT. Diagonalization arguments treat TMs as black boxes, paying attention only to the fact that we can make an enumeration of machines and the ability to construct a new machine which simulates each machine in an enumeration with very little overhead. As such, we can substitute an oracle Turing machine for a Turing machine in any diagonalization argument. Since we can use this alternate model of computation in diagonalization arguments, any such argument which shows that $A \ne B$ also implies that for any $O$, $A^O = B^O$. We say that diagonalization arguments ''relativize''. As an example of how this fundamentally limits the power of diagonalization arguments, note that {{zcite|BGS75}} showed that there exist oracles $A,B$ such that P<sup>$A$</sup> = NP<sup>$B$</sup> and P<sup>$B$</sup> &ne; NP<sup>$B$</sup>. Thus no relativizing argument cannot prove either P = NP or P &ne; NP. Complexity Dojo/Ladner's Theorem 3677 13086 2010-10-20T17:59:54Z Jeffrey Finkelstein 2067 changed typo: in -> is {{CD-Menu}} {{CZ-Stub}} We know that P &sube; NP, so {{zcls|p|p}} &ne; {{zcls|n|np}} if and only if this inclusion is proper. A plausible question, then, is whether all problems in NP \ P are {{zcls|n|npc|NP-complete}}. '''Ladner's Theorem''', proved in {{zcite|Lad75}}, shows that this is not the case: there exist languages which are in NP \ P but are not NP-complete. The set of such problems is denoted by {{zcls|n|npi|NP-intermediate}}. The proof of Ladner's Theorem can be easily modified to imply an infinite structure within NP \ P. The NP-intermediate language constructed in {{zcite|Lad75}} is artificial. Natural languages believed to be NP-intermediate are Integer Factorization, Graph Isomorphism, and Nash Equilibria. {{Theorem|Ladner's Theorem|statement=If {{zcls|p|p}} &ne; {{zcls|n|np}}, then NPI is non-empty. |proof= }} Complexity Dojo/Savitch's Theorem 3654 11452 2008-07-25T15:30:01Z Christopher Granade 1266 [[Christopher Granade:Complexity Dojo:Savitch's Theorem]] moved to [[Complexity Dojo/Savitch's Theorem]]: Moving out of [[User:Christopher Granade]] and fixing namespace separator. {{CD-Menu}} '''Savitch's Theorem''' shows that the Reachability problem can be solved in space $O(\log^2 n)$ for a graph with $n$ nodes. As a corollary, we can apply the reachability method to show that {{zcls|n|nspace}}$(f(n))$ &sube; {{zcls|s|space}}$(f^2(n))$. This in turn gives us immediately that {{zcls|n|npspace}} = {{zcls|p|pspace}}; that is, that for polynomially-bounded space, non-determinism doesn't buy us anything, in contrast to what we suspect about polynomially-bounded time. {{Theorem |Savitch's Theorem|statement=Reachability &isin; {{zcls|s|space}}$(\log^2 n)$. |proof=Let $G=(V,E)$ be a directed graph (given in the form of an adjacency matrix $A^G$), and let $n=\left\vert V\right\vert$. We shall proceed by building up a predicate $\mathrm{Path} : V \times V \times \mathbb{N} \to \{0,1\}$ such that, for some vertices $a,b$ and natural number $i$, $\mathrm{Path}(a,b,i) = 1$ if and only if there is a path of length at most $2^i$ connecting $a$ to $b$. Then, $\mathrm{Reachability}(a,b) = \mathrm{Path}(a,b,\left\lceil \log n \right\rceil)$, since any path longer than $n$ must visit some vertex twice. To compute $\mathrm{Path}(a,b,i)$, we shall use a Turing machine $M$ with an input string $A^G$ and two work strings. The first work string will initially contain the a triple $(a,b,i)$, where $a,b$ are represented as the indices of the vertices. Note that the length of this triple is $O(\left\lceil\log n\right\rceil)$. During the course of the algorithm, we shall add additional triples of the same form for intermediate problems. We shall see soon that no more than $O(\left\lceil \log n \right\rceil)$ triples will be needed. $M$ shall work by noting that if $\mathrm{Path}(a,b,i)$ for $i>0$, then the path described has a midpoint $z$. Formally, if $\mathrm{Path}(a,b,i)$ and $i>0$, there exists a node $z$ such that $\mathrm{Path}(a,z,i-1) \wedge \mathrm{Path}(z,b,i-1)$. Thus, to compute $\mathrm{Path}(a,b,i)$, $M$ will iterate through all vertices $z\in V$ (using the second work tape) and check $\mathrm{Path}(a,z,i-1)$ and $\mathrm{Path}(z,b,i-1)$ recursively, using the first work tape as a stack to store which sub-problem we're working on. Since we'll never need more than $\log n$ levels of recursion, we will be able to run this algorithm in $O(\log^2 n)$ space, as claimed. }} In and of itself, this theorem hides its true importance. The true power of the theorem comes when we apply it to the ''configuration graph'' of an {{zcls|n|nspace}} machine. {{Theorem |theorem=Corollary |statement=For all constructable $f(n)=\omega(\log n)$, NSPACE$(f(n))$ &sube; SPACE$(f^2(n))$. |proof=Let $M$ be an NSPACE$(f(n))$ machine, and let $k$ be the number of tapes used by $M$. We start by defining what we mean by a ''configuration'' of $M$. We say that a configuration of $M$ is a $2k+1$ tuple $(q, x_1, y_1, \dots, x_k, y_k)$ where $q$ is a state of $M$, and where $x_i,y_i$ are strings over the tape alphabet of $M$. We interpret a configuration as a "snapshot" of $M$ during its operation. Thus, given a configuration $(q, x_1, y_1, \dots, x_k, y_k)$, we say that $M$ is in state $q$ and that each of the tapes $i\in[1..k]$ contains the string $x_i y_i$, where the read head for that tape is between the two strings. We can build a graph $G_M$ where each vertex is a possible configuration of $M$, since there are a finite number of possible configurations reachable by a machine with bounded space. For each pair of configurations $A, B\in G_M$, there is an edge in $G_M$ from $A$ to $B$ if and only if $B$ can be reached from $A$ in one step of computation. We can do better than simply stating that the configuration graph of $M$ is finite, though. Given a configuration $(q, x_1, y_1, \dots, x_k, y_k)$, the number of choices for $q$ is limited to $\left\vert Q\right\vert$ where $Q$ is the set of states for $M$. Moreover, by the definition of NSPACE, the total of the lengths of each string $x_i,y_i$ is bounded by $f(n)$. We can partition this length into the various strings with $2k$ integers in the range $[0..f(n)]$. Thus, the number of choices for each configuration is bounded by $\left\vert Q\right\vert \left\vert\Sigma\right\vert^{2k\cdot f(n)}$, where $\Sigma$ is the tape alphabet of $M$. Finally, the number of possible configurations of $M$ is bounded by $nc^{f(n)}=c^{\log n + f(n)}$ for some constant $c$ depending only on $M$. Thus, we can run the algorithm for Reachability given above on the configuration graph of $M$ by performing a step of computation on $M$ whenever the algorithm would check if two verticies are adjacent or not. Performing that check requires space bounded by $O(f(n))$. Since there are $O(c^{\log n + f(n)})$ vertices in the graph, Reachability for the initial and accepting configurations of $M$ can be computed in space bounded by $O(\log^2 (c^{\log n + f(n})) = O(f^2(n) + \log^2 n)$. If $\log(n) = o(f(n))$, then this means that the space bound is $O(f^2(n))$. Finally, note that the algorithm for Reachability given above is deterministic. Hence, NSPACE$(f(n))$ &sube; SPACE$(f^2(n))$ for all constructable $f(n) = \omega(\log n)$, as claimed. }} As mentioned before, letting $f(n)$ in the corollary be a polynomial gives that NPSPACE = PSPACE. Complexity Garden 3442 39567 2012-05-26T15:24:38Z Ben Lund 11340 Undo revision 37738 by [[Special:Contributions/Gregory|Gregory]] ([[User talk:Gregory|Talk]]) Remove link spam __NOTOC__ [[Category:Computational Complexity]] {{Menubox|{{CZ-Navbar}}}} Welcome to the '''Complexity Garden''', the botanical companion to the [[Complexity Zoo]]. This field guide lists rigorously defined computational problems, together with their relations to complexity classes, their best algorithmic results, and their relations to other problems. There are now 39 problems and (one can only hope) counting. The initial members either have or might have some exotic property related to [[speedup]] (such as [[Zoo_Glossary#ospeedup|O-speedup]], [[Zoo_Glossary#gap|monotone-nonmonotone gap]], or [[Zoo_Glossary#puniform|P-nonuniformity]]), or provide a canonical example of a complexity class (i.e. {{zcls|n|npc|NP-complete}}). ''However, all additions are welcome, and it is hoped that this will grow into a comprehensive collection.'' '''Gardener''': Hunter Monroe (volunteers welcome) To create a new problem, click on the edit link of the problem before or after the one that you want to add and copy the format, and save. The preferred format of each problem is as follows: description of the problem, relations to complexity classes, their best algorithmic results (upper-bounds and lower-bounds e.g. see the [[#setcover|Set Cover]] problem), memberships and properties, and relations to other problems. Then, add the problem to the table of contents and increment the total number of problems. After this, you can use the side edit links to edit the individual sections. For more on using the wiki language, see our [[Simple_wiki_help | simple wiki help page]]. If your problem is not on the list and you suspect that it might be an open problem you can check the [http://garden.irmacs.sfu.ca/ Open Problem Garden]. ==Table of Contents== ''Graph theoretic problems:'' [[#sharpperfect_matching|#Perfect Matching]] - [[#clique-like|Clique-Like]] - [[#graph_automorphism|Graph Automorphism]] - [[#graph_isomorphism|Graph Isomorphism]] - [[#perfect_matching|Perfect Matching]] ''Satisfiability problems:'' [[#sharpsat|#SAT]] - [[#sharpwsat|#WSAT]] - [[#constraint-sat|Constraint Satisfaction]] - [[#qbf|QBF]] - [[#qksat|Quantum k-SAT]] - [[#sat|SAT]] - [[#ksat|k-SAT]] - [[#unique-ksat|Unique $k$-SAT]] ''Sets and partitions:'' [[#setcover|Set Cover]] ''Uncategorized problems:'' [[#3sum|3SUM]] - [[#approximate_shortest_lattice_vector|Approximate Shortest Lattice Vector]] - [[#boolean_convolution|Boolean Convolution]] - [[#boolean_matrix_multiplication|Boolean Matrix Multiplication]] - [[#boolean_sorting|Boolean Sorting]] - [[#discrete_logarithm|Discrete Logarithm]] - [[#equality|Equality]] - [[#group_nonmembership|Group Nonmembership]] - [[#integer_factorization|Integer Factorization]] - [[#integer_factor|Integer Factor &#8804; k]] - [[#integer_multiplication|Integer Multiplication]] - [[#k-local-ham|k-Local Hamiltonians]] - [[#k-round_sorting|k-Round Sorting]] - [[#linear_programming|Linear Programming]] - [[#majority|Majority]] - [[#matrix_multiplication|Matrix Multiplication]] - [[#parity|Parity]] - [[#permanent|Permanent]] - [[#ra|Ring Automorphism]] - [[#ri|Ring Isomorphism]] - [[#shortest_implicant|Short Implicant]] - [[#stochastic_games|Stochastic Games]] - [[#tautology|Tautology]] - [[#square_root|Square Root mod n]] - [[#threshold(k)|Threshold(k)]] ==The Problems== ===== <span id="sharpperfect_matching" style="color:red">#Perfect Matching</span>: Count perfect matchings ===== The #Perfect Matching problem is to count the number of perfect matchings in a bipartite graph. It is the counting version of [[#perfect_matching|Perfect Matching]]. Algorithms: ? Memberships: &#8712; [[Complexity Zoo:Symbols#sharpp|#P]]-complete Related Problems: #Perfect Matching is equivalent to [[#permanent|Permanent]]. ---- ===== <span id="sharpsat" style="color:red">#SAT</span>: Count satisfying truth assignments ===== This is the counting version of [[sat|SAT]]: given a Boolean formula, compute how many satisfying truth assignments it has. Algorithms: ? Memberships: &#8712; [[Complexity Zoo:Symbols#sharpp|#P]]-complete Related Problems: The version '''#CNF-SAT''' (counting version of [[CNF-SAT|CNF-SAT]]) and '''#3-CNF-SAT''' also called '''#3SAT''' (counting version of [[3-CNF-SAT]]) also are two '''#P-complete''' problems. ---- ===== <span id="sharpwsat" style="color:red">#WSAT</span>: Weighted SAT ===== Given a Boolean formula, count the number of satisfying assignments of [[Zoo Glossary#hamming-weight|Hamming weight]] $k$. This is the canonical problem for {{zcls|symbols|sharpwt|#WT}}. Algorithms: ? Memberships: &#8712; {{zcls|symbols|sharpwt|#WT}} ---- ===== <span id="3sum" style="color:red">3SUM</span>: Do there exist members of a list satisfying $a+b+c=0$? ===== Given a list $X=\{x_i\}_{i=1}^n$ of integers, do there exist elements $a,b,c\in X$ such that $a+b+c=0$? This problem is important enough to computational geometry that there is defined a class of problems to which it is reducible: {{zcls|symbols|3sumhard|3SUM-hard}}. Algorithms: ? Memberships: ? ---- ===== <span id="approximate_shortest_lattice_vector" style="color:red">Approximate Shortest Lattice Vector</span>: Does the shortest vector exceed kn? ===== Given a lattice L in '''Z'''<sup>n</sup> and an integer n, does the shortest vector of L have (Euclidean) length at most kn? Algorithms: ? Memberships: &#8712; [[Zoo#np|NP]] &#8745; [[Zoo#conp|coNP]], $\notin$ [[Zoo#p|P]]? ---- ===== <span id="boolean_convolution" style="color:red">Boolean Convolution</span>: Convolution of two n-bit integers. ===== Compute the convolution of two n-bit integers in binary notation $\sum_{i+j=k}x_i \cdot y_j$, where the multiplicands are respectively the i-1 and j-1 bits of the two integer inputs, and k is the k-1 bit of the output. It is a Boolean function with n input bits and 2n-1 output bits. It has monotone circuit complexity $\Omega(n^{3/2})$ (Weiss) and nonmonotone circuit complexity $n\log n 2^{O(\log^* n)}$ (Furer [[zooref#fur07|[Fur07]]]). $\log^*(n)$ means iteratively taking $\log$ of n until the result is less than 2. Nonmonotone circuits use the discrete Fourier transform (Wegener [[zooref#weg87|[Weg87]]]). Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] <br>Properties: [[Zoo_Glossary#puniform|P-nonuniform?]], [[Zoo_Glossary#gap|monotone-nonmonotone gap]] ---- ===== <span id="boolean_matrix_multiplication" style="color:red">Boolean Matrix Multiplication</span>: Monotone product of Boolean matrices ===== Boolean Matrix Multiplication is a Boolean function with 2n<sup>2</sup> input bits (two nxn matrices) and n<sup>2</sup> output bits (an nxn matrix). The function is defined using the usual row-column rule, but using OR instead of binary addition. It has monotone circuit complexity of exactly $2n^3-n^2$ (Pratt [[zooref#pra74|[Pra74]]]), but its nonmonotone circuit complexity is the same as matrix multiplication, presently $O(n^{2.376})$ (Wegener [[zooref#weg87|[Weg87]]]). Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] <br>Properties: [[Zoo_Glossary#puniform|P-nonuniform?]], [[Zoo_Glossary#gap|monotone-nonmonotone gap]] ---- ===== <span id="boolean_sorting" style="color:red">Boolean Sorting</span>: Sort n input bits. ===== A Boolean function with n inputs and n outputs that puts the 0s before the 1s. For example, 101 → 011 and 11000 → 00011. It has monotone circuit complexity $\Theta(n \log n)$ (Lamagna and Savage [[zooref#LS74|[LS74]]]) and nonmonotone circuit complexity $\Theta(n)$ (Muller and Preparata [[zooref#MP75|[MP75]]]). The nonmonotone circuits use binary rather than unary addition to count the 0 inputs. The outputs are the [[#threshold(k)|Threshold(k)]] functions in reverse order; in particular, the middle output is [[#majority|Majority]]. Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] <br>Properties: [[Zoo_Glossary#ospeedup|O-optimal]], symmetric, [[Zoo_Glossary#gap|monotone-nonmonotone gap]] ---- ===== <span id="clique-like" style="color:red">Clique-Like</span>: Tardos' Clique-like approximation ===== Clique-Like is a Boolean function with $n^2$ inputs (an adjacency matrix) and one output. It has monotone circuit complexity of $\Omega\left(e^{cn^{1/6-o(1)}}\right)$ (Tardos [[zooref#tar88|[Tar88]]]). By contrast it has polynomial nonmonotone circuit complexity, because it reduces to [[#linear_programming|Linear Programming]]. Algorithms: ? Memberships: &#8712; [[Zoo#p|P]] <br>Properties: [[Zoo_Glossary#gap|monotone-nonmonotone gap]] ---- {{Garden-Problem |id=constraint-sat |title=Constraint Satisfaction Problem |descript=Generalized version of satisfiability problems |body= Given two sets of relations $I,T$, where $I$ is the ''instance'' (not to be confused with an instance of CSP) and $T$ is the ''template'', over the same vocabulary, where the vocabulary defines the names and arities of allowed relations, is there a mapping $h$ such that for all relations $R(x_1, x_2, \dots, x_k)\in I$, $R\left(h(x_1, x_2, \dots, x_k)\right)\in T$? Algorithms: ? ''Memberships:'' [[Complexity Zoo:N#npc|NP-complete]]. ''See Also:'' [[zooref#fv93|[FV93]]]. }} ===== <span id="discrete_logarithm" style="color:red">Discrete Logarithm</span>: Reverse exponentiation ===== The discrete logarithm problem is to solve for x in the equation a<sup>x</sup> = b in some number-theoretic abelian group, typically either the group of units of a finite field or an elliptic curve over a finite field. Like the related [[#integer_factorization|Integer Factorization]], the fastest classical algorithm is the number field sieve, with heuristic time complexity $2^{O(n^{1/3}(\log n)^{2/3})}$. Also like [[#integer_factorization|Integer Factorization]], Shor's algorithm solves Discrete Logarithm in quantum polynomial time. In fact, Shor's algorithm solves Discrete Logarithm even in a black-box abelian group, provided that group elements have unique names. Algorithms: ? Memberships: &#8712; [[Zoo#fnp|FNP]] &#8745; [[Zoo#fbqp|FBQP]] <br>Properties: Is a one-way function? ---- {{Garden-Problem |id=equality |title=Equality |descript=Are two strings equal? |body= If Alice has a string $x\in\left\{0,1\right\}^n$ and Bob has a string $y\in\left\{0,1\right\}^n$, define EQUALITY(''x'', ''y'') = 1 if and only if ''x'' = ''y''. Algorithms: ? Memberships: <!-- TODO: Fill in. --> }} ===== <span id="graph_automorphism" style="color:red">Graph Automorphism</span>: Is there a nontrivial automorphism? ===== Graph Automorphism is equivalent to [[#graph_isomorphism|Graph Isomorphism]] in the case where the two graphs are identical. Algorithms: ? Memberships: &#8712; [[Zoo#np|NP]] &#8745; [[Zoo#coam|coAM]]. ---- ===== <span id="graph_isomorphism" style="color:red">Graph Isomorphism</span>: Are two graphs isomorphic? ===== Given two graphs, are they isomorphic, i.e., is there a bijection between their vertices which preserves edges? Luks showed that Graph Isomorphism for bounded-valence graphs is in P non-uniformly (the exponent of algorithm's running time depends on the bound). Combining Luks' algorithm with a trick due to Zemlyachenko yields a time complexity upper bound of $2^{O(\sqrt{v \log v})}$ for graphs with v vertices. However, some practical Graph Isomorphism algorithms, such as NAUTY, seem to run much faster than this rigorous upper bound. Like [[#perfect_matching|Perfect Matching]], it is not known to be complete for a natural complexity class. Algorithms: ? Memberships: &#8712; [[Zoo#np|NP]] &#8745; [[Zoo#coam|coAM]], [[Zoo_Glossary#puniform|P-nonuniform?]] Properties: In [[Zoo#np|NP]]\[[Zoo#p|P]] but not [[Complexity Zoo:N#npc|NP-complete]]? ---- {{Garden-Problem |id=group_nonmembership |title=Group Non-Membership |descript=Is an element of ''G'' a member of a subgroup ''H''? |body= Defined by [[zooref#wat00|[Wat00]]]. Let $G$ be a group, whose elements are represented by polynomial-size strings. We're given a "black box" that correctly multiplies and inverts elements of $G$. Then given elements $g\in G$ and $h_1,\dots,h_k\in G$, we can asked to find if $g\notin\left\langle h_1, \dots, h_k \right\rangle$ (the subgroup generated by $h_1,\dots,h_k\in G$). Algorithms: ? ''Memberships:'' [[Complexity Zoo:Q#qma|QMA]] [[zooref#wat00|[Wat00]]]. }} ===== <span id="" style="color:red">Hamiltonian circuit</span>: Exists one Hamiltonian circuit?===== Given a Graph $G$, '''exists one Hamiltonian circuit''' in $G$? Algorithms: ? ''Memberships:'' [[Complexity Zoo:N#npc|NP-complete]] ---- ===== <span id="integer_factorization" style="color:red">Integer Factorization</span>: Find an integer's prime factors ===== Algorithms: The fastest known algorithm for integer factorization is the number field sieve. It has heuristic randomized time complexity $2^{O(n^{1/3}(\log n)^{2/3})}$ for inputs with n digits. On the other hand, Shor's algorithm famously solves Integer Factorization in ''quantum'' polynomial time. Memberships: &#8712; [[Complexity Zoo:F#fnp|FNP]] &#8745; [[Zoo#fbqp|FBQP]] Properties: In [[Zoo#np|NP]]\[[Zoo#p|P]] but not [[Zoo#npc|NP]]-complete? ---- ===== <span id="integer_factor" style="color:red">Integer Factor &#8804; k </span>: Is there a factor &#8804; k? ===== With an upper bound on the desired prime factor, this problem is subtly different from Integer Factorization. Algorithms: The fastest algorithm is either the number field sieve or Lenstra's elliptic curve method, depending on the relative size of n and k. Lenstra's algorithm has heuristic randomized time complexity $\mathrm{poly}(n)2^{O(\sqrt{k(\log k))})}$ if n and k have n and k digits, respectively. Memberships: &#8712; [[Zoo#np|NP]] &#8745; [[Zoo#conp|coNP]] ---- ===== <span id="integer_multiplication" style="color:red">Integer Multiplication</span>: Product of two n-bit integers ===== Integer Multiplication has an [[Zoo_Glossary#ospeedup|O-optimal]] linear-time algorithm on a RAM or SMM, but is thought to have [[Zoo_Glossary#ospeedup|O-speedup]] on Turing machines or [[Zoo_Glossary#puniform|P-uniform]] Boolean circuits. Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] <br>Properties: [[Zoo_Glossary#puniform|P-nonuniform?]] ---- {{Garden-Problem |id=k-local-ham |title=k-Local Hamiltonians |descript=Find the smallest eigenvalue of ''m'' ''k''-local Hamiltonians acting on ''n'' qubits. |body= Given an ''n''-qubit Hilbert space, as well as a collection H<sub>1</sub>,...,H<sub>''m''</sub> of Hamiltonians (i.e. Hermitian positive semidefinite matrices), each of which acts on at most ''k'' qubits of the space. Also given real numbers ''a'',''b'' such that $b-a \in \Theta(1/\mathsf{poly}(n))$. Decide whether the smallest eigenvalue of $H=\sum_{i=1}^m H_i$ is less than ''a'' or greater than ''b'', promised that one of these is the case. Algorithms: ? Memberships: ? ''Properties:'' * [[Complexity Zoo:Q#qma|QMA]]-complete for ''k'' = 5 [[Zooref#ksv02|[KSV02]]]. * [[Complexity Zoo:Q#qma|QMA]]-complete for ''k'' = 3 [[Zooref#kr03|[KR03]]]. * [[Complexity Zoo:Q#qma|QMA]]-complete for ''k'' = 2, under the assumption that [[Complexity Zoo:P#p|P]]&ne;[[Complexity Zoo:Q#q|QMA]] [[Zooref#kkr04|[KKR04]]]. }} ===== <span id="k-round_sorting" style="color:red">k-Round Sorting</span>: Sort inputs in &#8804; k rounds ===== There are k-round sorting networks not known to be constructible in deterministic polynomial time which outperform the best-known networks constructible in deterministic polynomial time [[zooref#GGK03|[GGK03]]]. Algorithms: ? Memberships: ? Properties: [[Zoo_Glossary#puniform|P-nonuniform?]] ---- ===== <span id="linear_programming" style="color:red">Linear Programming</span>: Maximize a linear function with linear constraints ===== The Linear Programming problem is to maximize a linear function in a convex polytope. It was famously shown to be in FP by Leonid Khachiyan by means of the ellipsoid method. The main algorithms used in practice are simplex and interior-point methods. Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] ---- ===== <span id="majority" style="color:red">Majority</span>: Are most inputs 1? ===== Majority is a Boolean function with n input bits and 1 output bit. The output is 1 if the majority of input bits are 1. Examples: 001 &#8594; 0, 1100 &#8594; 1. Majority$\in$[[Zoo#p|P]]. Majority $\notin$[[Complexity_Zoo:R#reg|REG]]. Therefore, REG$\subsetneq$P. Algorithms: ? Memberships: &#8712; [[Zoo#p|P]] <br>Properties: [[Zoo_Glossary#ospeedup|O-optimal]], symmetric. Related Problems: See also [[#boolean_sorting|Boolean Sorting]] and the [http://www.math.ucdavis.edu/~greg/zoology/relations.html#majority Complexity Zoology] entry. ---- ===== <span id="matrix_multiplication" style="color:red">Matrix Multiplication</span>: Multiply two $n\times n$ matrices ===== Multiply two dense $n\times n$ matrices over a field $F$. Matrix Multiplication has [[Zoo_Glossary#ospeedup|O-speedup]] among Strassen-type bilinear algorithms [[zooref#cw82|[CW82]]]. Determining the minimal number of multiplications needed to compute a bilinear form (of which Matrix Multiplication is one) is {{zcls|n|npc|NP-complete}} ([[zooref#has90|[Has90]]]). This suggests that Matrix Multiplication is [[Zoo_Glossary#puniform|P-nonuniform]] over bilinear algorithms if {{zcls|n|np}}$\neq${{zcls|c|conp|coNP}}. If the group-theoretic algorithms of Cohn et al can perform Matrix Multiplication in $O(n^2)$, then Matrix Multiplication has [[Zoo_Glossary#ospeedup|O-speedup]] among algorithms of the type they consider [[zooref#cksu05|[CKSU05]]]. Algorithms: Memberships: &#8712; {{zcls|f|fp}} <br>Properties: [[Zoo_Glossary#ospeedup|O-speedup?]], [[Zoo_Glossary#puniform|P-nonuniform]]? ---- ===== <span id="parity" style="color:red">Parity</span>: Is the number of 1 inputs odd? ===== Parity is a Boolean function with n inputs and 1 output. The output is 1 if the number of 1 inputs is odd. Examples: 001 &#8594; 1, 11011 &#8594; 0. Parity$\in$[[Zoo#p|P]]. Parity $\notin$[[Complexity_Zoo:F#fo|FO]] ([[zooref#Ajt83|[Ajt83]]] and [[zooref#FSS84|[FSS84]]]). Therefore, FO$\subsetneq$P. Algorithms: ? Memberships: &#8712; [[Zoo#p|P]] <br>Properties: [[Zoo_Glossary#ospeedup|O-optimal]], symmetric. Related Problems: Equals XOR. See the [http://www.math.ucdavis.edu/~greg/zoology/relations.html#parity Complexity Zoology] entry. ---- ===== <span id="perfect_matching" style="color:red">Perfect Matching</span>: Is there a perfect matching? ===== Perfect Matching is a Boolean function with n<sup>2</sup> inputs (an adjacency matrix) describing a bipartite graph and one output which is 1 if the graph has a perfect matching. Perfect Matching reduces to Linear Programming, and is therefore in [[Zoo#p|P]], although specialized algorithms are also known. It has monotone circuit complexity of $n^{\Omega(\log n)}$ (Razborov [[zooref#raz85b|[Raz85b]]]) but polynomial nonmonotone circuit complexity. Perfect Matching is nonuniformly reducible to determinant and is in [[Zoo#rnc|RNC]] and [[zooref#mvv87|[MVV87]]], [[zooref#kuw86|[KUW86]]], but no deterministic [[Zoo#nc|NC]] algorithm is known. Like [[#graph_isomorphism|Graph Isomorphism]], it is not known to be complete for a natural complexity class. There is a randomized or nonuniform log-space reduction of Perfect Matching to [[#graph_isomorphism|Graph Isomorphism]] [[zooref#tor00|[Tor00]]]. Algorithms: ? Memberships: &#8712; [[Zoo#p|P]] <br>Properties: [[Zoo_Glossary#gap|monotone-nonmonotone gap]], [[Zoo_Glossary#puniform|P-nonuniform?]]. ---- ===== <span id="permanent" style="color:red">Permanent</span>: What is a 0-1 matrix's permanent ===== The permanent of an ''n''-by-''n'' 0-1 matrix (''a''<sub>''i,j''</sub>) is defined as $\sum_{\sigma}\prod_{i=1}^n a_{i,\sigma(i)}$ where &sigma; ranges over all permutations of the numbers 1, 2, ..., ''n''. The value of the permanent is equivalent to [[#sharpperfect_matching|#Perfect Matching]] Algorithms: Memberships: &#8712; [[Complexity Zoo:Symbols#sharpp|#P]] Properties: [[Complexity Zoo:Symbols#sharpp|#P]]-complete ---- {{Garden-Problem |id=ra |title=Ring Automorphism |descript=Does a ring have non-trivial an automorphism? |body= A special case of [[#ri|Ring Isomorphism]] where the two rings investigated are the same, and where we are looking for non-trivial automorphisms. }} {{Garden-Problem |id=ri |title=Ring Isomorphism |descript=Are two rings isomorphic? |body= Given two rings, are they isomorphic to each other? The counting version of the problem, #RI, asks how many different isomorphisms exist between the two rings. Algorithms: ? ''Memberships:'' {{zcls|n|np}} &cap; {{zcls|c|coam|coAM}} {{zcite|KS05}}. }} ===== <span id="qbf" style="color:red">QBF</span>: Quantified Boolean Formula ===== Given a Boolean formula with universal and existential quantifiers, is it true? Quantified Boolean Formula (QBF) is the canonical PSPACE-complete problem. Note that {{zcite|Pap94}} calls this problem QSAT to emphasize its relationship to [[#sat|SAT]]. In particular, any instance of QBF can be written as $\exists x_1 \forall x_2 \cdots Q_n x_n \phi(x_1, x_2, \dots, x_n)$, where $\phi$ is a Boolean formula as in SAT, and where $Q_n$ is either a universal or existential qualifier, depending on whether $n$ is even or odd. This characterization lends itself well as a candidate for reductions from two-player games. Algorithms: ? Memberships: &#8712; [[Zoo#pspace|PSPACE]] ---- {{Garden-Problem |id=qksat |title=Quantum k-SAT |descript=Quantum Analog for [[#sat|SAT]] |body= Given a set of measurements, each ''i'' of which involves no more than ''k'' qubits and accepts with probability ''P''<sub>''i''</sub>, and given the promise that either there exists a state such that the number of accepting measurements is "very large," or that for all states, the number of accepting measurements is very small. We are asked which of the two promise conditions holds. Algorithms: ? ''Properties:'' [[Complexity Zoo:Q#qma|QMA]]-complete for ''k'' = 3.<!-- TODO: Cite this! --> ''See also:'' [http://www.scottaaronson.com/democritus/lec13.html Democritus Lecture 13]. }} ===== <span id="sat" style="color:red">SAT</span>: Is there a satisfying truth assignment? ===== The SAT problem is to decide whether a given Boolean formula has any satisfying truth assignments. SAT is in NP, since a "yes" answer can be proved by just exhibiting a satisfying assignment. Algorithms: ? ''Memberships:'' &#8712; {{zcls|n|npc|NP-complete}} ---- ===== <span id="setcover" style="color:red">Set Cover</span>: Cover a set with some of its subsets ===== Given a universe $\mathcal{U}$ and a family $\mathcal{S}$ of subsets of $\mathcal{U}$, a ''cover'' is a subfamily $\mathcal{C}\subseteq\mathcal{S}$ of sets whose union is $\mathcal{U}$. In the set covering decision problem, the input is a pair $(\mathcal{U},\mathcal{S})$ and an integer $k$; the question is whether there is a set covering of size $k$ or less. In the set covering optimization problem, the input is a pair $(\mathcal{U},\mathcal{S})$, and the task is to find a set covering that uses the fewest sets. ''Algorithms'': A simple greedy algorithm yields an $H(l)$-approximation (and hence, $(\ln(l)+1)$-approximation)where $l$ is the size of largest subset in $\mathcal{S}$ and $H(l)$ is $l$th Harmonic number. Set covering cannot be approximated in polynomial time to within a factor of $\bigl(1-o(1)\bigr)\cdot\ln{n}$, unless '''NP''' has quasi-polynomial time algorithms [[zooref#fie98|[Fie98]]]. In addition, Set covering cannot be approximated in polynomial time to within a factor of $c\cdot\ln{n}$, where $c$ is a constant, unless '''P'''$=$'''NP'''. The largest value of $c$ is proved in [[zooref#ams06|[AMS06]]]. ''Memberships:'' Decision problem &#8712; {{zcls|n|npc|NP-complete}}, Optimization problem &#8712; {{zcls|n|npo|NP Optimization}} ---- ===== <span id="ksat" style="color:red">$k$-SAT</span>: Satisfiability with clauses of length $k$ ==== For some natural number $k$, an instance of $k$-SAT is an instance of [[#sat|SAT]] in conjunctive normal form (CNF) where all clauses are the logical OR of $k$ Boolean variables. Algorithms: ? Memberships: It is known that 2SAT is in {{zcls|p|p}} while 3SAT is in {{zcls|n|npc|NP-complete}}. }} ===== <span id="shortest_implicant" style="color:red">Short Implicant</span>: Is there a short implicant? ===== Given a DNF expression &#934;, is there a conjunction of at most k negated or non-negated literals that implies &#934;? Algorithms: ? Memberships: [[Zoo#gc|GC]]-complete ---- ===== <span id="stochastic_games" style="color:red">Stochastic Games</span>: Is there a first player advantage? ===== White, Black, and Nature alternate moving a token on the edges of a directed graph. Nature's moves are random. Given a graph, start and target nodes for the token, does White have a strategy which will make the token reach the target with probability &#8805; 1/2? Algorithms: ? Memberships: &#8712; [[Zoo#np|NP]] &#8745; [[Zoo#conp|coNP]], $\notin$[[Zoo#p|P]]'''? ---- ===== <span id="tautology" style="color:red">Tautology</span>: Are all truth assignments satisfying? ===== Tautology is {{zcls|c|conp|coNP}}-complete. Algorithms: ? ''Memberships:'' &#8712; {{zcls|c|conp|coNP}} ''Properties:'' [[Zoo_Glossary#pspeedup|p-speedup]]? (If so then {{zcls|n|np}} $\neq$ {{zcls|c|conp|coNP}}) ---- ===== <span id="square_root" style="color:red">Square Root mod n</span>: Find square roots mod n ===== The Square Root mod n problem is to solve for x in the equation x<sup>2</sup> = a mod N. Rabin noted that [[#integer_factorization|Integer Factorization]] BPP-reduces to Square Root mod n and vice-versa; the problems are equivalent. Algorithms: ? Memberships: &#8712; [[Zoo#fp|FP]] Properties: Is a one-way function? ---- ===== <span id="threshold(k)" style="color:red">Threshold(k)</span>: Are &#8805; k inputs 1?===== Threshold(k) is a Boolean function with n input bits and one output bit. [[#boolean_sorting|Boolean Sorting]] is equivalent to the n Threshold(k) functions in reverse order. [[#majority|Majority]] is equivalent to Threshold($\lceil n/2\rceil$). Algorithms: ? Memberships: &#8712; [[Zoo#p|P]] <br>Properties: symmetric. ---- ===== <span id="unique-ksat" style="color:red">Unique ''k''-SAT</span>: [[#ksat|''k''-SAT]] with uniqueness promise. ===== The Unique $k$-SAT problem is a [[Zoo Glossary#promise-problem|promise problem]] variant of [[#ksat|$k$-SAT]], where the promise is that each instance has either no satisfying assignment, or has exactly one satisfying assignment. Intuitively, adding this promise restricts us to only the hardest instances, as the more satisfying assignments there are, the easier it should be to find one. This intuition is justified by {{zcite|CIK+03}}, where it is also shown that if Unique $k$-SAT can be solved in deterministic time $O(2^{\epsilon n})$ for all $\epsilon>0$, then so can $k$-SAT for all $k\ge 3$. Algorithms: ? Memberships: ? ---- Complexity Zoo 3546 80362 2012-08-01T14:20:17Z Andras Salamon 664 Undo revision 67399 by [[Special:Contributions/CamilleReed|CamilleReed]] ([[User talk:CamilleReed|Talk]]) spam __NOTOC__ ==Introduction== Welcome to the '''Complexity Zoo'''... There are now 495 classes and counting! [[Image:zoo.gif|thumb|right|200px|what's your problem?]] {{CZ-Menu-Content}} This information was originally moved from http://www.complexityzoo.com/ in August 2005, and is currently under the watchful eyes of its original creators: '''Zookeeper''': [[Scott Aaronson]]<br> '''Veterinarian''': [[Greg Kuperberg]]<br> '''Tour Guide''': [[Christopher Granade]] Errors? Omissions? Misattributions? Your favorite class not here? Then please contribute to the zoo as you see fit by [[sign_up_instructions | signing up]] and clicking on the edit links. Please include references, or better yet links to papers if available. To create a new class, click on the edit link of the class before or after the one that you want to add and copy the format of that class. (The classes are alphabetized by their tag names.) Then add the class to the table of contents and increment the total number of classes. After this, you can use the side edit links to edit the individual sections. For more on using the wiki language, see our [[Simple_wiki_help | simple wiki help page]]. If you would like to contribute but feel unable to make the updates yourself, email the zookeeper at scott at scottaaronson.com. ==See Also== ''Introductory Resources'' * [[Zoo Intro|Introductory Essay]]: New visitors may want to stop here and see what the Zoo is all about. * [[Petting Zoo]]: A more gentle version of the Zoo with fewer classes, meant for new initiates in complexity. (If you're looking for where the Most Important Classes went, look in the Petting Zoo.) ''Other Collections and Resources'' * [[Complexity Garden]]: Problems of interest in complexity theory and some notes about important inclusions. * [[Zoo Exhibit|Special Exhibit]]: A collection of classes of quantum states and probability distributions. * [http://www.math.ucdavis.edu/~greg/zoology/intro.html Complexity Zoology]: A computer-assisted survey maintained by the [[Greg Kuperberg|Veterinarian]], including [http://www.math.ucdavis.edu/~greg/zoology/diagram.xml active] and [http://www.math.ucdavis.edu/~greg/zoology/diagram.pdf static] inclusion diagrams. * [http://satoshihada.wordpress.com/complexity-zoo-for-ipad/ Complexity Zoo for iPad (and iPhone)]: An iOS viewer for Complexity Zoo. ''Appendices'' *[[Zoo Glossary|Glossary]]: Definitions of some complexity theoretic terms. *[[Zoo References|References]]: Bibliography for the Zoo. *[[Zoo Pronunciation|Pronunciation Guide]]: A resource for those who insist on communicating verbally about complexity. *[[Zoo Conventions|Conventions and Notation]]: Common notational conventions used here at the Zoo. *[[Zoo Operators|Operators]]: A (very short) list of operators which act upon classes. *[[Zoo Acknowledgments|Acknowledgments]]: Where the Zookeeper and friends acknowledge those who have helped out with the Zoo. *[[Meta:Complexity Zoo Contributor's Guide|Complexity Zoo Contributor's Guide]]: A guide on how to get started helping out with the Zoo. ''NB:'' Longtime Zoo watchers may recall Chris Bourke's LaTeX version of the Zoo and Chad Brewbaker's graphical inclusion diagram. These references are obsolete until further notice. <!-- Moved Most Important Classes to Petting Zoo --> == All Classes == {{CZ-Menu-Content}} {{CZ-Letter-Section|Symbols}} {{CZ-Letter-Section|A}} {{CZ-Letter-Section|B}} {{CZ-Letter-Section|C}} {{CZ-Letter-Section|D}} {{CZ-Letter-Section|E}} {{CZ-Letter-Section|F}} {{CZ-Letter-Section|G}} {{CZ-Letter-Section|H}} {{CZ-Letter-Section|I}} <!--{{CZ-Letter-Section|J}} {{CZ-Letter-Section|K}}--> {{CZ-Letter-Section|L}} {{CZ-Letter-Section|M}} {{CZ-Letter-Section|N}} {{CZ-Letter-Section|O}} {{CZ-Letter-Section|P}} {{CZ-Letter-Section|Q}} {{CZ-Letter-Section|R}} {{CZ-Letter-Section|S}} {{CZ-Letter-Section|T}} {{CZ-Letter-Section|U}} {{CZ-Letter-Section|V}} {{CZ-Letter-Section|W}} {{CZ-Letter-Section|X}} {{CZ-Letter-Section|Y}} {{CZ-Letter-Section|Z}} {{CZ-Categories}} Complexity Zoo 1.0 1959 12670 2010-04-17T18:08:30Z Eric Ringger 2103 /* LOGNP: Logarithmically-Restricted NP */ __NOTOC__ ==Introduction== Welcome to the '''Complexity Zoo'''... There are now 468 classes and counting! [[Image:zoo.gif|thumb|right|200px|what's your problem?]] This information was originally moved from http://www.complexityzoo.com/ in August 2005, and is currently under the watchful eyes of its original creators: '''Zookeeper''': [[Scott Aaronson]]<br> '''Veterinarian''': [[Greg Kuperberg]]<br> Errors? Omissions? Misattributions? Your favorite class not here? Then please contribute to the zoo as you see fit by [[sign_up_instructions | signing up]] and clicking on the edit links. Please include references, or better yet links to papers if available. To create a new class, click on the edit link of the class before or after the one that you want to add and copy the format of that class. (The classes are alphabetized by their tag names.) Then add the class to the table of contents and increment the total number of classes. After this, you can use the side edit links to edit the individual sections. For more on using the wiki language, see our [[Simple_wiki_help | simple wiki help page]]. If you would like to contribute but feel unable to make the updates yourself, email the zookeeper at scott at scottaaronson.com. ==See Also== *[[Zoo Intro|Introductory Essay]] *[[Zoo Glossary|Glossary]] *[[Zoo Pronunciation|Pronunciation Guide]] *[[Zoo References|References]] *[[Zoo Exhibit|Special Zoo Exhibit]] *[[Zoo Acknowledgments|Acknowledgments]] *[[Complexity Garden]] *<span style="color:red">**New**</span> [http://www.math.ucdavis.edu/~greg/zoology/intro.html Complexity Zoology], a computer-assisted survey, with [http://www.math.ucdavis.edu/~greg/zoology/diagram.xml active] and [http://www.math.ucdavis.edu/~greg/zoology/diagram.pdf static] inclusion diagrams. *[[Petting Zoo]], an introduction to complexity theory. (Complexity classes currently being weaned.) (Longtime Zoo watchers may recall Chris Bourke's LaTeX version of the Zoo and Chad Brewbaker's graphical inclusion diagram. These references are obsolete until further notice.) ==Table of Contents== '''<font color="red">&#8709;:</font>''' [[#01npc|0-1-NP<sub>C</sub>]] - [[#1nauxpdap|1NAuxPDA<sup>p</sup>]] - [[#sharpac0|#AC<sup>0</sup>]] - [[#sharpl|#L]] - [[#sharplpoly|#L/poly]] - [[#sharpga|#GA]] - [[#sharpp|#P]] - [[#sharpwt|#W[t]]] - [[#parityexp|&#8853;EXP]] - [[#parityl|&#8853;L]] - [[#paritylpoly|&#8853;L/poly]] - [[#parityp|&#8853;P]] - [[#paritysac0|&#8853;SAC<sup>0</sup>]] - [[#paritysac1|&#8853;SAC<sup>1</sup>]] '''<font color="red">A:</font>''' [[#a0pp|A<sub>0</sub>PP]] - [[#ac|AC]] - [[#ac0|AC<sup>0</sup>]] - [[#ac0m|AC<sup>0</sup>[m]]] - [[#ac1|AC<sup>1</sup>]] - [[#acc0|ACC<sup>0</sup>]] - [[#ah|AH]] - [[#al|AL]] - [[#all|ALL]] - [[#alogtime|ALOGTIME]] - [[#algppoly|AlgP/poly]] - [[#almostnp|Almost-NP]] - [[#almostp|Almost-P]] - [[#almostpspace|Almost-PSPACE]] - [[#am|AM]] - [[#amexp|AM<sub>EXP</sub>]] - [[#amicoam|AM &#8745; coAM]] - [[#ampolylog|AM[polylog]]] - [[#ampmp|AmpMP]] - [[#amppbqp|AmpP-BQP]] - [[#ap|AP]] - [[#app|APP]] - [[#apx|APX]] - [[#aucspace|AUC-SPACE(f(n))]] - [[#auxpda|AuxPDA]] - [[#avbpp|AVBPP]] - [[#avge|AvgE]] - [[#avgp|AvgP]] - [[#awp|AW[P]]] - [[#awpp|AWPP]] - [[#awsat|AW[SAT]]] - [[#awstar|AW[*]]] - [[#awt|AW[t]]] - [[#axp|AxP]] - [[#axpp|AxPP]] '''<font color="red">B:</font>''' [[#betap|&beta;P]] - [[#bh|BH]] - [[#bpdp|BP<sub>d</sub>(P)]] - [[#bpe|BPE]] - [[#bpee|BPEE]] - [[#bphspace|BP<sub>H</sub>SPACE(f(n))]] - [[#bpl|BPL]] - [[#bpnp|BP&#149;NP]] - [[#bpp|BPP]] - [[#bppcc|BPP<sup>cc</sup>]] - [[#bppkt|BPP<sup>KT</sup>]] - [[#bpplog|BPP/log]] - [[#bppmlog|BPP/mlog]] - [[#bppsslog|BPP//log]] - [[#bpprlog|BPP/rlog]] - [[#bppobdd|BPP-OBDD]] - [[#bpppath|BPP<sub>path</sub>]] - [[#bpqp|BPQP]] - [[#bpspace|BPSPACE(f(n))]] - [[#bptime|BPTIME(f(n))]] - [[#bqnc|BQNC]] - [[#bqnp|BQNP]] - [[#bqp|BQP]] - [[#bqplog|BQP/log]] - [[#bqppoly|BQP/poly]] - [[#bqpmlog|BQP/mlog]] - [[#bqpmpoly|BQP/mpoly]] - [[#bqpqlog|BQP/qlog]] - [[#bqpqpoly|BQP/qpoly]] - [[#bqpobdd|BQP-OBDD]] - [[#bqpspace|BQPSPACE]] - [[#bqpttpoly|BQP<sub>tt</sub>/poly]] - [[#bqtime|BQTIME(f(n))]] - [[#bwbp|k-BWBP]] '''<font color="red">C:</font>''' [[#cequalsac0|C<sub>=</sub>AC<sup>0</sup>]] - [[#cequalsl|C<sub>=</sub>L]] - [[#cequalsp|C<sub>=</sub>P]] - [[#cfl|CFL]] - [[#clog|CLOG]] - [[#ch|CH]] - [[#check|Check]] - [[#clsharpp|CL#P]] - [[#ckp|C<sub>k</sub>P]] - [[#cnp|CNP]] - [[#coam|coAM]] - [[#cocequalsp|coC<sub>=</sub>P]] - [[#cofrip|cofrIP]] - [[#coh|Coh]] - [[#coma|coMA]] - [[#comodkp|coMod<sub>k</sub>P]] - [[#compip|compIP]] - [[#compnp|compNP]] - [[#cone|coNE]] - [[#conexp|coNEXP]] - [[#conl|coNL]] - [[#conp|coNP]] - [[#conpcc|coNP<sup>cc</sup>]] - [[#conppoly|coNP/poly]] - [[#conqp|coNQP]] - [[#core|coRE]] - [[#cornc|coRNC]] - [[#corp|coRP]] - [[#cosl|coSL]] - [[#cosparse|coSPARSE]] - [[#coucc|coUCC]] - [[#coup|coUP]] - [[#cp|CP]] - [[#csize|CSIZE(f(n))]] - [[#csl|CSL]] - [[#czk|CZK]] '''<font color="red">D:</font>''' [[#dsharpp|D#P]] - [[#dcfl|DCFL]] - [[#delta2p|&#916;<sub>2</sub>P]] - [[#deltabpp|&#948;-BPP]] - [[#deltarp|&#948;-RP]] - [[#det|DET]] - [[#diffac0|DiffAC<sup>0</sup>]] - [[#disnp|DisNP]] - [[#distnp|DistNP]] - [[#dp|DP]] - [[#dqp|DQP]] - [[#dspace|DSPACE(f(n))]] - [[#dtime|DTIME(f(n))]] - [[#dtisp|DTISP(t(n),s(n))]] - [[#dynfo|Dyn-FO]] - [[#dynthc0|Dyn-ThC<sup>0</sup>]] '''<font color="red">E:</font>''' [[#e|E]] - [[#ee|EE]] - [[#eee|EEE]] - [[#eespace|EESPACE]] - [[#eexp|EEXP]] - [[#eh|EH]] - [[#elementary|ELEMENTARY]] - [[#elkp|EL<sub>k</sub>P]] - [[#ep|EP]] - [[#eptas|EPTAS]] - [[#eqbp|k-EQBP]] - [[#eqp|EQP]] - [[#eqpk|EQP<sub>K</sub>]] - [[#eqtime|EQTIME(f(n))]] - [[#espace|ESPACE]] - [[#existsbpp|&#8707;BPP]] - [[#existsniszk|&#8707;NISZK]] - [[#exp|EXP]] - [[#exppoly|EXP/poly]] - [[#expspace|EXPSPACE]] '''<font color="red">F:</font>''' [[#fbqp|FBQP]] - [[#few|Few]] - [[#fewp|FewP]] - [[#fh|FH]] - [[#fixp|FIXP]] - [[#fnl|FNL]] - [[#fnlpoly|FNL/poly]] - [[#fnp|FNP]] - [[#fo|FO(t(n))]] - [[#foll|FOLL]] - [[#fp|FP]] - [[#fpnplog|FP<sup>NP[log]</sup>]] - [[#fpr|FPR]] - [[#fpras|FPRAS]] - [[#fpt|FPT]] - [[#fptnu|FPT<sub>nu</sub>]] - [[#fptsu|FPT<sub>su</sub>]] - [[#fptas|FPTAS]] - [[#fqma|FQMA]] - [[#frip|frIP]] - [[#ftape|F-TAPE(f(n))]] - [[#ftime|F-TIME(f(n))]] '''<font color="red">G:</font>''' [[#ga|GA]] - [[#ganspace|GAN-SPACE(f(n))]] - [[#gapac0|GapAC<sup>0</sup>]] - [[#gapl|GapL]] - [[#gapp|GapP]] - [[#gc|GC(s(n),C)]] - [[#gcsl|GCSL]] - [[#gi|GI]] - [[#glo|GLO]] - [[#gpcd|GPCD(r(n),q(n))]] - [[#gt|G[t]]] '''<font color="red">H:</font>''' [[#halfp|HalfP]] - [[#heurbpp|HeurBPP]] - [[#heurbptime|HeurBPTIME(f(n))]] - [[#hkp|H<sub>k</sub>P]] - [[#hvszk|HVSZK]] '''<font color="red">I:</font>''' [[#iclogpoly|IC[log,poly]]] - [[#ip|IP]] - [[#ipp|IPP]] - [[#ippolylog|IP[polylog]]] '''<font color="red">L:</font>''' [[#l|L]] - [[#lin|LIN]] - [[#lkp|L<sub>k</sub>P]] - [[#logcfl|LOGCFL]] - [[#logfew|LogFew]] - [[#logfewnl|LogFewNL]] - [[#lognp|LOGNP]] - [[#logsnp|LOGSNP]] - [[#l/poly|L/poly]] - [[#lwpp|LWPP]] '''<font color="red">M:</font>''' [[#ma|MA]] - [[#maprime|MA']] - [[#mac0|MAC<sup>0</sup>]] - [[#mae|MA<sub>E</sub>]] - [[#maexp|MA<sub>EXP</sub>]] - [[#mal|mAL]] - [[#maxnp|MaxNP]] - [[#maxpb|MaxPB]] - [[#maxsnp|MaxSNP]] - [[#maxsnp0|MaxSNP<sub>0</sub>]] - [[#mconl|mcoNL]] - [[#minpb|MinPB]] - [[#mip|MIP]] - [[#mipstar21|MIP*[2,1]]] - [[#mipexp|MIP<sub>EXP</sub>]] - [[#mkp|(M<sub>k</sub>)P]] - [[#ml|mL]] - [[#mmsnp|MMSNP]] - [[#mnc1|mNC<sup>1</sup>]] - [[#mnl|mNL]] - [[#mnp|mNP]] - [[#modkl|Mod<sub>k</sub>L]] - [[#modkp|Mod<sub>k</sub>P]] - [[#modp|ModP]] - [[#modzkl|ModZ<sub>k</sub>L]] - [[#mp|mP]] - [[#mp2|MP]] - [[#mpc|MPC]] - [[#mppoly|mP/poly]] - [[#mtc0|mTC<sup>0</sup>]] '''<font color="red">N:</font>''' [[#nauxpdap|NAuxPDA<sup>p</sup>]] - [[#nc|NC]] - [[#nc0|NC<sup>0</sup>]] - [[#nc1|NC<sup>1</sup>]] - [[#nc2|NC<sup>2</sup>]] - [[#ne|NE]] - [[#nepoly|NE/poly]] - [[#nearlyp|Nearly-P]] - [[#nee|NEE]] - [[#neee|NEEE]] - [[#neexp|NEEXP]] - [[#nexp|NEXP]] - [[#nexppoly|NEXP/poly]] - [[#nipzk|NIPZK]] - [[#niqszk|NIQSZK]] - [[#niszk|NISZK]] - [[#niszkh|NISZK<sub>h</sub>]] - [[#nl|NL]] - [[#nlpoly|NL/poly]] - [[#nlin|NLIN]] - [[#nlog|NLOG]] - [[#none|NONE]] - [[#np|NP]] - [[#npc|NPC]] - [[#npc2|NP<sub>C</sub>]] - [[#npcc|NP<sup>cc</sup>]] - [[#npi|NPI]] - [[#npiconp|NP &#8745; coNP]] - [[#npiconppoly|(NP &#8745; coNP)/poly]] - [[#nplog|NP/log]] - [[#npmv|NPMV]] - [[#npmvsel|NPMV-sel]] - [[#npmvt|NPMV<sub>t</sub>]] - [[#npmvtsel|NPMV<sub>t</sub>-sel]] - [[#npo|NPO]] - [[#npopb|NPOPB]] - [[#nppoly|NP/poly]] - [[#nppsamp|(NP,P-samplable)]] - [[#npr|NP<sub>R</sub>]] - [[#npspace|NPSPACE]] - [[#npsv|NPSV]] - [[#npsvsel|NPSV-sel]] - [[#npsvt|NPSV<sub>t</sub>]] - [[#npsvtsel|NPSV<sub>t</sub>-sel]] - [[#nqp|NQP]] - [[#nspace|NSPACE(f(n))]] - [[#nt|NT]] - [[#ntstar|NT*]] - [[#ntime|NTIME(f(n))]] '''<font color="red">O:</font>''' [[#ocq|OCQ]] - [[#optp|OptP]] '''<font color="red">P:</font>''' [[#p|P]] - [[#plog|P/log]] - [[#ppoly|P/poly]] - [[#psharpp|P<sup>#P</sup>]] - [[#psharpp1|P<sup>#P</sup>]] - [[#pac0|PAC<sup>0</sup>]] - [[#pbp|PBP]] - [[#kpbp|k-PBP]] - [[#pc|P<sub>C</sub>]] - [[#pcc|P<sup>cc</sup>]] - [[#pcd|PCD(r(n),q(n))]] - [[#pclose|P-Close]] - [[#pcp|PCP(r(n),q(n))]] - [[#permup|PermUP]] - [[#pexp|PEXP]] - [[#pf|PF]] - [[#pfchk|PFCHK(t(n))]] - [[#ph|PH]] - [[#phcc|PH<sup>cc</sup>]] - [[#phi2p|&#934;<sub>2</sub>P]] - [[#php|PhP]] - [[#pi2p|&#928;<sub>2</sub>P]] - [[#pinc|PINC]] - [[#pio|PIO]] - [[#pk|P<sup>K</sup>]] - [[#pkc|PKC]] - [[#pl|PL]] - [[#pl1|PL<sub>1</sub>]] - [[#plinfinity|PL<sub>&#8734;</sub>]] - [[#plf|PLF]] - [[#pll|PLL]] - [[#pls|PLS]] - [[#pnp|P<sup>NP</sup>]] - [[#pparnp|P<sup>&#124;&#124;NP</sup>]] - [[#pnpk|P<sup>NP[k]</sup>]] - [[#pnplog|P<sup>NP[log]</sup>]] - [[#pnplog2|P<sup>NP[log^2]</sup>]] - [[#pobdd|P-OBDD]] - [[#podn|PODN]] - [[#polyl|polyL]] - [[#postbqp|PostBQP]] - [[#pp|PP]] - [[#pppoly|PP/poly]] - [[#ppa|PPA]] - [[#ppad|PPAD]] - [[#ppads|PPADS]] - [[#ppp2|P<sup>PP</sup>]] - [[#ppp|PPP]] - [[#ppspace|PPSPACE]] - [[#pquery|PQUERY]] - [[#pr|PR]] - [[#pr2|P<sub>R</sub>]] - [[#prhspace|Pr<sub>H</sub>SPACE(f(n))]] - [[#promisebpp|PromiseBPP]] - [[#promisebqp|PromiseBQP]] - [[#promisep|PromiseP]] - [[#promiserp|PromiseRP]] - [[#prspace|PrSPACE(f(n))]] - [[#psel|P-Sel]] - [[#psk|PSK]] - [[#pspace|PSPACE]] - [[#pspacepoly|PSPACE/poly]] - [[#pt1|PT<sub>1</sub>]] - [[#ptape|PTAPE]] - [[#ptas|PTAS]] - [[#ptwk|PT/WK(f(n),g(n))]] - [[#pzk|PZK]] '''<font color="red">Q:</font>''' [[#q|Q]] - [[#qac0|QAC<sup>0</sup>]] - [[#qac0m|QAC<sup>0</sup>[m]]] - [[#qacc0|QACC<sup>0</sup>]] - [[#qacwf0|QAC<sub>f</sub><sup>0</sup>]] - [[#qam|QAM]] - [[#qcfl|QCFL]] - [[#qcma|QCMA]] - [[#qh|QH]] - [[#qip|QIP]] - [[#qip2|QIP]] - [[#qma|QMA]] - [[#qma-plus|QMA-plus]] - [[#qma2|QMA(2)]] - [[#qma1|QMA<sub>1</sub>]] - [[#qmalog|QMA<sub>log</sub>]] - [[#qmam|QMAM]] - [[#qmaqpoly|QMA/qpoly]] - [[#qmip|QMIP]] - [[#qmiple|QMIP<sub>le</sub>]] - [[#qmipne|QMIP<sub>ne</sub>]] - [[#qnc|QNC]] - [[#qnc0|QNC<sup>0</sup>]] - [[#qncf0|QNC<sub>f</sub><sup>0</sup>]] - [[#qnc1|QNC<sup>1</sup>]] - [[#qp|QP]] - [[#qplin|QPLIN]] - [[#qpspace|QPSPACE]] - [[#qrg|QRG]] - [[#qs2p|QS<sub>2</sub>P]] - [[#qszk|QSZK]] '''<font color="red">R:</font>''' [[#r|R]] - [[#rbqp|RBQP]] - [[#re|RE]] - [[#reg|REG]] - [[#revspace|RevSPACE(f(n))]] - [[#rg|RG]] - [[#rg1|RG]] - [[#rhl|R<sub>H</sub>L]] - [[#rhspace|R<sub>H</sub>SPACE(f(n))]] - [[#rl|RL]] - [[#rnc|RNC]] - [[#rp|RP]] - [[#rpp|RPP]] - [[#rqp|RQP]] - [[#rspace|RSPACE(f(n))]] '''<font color="red">S:</font>''' [[#s2p|S<sub>2</sub>P]] - [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]] - [[#sac|SAC]] - [[#sac0|SAC<sup>0</sup>]] - [[#sac1|SAC<sup>1</sup>]] - [[#saptime|SAPTIME]] - [[#sbp|SBP]] - [[#sc|SC]] - [[#se|SE]] - [[#seh|SEH]] - [[#selfnp|SelfNP]] - [[#sfk|SF<sub>k</sub>]] - [[#sigma2p|&#931;<sub>2</sub>P]] - [[#skc|SKC]] - [[#sl|SL]] - [[#slicewisepspace|SLICEWISE PSPACE]] - [[#snp|SNP]] - [[#soe|SO-E]] - [[#sp|SP]] - [[#spanp|span-P]] - [[#sparse|SPARSE]] - [[#spl|SPL]] - [[#spp|SPP]] - [[#sqg|SQG]] - [[#subexp|SUBEXP]] - [[#symp|symP]] - [[#szk|SZK]] - [[#szkh|SZK<sub>h</sub>]] '''<font color="red">T:</font>''' [[#tally|TALLY]] - [[#tc0|TC<sup>0</sup>]] - [[#tfnp|TFNP]] - [[#theta2p|&Theta;<sub>2</sub>P]] - [[#treebqp|TreeBQP]] - [[#treeregular|TREE-REGULAR]] '''<font color="red">U:</font>''' [[#uap|UAP]] - [[#ucc|UCC]] - [[#ue|UE]] - [[#ul|UL]] - [[#ulpoly|UL/poly]] - [[#up|UP]] - [[#us|US]] '''<font color="red">V:</font>''' [[#vck|VC<sub>k</sub>]] - [[#vcor|VC<sub>OR</sub>]] - [[#vnc|VNC<sub>k</sub>]] - [[#vnp|VNP<sub>k</sub>]] - [[#vp|VP<sub>k</sub>]] - [[#vqp|VQP<sub>k</sub>]] '''<font color="red">W:</font>''' [[#w1|W]] - [[#wapp|WAPP]] - [[#wp|W[P]]] - [[#wpp|WPP]] - [[#wsat|W[SAT]]] - [[#wstar|W[*]]] - [[#wt|W[t]]] - [[#wstart|W<sup>*</sup>[t]]] '''<font color="red">X:</font>''' [[#xormipstar21|XOR-MIP*[2,1]]] - [[#xp|XP]] - [[#xpuniform|XP<sub>uniform</sub>]] '''<font color="red">Y:</font>''' [[#yacc|YACC]] - [[#yp|YP]] - [[#ypp|YPP]] - [[#yqp|YQP]] '''<font color="red">Z:</font>''' [[#zbqp|ZBQP]] - [[#zpe|ZPE]] - [[#zpp|ZPP]] - [[#zptime|ZPTIME(f(n))]] - [[#zqp|ZQP]] ==The Classes== '''<font color="red">Warning:</font>''' Please do not feed oracles to the complexity classes! These classes require a specially balanced diet to ensure proper relativization. ---- ===== <span id="01npc" style="color:red">0-1-NP<sub>C</sub></span>: Binary Restriction of [[#np|NP]] Over The Complex Numbers ===== The intersection of [[#npc2|NP<sub>C</sub>]] with {0,1}<sup>*</sup> (i.e. the set of binary strings). Contains [[#np|NP]]. Is contained in [[#pspace|PSPACE]], and in [[#am|AM]] assuming the Extended Riemann Hypothesis [[zooref#koi96|[Koi96]]]. ---- ===== <span id="1nauxpdap" style="color:red">1NAuxPDA<sup>p</sup></span>: One-Way [[#nauxpdap|NAuxPDA<sup>p</sup>]] ===== Defined in [[zooref#bra77|[Bra77]]], where it was also shown that 1NAuxPDA<sup>p</sup> strictly contains [[#cfl|CFL]] and is strictly contained in [[#logcfl|LOGCFL]]. The class corresponds to the closure of [[#cfl|CFL]] under one-way log-space reductions. ---- ===== <span id="sharpac0" style="color:red">#AC<sup>0</sup></span>: Sharp-[[#ac0|AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to nonnegative integers computed by polynomial-size constant-depth arithmetic circuits, using addition and multiplication gates and the constants 0 and 1. Contained in [[#gapac0|GapAC<sup>0</sup>]]. ---- ===== <span id="sharpga" style="color:red">#GA</span>: Graph Automorphism ===== The class of problems (Karp-)reducible to counting the number of automorphisms of a graph. Counterpart of [[#ga|GA]]. ---- ===== <span id="sharpl" style="color:red">#L</span>: Sharp-L ===== Has the same relation to [[#l|L]] as [[#sharpp|#P]] does to [[#p|P]]. &#35;L is contained in [[#det|DET]] [[zooref#aj93|[AJ93]]]. ---- ===== <span id="sharplpoly" style="color:red">#L/poly</span>: Nonuniform [[#sharpl|#L]] ===== Has the same relation to [[#sharpl|#L]] as [[#ppoly|P/poly]] does to [[#p|P]]. ---- ===== <span id="sharpp" style="color:red">#P</span>: Sharp-P ===== The class of function problems of the form "compute f(x)," where f is the number of accepting paths of an [[#np|NP]] machine. The canonical #P-complete problem is [[Complexity_Garden#sharpsat|#SAT]]. Defined in [[zooref#val79|[Val79]]], where it was also shown that [[Complexity_Garden#sharpperfect_matching|#Perfect Matching]] (or equivalently, [[Complexity_Garden#permanent|Permanent]]) is #P-complete. What makes that interesting is that the associated decision problem [[Complexity_Garden#perfect_matching|Perfect Matching]] is in [[#p|P]]. [[#ph|PH]] is in [[#psharpp|P<sup>#P</sup>]] [[zooref#tod89|[Tod89]]]. Any function in #P can be approximated to within a polynomial factor in [[#bpp|BPP]] with [[#np|NP]] oracle [[zooref#sto85|[Sto85]]]. ---- ===== <span id="sharpwt" style="color:red">#W[t]</span>: Sharp-[[#wt|W[t]]] ===== Roughly, the analogue of [[#sharpp|#P]] for parameterized complexity. I.e. the class of parameterized counting problems that are fixed-parameter parsimonious reducible to [[Complexity_Garden#sharpwsat|#WSAT]]. Defined in [[zooref#fg02|[FG02]]], which should be consulted for the full definition. [[zooref#fg02|[FG02]]] also showed that there exist #W-complete problems whose corresponding decision problems are fixed-parameter tractable (i.e. in [[#fpt|FPT]]). ---- ===== <span id="parityexp" style="color:red">&#8853;EXP</span>: Parity [[#exp|EXP]] ===== The exponential-time analogue of [[#parityp|&#8853;P]]. There exists an oracle relative to which &#8853;EXP = [[#zpp|ZPP]] [[zooref#bbf98|[BBF98]]]. ---- ===== <span id="parityl" style="color:red">&#8853;L</span>: Parity [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#parityp|&#8853;P]] does to [[#p|P]]. Contains [[#sl|SL]] [[zooref#kw93|[KW93]]]. Solving a linear system over Z<sub>2</sub> is complete for &#8853;L [[zooref#dam90|[Dam90]]]. &#8853;L<sup>&#8853;L</sup> = &#8853;L [[zooref#hrv00|[HRV00]]]. ---- ===== <span id="paritylpoly" style="color:red">&#8853;L/poly</span>: Nonuniform [[#parityl|&#8853;L]] ===== Has the same relation to [[#parityl|&#8853;L]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contains [[#nl/poly|NL/poly]] [[zooref#gw96|[GW96]]]. ---- ===== <span id="parityp" style="color:red">&#8853;P</span>: Parity [[#p|P]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' then the number of accepting paths is odd.</li> <li>If the answer is 'no,' then the number of accepting paths is even.</li> </ol> Defined in [[zooref#pz83|[PZ83]]]. Contains [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]]; indeed, [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] is low for &#8853;P [[zooref#ak02|[AK02]]]. Contains [[#fewp|FewP]] [[zooref#ch89|[CH89]]]. There exists an oracle relative to which [[#p|P]] = &#8853;P but [[#p|P]] is not equal to [[#np|NP]] (and indeed [[#np|NP]] = [[#exp|EXP]]) [[zooref#bbf98|[BBF98]]]. Equals [[#modkp|Mod<sub>2^m</sub>P]] for every positive integer m. ---- ===== <span id="paritysac0" style="color:red">&#8853;SAC<sup>0</sup></span>: [[#ac0|AC<sup>0</sup>]] With Unbounded Parity Gates ===== ---- ===== <span id="paritysac1" style="color:red">&#8853;SAC<sup>1</sup></span>: [[#ac1|AC<sup>1</sup>]] With Unbounded Parity Gates ===== The class of problems solvable by a nonuniform family of polynomial-size, polylog-depth circuits with unbounded-fanin [[Complexity_Garden#parity|XOR]] and bounded-fanin AND gates. Defined in [[zooref#gw96|[GW96]]], where it was also shown that &#8853;SAC<sup>1</sup> contains [[#sac1|SAC<sup>1</sup>]]. ---- ===== <span id="a0pp" style="color:red">A<sub>0</sub>PP</span>: One-Sided Analog of [[#awpp|AWPP]] ===== Same as [[#sbp|SBP]], except that f is a nonnegative-valued [[#gapp|GapP]] function rather than a [[#sharpp|#P]] function. Defined in [[zooref#vya03|[Vya03]]], where the following was also shown: <ul> <li>A<sub>0</sub>PP contains [[#qma|QMA]], [[#awpp|AWPP]], and [[#cocequalsp|coC<sub>=</sub>P]].</li> <li>A<sub>0</sub>PP is contained in [[#pp|PP]].</li> <li>If A<sub>0</sub>PP = [[#pp|PP]] then [[#ph|PH]] is contained in [[#pp|PP]].</li> </ul> ---- ===== <span id="ac" style="color:red">AC</span>: Unbounded Fanin Polylogarithmic-Depth Circuits ===== AC<sup>i</sup> is the class of decision problems solvable by a nonuniform family of Boolean circuits, with polynomial size, depth O(log<sup>i</sup>(n)), and unbounded fanin. The gates allowed are AND, OR, and NOT. Then AC is the union of AC<sup>i</sup> over all nonnegative i. AC<sup>i</sup> is contained in [[#nc|NC]]<sup>i+1</sup>; thus, AC = [[#nc|NC]]. Contains [[#nl|NL]]. For a random oracle A, (AC<sup>i</sup>)<sup>A</sup> is strictly contained in (AC<sup>i+1</sup>)<sup>A</sup>, and (uniform) AC<sup>A</sup> is strictly contained in P<sup>A</sup>, with probability 1 [[zooref#mil92|[Mil92]]]. ---- ===== <span id="ac0" style="color:red">AC<sup>0</sup></span>: Unbounded Fanin Constant-Depth Circuits ===== An especially important subclass of [[#ac|AC]], corresponding to constant-depth, unbounded-fanin, polynomial-size circuits with AND, OR, and NOT gates. Computing the [[Complexity_Garden#parity|Parity]] or [[Complexity_Garden#majority|Majority]] of n bits is not in AC<sup>0</sup> [[zooref#fss84|[FSS84]]]. There are functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in AC<sup>0</sup> [[zooref#nw94|[NW94]]]. But there are no functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in [[#qp|QP]] (quasipolynomial time) [[zooref#lmn93|[LMN93]]]. [[zooref#lmn93|[LMN93]]] showed furthermore that functions with AC<sup>0</sup> circuits of depth d are learnable in [[#qp|QP]], given their outputs on O(2<sup>log(n)^O(d)</sup>) randomly chosen inputs. On the other hand, this learning algorithm is essentially optimal, unless there is a 2<sup>n^o(1)</sup> algorithm for [[Complexity_Garden#integer_factorization|factoring]] [[zooref#kha93|[Kha93]]]. Although there are no good pseudorandom <i>functions</i> in AC<sup>0</sup>, [[zooref#in96|[IN96]]] showed that there are pseudorandom <i>generators</i> that stretch n bits to n+&#920;(log n), assuming the hardness of a problem based on subset sum. AC<sup>0</sup> contains [[#nc0|NC<sup>0</sup>]], and is contained in [[#qac0|QAC<sup>0</sup>]] and [[#mac0|MAC<sup>0</sup>]]. In descriptive complexity, uniform AC<sup>0</sup> can be characterized as the class of problems expressible by first-order predicates with addition and multiplication operators - or indeed, with ordering and multiplication, or ordering and division (see [[zooref#lee02|[Lee02]]]). [[zooref#blm98|[BLM+98]]] showed the following problem is complete for depth-k AC<sup>0</sup> circuits (with a uniformity condition): <ul> Given a grid graph of polynomial length and width k, decide whether there is a path between vertices s and t (which can be given as part of the input). </ul> ---- ===== <span id="ac0m" style="color:red">AC<sup>0</sup>[m]</span>: [[#ac0|AC<sup>0</sup>]] With MOD m Gates ===== Same as [[#ac0|AC<sup>0</sup>]], but now "MOD m" gates (for a specific m) are allowed in addition to AND, OR, and NOT gates. (A MOD m gate outputs 0 if the sum of its inputs is congruent to 0 modulo m, and 1 otherwise.) If m is a power of a prime p, then for any prime q not equal to p, deciding whether the sum of n bits is congruent to 0 modulo q is not in AC<sup>0</sup>[m] [[zooref#raz87|[Raz87]]] [[zooref#smo87|[Smo87]]]. It follows that, for any such m, AC<sup>0</sup>[m] is strictly contained in [[#nc1|NC<sup>1</sup>]]. However, if m is a product of distinct primes (i.e. 6), then it is not even known whether AC<sup>0</sup>[m] = [[#np|NP]]! See also: [[#qac0m|QAC<sup>0</sup>[m]]]. ---- ===== <span id="ac1" style="color:red">AC<sup>1</sup></span>: Unbounded Fanin Log-Depth Circuits ===== See [[#ac|AC]]. ---- ===== <span id="acc0" style="color:red">ACC<sup>0</sup></span>: [[#ac0|AC<sup>0</sup>]] With Arbitrary MOD Gates ===== Same as [[#ac0m|AC<sup>0</sup>[m]]], but now the constant-depth circuit can contain MOD m gates for <i>any</i> m. Contained in [[#tc0|TC<sup>0</sup>]]. Indeed, can be simulated by depth-3 threshold circuits of quasipolynomial size [[zooref#yao90|[Yao90]]]. According to [[zooref#all96|[All96]]], there is no good evidence for the existence of cryptographically secure functions in ACC<sup>0</sup>. On the other hand, no nontrivial lower bounds against ACC<sup>0</sup> are known either. Thus, this class represents the current frontier for circuit lower bounds. Contains 4-[[#kpbp|PBP]] [[zooref#bt88|[BT88]]]. See also: [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="ah" style="color:red">AH</span>: Arithmetic Hierarchy ===== The analog of [[#ph|PH]] in computability theory. Let &#916;<sub>0</sub> = &#931;<sub>0</sub> = &#928;<sub>0</sub> = [[#r|R]]. Then for i&gt;0, let <ul> <li>&#916;<sub>i</sub> = [[#r|R]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#931;<sub>i</sub> = [[#re|RE]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#928;<sub>i</sub> = [[#core|coRE]] with &#931;<sub>i-1</sub> oracle.</li> </ul> Then AH is the union of these classes for all nonnegative constant i. Each level of AH strictly contains the levels below it. ---- ===== <span id="al" style="color:red">AL</span>: Alternating [[#l|L]] ===== Same as [[#ap|AP]], but for logarithmic-space instead of polynomial-time. AL = [[#p|P]] [[zooref#cks81|[CKS81]]]. ---- ===== <span id="all" style="color:red">ALL</span>: The Class of All Languages ===== Literally, the class of ALL languages. ALL is a gargantuan beast that's been wreaking havoc in the Zoo of late. First [[zooref#aar04b|[Aar04b]]] observed that [[#pp|PP]]/rpoly ([[#pp|PP]] with polynomial-size randomized advice) equals ALL, as does [[#postbqp|PostBQP]]/qpoly ([[#postbqp|PostBQP]] with polynomial-size quantum advice). Then [[zooref#raz05|[Raz05]]] showed that [[#qip|QIP]]/qpoly, and even [[#ip|IP]](2)/rpoly, equal ALL. Nor is it hard to show that [[#maexp|MA<sub>EXP</sub>]]/rpoly = ALL. On the other hand, even though [[#pspace|PSPACE]] contains [[#pp|PP]], and [[#expspace|EXPSPACE]] contains [[#maexp|MA<sub>EXP</sub>]], it's easy to see that [[#pspace|PSPACE]]/rpoly = [[#pspace|PSPACE]]/poly and [[#expspace|EXPSPACE]]/rpoly = [[#expspace|EXPSPACE]]/poly are not ALL. So does ALL have no respect for complexity class inclusions at ALL? (Sorry.) It is not as contradictory as it first seems. The deterministic base class in all of these examples is modified by computational non-determinism ''after'' it is modified by advice. For example, [[#maexp|MA<sub>EXP</sub>]]/rpoly means M(A<sub>EXP</sub>/rpoly), while ([[#maexp|MA<sub>EXP</sub>]])/rpoly equals [[#maexp|MA<sub>EXP</sub>]]/poly by a standard argument. In other words, it's only the verifier, not the prover or post-selector, who receives the randomized or quantum advice. The prover knows a description of the advice state, but not its measured values. Modification by /rpoly does preserve class inclusions when it is applied after other changes. ---- ===== <span id="alogtime" style="color:red">ALOGTIME</span>: Logarithmic time alternating RAM ===== ALOGTIME is the class of languages decidable in logarithmic time by a random access alternating Turing machine. Known to be equal to U<sub>E<sup>*</sup></sub>-uniform [[#nc1|NC<sup>1</sup>]]. ---- ===== <span id="algppoly" style="color:red">AlgP/poly</span>: Polynomial-Size Algebraic Circuits ===== The class of multivariate polynomials over the integers that can be evaluated using a polynomial (in the input size n) number of additions, subtractions, and multiplications, together with the constants -1 and 1. The class is nonuniform, in the sense that the polynomial for each input size n can be completely different. Named in [[zooref#imp02|[Imp02]]], though it has been considered since the 1970's. If [[#p|P]] = [[#bpp|BPP]] (or even [[#bpp|BPP]] is contained in [[#ne|NE]]), then either [[#nexp|NEXP]] is not in [[#ppoly|P/poly]], or else the permanent polynomial of a matrix is not in AlgP/poly [[zooref#ki02|[KI02]]]. ---- ===== <span id="almostnp" style="color:red">Almost-[[#np|NP]]</span>: Languages Almost Surely in [[#np|NP]]<sup>A</sup> ===== The class of problems that are in [[#np|NP]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[#am|AM]] [[zooref#nw94|[NW94]]]. ---- ===== <span id="almostp" style="color:red">Almost-[[#p|P]]</span>: Languages Almost Surely in [[#p|P]]<sup>A</sup> ===== The class of problems that are in [[#p|P]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[#bpp|BPP]] [[zooref#bg81|[BG81]]]. ---- ===== <span id="almostpspace" style="color:red">Almost-[[#pspace|PSPACE]]</span>: Languages Almost Surely in [[#pspace|PSPACE]]<sup>A</sup> ===== The class of problems that are in [[#pspace|PSPACE]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Almost-PSPACE is not known to equal [[#pspace|PSPACE]] -- rather surprisingly, given the fact that [[#pspace|PSPACE]] equals BPPSPACE and even [[#ppspace|PPSPACE]]. What's known is that Almost-PSPACE = BP<sup>exp</sup>&#149;[[#pspace|PSPACE]], where BP<sup>exp</sup>&#149; is like the BP&#149; operator but with exponentially-long strings [[zooref#bvw98|[BVW98]]]. It follows that Almost-PSPACE is contained in [[#nexp|NEXP]]<sup>[[#np|NP]]</sup> &#8745; [[#conexp|coNEXP]]<sup>[[#np|NP]]</sup>. Whereas both BP<sup>exp</sup>&#149;[[#pspace|PSPACE]] and BPPSPACE machines are allowed exponentially many random bits, the former has a reusable record of all of these bits on a witness tape, while the latter can only preserve a fraction of them on the work tape. ---- ===== <span id="am" style="color:red">AM</span>: Arthur-Merlin ===== The class of decision problems for which a "yes" answer can be verified by an <i>Arthur-Merlin protocol</i>, as follows. Arthur, a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier, generates a "challenge" based on the input, and sends it together with his random coins to Merlin. Merlin sends back a response, and then Arthur decides whether to accept. Given an algorithm for Arthur, we require that <ol> <li>If the answer is "yes," then Merlin can act in such a way that Arthur accepts with probability at least 2/3 (over the choice of Arthur's random bits).</li> <li>If the answer is "no," then however Merlin acts, Arthur will reject with probability at least 2/3.</li> </ol> Surprisingly, it turns out that such a system is just as powerful as a <i>private-coin</i> one, in which Arthur does not need to send his random coins to Merlin [[zooref#gs86|[GS86]]]. So, Arthur never needs to hide information from Merlin. Furthermore, define AM[k] similarly to AM, except that Arthur and Merlin have k rounds of interaction. Then for all constant k&gt;2, AM[k] = AM = AM [[zooref#bm88|[BM88]]]. Also, the result of [[zooref#gs86|[GS86]]] can then be stated as follows: [[#ip|IP]][k] is contained in AM[k+2] for every k (constant or non-constant). AM contains [[Complexity_Garden#graph_isomorphism|graph nonisomorphism]]. Contains [[#np|NP]], [[#bpp|BPP]], and [[#szk|SZK]], and is contained in [[#pi2p|&#928;<sub>2</sub>P]] and [[#nppoly|NP/poly]]. If AM contains [[#conp|coNP]] then [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]] [[zooref#bhz87|[BHZ87]]]. There exists an oracle relative to which AM is not contained in [[#pp|PP]] [[zooref#ver92|[Ver92]]]. AM = [[#np|NP]] under a strong derandomization assumption: namely that some language in [[#ne|NE]] &#8745; [[#cone|coNE]] requires nondeterministic circuits of size 2<sup>&#937;(n)</sup> ([[zooref#mv99|[MV99]]], improving [[zooref#km99|[KM99]]]). (A nondeterministic circuit C has two inputs, x and y, and accepts on x if there exists a y such that C(x,y)=1.) ---- ===== <span id="amexp" style="color:red">AM<sub>EXP</sub></span>: Exponential-Time [[#am|AM]] ===== Same as [[#am|AM]], except that Arthur is exponential-time and can exchange exponentially long messages with Merlin. Contains [[#maexp|MA<sub>EXP</sub>]], and is contained in [[#eh|EH]] and indeed [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. If [[#conp|coNP]] is contained in [[#ampolylog|AM[polylog]]] then [[#eh|EH]] collapses to AM<sub>EXP</sub> [[zooref#pv04|[PV04]]]. ---- ===== <span id="amicoam" style="color:red">AM &#8745; coAM</span> ===== The class of decision problems for which both "yes" and "no" answers can be verified by an [[#am|AM]] protocol. If [[#exp|EXP]] requires exponential time even for [[#am|AM]] protocols, then AM &#8745; coAM = [[#npiconp|NP &#8745; coNP]] [[zooref#gst03|[GST03]]]. There exists an oracle relative to which AM &#8745; coAM is not contained in [[#pp|PP]] [[zooref#ver95|[Ver95]]]. ---- ===== <span id="ampolylog" style="color:red">AM[polylog]</span>: [[#am|AM]] With Polylog Rounds ===== Same as [[#am|AM]], except that we allow polylog(n) rounds of interaction between Arthur and Merlin instead of a constant number. Not much is known about AM[polylog] -- for example, whether it sits in [[#ph|PH]]. However, [[zooref#ss04|[SS04]]] show that if AM[polylog] contains [[#conp|coNP]], then [[#eh|EH]] collapses to [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. ([[zooref#pv04|[PV04]]] improved the collapse to [[#amexp|AM<sub>EXP</sub>]].) ---- ===== <span id="ampmp" style="color:red">AmpMP</span>: Amplifiable [[#mp2|MP]] ===== The class of decision problems such that for some [[#sharpp|#P]] function f(x,0<sup>m</sup>), <ol> <li>The answer on input x is 'yes' if and only if the middle bit of f(x) is 1.</li> <li>The m bits of f(x) to the left and right of the middle bit are all 0.</li> </ol> Defined in [[zooref#gkr95|[GKR+95]]]. Contains [[#ph|PH]] and Contained in [[#mp2|MP]]. ---- ===== <span id="amppbqp" style="color:red">AmpP-BQP</span>: [[#bqp|BQP]] Restricted To [[Zoo_Exhibit#ampp|AmpP]] States ===== Similar to [[#treebqp|TreeBQP]] except that the quantum computer's state at each time step is restricted to being exponentially close to a state in [[Zoo_Exhibit#ampp|AmpP]] (that is, a state for which the amplitudes are computable by a classical polynomial-size circuit). Defined in [[zooref#aar03b|[Aar03b]]], where it was also observed that AmpP-BQP is contained in the third level of [[#ph|PH]], just as [[#treebqp|TreeBQP]] is. ---- ===== <span id="ap" style="color:red">AP</span>: Alternating [[#p|P]] ===== An <i>alternating Turing machine</i> is a nondeterministic machine with two kinds of states, AND states and OR states. It accepts if and only if the tree of all computation paths, considered as an AND-OR tree, evaluates to 1. (Here 'Accept' corresponds to 1 and 'Reject' to 0.) Then AP is the class of decision problems solvable in polynomial time by an alternating Turing machine. AP = [[#pspace|PSPACE]] [[zooref#cks81|[CKS81]]]. The abbreviation AP is also used for Approximable in Polynomial Time, see [[#axp|AxP]]. ---- ===== <span id="app" style="color:red">APP</span>: Amplified [[#pp|PP]] ===== Roughly, the class of decision problems for which the following holds. For all polynomials p(n), there exist [[#gapp|GapP]] functions f and g such that for all inputs x with n=|x|, <ol> <li>If the answer is "yes" then 1 &gt; f(x)/g(1<sup>n</sup>) &gt; 1-2<sup>-p(n)</sup>.</li> <li>If the answer is "no" then 0 &lt; f(x)/g(1<sup>n</sup>) &lt; 2<sup>-p(n)</sup>.</li> </ol> Defined in [[zooref#li93|[Li93]]], where the following was also shown: <ul> <li>APP is contained in [[#pp|PP]], and indeed is low for [[#pp|PP]].</li> <li>APP is closed under intersection, union, and complement.</li> </ul> APP contains [[#awpp|AWPP]] [[zooref#fen02|[Fen02]]]. The abbreviation APP is also used for Approximable in Probabilistic Polynomial Time, see [[#axpp|AxPP]]. ---- ===== <span id="apx" style="color:red">APX</span>: Approximable ===== The subclass of [[#npo|NPO]] problems that admit constant-factor approximation algorithms. (I.e., there is a polynomial-time algorithm that is guaranteed to find a solution within a constant factor of the optimum cost.) Contains [[#ptas|PTAS]]. Equals the closure of [[#maxsnp|MaxSNP]] and of [[#maxnp|MaxNP]] under [[#ptas|PTAS]] reduction [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. Defined in [[zooref#acg99|[ACG+99]]]. ---- ===== <span id="aucspace" style="color:red">AUC-SPACE(f(n))</span>: Randomized Alternating f(n)-Space ===== The class of problems decidable by an O(f(n))-space Turing machine with three kinds of quantifiers: existential, universal, and randomized. Contains [[#ganspace|GAN-SPACE(f(n))]]. AUC-SPACE(poly(n)) = [[#saptime|SAPTIME]] = [[#pspace|PSPACE]] [[zooref#pap83|[Pap83]]]. [[zooref#con92|[Con92]]] shows that AUC-SPACE(log n) has a natural complete problem, and is contained in [[#npiconp|NP &#8745; coNP]]. ---- ===== <span id="auxpda" style="color:red">AuxPDA</span>: Auxiliary Pushdown Automata ===== Equivalent to [[#nauxpdap|NAuxPDA<sup>p</sup>]] without the running-time restriction. Equals [[#p|P]] [[zooref#coo71b|[Coo71b]]]. ---- ===== <span id="avbpp" style="color:red">AVBPP</span>: Average-Case [[#bpp|BPP]] ===== Defined in [[zooref#ow93|[OW93]]] to be the class of decision problems that have a good average-case [[#bpp|BPP]] algorithm, whenever the input is chosen from an efficiently samplable distribution. Note that this is <i>not</i> the same as the [[#bpp|BPP]] version of [[#avgp|AvgP]]. ---- ===== <span id="avge" style="color:red">AvgE</span>: Average Exponential-Time With Linear Exponent ===== Has the same relation to [[#e|E]] as [[#avgp|AvgP]] does to [[#p|P]]. ---- ===== <span id="avgp" style="color:red">AvgP</span>: Average Polynomial-Time ===== A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. A function f, from strings to integers, is <i>polynomial on &#956;-average</i> if there exists a constant &#949;&gt;0 such that the expectation of f<sup>&#949;</sup>(x) is finite, when x is drawn from &#956;. Then (A,&#956;) is in AvgP if there is an algorithm for A whose running time is polynomial on &#956;-average. This convoluted definition is due to Levin [[zooref#lev86|[Lev86]]], who realized that simpler definitions lead to classes that fail to satisfy basic closure properties. Also see [[zooref#gol97|[Gol97]]] for more information. If AvgP = [[#distnp|DistNP]] then [[#exp|EXP]] = [[#nexp|NEXP]] [[zooref#bcg92|[BCG+92]]]. See also: [[#nppsamp|(NP,P-samplable)]]. ---- ===== <span id="awp" style="color:red">AW[P]</span>: Alternating [[#wp|W[P]]] ===== Same as [[#awsat|AW[SAT]]] but with 'circuit' instead of 'formula.' Has the same relation to [[#awsat|AW[SAT]]] as [[#wp|W[P]]] has to [[#wsat|W[SAT]]]. Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="awpp" style="color:red">AWPP</span>: Almost [[#wpp|WPP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that for some polynomial-time computable (i.e. [[#fp|FP]]) function f, <ol> <li>If the answer is "no," then the difference between the number of accepting and rejecting paths is non-negative and at most 2<sup>-poly(n)</sup>f(x).</li> <li>If the answer is "yes," then the difference is between (1-2<sup>-poly(n)</sup>)f(x) and f(x).</li> </ol> Defined in [[zooref#ffk94|[FFK94]]]. Contains [[#bqp|BQP]] [[zooref#fr98|[FR98]]], [[#wapp|WAPP]] [[zooref#bgm02|[BGM02]]], [[#lwpp|LWPP]], and [[#wpp|WPP]]. Contained in [[#app|APP]] [[zooref#fen02|[Fen02]]]. ---- ===== <span id="awsat" style="color:red">AW[SAT]</span>: Alternating [[#wsat|W[SAT]]] ===== Basically has the same relation to [[#wsat|W[SAT]]] as [[#pspace|PSPACE]] does to [[#np|NP]]. The class of decision problems of the form (x,r,k<sub>1</sub>,...,k<sub>r</sub>) (r,k<sub>1</sub>,...,k<sub>r</sub> parameters), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Parameterized QBFSAT:''' Given a Boolean formula F (with no restriction on depth), over disjoint variable sets S<sub>1</sub>,...,S<sub>r</sub>. Does there exist an assignment to S<sub>1</sub> of Hamming weight k<sub>1</sub>, such that for all assignments to S<sub>2</sub> of Hamming weight k<sub>2</sub>, etc. (alternating 'there exists' and 'for all'), F is satisfied? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#awstar|AW[*]]], and is contained in [[#awp|AW[P]]]. ---- ===== <span id="awstar" style="color:red">AW[*]</span>: Alternating [[#wstar|W[*]]] ===== The union of [[#awt|AW[t]]] over all t. ---- ===== <span id="awt" style="color:red">AW[t]</span>: Alternating [[#wt|W[t]]] ===== Has the same relation to [[#wt|W[t]]] as [[#pspace|PSPACE]] does to [[#np|NP]]. Same as [[#awsat|AW[SAT]]], except that the formula F can have depth at most t. Defined in [[zooref#df99|[DF99]]]. Contained in [[#awstar|AW[*]]]. ---- ===== <span id="axp" style="color:red">AxP</span>: Approximable in Polynomial Time ===== Usually called AP in the literature. I've renamed it AxP to distinguish it from the "other" [[#ap|AP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a deterministic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also showed that the set of AxP machines is in [[#re|RE]]. ---- ===== <span id="axpp" style="color:red">AxPP</span>: Approximable in Probabilistic Polynomial Time ===== Usually called APP. I've renamed it AxPP to distinguish it from the "other" [[#app|APP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a probabilistic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also show the following: <ul> <li>Approximating the acceptance probability of a Boolean circuit is AxPP-complete. The authors argue that this makes AxPP a more natural class than [[#bpp|BPP]], since the latter is not believed to have complete problems.</li> <li>If AxPP = [[#axp|AxP]], then [[#bpp|BPP]] = [[#p|P]].</li> <li>On the other hand, there exists an oracle relative to which [[#bpp|BPP]] = [[#p|P]] but AxPP does not equal [[#axp|AxP]].</li> </ul> Interestingly, it is unclear whether the set of AxPP machines is in [[#re|RE]]. ---- ===== <span id="betap" style="color:red">&#946;P</span>: Limited-Nondeterminism [[#np|NP]] ===== &#946;<sub>k</sub>P is the class of decision problems solvable by a polynomial-time Turing machine that makes O(log<sup>k</sup>n) nondeterministic transitions, with the same acceptance mechanism as [[#np|NP]]. Equivalently, the machine receives a purported proof of size O(log<sup>k</sup>n) that the answer is 'yes.' Then &#946;P is the union of &#946;<sub>k</sub>P over all constant k. Defined in [[zooref#kf84|[KF84]]]. See also the survey [[zooref#glm96|[GLM96]]]. There exist oracles relative to which basically any consistent inclusion structure among the &#946;<sub>k</sub>P's can be realized [[zooref#bg98|[BG98]]]. &#946;<sub>2</sub>P contains [[#lognp|LOGNP]] and [[#logsnp|LOGSNP]]. ---- ===== <span id="bh" style="color:red">BH</span>: Boolean Hierarchy Over [[#np|NP]] ===== The smallest class that contains [[#np|NP]] and is closed under union, intersection, and complement. The levels are defined as follows: <ul> <li>BH<sub>1</sub> = [[#np|NP]].</li> <li>BH<sub>2i</sub> is the class of languages that are the intersection of a BH<sub>2i-1</sub> language with a [[#conp|coNP]] language.</li> <li>BH<sub>2i+1</sub> is the class of languages that are the union of a BH<sub>2i</sub> language with an [[#np|NP]] language.</li> </ul> Then BH is the union over all i of BH<sub>i</sub>. Defined in [[zooref#ww85|[WW85]]]. For more detail see [[zooref#cgh88|[CGH+88]]]. Contained in [[#delta2p|&#916;<sub>2</sub>P]] and indeed in [[#pnplog|P<sup>NP[log]</sup>]]. If BH collapses at any level, then [[#ph|PH]] collapses to &#931;<sub>3</sub>P [[zooref#kad88|[Kad88]]]. See also: [[#qh|QH]]. ---- ===== <span id="bpdp" style="color:red">BP<sub>d</sub>(P)</span>: Polynomial Size d-Times-Only Branching Program ===== Defined in [[zooref#weg88|[Weg88]]]. The class of decision problems solvable by a family of polynomial size branching programs, with the additional condition that each bit of the input is tested at most d times. BP<sub>d</sub>(P) strictly contains BP<sub>d-1</sub>(P), for every d &gt; 1 [[zooref#tha98|[Tha98]]]. Contained in [[#pbp|PBP]]. See also: [[#pobdd|P-OBDD]], [[#kpbp|k-PBP]]. ---- ===== <span id="bpe" style="color:red">BPE</span>: Bounded-Error Probabilistic [[#e|E]] ===== Has the same relation to [[#e|E]] as [[#bpp|BPP]] does to [[#p|P]]. [[#ee|EE]] = BPE if and only if [[#exp|EXP]] = [[#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="bpee" style="color:red">BPEE</span>: Bounded-Error Probabilistic [[#ee|EE]] ===== Has the same relation to [[#ee|EE]] as [[#bpp|BPP]] does to [[#p|P]]. ---- ===== <span id="bphspace" style="color:red">BP<sub>H</sub>SPACE(f(n))</span>: Bounded-Error Halting Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts on every input <i>and</i> every random tape setting. Contains [[#rhspace|R<sub>H</sub>SPACE]](f(n)). Is contained in [[#dspace|DSPACE]](f(n)<sup>3/2</sup>) [[zooref#sz95|[SZ95]]]. ---- ===== <span id="bpl" style="color:red">BPL</span>: Bounded-Error Probabilistic [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#bpp|BPP]] does to [[#p|P]]. The Turing machine has to halt with probability 1 on every input. Contained in [[#sc|SC]] [[zooref#nis92|[Nis92]]] and in [[#pl|PL]]. ---- ===== <span id="bpnp" style="color:red">BP&#149;NP</span>: Probabilistic [[#np|NP]] ===== Equals [[#am|AM]]. ---- ===== <span id="bpp" style="color:red">BPP</span>: Bounded-Error Probabilistic Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes' then at least 2/3 of the computation paths accept.</li> <li>If the answer is 'no' then at most 1/3 of the computation paths accept.</li> </ol> (Here all computation paths have the same length.) Often identified as the class of feasible problems for a computer with access to a genuine random-number source. Defined in [[zooref#gil77|[Gil77]]]. Contained in [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]] [[zooref#lau83|[Lau83]]], and indeed in [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#gz97|[GZ97]]]. If BPP contains [[#np|NP]], then [[#rp|RP]] = [[#np|NP]] [[zooref#ko82|[Ko82]]] and [[#ph|PH]] is contained in BPP [[zooref#zac88|[Zac88]]]. If any problem in [[#e|E]] requires circuits of size 2<sup>&#937;(n)</sup>, then BPP = [[#p|P]] [[zooref#iw97|[IW97]]] (in other words, BPP can be derandomized). Indeed, <i>any</i> proof that BPP = [[#p|P]] requires showing either that [[#nexp|NEXP]] is not in [[#ppoly|P/poly]], or else that [[#sharpp|#P]] requires superpolynomial-size arithmetic circuits [[zooref#ki02|[KI02]]]. BPP is not known to contain complete problems. [[zooref#sip82|[Sip82]]], [[zooref#hh86|[HH86]]] give oracles relative to which BPP has no complete problems. There exist oracles relative to which [[#p|P]] = [[#rp|RP]] but still [[#p|P]] is not equal to BPP [[zooref#bf99|[BF99]]]. In contrast to the case of [[#p|P]], it is unknown whether BPP collapses to [[#bptime|BPTIME]](n<sup>c</sup>) for some fixed constant c. However, [[zooref#bar02|[Bar02]]] and [[zooref#fs04|[FS04]]] have shown hierarchy theorems for BPP with a small amount of advice. Equals [[#almostp|Almost-P]]. See also: [[#bpppath|BPP<sub>path</sub>]]. ---- ===== <span id="bppcc" style="color:red">BPP<sup>cc</sup></span>: Communication Complexity [[#bpp|BPP]] ===== The analogue of [[#pcc|P<sup>cc</sup>]] for bounded-error probabilistic communication complexity. Does not equal [[#pcc|P<sup>cc</sup>]], and is not contained in [[#npcc|NP<sup>cc</sup>]], because of the EQUALITY problem. Defined in [[zooref#bfs86|[BFS86]]]. ---- ===== <span id="bppkt" style="color:red">BPP<sup>KT</sup></span>: [[#bpp|BPP]] With Time-Bounded Kolmogorov Complexity Oracle ===== [[#bpp|BPP]] with an oracle that, given a string x, returns the minimum over all programs P that output x<sub>i</sub> on input i, of the length of P plus the maximum time taken by P on any input. A similar class was defined in [[zooref#abk02|[ABK+02]]], where it was also shown that in BPP<sup>KT</sup> one can [[Complexity_Garden#integer_factorization|factor]], compute [[Complexity_Garden#discrete_logarithm|discrete logarithms]], and more generally invert any one-way function on a non-negligible fraction of inputs. See also: [[#pk|P<sup>K</sup>]]. ---- ===== <span id="bpplog" style="color:red">BPP/log</span>: [[#bpp|BPP]] With Logarithmic Karp-Lipton Advice ===== The class of problems solvable by a semantic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, the machine must provide some answer with probability at least 2/3. See the discussion for [[#bqppoly|BQP/poly]]. Contained in [[#bppmlog|BPP/mlog]]. ---- ===== <span id="bppmlog" style="color:red">BPP/mlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, it need not be. Contained in [[#bpprlog|BPP/rlog]]. ---- ===== <span id="bppsslog" style="color:red">BPP//log</span>: [[#bpp|BPP]] With Logarithmic Randomness-Dependent Advice ===== The class of problems solvable by a [[#bpp|BPP]] machine that is given O(log n) advice bits, which can depend on both the machine's random coin flips and the input length n, but not on the input itself. Defined in [[zooref#tv02|[TV02]]], where it was also shown that if [[#exp|EXP]] is in BPP//log then [[#exp|EXP]] = [[#bpp|BPP]], and if [[#pspace|PSPACE]] is in BPP//log then [[#pspace|PSPACE]] = [[#bpp|BPP]]. ---- ===== <span id="bpprlog" style="color:red">BPP/rlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) random advice bits whose probability distribution depends only on the input length n. For each n, there exists good advice such that the output is correct with probability at least 2/3. Contains [[#bppmlog|BPP/mlog]]. The inclusion is strict, because BPP/rlog contains any finitely sparse language by fingerprinting; see the discussion for [[#all|ALL]]. Contained in [[#bppsslog|BPP//log]]. ---- ===== <span id="bppobdd" style="color:red">BPP-OBDD</span>: Polynomial-Size Bounded-Error Ordered Binary Decision Diagram ===== Same as [[#pobdd|P-OBDD]], except that probabilistic transitions are allowed and the OBDD need only accept with probability at least 2/3. Does not contain the integer multiplication problem [[zooref#ak96|[AK96]]]. Strictly contained in [[#bqpobdd|BQP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bpppath" style="color:red">BPP<sub>path</sub></span>: Threshold [[#bpp|BPP]] ===== Same as [[#bpp|BPP]], except that now the computation paths need not all have the same length. Defined in [[zooref#hht97|[HHT97]]], where the following was also shown: <ul> <li>BPP<sub>path</sub> contains [[#ma|MA]] and [[#pnplog|P<sup>NP[log]</sup>]], and is contained in [[#pp|PP]] and [[#bpp|BPP]]<sup>[[#np|NP]]</sup>.</li> <li>BPP<sub>path</sub> is closed under complementation, intersection, and union.</li> <li>If BPP<sub>path</sub> = BPP<sub>path</sub><sup>BPPpath</sup>, then [[#ph|PH]] collapses to BPP<sub>path</sub>.</li> <li>If BPP<sub>path</sub> contains [[#sigma2p|&#931;<sub>2</sub>P]], then [[#ph|PH]] collapses to [[#bpp|BPP]]<sup>[[#np|NP]]</sup>.</li> </ul> There exists an oracle relative to which BPP<sub>path</sub> is not contained in [[#sigma2p|&#931;<sub>2</sub>P]] [[zooref#bgm02|[BGM02]]]. ---- ===== <span id="bpqp" style="color:red">BPQP</span>: Bounded-Error Probabilistic [[#qp|QP]] ===== Equals [[#bptime|BPTIME]](2<sup>O((log n)^k)</sup>); that is, the class of problems solvable in quasipolynomial-time on a bounded-error machine. Defined in [[zooref#cns99|[CNS99]]], where the following was also shown: <ul> If either (1) [[#sharpp|#P]] does not have a subexponential-time bounded-error algorithm, or (2) [[#exp|EXP]] does not have subexponential-size circuits, then the BPQP hierarchy is strict -- that is, for all a &lt; b at least 1, [[#bptime|BPTIME]](2<sup>(log n)^a</sup>) is strictly contained in [[#bptime|BPTIME]](2<sup>(log n)^b</sup>). </ul> ---- ===== <span id="bpspace" style="color:red">BPSPACE(f(n))</span>: Bounded-Error Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts with probability 1 on every input. Contains [[#rspace|RSPACE(f(n))]] and [[#bphspace|BP<sub>H</sub>SPACE(f(n))]]. ---- ===== <span id="bptime" style="color:red">BPTIME(f(n))</span>: Bounded-Error Probabilistic f(n)-Time ===== Same as [[#bpp|BPP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#gil77|[Gil77]]]. BPTIME(n<sup>log n</sup>) does not equal BPTIME(2<sup>n^&epsilon;</sup>) for any &epsilon;>0 [[zooref#kv88|[KV88]]]. Proving a stronger time hierarchy theorem for BPTIME is a longstanding open problem; see [[zooref#bh97|[BH97]]] for details. [[zooref#bar02|[Bar02]]] has shown the following: <ul> <li>If we allow a small number of advice bits (say log n), then there is a strict hierarchy: for every d at least 1, BPTIME(n<sup>d</sup>)/(log n) does not equal BPTIME(n<sup>d+1</sup>)/(log n).</li> <li>In the uniform setting, if [[#bpp|BPP]] has complete problems then BPTIME(n<sup>d</sup>) does not equal BPTIME(n<sup>d+1</sup>).</li> <li>BPTIME(n) does not equal [[#np|NP]].</li> </ul> Subsequently, [[zooref#fs04|[FS04]]] managed to reduce the number of advice bits to only 1: BPTIME(n<sup>d</sup>)/1 does not equal BPTIME(n<sup>d+1</sup>)/1. They also proved a hierarchy theorem for [[#heurbptime|HeurBPTIME]]. For another bounded-error hierarchy result, see [[#bpqp|BPQP]]. ---- ===== <span id="bqnc" style="color:red">BQNC</span>: Alternate Name for [[#qnc|QNC]] ===== ---- ===== <span id="bqnp" style="color:red">BQNP</span>: Alternate Name for [[#qma|QMA]] ===== ---- ===== <span id="bqp" style="color:red">BQP</span>: Bounded-Error Quantum Polynomial-Time ===== The class of decision problems solvable in polynomial time by a quantum Turing machine, with at most 1/3 probability of error. One can equivalently define BQP as the class of decision problems solvable by a uniform family of polynomial-size quantum circuits, with at most 1/3 probability of error [[zooref#yao93|[Yao93]]]. Any universal gate set can be used as a basis; however, a technicality is that the transition amplitudes must be efficiently computable, since otherwise one could use them to encode the solutions to hard problems (see [[zooref#adh97|[ADH97]]]). BQP is often identified as the class of feasible problems for quantum computers. Contains the [[Complexity_Garden#integer_factorization|factoring]] and [[Complexity_Garden#discrete_logarithm|discrete logarithm]] problems [[zooref#sho97|[Sho97]]], the hidden Legendre symbol problem [[zooref#dhi02|[DHI02]]], the Pell's equation and principal ideal problems [[zooref#hal02|[Hal02]]], and some other problems not thought to be in [[#bpp|BPP]]. Defined in [[zooref#bv97|[BV97]]], where it is also shown that BQP contains [[#bpp|BPP]] and is contained in [[#p|P]] with a [[#sharpp|#P]] oracle. BQP<sup>BQP</sup> = BQP [[zooref#bv97|[BV97]]]. [[zooref#adh97|[ADH97]]] showed that BQP is contained in [[#pp|PP]], and [[zooref#fr98|[FR98]]] showed that BQP is contained in [[#awpp|AWPP]]. There exist oracles relative to which: <ul> <li>BQP does not equal [[#bpp|BPP]] [[zooref#bv97|[BV97]]] (and by similar arguments, is not in [[#ppoly|P/poly]]).</li> <li>BQP is not contained in [[#ma|MA]] [[zooref#wat00|[Wat00]]].</li> <li>BQP is not contained in [[#modkp|Mod<sub>p</sub>P]] for prime p [[zooref#gv02|[GV02]]].</li> <li>[[#np|NP]], and indeed [[#npiconp|NP &#8745; coNP]], are not contained in BQP (in fact, this holds with probability 1 relative to a random oracle and a random permutation oracle, respectively) [[zooref#bbb97|[BBB+97]]].</li> <li>[[#szk|SZK]] is not contained in BQP [[zooref#aar02|[Aar02]]].</li> <li>BQP is not contained in [[#szk|SZK]] (follows easily using the quantum walk problem in [[zooref#ccd03|[CCD+03]]]).</li> </ul> ---- ===== <span id="bqplog" style="color:red">BQP/log</span>: [[#bqp|BQP]] With Logarithmic-Size Karp-Lipton Advice ===== Same as [[#bqppoly|BQP/poly]] except that the advice is O(log n) bits instead of a polynomial number. Contained in [[#bqpmlog|BQP/mlog]]. ---- ===== <span id="bqppoly" style="color:red">BQP/poly</span>: [[#bqp|BQP]] With Polynomial-Size Karp-Lipton Advice ===== Is to [[#bqpmpoly|BQP/mpoly]] as [[#existsbpp|&#8707;BPP]] is to [[#ma|MA]]. Namely, the [[#bqp|BQP]] machine is required to give some answer with probability at least 2/3 even if the advice is bad. Even though [[#bqpmpoly|BQP/mpoly]] is a more natural class, BQP/poly follows the standard definition of advice as a class operator [[zooref#kl82|[KL82]]]. Contained in [[#bqpmpoly|BQP/mpoly]] and contains [[#bqplog|BQP/log]]. ---- ===== <span id="bqpmlog" style="color:red">BQP/mlog</span>: [[#bqp|BQP]] With Logarithmic-Size Deterministic Merlin-Like Advice ===== Same as [[#bqpmpoly|BQP/mpoly]] except that the advice is O(log n) bits instead of a polynomial number. Strictly contained in [[#bqpqlog|BQP/qlog]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpmpoly" style="color:red">BQP/mpoly</span>: [[#bqp|BQP]] With Polynomial-Size Deterministic Merlin-Like Advice ===== The class of languages recognized by a syntactic BQP machine with deterministic polynomial advice that depends only on the input length, such that the output is correct with probability 2/3 when the advice is good. Can also be defined as the class of problems solvable by a nonuniform family of polynomial-size quantum circuits, just as [[#ppoly|P/poly]] is the class solvable by a nonuniform family of polynomial-size classical circuits. Referred to with a variety of other ad hoc names, including [[#bqppoly|BQP/poly]] on occassion. Contains [[#bqpqlog|BQP/qlog]], and is contained in [[#bqpqpoly|BQP/qpoly]]. Does not contain [[#espace|ESPACE]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpqlog" style="color:red">BQP/qlog</span>: [[#bqp|BQP]] With Logarithmic-Size Quantum Advice ===== Same as [[#bqpmlog|BQP/mlog]] except that the advice is quantum instead of classical. Strictly contains [[#bqpmlog|BQP/mlog]] [[zooref#ny03|[NY03]]]. Contained in [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpqpoly" style="color:red">BQP/qpoly</span>: [[#bqp|BQP]] With Polynomial-Size Quantum Advice ===== The class of problems solvable by a [[#bqp|BQP]] machine that receives a quantum state &psi;<sub>n</sub> as advice, which depends only on the input length n. As with [[#bqpmpoly|BQP/mpoly]], the acceptance probability does not need to be bounded away from 1/2 if the machine is given bad advice. (Thus, we are discussing the class that [[zooref#ny03|[NY03]]] call BQP/*Qpoly.) Indeed, such a condition would make ''quantum'' advice unusable, by a continuity argument. Does not contain [[#eespace|EESPACE]] [[zooref#ny03|[NY03]]]. [[zooref#aar04b|[Aar04b]]] shows the following: <ul> <li>There exists an oracle relative to which BQP/qpoly does not contain [[#np|NP]].</li> <li>BQP/qpoly is contained in [[#pppoly|PP/poly]].</li> </ul> A ''classical'' oracle separation between BQP/qpoly and [[#bqpmpoly|BQP/mpoly]] is presently unknown, but there is a ''quantum'' oracle separation [[zooref#ak06|[AK06]]]. An unrelativized separation is too much to hope for, since it would imply that [[#pp|PP]] is not contained in [[#ppoly|P/poly]]. Contains [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpobdd" style="color:red">BQP-OBDD</span>: Polynomial-Size Bounded-Error Quantum Ordered Binary Decision Diagram ===== Same as [[#pobdd|P-OBDD]], except that unitary (quantum) transitions are allowed and the OBDD need only accept with probability at least 2/3. Strictly contains [[#bppobdd|BPP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bqpspace" style="color:red">BQPSPACE</span>: Bounded-Error Quantum [[#pspace|PSPACE]] ===== Equals [[#pspace|PSPACE]] and [[#ppspace|PPSPACE]]. ---- ===== <span id="bqtime" style="color:red">BQTIME(f(n))</span>: Bounded-Error Quantum f(n)-Time ===== Same as [[#bqp|BQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="bqpttmpoly" style="color:red">BQP<sub>tt</sub>/poly</span>: [[#bqpmpoly|BQP/mpoly]] With Truth-Table Queries ===== Same as [[#bqpmpoly|BQP/mpoly]], except that the machine only gets to make <i>nonadaptive</i> queries to whatever oracle it might have. Defined in [[zooref#ny03b|[NY03b]]], where it was also shown that [[#p|P]] is not contained in BQP<sub>tt</sub>/poly relative to an oracle. ---- ===== <span id="bwbp" style="color:red">k-BWBP</span>: Bounded-Width Branching Program ===== Alternate name for k-[[#kpbp|PBP]]. ---- ===== <span id="cequalsac0" style="color:red">C<sub>=</sub>AC<sup>0</sup></span>: Exact-Counting [[#ac0|AC<sup>0</sup>]] ===== The class of problems for which there exists a [[#diffac0|DiffAC<sup>0</sup>]] function f such that the answer is "yes" on input x if and only if f(x)=0. Equals [[#tc0|TC<sup>0</sup>]] and [[#pac0|PAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="cequalsl" style="color:red">C<sub>=</sub>L</span>: Exact-Counting [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#cequalsp|C<sub>=</sub>P]] does to [[#p|P]]. C<sub>=</sub>L<sup>C=L</sup> = L<sup>C=L</sup> [[zooref#abo99|[ABO99]]]. ---- ===== <span id="cequalsp" style="color:red">C<sub>=</sub>P</span>: Exact-Counting Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that the number of accepting paths exactly equals the number of rejecting paths, if and only if the answer is 'yes.' Equals [[#conqp|coNQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cfl" style="color:red">CFL</span>: Context-Free Languages ===== Does not equal [[#qcfl|QCFL]] [[zooref#mc00|[MC00]]]. Contained in [[#logcfl|LOGCFL]]. Strictly contains [[#dcfl|DCFL]] [[zooref#bra77|[Bra77]]]. ---- ===== <span id="ch" style="color:red">CH</span>: Counting Hierarchy ===== The union of the [[#ckp|C<sub>k</sub>P]]'s over all constant k. Contained in [[#pspace|PSPACE]]. It is an open problem whether there exists an oracle relative to which CH is infinite, or even unequal to [[#pspace|PSPACE]]. This is closely related to the problem of whether [[#tc0|TC<sup>0</sup>]] = [[#nc1|NC<sup>1</sup>]]. ---- ===== <span id="check" style="color:red">Check</span>: Checkable Languages ===== The class of problems such that a polynomial-time program P that allegedly solves them can be <i>checked</i> efficiently. That is, f is in Check if there exists a [[#bpp|BPP]] algorithm C such that for all programs P and inputs x, <ol> <li>If P(y)=f(y) for all inputs y, then C<sup>P</sup>(x) (C with oracle access to P) accepts with probability at least 2/3.</li> <li>If P(x) is not equal to f(x) then C<sup>P</sup>(x) accepts with probability at most 1/3.</li> </ol> Introduced in [[zooref#bk89|[BK89]]], where it was also shown that Check equals [[#frip|frIP]] &#8745; [[#cofrip|cofrIP]]. Check is contained in [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#frs88|[FRS88]]]. [[zooref#bg94|[BG94]]] show that if [[#nee|NEE]] is not contained in [[#bpee|BPEE]] then [[#np|NP]] is not contained in Check. ---- ===== <span id="clsharpp" style="color:red">CL#P</span>: Cluster Sharp-P ===== The class of [[#sharpp|#P]] function problems such that some underlying [[#np|NP]] machine $M$ witnessing membership in [[#sharpp|#P]] has "clustered" accepting paths. That is: <ul> <li>There exists a polynomial $p$ such that each computation path of $M$ on each input $x$ is exactly $p(|x|)$ bits long.</li> <li>There is a length-respecting total order $A$ having polynomial-time computable adjacency checks on the computation paths of $M$.</li> <li>The accepting paths of $M$ on any input $x$ are contiguous with respect to $A$.</li> </ul> Defined in [[zooref#hhk05|[HHK+05]]]. ---- ===== <span id="ckp" style="color:red">C<sub>k</sub>P</span>: k<sup>th</sup> Level of [[#ch|CH]] ===== Defined as follows: <ul> <li>C<sub>0</sub>P = [[#p|P]]</li> <li>C<sub>1</sub>P = [[#pp|PP]]</li> <li>C<sub>2</sub>P = [[#pp|PP]]<sup>[[#pp|PP]]</sup></li> <li>In general, C<sub>k+1</sub>P is [[#pp|PP]] with C<sub>k</sub>P oracle</li> </ul> The union of the C<sub>k</sub>P's is called the counting hierarchy, [[#ch|CH]]. Defined in [[zooref#wag86|[Wag86]]]. See [[zooref#tor91|[Tor91]]] or [[zooref#aw90|[AW90]]] for more information. ---- ===== <span id="clog" style="color:red">CLOG</span>: Continuous Logarithmic-Time ===== Roughly, the class of continuous problems solvable by an ordinary differential equation (ODE) with convergence time logarithmic in the size of the input. The vector field of the ODE is specified by an [[#nc1|NC<sup>1</sup>]] formula, with n parameters that represent the input. The point to which the ODE converges (assuming it does) is the output. Defined in [[zooref#bsf02|[BSF02]]], which should be consulted for more details. [[zooref#bsf02|[BSF02]]] show that finding the maximum of n integers is in CLOG. Thus, CLOG is best thought of as the continuous-time analog of [[#nc1|NC<sup>1</sup>]], not of [[#dtime|DTIME]](log n). Contained in [[#cp|CP]]. ---- ===== <span id="cnp" style="color:red">CNP</span>: Continuous [[#np|NP]] ===== A nondeterministic analog of [[#cp|CP]]. Defined in [[zooref#sf98|[SF98]]], which should be consulted for the definition (it has something to do with strange attractors, I think). The authors raise the question of whether [[#cp|CP]] equals CNP. ---- ===== <span id="coam" style="color:red">coAM</span>: Complement of [[#am|AM]] ===== ---- ===== <span id="cocequalsp" style="color:red">coC<sub>=</sub>P</span>: Complement of [[#cequalsp|C<sub>=</sub>P]] ===== Equals [[#nqp|NQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cofrip" style="color:red">cofrIP</span>: Complement of [[#frip|frIP]] ===== ---- ===== <span id="coh" style="color:red">Coh</span>: Coherent Languages ===== The class of problems L that are <i>efficiently autoreducible</i>, in the sense that given an input x and access to an oracle for L, a [[#bpp|BPP]] machine can compute L(x) by querying L only on points that differ from x. Defined in [[zooref#yao90b|[Yao90b]]]. [[zooref#bg94|[BG94]]] show that, assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], Coh &#8745; [[#np|NP]] is not contained in any of [[#compnp|compNP]], [[#check|Check]], or [[#frip|frIP]]. ---- ===== <span id="coma" style="color:red">coMA</span>: Complement of [[#ma|MA]] ===== ---- ===== <span id="comodkp" style="color:red">coMod<sub>k</sub>P</span>: Complement of [[#modkp|Mod<sub>k</sub>P]] ===== ---- ===== <span id="compip" style="color:red">compIP</span>: Competitive [[#ip|IP]] Proof System ===== Same as [[#compnp|compNP]] but for interactive ([[#ip|IP]]) proofs instead of [[#np|NP]] proofs. More formally, compIP is the class of decision problems L in [[#ip|IP]] = [[#pspace|PSPACE]] such that, if the answer is "yes," then that can be proven by an interactive protocol between a [[#bpp|BPP]] verifier and a prover, a [[#bpp|BPP]] machine with access only to an oracle for L. Assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], [[#np|NP]] (and indeed [[#np|NP]] &#8745; [[#coh|Coh]]) is not contained in [[#compip|compIP]] [[zooref#bg94|[BG94]]]. ---- ===== <span id="compnp" style="color:red">compNP</span>: Competitive [[#np|NP]] Proof System ===== The class of decision problems L in [[#np|NP]] such that, if the answer is "yes," then a proof can be constructed in polynomial time given access only to an oracle for L. Contains [[#npc|NPC]]. [[zooref#bg94|[BG94]]] show that compNP is contained in [[#frip|frIP]], and that assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], compNP does not equal [[#np|NP]]. ---- ===== <span id="cone" style="color:red">coNE</span>: Complement of [[#ne|NE]] ===== ---- ===== <span id="conexp" style="color:red">coNEXP</span>: Complement of [[#nexp|NEXP]] ===== Contained in [[#nexppoly|NEXP/poly]] (folklore result reported in [[http://weblog.fortnow.com/|Fortnow's weblog]]). ---- ===== <span id="conl" style="color:red">coNL</span>: Complement of [[#nl|NL]] ===== Equals [[#nl|NL]] [[zooref#imm88|[Imm88]]] [[zooref#sze87|[Sze87]]]. ---- ===== <span id="conp" style="color:red">coNP</span>: Complement of [[#np|NP]] ===== If [[#np|NP]] = coNP, then any inconsistent Boolean formula of size n has a proof of inconsistency of size polynomial in n. If [[#np|NP]] does not equal coNP, then [[#p|P]] does not equal [[#np|NP]]. But the other direction is not known. See also: [[#npiconp|NP &#8745; coNP]]. Every problem in coNP has an [[#ip|IP]] (interactive proof) system, where moreover the prover can be restricted to [[#bpp|BPP]]<sup>[[#sharpp|#P]]</sup>. ---- ===== <span id="conpcc" style="color:red">coNP<sup>cc</sup></span>: Complement of [[#npcc|NP<sup>cc</sup>]] ===== ---- ===== <span id="conppoly" style="color:red">coNP/poly</span>: Complement of [[#nppoly|NP/poly]] ===== If [[#np|NP]] is contained in coNP/poly then [[#ph|PH]] collapses to [[#s2p|S<sub>2</sub>P]]<sup>[[#np|NP]]</sup> [[zooref#cch01|[CCH+01]]]. <table border="2"><tr><td>[[#np|NP]]<sup>[[#np|NP]]^[[#np|NP]]^([[#conppoly|coNP/poly]] &#8745; [[#np|NP]])</sup> = [[#np|NP]]<sup>[[#np|NP]]^[[#np|NP]]</sup> [[zooref#hno96|[HNO+96]]]</td></tr></table> <i>Note:</i> At the suggestion of Luis Antu&ntilde;es, the above specimen of the Complexity Zoo has been locked in a cage. ---- ===== <span id="conqp" style="color:red">coNQP</span>: Complement of [[#nqp|NQP]] ===== Equals [[#cequalsp|C<sub>=</sub>P]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="core" style="color:red">coRE</span>: Complement of [[#re|RE]] ===== Does not equal [[#re|RE]]. The problem "given a computable predicate P, is P true of all positive integers?" is coRE-complete. ---- ===== <span id="cornc" style="color:red">coRNC</span>: Complement of [[#rnc|RNC]] ===== Contains the problem of whether a bipartite graph has a perfect matching [[zooref#kar86|[Kar86]]]. ---- ===== <span id="corp" style="color:red">coRP</span>: Complement of [[#rp|RP]] ===== Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ss77|[SS77]]]. ---- ===== <span id="cosl" style="color:red">coSL</span>: Complement of [[#sl|SL]] ===== ---- ===== <span id="cosparse" style="color:red">coSPARSE</span>: Complement of [[#sparse|SPARSE]] ===== ---- ===== <span id="coucc" style="color:red">coUCC</span>: Complement of [[#ucc|UCC]] ===== [[zooref#tor00|[Tor00]]] showed the following problem complete for coUCC under [[#l|L]] reductions: <ul> Given a colored graph G with at most two vertices having any given color, does G have any nontrivial automorphisms? </ul> ---- ===== <span id="coup" style="color:red">coUP</span>: Complement of [[#up|UP]] ===== ---- ===== <span id="cp" style="color:red">CP</span>: Continuous [[#p|P]] ===== Same as [[#clog|CLOG]], except that the convergence time can be polynomial rather than logarithmic in the input size. Defined in [[zooref#bsf02|[BSF02]]] and [[zooref#sf98|[SF98]]]. Finding a maximum flow, which is [[#p|P]]-complete, can be done in CP [[zooref#bsf02|[BSF02]]]. Based on this the authors argue that "[[#p|P]] is contained in CP," but this seems hard to formalize, since CP is not a complexity class in the usual sense. They also conjecture that "CP is contained in [[#p|P]]" (i.e. the class of ODE's they consider can be integrated efficiently on a standard Turing machine), but this is open. Contained in [[#cnp|CNP]]. ---- ===== <span id="csize" style="color:red">CSIZE(f(n))</span>: Circuit Size f(n) ===== The class of decision problems solvable by a (nonuniform) family of Boolean circuits of size O(f(n)). So for example, CSIZE(poly(n)) (the union of CSIZE(n<sup>k</sup>) over all k) equals [[#ppoly|P/poly]]. Defined in [[zooref#sm02|[SM02]]] among other places. ---- ===== <span id="csl" style="color:red">CSL</span>: Context Sensitive Languages ===== The class of languages generated by context-sensitive grammars. Equals [[#nspace|NSPACE]](n) [[zooref#kur64|[Kur64]]]. ---- ===== <span id="czk" style="color:red">CZK</span>: Computational Zero-Knowledge ===== Same as [[#szk|SZK]], except that now the two distributions are merely required to be <i>computationally indistinguishable</i> by any [[#bpp|BPP]] algorithm; they don't have to be statistically close. (The "two distributions" are (1) the distribution over Arthur's view of his interaction with Merlin, conditioned on Arthur's random coins, and (2) the distribution over views that Arthur can <i>simulate</i> without Merlin's help.) Unlike [[#szk|SZK]], it is not known if CZK is closed under complement. CZK is now known to share other properties with [[#szk|SZK]]: the verifier may as well be honest and may as well show his coins, and CZK is closed under unions [[zooref#vad06|[Vad06]]]. (Previously, these properties were only established in the presence of one-way functions.) Assuming the existence of one-way functions, CZK contains [[#np|NP]] [[zooref#gmw91|[GMW91]]], and indeed equals [[#ip|IP]]=[[#pspace|PSPACE]] [[zooref#bgg90|[BGG+90]]]. However, none of these implications of one-way functions relativize (Impagliazzo, unpublished). On the other hand, if one-way functions do not exist then CZK = [[#avbpp|AVBPP]] [[zooref#ow93|[OW93]]]. Contains [[#pzk|PZK]] and [[#szk|SZK]]. ---- ===== <span id="dsharpp" style="color:red">D#P</span>: Alternate Name for [[#psharpp|P<sup>#P</sup>]] ===== ---- ===== <span id="dcfl" style="color:red">DCFL</span>: Deterministic [[#cfl|CFL]] ===== The class of languages accepted by deterministic pushdown automata. Defined in [[zooref#gg66|[GG66]]], where it was also shown that DCFL is strictly contained in [[#cfl|CFL]] and strictly contains [[#reg|REG]]. ---- ===== <span id="delta2p" style="color:red">&#916;<sub>2</sub>P</span>: [[#p|P]] With [[#np|NP]] Oracle ===== A level of [[#ph|PH]], the polynomial hierarchy. Contains [[#bh|BH]]. There exists an oracle relative to which &#916;<sub>2</sub>P is not contained in [[#pp|PP]] [[zooref#bei94|[Bei94]]]. There exists another oracle relative to which &#916;<sub>2</sub>P is contained in [[#ppoly|P/poly]] [[zooref#bgs75|[BGS75]]], and indeed has linear-size circuits [[zooref#wil85|[Wil85]]]. If [[#p|P]] = [[#np|NP]], then any polynomial-size circuit C can be learned in &#916;<sub>2</sub>P with C oracle [[zooref#aar06|[Aar06]]]. ---- ===== <span id="deltabpp" style="color:red">&#948;-BPP</span>: &#948;-Semi-Random [[#bpp|BPP]] ===== Same as [[#bpp|BPP]], except that the random bit source is biased as follows. Each bit could depend on all the previous bits in arbitrarily complicated ways; the only promise is that the bit is 1 with probability in the range [&#948;,1-&#948;], conditioned on all previous bits. So clearly 0-BPP = [[#p|P]] and 1/2-BPP = [[#bpp|BPP]]. It turns out that, for any &#948;&gt;0, &#948;-BPP = [[#bpp|BPP]] [[zooref#vv85|[VV85]]], [[zooref#zuc91|[Zuc91]]]. ---- ===== <span id="deltarp" style="color:red">&#948;-RP</span>: &#948;-Semi-Random [[#rp|RP]] ===== Same as [[#deltabpp|&#948;-BPP]], but for [[#rp|RP]] instead of [[#bpp|BPP]]. For any &#948;&gt;0, &#948;-RP = [[#rp|RP]] [[zooref#vv85|[VV85]]]. ---- ===== <span id="det" style="color:red">DET</span>: Determinant ===== The class of decision problems reducible in [[#l|L]] to the problem of computing the determinant of an n-by-n matrix of n-bit integers. Defined in [[zooref#coo85|[Coo85]]]. Contained in [[#nc2|NC<sup>2</sup>]], and contains [[#nl|NL]] and [[#pl|PL]] [[zooref#bcp83|[BCP83]]]. [[Complexity_Garden#graph_isomorphism|Graph isomorphism]] is hard for DET under [[#l|L]]-reductions [[zooref#tor00|[Tor00]]]. ---- ===== <span id="diffac0" style="color:red">DiffAC<sup>0</sup></span>: Difference [[#sharpac0|#AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to integers expressible as the difference of two [[#sharpac0|#AC<sup>0</sup>]] functions. Equals [[#gapac0|GapAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="disnp" style="color:red">DisNP</span>: Disjoint [[#np|NP]] Pairs ===== The class of pairs (A,B), where A and B are [[#np|NP]] problems whose sets of "yes" instances are nonempty and disjoint. If there exists an optimal propositional proof system, then DisNP has a complete pair [[zooref#raz94|[Raz94]]]. On the other hand, there exists an oracle relative to which DisNP does not have a complete pair [[zooref#gss03|[GSS+03]]]. If [[#p|P]] does not equal [[#up|UP]], then DisNP contains pairs not separated by any set in [[#p|P]] [[zooref#gs88|[GS88]]]. On the other hand, there exists an oracle relative to which [[#p|P]] does not equal [[#np|NP]] but still DisNP does not contain any [[#p|P]]-inseparable pairs [[zooref#hs92|[HS92]]]. ---- ===== <span id="distnp" style="color:red">DistNP</span>: Distributional [[#np|NP]] ===== (also called (NP,P-computable) or RNP) A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. (A,&#956;) is in DistNP if A is in [[#np|NP]], and &#956; is [[#p|P]]-computable (meaning that its cumulative density function can be evaluated in polynomial time). DistNP has complete problems [[zooref#lev86|[Lev86]]] (see also [[zooref#gur87|[Gur87]]]), although unlike for [[#np|NP]] this is not immediate. Any DistNP-complete problem is also complete for [[#nppsamp|(NP,P-samplable)]] [[zooref#il90|[IL90]]]. ---- ===== <span id="dp" style="color:red">DP</span>: Difference Polynomial-Time ===== DP = [[#bh|BH]]<sub>2</sub>, the second level of the Boolean hierarchy. Defined in [[zooref#py84|[PY84]]]. ---- ===== <span id="dqp" style="color:red">DQP</span>: Dynamical Quantum Polynomial-Time ===== The class of decision problems solvable by a [[#bqp|BQP]] machine with oracle access to a <i>dynamical simulator</i>. When given a polynomial-size quantum circuit, the simulator returns a sample from the distribution over "classical histories" induced by the circuit. The simulator can adversarially choose any history distribution that satisfies the axioms of "symmetry" and "locality" -- so that the DQP algorithm has to work for any distribution satisfying these axioms. See [[zooref#aar05|[Aar05]]] for a full definition. There it is also shown that [[#szk|SZK]] is contained in DQP. Contains [[#bqp|BQP]], and is contained in [[#exp|EXP]] [[zooref#aar05|[Aar05]]]. There exists an oracle relative to which DQP does not contain [[#np|NP]] [[zooref#aar05|[Aar05]]]. ---- ===== <span id="dspace" style="color:red">DSPACE(f(n))</span>: Deterministic f(n)-Space ===== The class of decision problems solvable by a Turing machine in space O(f(n)). The Space Hierarchy Theorem: For constructible f(n) greater than log n, DSPACE(f(n)) is strictly contained in DSPACE(f(n) log(f(n))) [[zooref#hls65|[HLS65]]]. For space constructible f(n), strictly contains [[#dtime|DTIME]](f(n)) [[zooref#hpv77|[HPV77]]]. DSPACE(n) does not equal [[#np|NP]] (though we have no idea if one contains the other)! See also: [[#nspace|NSPACE]](f(n)). ---- ===== <span id="dtime" style="color:red">DTIME(f(n))</span>: Deterministic f(n)-Time ===== The class of decision problems solvable by a Turing machine in time O(f(n)). The Time Hierarchy Theorem: For constructible f(n) greater than n, DTIME(f(n)) is strictly contained in DTIME(f(n) log(f(n)) loglog(f(n))) [[zooref#hs65|[HS65]]]. For any space constructible f(n), DTIME(f(n)) is strictly contained in DSPACE(f(n)) [[zooref#hpv77|[HPV77]]]. Also, DTIME(n) is strictly contained in [[#ntime|NTIME(n)]] [[zooref#pps83|[PPS+83]]] (this result does not work for arbitrary f(n)). For any constructible superpolynomial f(n), DTIME(f(n)) with [[#pp|PP]] oracle is not in [[#ppoly|P/poly]] (see [[zooref#all96|[All96]]]). ---- ===== <span id="dtisp" style="color:red">DTISP(t(n),s(n))</span>: Simultaneous t(n)-Time and s(n)-Space ===== The class of decision problems solvable by a Turing machine that uses time O(t(n)) and space O(s(n)) simultaneously. Thus [[#sc|SC]] = DTISP(poly,polylog) for example. Defined in [[zooref#nis92|[Nis92]]], where it was also shown that for all space-constructible s(n)=&Omega;(log n), [[#bpspace|BPSPACE(s(n))]] is contained in DTISP(2<sup>O(s(n))</sup>,s<sup>2</sup>(n)). ---- ===== <span id="dynfo" style="color:red">Dyn-FO</span>: Dynamic [[#fo|FO]] ===== The class of <i>dynamic</i> problems solvable using first-order predicates. Basically what this means is that an algorithm maintains some polynomial-size data structure (say a graph), and receives a sequence of updates (add this edge, delete that one, etc.). For each update, it computes a new value for the data structure in [[#fo|FO]] -- that is, for each bit of the data structure, there is an [[#fo|FO]] function representing the new value of that bit, which takes as input both the update and the previous value of the data structure. At the end the algorithm needs to answer some question (i.e. is the graph connected?). See [[zooref#hi02|[HI02]]] for more information, and a complete problem for Dyn-FO. See also [[#dynthc0|Dyn-ThC<sup>0</sup>]]. ---- ===== <span id="dynthc0" style="color:red">Dyn-ThC<sup>0</sup></span>: Dynamic Threshold Circuits ===== Same as [[#dynfo|Dyn-FO]], except that now updates are computed via constant-depth predicates that have "COUNT" available, in addition to AND, OR, and NOT -- so it's a uniform version of [[#tc0|TC<sup>0</sup>]] rather than of [[#ac0|AC<sup>0</sup>]]. See [[zooref#hi02|[HI02]]] for more information. ---- ===== <span id="e" style="color:red">E</span>: Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>O(n)</sup>). Does not equal [[#np|NP]] [[zooref#boo72|[Boo72]]] or [[#pspace|PSPACE]] [[zooref#boo74|[Boo74]]] relative to any oracle. However, there is an oracle relative to which E is contained in [[#np|NP]] (see [[#zpp|ZPP]]), and an oracle relative to [[#pspace|PSPACE]] is contained in E (by equating the former with [[#p|P]]). There exists a problem that is complete for E under polynomial-time Turing reductions but not polynomial-time truth-table reductions [[zooref#wat87|[Wat87]]]. Problems hard for [[#bpp|BPP]] under Turing reductions have measure 1 in E [[zooref#as94|[AS94]]]. It follows that, if the problems complete for E under Turing reductions do not have measure 1 in E, then [[#bpp|BPP]] does not equal [[#exp|EXP]]. [[zooref#it89|[IT89]]] gave an oracle relative to which E = [[#ne|NE]] but still there is an exponential-time binary predicate whose corresponding <i>search</i> problem is not in E. Contrast with [[#exp|EXP]]. ---- ===== <span id="ee" style="color:red">EE</span>: Double-Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>2^O(n)</sup>) (though some authors alternatively define it as being equal to [[#dtime|DTIME]](2<sup>O(2^n)</sup>)). EE = [[#bpe|BPE]] if and only if [[#exp|EXP]] = [[#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. Contained in [[#eexp|EEXP]] and [[#nee|NEE]]. ---- ===== <span id="eee" style="color:red">EEE</span>: Triple-Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>2^2^O(n)</sup>). In contrast to the case of [[#ee|EE]], it is not known whether EEE = [[#bpee|BPEE]] implies [[#ee|EE]] = [[#bpe|BPE]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="eespace" style="color:red">EESPACE</span>: Double-Exponential Space With Linear Exponent ===== Equals [[#dspace|DSPACE]](2<sup>2^O(n)</sup>). Is not contained in [[#bqpqpoly|BQP/qpoly]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="eexp" style="color:red">EEXP</span>: Double-Exponential Time ===== Equals [[#dtime|DTIME]](2<sup>2^p(n)</sup>) for p a polynomial. Contains [[#ee|EE]], and is contained in [[#neexp|NEEXP]]. ---- ===== <span id="eh" style="color:red">EH</span>: Exponential-Time Hierarchy With Linear Exponent ===== Has roughly the same relationship to [[#e|E]] as [[#ph|PH]] does to [[#p|P]]. More formally, EH is defined as the union of [[#e|E]], [[#ne|NE]], [[#ne|NE]]<sup>[[#np|NP]]</sup>, [[#ne|NE]] with [[#sigma2p|&#931;<sub>2</sub>P]] oracle, and so on. See [[zooref#har87|[Har87]]] for more information. If [[#conp|coNP]] is contained in [[#ampolylog|AM[polylog]]], then EH collapses to [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]] [[zooref#ss04|[SS04]]] and indeed [[#amexp|AM<sub>EXP</sub>]] [[zooref#pv04|[PV04]]]. On the other hand, [[#cone|coNE]] is contained in [[#nepoly|NE/poly]], so perhaps it wouldn't be so surprising if NE collapses. There exists an oracle relative to which EH does not contain [[#seh|SEH]] [[zooref#hem89|[Hem89]]]. EH and [[#seh|SEH]] are incomparable for all anyone knows. ---- ===== <span id="elementary" style="color:red">ELEMENTARY</span>: Iterated Exponential Time ===== Equals the union of [[#dtime|DTIME]](2<sup>n</sup>), [[#dtime|DTIME]](2<sup>2^n</sup>), [[#dtime|DTIME]](2<sup>2^2^n</sup>), and so on. Contained in [[#pr|PR]]. ---- ===== <span id="elkp" style="color:red">EL<sub>k</sub>P</span>: Extended Low Hierarchy ===== An extension of [[#lkp|L<sub>k</sub>P]]. The class of problems A such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> is contained in [[#ph|&#931;<sub>k-1</sub>P]]<sup>A,[[#np|NP]]</sup>. Defined in [[zooref#bbs86|[BBS86]]]. ---- ===== <span id="ep" style="color:red">EP</span>: NP with 2<sup>k</sup> Accepting Paths ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then the number of accepting paths is a power of two.</li> </ol> Contained in [[#cequalsp|C<sub>=</sub>P]], and in [[#modkp|Mod<sub>k</sub>P]] for any odd k. Contains [[#up|UP]]. Defined in [[zooref#bhr00|[BHR00]]]. ---- ===== <span id="eptas" style="color:red">EPTAS</span>: Efficient Polynomial-Time Approximation Scheme ===== The class of optimization problems such that, given an instance of length n, we can find a solution within a factor 1+&epsilon; of the optimum in time f(&epsilon;)p(n), where p is a polynomial and f is arbitrary. Contains [[#fptas|FPTAS]] and is contained in [[#ptas|PTAS]]. Defined in [[zooref#ct97|[CT97]]], where the following was also shown: <ul> <li>If [[#fpt|FPT]] = [[#xpuniform|XP<sub>uniform</sub>]] then EPTAS = [[#ptas|PTAS]].</li> <li>If EPTAS = [[#ptas|PTAS]] then [[#fpt|FPT]] = [[#wp|W[P]]].</li> <li>If [[#fpt|FPT]] is strictly contained in [[#w1|W]], then there is a natural problem that is in [[#ptas|PTAS]] but not in EPTAS. (See [[zooref#ct97|[CT97]]] for the statement of the problem, since it's not <i>that</i> natural.)</li> </ul> ---- ===== <span id="eqbp" style="color:red">k-EQBP</span>: Width-k Polynomial-Time Exact Quantum Branching Programs ===== See k-[[#kpbp|PBP]] for the definition of a classical branching program. A quantum branching program is the natural quantum generalization: we have a quantum state in a Hilbert space of dimension k. Each step t consists of applying a unitary matrix U<sup>(t)</sup>(x<sub>i</sub>): that is, U<sup>(t)</sup> depends on a single bit x<sub>i</sub> of the input. (So these are the quantum analogues of so-called <i>oblivious</i> branching programs.) In the end we measure to decide whether to accept; there must be zero probability of error. Defined in [[zooref#amp02|[AMP02]]], where it was also shown that [[#nc1|NC<sup>1</sup>]] is contained in 2-EQBP. k-BQBP can be defined similarly. ---- ===== <span id="eqp" style="color:red">EQP</span>: Exact Quantum Polynomial-Time ===== The same as [[#bqp|BQP]], except that the quantum algorithm must return the correct answer with probability 1, and run in polynomial time with probability 1. Unlike bounded-error quantum computing, there is no theory of universal QTMs for exact quantum computing models. In the original definition in [[zooref#bv97|[BV97]]], each language in EQP is computed by a single QTM, equivalently to a uniform family of quantum circuits with a finite gate set K whose amplitudes can be computed in polynomial time. See [[#eqpk|EQP<sub>K</sub>]]. However, some results require an infinite gate set. The official definition here is that the gate set should be finite. Without loss of generality, the amplitudes in the gate set K are algebraic numbers [[zooref#adh97|[ADH97]]]. There is an oracle that separates EQP from [[#np|NP]] [[zooref#bv97|[BV97]]], indeed from [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#gp01|[GP01]]]. There is also an oracle relative to which EQP is not in [[#modkp|Mod<sub>p</sub>P]] where p is prime [[zooref#gv02|[GV02]]]. On the other hand, EQP is in [[#lwpp|LWPP]] [[zooref#fr98|[FR98]]]. [[#p|P]]<sup>||[[#np|NP]][2k]</sup> is contained in EQP<sup>||[[#np|NP]][k]</sup>, where "||[[#np|NP]][k]" denotes k nonadaptive oracle queries to [[#np|NP]] (queries that cannot depend on the results of previous queries) [[zooref#bd99|[BD99]]]. See also [[#zbqp|ZBQP]]. ---- ===== <span id="eqpk" style="color:red">EQP<sub>K</sub></span>: Exact Quantum Polynomial-Time with Gate Set K ===== The set of problems that can be answered by a uniform family of polynomial-sized quantum circuits whose gates are drawn from a set K, and that return the correct answer with probability 1, and run in polynomial time with probability 1, and the allowed gates are drawn from a set K. K may be either finite or countable and enumerated. If S is a ring, the union of EQP<sub>K</sub> over all finite gate sets K whose amplitudes are in the ring R can be written EQP<sub>S</sub>. Defined in [[zooref#adh97|[ADH97]]] in the special case of a finite set of 1-qubit gates controlled by a second qubit. It was shown there that transcendental gates may be replaced by algebraic gates without decreasing the size of EQP<sub>K</sub>. [[zooref#fr98|[FR98]]] show that EQP<sub>Q</sub> is in [[#lwpp|LWPP]]. The proof can be generalized to any finite, algebraic gate set K. The hidden shift problem for a vector space over Z/2 is in EQP<sub>Q</sub> by Simon's algorithm. The [[Complexity_Garden#discrete_logarithm|discrete logarithm]] problem over Z/p is in EQP<sub>Q-bar</sub> using infinitely many gates [[zooref#mz03|[MZ03]]]. ---- ===== <span id="eqtime" style="color:red">EQTIME(f(n))</span>: Exact Quantum f(n)-Time ===== Same as [[#eqp|EQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="espace" style="color:red">ESPACE</span>: Exponential Space With Linear Exponent ===== Equals [[#dspace|DSPACE]](2<sup>O(n)</sup>). If [[#e|E]] = ESPACE then [[#p|P]] = [[#bpp|BPP]] [[zooref#hy84|[HY84]]]. Indeed if [[#e|E]] has nonzero measure in ESPACE then [[#p|P]] = [[#bpp|BPP]] [[zooref#lut91|[Lut91]]]. ESPACE is not contained in [[#ppoly|P/poly]] [[zooref#kan82|[Kan82]]]. Is not contained in [[#bqpmpoly|BQP/mpoly]] [[zooref#ny03|[NY03]]]. See also: [[#expspace|EXPSPACE]]. ---- ===== <span id="existsbpp" style="color:red">&#8707;BPP</span>: [[#bpp|BPP]] With Existential Operator ===== The class of problems for which there exists a [[#bpp|BPP]] machine M such that, for all inputs x, <ul> <li>If the answer is "yes" then there exists a y such that M(x,y) accepts.</li> <li>If the answer is "no" then for all y, M(x,y) rejects.</li> </ul> Contains [[#np|NP]] and [[#bpp|BPP]], and is contained in [[#ma|MA]] and [[#sbp|SBP]]. &#8707;BPP seems <i>obviously</i> equal to [[#ma|MA]], yet [[zooref#ffk93|[FFK+93]]] constructed an oracle relative to which they're unequal! Here is the difference: if the answer is "yes," [[#ma|MA]] requires only that there exist a y such that for at least 2/3 of random strings r, M(x,y,r) accepts (where M is a [[#p|P]] predicate). For all other y's, the proportion of r's such that M(x,y,r) accepts can be arbitrary (say, 1/2). For &#8707;BPP, by contrast, the probability that M(x,y) accepts must <i>always</i> be either at most 1/3 or at least 2/3, for all y's. ---- ===== <span id="existsniszk" style="color:red">&#8707;NISZK</span>: [[#niszk|NISZK]] With Existential Operator ===== Contains [[#np|NP]] and [[#niszk|NISZK]], and is contained in the third level of [[#ph|PH]]. ---- ===== <span id="exp" style="color:red">EXP</span>: Exponential Time ===== Equals the union of [[#dtime|DTIME]](2<sup>p(n)</sup>) over all polynomials p. Also equals [[#p|P]] with [[#e|E]] oracle. If [[#l|L]] = [[#p|P]] then [[#pspace|PSPACE]] = EXP. If EXP is in [[#ppoly|P/poly]] then EXP = [[#ma|MA]] [[zooref#bfl91|[BFL91]]]. Problems complete for EXP under many-one reductions have measure 0 in EXP [[zooref#may94|[May94]]], [[zooref#jl95|[JL95]]]. There exist oracles relative to which <ul> <li>EXP = [[#np|NP]] = [[#zpp|ZPP]] [[zooref#hel84|[Hel84]]],</li> <li>EXP = [[#nexp|NEXP]] but still [[#p|P]] does not equal [[#np|NP]] [[zooref#dek76|[Dek76]]],</li> <li>EXP does not equal [[#pspace|PSPACE]] [[zooref#dek76|[Dek76]]].</li> </ul> [[zooref#bt04|[BT04]]] show the following rather striking result: let A be many-one complete for EXP, and let S be any set in [[#p|P]] of subexponential density. Then A-S is Turing-complete for EXP. ---- ===== <span id="exppoly" style="color:red">EXP/poly</span>: Exponential Time With Polynomial-Size Advice ===== The class of decision problems solvable in [[#exp|EXP]] with the help of a polynomial-length advice string that depends only on the input length. Contains [[#bqpqpoly|BQP/qpoly]] [[zooref#aar04b|[Aar04b]]]. ---- ===== <span id="expspace" style="color:red">EXPSPACE</span>: Exponential Space ===== Equals the union of [[#dspace|DSPACE]](2<sup>p(n)</sup>) over all polynomials p. See also: [[#espace|ESPACE]]. Given a first-order statement about real numbers, involving only addition and comparison (no multiplication), we can decide in EXPSPACE whether it's true or not [[zooref#ber80|[Ber80]]]. ---- ===== <span id="fbqp" style="color:red">FBQP</span>: Function [[#bqp|BQP]] ===== Has the same relation to [[#bqp|BQP]] as [[#fnp|FNP]] does to [[#np|NP]]. There exists an oracle relative to which [[#pls|PLS]] is not contained in [[#fbqp|FBQP]] [[zooref#aar03|[Aar03]]]. ---- ===== <span id="few" style="color:red">Few</span>: [[#fewp|FewP]] With Flexible Acceptance Mechanism ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>The number of accepting paths a is bounded by a polynomial in the size of the input x.</li> <li>For some polynomial-time predicate Q, Q(x,a) is true if and only if the answer is 'yes.'</li> </ol> Also called FewPaths. Defined in [[zooref#ch89|[CH89]]]. Contains [[#fewp|FewP]], and is contained in [[#p|P]]<sup>[[#fewp|FewP]]</sup> [[zooref#kob89|[Kob89]]] and in [[#spp|SPP]] [[zooref#ffk94|[FFK94]]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fewp" style="color:red">FewP</span>: [[#np|NP]] With Few Witnesses ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then at least one path accepts; furthermore, the number of accepting paths is upper-bounded by a polynomial in n, the size of the input.</li> </ol> Defined in [[zooref#ar88|[AR88]]]. Is contained in [[#parityp|&#8853;P]] [[zooref#ch89|[CH89]]]. There exists an oracle relative to which [[#p|P]], [[#up|UP]], FewP, and [[#np|NP]] are all distinct [[zooref#rub88|[Rub88]]]. Also, there exists an oracle relative to which FewP does not have a Turing-complete set [[zooref#hjv93|[HJV93]]]. Contained in [[#few|Few]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fh" style="color:red">FH</span>: Fourier Hierarchy ===== FH<sub>k</sub> is the class of problems solvable by a uniform family of polynomial-size quantum circuits, with k levels of Hadamard gates and all other gates preserving the computational basis. (Conditional phase flip gates are fine, for example.) Thus <ul> <li>FH<sub>0</sub> = [[#p|P]]</li> <li>FH<sub>1</sub> = [[#bpp|BPP]]</li> <li>FH<sub>2</sub> contains [[Complexity_Garden#integer_factorization|factoring]] because of Kitaev's phase estimation algorithm</li> </ul> It is an open problem to show that the Fourier hierarchy is infinite relative to an oracle (that is, FH<sub>k</sub> is strictly contained in FH<sub>k+1</sub>). Defined in [[zooref#shi03|[Shi03]]]. ---- ===== <span id="fixp" style="color:red">FIXP</span>: Fixed Point ===== The class of fixed point problems. In the framework of fixed point problems, an instance I is associated with a (continuous) function F<sub>I</sub>, and a solution of I is a fixed point of F<sub>I</sub>. Properties of FIXP problems: <ol> <li> the function F<sub>I</sub> is represented by an algebraic circuit over {+, -, *, /, max, min} with rational constants <li> there is a polynomial time algorithm that computes the circuit from I. </ol> Every FIXP problem has Partial Computation, Decision, (Strong) Approximation, and Existence counterparts; these can all be solved in PSPACE. The Nash equilibrium problem for 3 or more players is FIXP-complete. Linear-FIXP = PPAD. Defined in [[zooref#ey07|[EY07]]]. ---- ===== <span id="fnl" style="color:red">FNL</span>: Function [[#nl|NL]] ===== Has the same relation to [[#nl|NL]] as [[#fnp|FNP]] does to [[#np|NP]]. Defined by [[zooref#aj93|[AJ93]]], who also showed that if [[#nl|NL]] = [[#ul|UL]], then FNL is contained in [[#sharpl|#L]]. ---- ===== <span id="fnlpoly" style="color:red">FNL/poly</span>: Nonuniform [[#fnl|FNL]] ===== Has the same relation to [[#fnl|FNL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contained in [[#sharplpoly|#L/poly]] [[zooref#ra00|[RA00]]]. ---- ===== <span id="fnp" style="color:red">FNP</span>: Function [[#np|NP]] ===== The class of function problems of the following form: <ul> Given an input x and a polynomial-time predicate F(x,y), if there exists a y satisfying F(x,y) then output any such y, otherwise output 'no.' </ul> FNP generalizes [[#np|NP]], which is defined in terms of decision problems only. Actually the word "function" is misleading, since there could be many valid outputs y. That's unavoidable, since given a predicate F there's no "syntactic" criterion ensuring that y is unique. [[#fp|FP]] = FNP if and only if [[#p|P]] = [[#np|NP]]. Contains [[#tfnp|TFNP]]. A basic question about FNP problems is whether they're <i>self-reducible</i>; that is, whether they reduce to the corresponding [[#np|NP]] decision problems. Although this is true for all [[#npc|NPC]] problems, [[zooref#bg94|[BG94]]] shows that if [[#ee|EE]] does not equal [[#nee|NEE]], then there is a problem in [[#np|NP]] such that <i>no</i> corresponding FNP problem can be reduced to it. [[zooref#bg94|[BG94]]] cites Impagliazzo and Sudan as giving the same conclusion under the assumption that [[#ne|NE]] does not equal [[#cone|coNE]]. ---- ===== <span id="fo" style="color:red">FO(t(n))</span>: First-Order ===== The class of decision problems for which a "yes" answer can be expressed by a first-order logic predicate, with a block of restricted quantifiers repeated t(n) times. See [[zooref#imm98|[Imm98]]] for a full definition. FO(poly(n)) = [[#p|P]] (see [[zooref#var82|[Var82]]] for example). FO(poly(n)) is contained in [[#soe|SO-E]]. ---- ===== <span id="foll" style="color:red">FOLL</span>: First-Order loglog n ===== The class of decision problems solvable by a nonuniform family of polynomial-size, unbounded-fanin, depth O(loglog n) circuits with AND, OR, and NOT gates. Defined in [[zooref#bkl00|[BKL+00]]], where it was also shown that many problems on finite groups are in FOLL. Contains [[#ac0|AC<sup>0</sup>]], and is contained in [[#ac|AC]]<sup>1</sup>. Is not known to be comparable to [[#l/poly|L/poly]] or [[#nl/poly|NL/poly]]. ---- ===== <span id="fp" style="color:red">FP</span>: Function Polynomial-Time ===== Sometimes defined as the class of functions computable in polynomial time by a Turing machine. (Generalizes [[#p|P]], which is defined in terms of decision problems only.) However, if we want to compare FP to [[#fnp|FNP]], we should instead define it as the class of [[#fnp|FNP]] problems (that is, polynomial-time predicates P(x,y)) for which there exists a polynomial-time algorithm that, given x, outputs <i>any</i> y such that P(x,y). That is, there could be more than one valid output, even though any given algorithm only returns one of them. FP = [[#fnp|FNP]] if and only if [[#p|P]] = [[#np|NP]]. If FP<sup>[[#np|NP]]</sup> = FP<sup>[[#np|NP]][log]</sup> (that is, allowed only a logarithmic number of queries), then [[#p|P]] = [[#np|NP]] [[zooref#kre88|[Kre88]]]. The corresponding result for [[#pnp|P<sup>NP</sup>]] versus [[#pnplog|P<sup>NP[log]</sup>]] is not known, and indeed fails relative to some oracles (see [[zooref#har87b|[Har87b]]]). ---- ===== <span id="fpnplog" style="color:red">FP<sup>NP[log]</sup></span>: [[#fp|FP]] With Logarithmically Many Queries To [[#np|NP]] ===== Given a graph, the problem of outputting the size of its maximum clique is complete for FP<sup>NP[log]</sup>. ---- ===== <span id="fpr" style="color:red">FPR</span>: Fixed-Parameter Randomized ===== Has the same relation to [[#fpt|FPT]] as [[#r|R]] does to [[#p|P]]. Defined in [[zooref#ar01|[AR01]]], where it was shown that, if the Resolution proof system is <i>automatizable</i> (that is, if a refutation can always be found in time polynomial in the length of the shortest refutation), then [[#wp|W[P]]] is contained in FPR. ---- ===== <span id="fpras" style="color:red">FPRAS</span>: Fully Polynomial Randomized Approximation Scheme ===== The subclass of [[#sharpp|#P]] counting problems whose answer, y, is approximable in the following sense. There exists a randomized algorithm that, with probability at least 1-&delta;, approximates y to within an &epsilon; multiplicative factor in time polynomial in n (the input size), 1/&epsilon;, and log(1/&delta;). The permanent of a nonnegative matrix is in FPRAS [[zooref#jsv01|[JSV01]]]. ---- ===== <span id="fpt" style="color:red">FPT</span>: Fixed-Parameter Tractable ===== The class of decision problems of the form (x,k), k a parameter, that are solvable in time f(k)p(|x|), where f is arbitrary and p is a polynomial. The basic class of the theory of <i>fixed-parameter tractability</i>, as described by Downey and Fellows [[zooref#df99|[DF99]]]. To separate FTP and [[#w2|W]], one could show there is no proof system for CNF formulae that admits proofs of size f(k)n<sup>O(1)</sup>, where f is a computable function and n is the size of the formula. Contained in [[#fptnu|FPT<sub>nu</sub>]], [[#w1|W]], and [[#fpr|FPR]]. Contains [[#fptas|FPTAS]] [[zooref#cc97|[CC97]]], as well as [[#fptsu|FPT<sub>su</sub>]]. Contains [[#eptas|EPTAS]] unless FPT = [[#w1|W]] [[zooref#baz95|[Baz95]]]. ---- ===== <span id="fptnu" style="color:red">FPT<sub>nu</sub></span>: Fixed-Parameter Tractable (nonuniform) ===== Same as [[#fpt|FPT]] except that the algorithm can vary with the parameter k (though its running time must always be O(p(|x|)), for a fixed polynomial p). An alternate view is that a single algorithm can take a polynomial-length advice string, depending on k. Defined in [[zooref#df99|[DF99]]] (though they did not use our notation). ---- ===== <span id="fptsu" style="color:red">FPT<sub>su</sub></span>: Fixed-Parameter Tractable (strongly uniform) ===== Same as [[#fpt|FPT]] except that f has to be recursive. Defined in [[zooref#df99|[DF99]]] (though they did not use our notation). ---- ===== <span id="fptas" style="color:red">FPTAS</span>: Fully Polynomial-Time Approximation Scheme ===== The subclass of [[#npo|NPO]] problems that admit an approximation scheme in the following sense. For any &#949;&gt;0, there is an algorithm that is guaranteed to find a solution whose cost is within a 1+&#949; factor of the optimum cost. Furthermore, the running time of the algorithm is polynomial in n (the size of the problem) and in 1/&#949;. Contained in [[#ptas|PTAS]]. Defined in [[zooref#acg99|[ACG+99]]]. Contained in [[#fpt|FPT]] [[zooref#cc97|[CC97]]]. ---- ===== <span id="fqma" style="color:red">FQMA</span>: Function [[#qma|QMA]] ===== The class of problems for which the task is to output a quantum certificate for a [[#qma|QMA]] problem, when such a certificate exists. Thus, the desired output is a quantum state. Defined in [[zooref#jwb03|[JWB03]]], where it is also shown that state preparation for 3-local Hamiltonians is FQMA-complete. The authors also observe that, in contrast to the case of [[#fnp|FNP]] versus [[#np|NP]], there is no obvious reduction of FQMA problems to [[#qma|QMA]] problems. ---- ===== <span id="frip" style="color:red">frIP</span>: Function-Restricted [[#ip|IP]] Proof Systems ===== The class of problems L that have a <i>decider</i> in the following sense. There exists a [[#bpp|BPP]] machine D such that for all inputs x, <ol> <li>If the answer is "yes" then D<sup>L</sup>(x) (D with oracle for L) accepts with probability at least 2/3.</li> <li>If the answer is "no" then D<sup>A</sup>(x) accepts with probability at most 1/3 for all oracles A.</li> </ol> Contains [[#compip|compIP]] [[zooref#bg94|[BG94]]] and [[#check|Check]] [[zooref#bk89|[BK89]]]. Contained in [[#mip|MIP]] = [[#nexp|NEXP]] [[zooref#frs88|[FRS88]]]. Assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], [[#np|NP]] (and indeed [[#np|NP]] &#8745; [[#coh|Coh]]) is not contained in [[#frip|frIP]] [[zooref#bg94|[BG94]]]. ---- ===== <span id="ftape" style="color:red">F-TAPE(f(n))</span>: Provable [[#dspace|DSPACE(f(n))]] For Formal System F ===== The class of decision problems that can be <i>proven</i> to be solvable in O(f(n)) space on a deterministic Turing machine, from the axioms of formal system F. Defined in [[zooref#har78|[Har78]]]. See also [[#ftime|F-TIME(f(n))]]. The results about F-TAPE mirror those about [[#ftime|F-TIME]], but in some cases are sharper. ---- ===== <span id="ftime" style="color:red">F-TIME(f(n))</span>: Provable [[#dtime|DTIME(f(n))]] For Formal System F ===== The class of decision problems that can be <i>proven</i> to be solvable in O(f(n)) time on a deterministic Turing machine, from the axioms of formal system F. Defined in [[zooref#har78|[Har78]]], where the following was also shown: <ul> <li>If F-TIME(f(n)) = [[#dtime|DTIME(f(n))]], then [[#dtime|DTIME(f(n))]] is strictly contained in [[#dtime|DTIME(f(n)g(n))]] for any nondecreasing, unbounded, recursive g(n).</li> <li>There exist recursive, monotonically increasing f(n) such that F-TIME(f(n)) is strictly contained in [[#dtime|DTIME(f(n))]].</li> </ul> See also [[#ftape|F-TAPE(f(n))]]. ---- ===== <span id="ga" style="color:red">GA</span>: Graph Automorphism ===== Can be defined as the class of problems polynomial-time Turing reducible to the [[Complexity_Garden#graph_automorphism|Graph Automorphism]] problem. Contains [[#p|P]] and is contained in [[#gi|GI]]. See [[zooref#kst93|[KST93]]] for much more information about GA. ---- ===== <span id="ganspace" style="color:red">GAN-SPACE(f(n))</span>: Games Against Nature f(n)-Space ===== The class of problems decidable by an O(f(n))-space Turing machine with two kinds of quantifiers: existential and randomized. Contains [[#nspace|NSPACE(f(n))]] and [[#bpspace|BPSPACE(f(n))]], and is contained in [[#aucspace|AUC-SPACE(f(n))]]. By linear programming, GAN-SPACE(log n) is contained in [[#p|P]]. ---- ===== <span id="gapac0" style="color:red">GapAC<sup>0</sup></span>: Gap [[#sharpac0|#AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to integers computable by constant-depth, polynomial-size arithmetic circuits with addition and multiplication gates and the constants 0, 1, and -1. (The only difference from [[#sharpac0|#AC<sup>0</sup>]] is the ability to subtract, using the constant -1.) Equals [[#diffac0|DiffAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="gapl" style="color:red">GapL</span>: Gap Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#gapp|GapP]] does to [[#p|P]]. ---- ===== <span id="gapp" style="color:red">GapP</span>: Gap Polynomial-Time ===== The class of functions f(x) such that for some [[#np|NP]] machine, f(x) is the number of accepting paths minus the number of rejecting paths. Equivalently, the closure of the [[#sharpp|#P]] functions under subtraction. Defined in [[zooref#ffk94|[FFK94]]] and independently [[zooref#gup95|[Gup95]]]. ---- ===== <span id="gc" style="color:red">GC(s(n),C)</span>: Guess and Check ===== The class of decision problems for which a "yes" answer can be verified by <ol> <li>guessing s(n) bits, then</li> <li>verifying the answer in complexity class C.</li> </ol> For example, GC(p(n),[[#p|P]]) = [[#np|NP]] where p is a polynomial. Defined in [[zooref#cc93|[CC93]]]. Umans [[zooref#uma98|[Uma98]]] has shown that given a DNF expression &#934;, the [[Complexity_Garden#shortest_implicant|Shortest Implicant]] problem is GC(log<sup>2</sup>n, [[#conp|coNP]])-complete. ---- ===== <span id="gcsl" style="color:red">GCSL</span>: Growing [[#csl|CSL]] ===== The class of languages generated by context-sensitive grammars in which the right-hand side of each transformation is strictly longer than the left-hand side. Defined in [[zooref#dw86|[DW86]]]. ---- ===== <span id="gi" style="color:red">GI</span>: Graph Isomorphism ===== Can be defined as the class of problems polynomial-time Turing reducible to the [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] problem. Contains [[#ga|GA]] and is contained in [[#delta2p|&#916;<sub>2</sub>P]]. The [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] <i>problem</i> itself (as opposed to the set of problems Turing reducible to [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]]) is contained in [[#np|NP]] as well as [[#coam|coAM]] (and indeed [[#szk|SZK]]). So in particular, if [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] is [[#np|NP]]-complete, then [[#ph|PH]] collapses. See [[zooref#kst93|[KST93]]] for much more information about GI. ---- ===== <span id="glo" style="color:red">GLO</span>: Guaranteed Local Optima ===== The class of [[#npo|NPO]] problems which have the property that for all locally optimal solutions, the ratio between the values of the local and global optima is upper-bounded by a constant. Defined in [[zooref#ap95|[AP95]]], where it was also shown that GLO is strictly contained in [[#apx|APX]]. [[zooref#kms99|[KMS+99]]] showed that [[#maxsnp|MaxSNP]] is not contained in GLO. ---- ===== <span id="gpcd" style="color:red">GPCD(r(n),q(n))</span>: Generalized Probabilistically Checkable Debate ===== Same as [[#pcd|PCD]](r(n),q(n)), except that now the verifier is allowed nonadaptively to query O(q(n)) <i>rounds</i> of the debate, with no restriction on the number of bits it looks at within each round. Defined in [[zooref#cfl93|[CFL+93]]], who also showed that [[#pcd|PCD]](log n, q(n)) = GPCD(log n, q(n)) for every q(n). ---- ===== <span id="gt" style="color:red">G[t]</span>: Stratification of Fixed-Parameter Tractable Problems ===== (Basically) the class of decision problems of the form (x,k) (k a parameter), that are solvable by a parameterized family of circuits with unbounded fanin and depth t. A uniformity condition may also be imposed. Defined in [[zooref#df99|[DF99]]], which should be consulted for the full definition. Uniform G[P] (i.e. with no restriction on depth) is equal to [[#fpt|FPT]]. ---- ===== <span id="halfp" style="color:red">HalfP</span>: RP With Exactly Half Acceptance ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' exactly 1/2 of computation paths accept.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> Significantly, the number of candidate witnesses is restricted to be a power of 2. (This is implicit if they are binary strings.) Contained in [[#rp|RP]], [[#ep|EP]], and [[#modkp|Mod<sub>k</sub>P]] for every odd k. Contained in [[#eqp|EQP]] by the Deutsch-Jozsa algorithm. Defined in [[zooref#bb92|[BB92]]], where it was called C<sub>==</sub>P[half]. The name used here is from [[zooref#BS00|[BS00]]]. There it was shown that HalfP is contained in every similar class in which 1/2 is replaced by some other dyadic fraction. ---- ===== <span id="heurbpp" style="color:red">HeurBPP</span>: Heuristic [[#bpp|BPP]] ===== The class of problems for which a 1-1/poly(n) fraction of instances are solvable by a [[#bpp|BPP]] machine. [[zooref#fs04|[FS04]]] showed a strict hierarchy theorem for HeurBPP; thus, HeurBPP does not equal [[#heurbptime|HeurBPTIME]](n<sup>c</sup>) for any fixed c. ---- ===== <span id="heurbptime" style="color:red">HeurBPTIME(f(n))</span>: Heuristic [[#bptime|BPTIME]](f(n)) ===== The class of problems for which a 1-1/poly(n) fraction of instances are solvable by a [[#bptime|BPTIME]](f(n)) machine. Thus [[#heurbpp|HeurBPP]] is the union of HeurBPTIME(n<sup>c</sup>) over all c. ---- ===== <span id="hkp" style="color:red">H<sub>k</sub>P</span>: High Hierarchy In [[#np|NP]] ===== The class of problems A in [[#np|NP]] such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> = [[#ph|&#931;<sub>k+1</sub>P]]; that is, adding A as an oracle increases the power of the k<sup>th</sup> level of the polynomial hierarchy by a maximum amount. For all k, H<sub>k</sub> is contained in H<sub>k+1</sub>. Defined in [[zooref#sch83|[Sch83]]]. See also [[#lkp|L<sub>k</sub>P]]. ---- ===== <span id="hvszk" style="color:red">HVSZK</span>: Honest-Verifier [[#szk|SZK]] ===== The class of decision problems that have [[#szk|SZK]] protocols assuming an honest verifier (i.e. one who doesn't try to learn more about the problem by deviating from the protocol). Equals [[#szk|SZK]] [[zooref#oka96|[Oka96]]]. ---- ===== <span id="iclogpoly" style="color:red">IC[log,poly]</span>: Logarithmic Instance Complexity, Polynomial Time ===== The class of decision problems such that, for every n-bit string x, there exists a program A of size O(log n) that, given x as input, "correctly decides" the answer on x in time polynomial in n. This means: <ul> <li>There exists a polynomial p such that for any input y, A returns either "yes", "no", or "I don't know" in time p(|y|).</li> <li>Whenever A returns "yes" or "no", it is correct.</li> <li>A returns either "yes" or "no" on x.</li> </ul> Defined in [[zooref#oks94|[OKS+94]]]; see also [[zooref#lv97|[LV97]]]. If [[#np|NP]] is contained in IC[log,poly], then [[#p|P]] = [[#np|NP]] [[zooref#oks94|[OKS+94]]]. Indeed, any self-reducible problem in IC[log,poly] is also in [[#p|P]]. Strictly contains [[#plog|P/log]], and is strictly contained in [[#ppoly|P/poly]]. ---- ===== <span id="ip" style="color:red">IP</span>: Interactive Proof ===== The class of decision problems for which a "yes" answer can be verified by an <i>interactive proof</i>. Here a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier sends messages back and forth with an all-powerful prover. They can have polynomially many rounds of interaction. Given the verifier's algorithm, at the end: <ol> <li>If the answer is "yes," the prover must be able to behave in such a way that the verifier accepts with probability at least 2/3 (over the choice of the verifier's random bits).</li> <li>If the answer is "no," then however the prover behaves the verifier must reject with probability at least 2/3.</li> </ol> IP contains [[#ph|PH]] [[zooref#lfk90|[LFK+90]]], and indeed (this was discovered only a few days later) equals [[#pspace|PSPACE]] [[zooref#sha90|[Sha90]]]. On the other hand, [[#conp|coNP]] is not contained in IP relative to a random oracle [[zooref#ccg94|[CCG+94]]]. See also: [[#mip|MIP]], [[#qip|QIP]], [[#ma|MA]], [[#am|AM]]. ---- ===== <span id="ipp" style="color:red">IPP</span>: Unbounded [[#ip|IP]] ===== Same as [[#ip|IP]], except that if the answer is "yes," there need only be a prover strategy that causes the verifier to accept with probability greater than 1/2, while if the answer is "no," then for all prover strategies the verifier accepts with probability less than 1/2. Defined in [[zooref#ccg94|[CCG+94]]], where it was also shown that IPP = [[#pspace|PSPACE]] relative to <i>all</i> oracles. Since [[#ip|IP]] is strictly contained in [[#pspace|PSPACE]] relative to a random oracle, the authors interpreted this as evidence against the Random Oracle Hypothesis (a slight change in definition can cause the behavior of a class relative to a random oracle to change drastically). See also: [[#ppspace|PPSPACE]]. ---- ===== <span id="ippolylog" style="color:red">IP[polylog]</span>: Alternate Name for [[#ampolylog|AM[polylog]]] ===== ---- ===== <span id="l" style="color:red">L</span>: Logarithmic Space ===== The class of decision problems solvable by a Turing machine restricted to use an amount of memory logarithmic in the size of the input, n. (The input itself is not counted as part of the memory.) L contains [[#nc1|NC<sup>1</sup>]] [[zooref#bor77|[Bor77]]], and is contained in generalizations including [[#nl|NL]], [[#l/poly|L/poly]], [[#sl|SL]], [[#rl|RL]], [[#parityl|&#8853;L]], and [[#modkl|Mod<sub>k</sub>L]]. Reingold [[zooref#rei04|[Rei04]]] showed that, remarkably, L = [[#sl|SL]]. In other words, undirected graph connectivity is solvable in deterministic logarithmic space. ---- ===== <span id="lin" style="color:red">LIN</span>: Linear Time ===== The class of decision problems solvable by a deterministic Turing machine in linear time. Contained in [[#nlin|NLIN]]. ---- ===== <span id="lkp" style="color:red">L<sub>k</sub>P</span>: Low Hierarchy In [[#np|NP]] ===== The class of problems A such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> = [[#ph|&#931;<sub>k</sub>P]]; that is, adding A as an oracle does not increase the power of the k<sup>th</sup> level of the polynomial hierarchy. L<sub>1</sub>P = [[#npiconp|NP &#8745; coNP]]. For all k, L<sub>k</sub> is contained in L<sub>k+1</sub> and in [[#np|NP]]. Defined in [[zooref#sch83|[Sch83]]]. See also [[#hkp|H<sub>k</sub>P]]. ---- ===== <span id="logcfl" style="color:red">LOGCFL</span>: Logarithmically Reducible to CFL ===== The class of decision problems reducible in [[#l|L]] to the problem of deciding membership in a context-free language. Equivalently, LOGCFL is the class of decision problems solvable by a uniform family of [[#ac1|AC<sup>1</sup>]] circuits, in which no AND gate has fan-in exceeding 2 (see e.g. [[zooref#joh90|[Joh90]]], p. 137). LOGCFL is closed under complement [[zooref#bcd89|[BCD+89]]]. Contains [[#nl|NL]] [[zooref#sud78|[Sud78]]]. ---- ===== <span id="logfew" style="color:red">LogFew</span>: Logspace-Bounded [[#few|Few]] ===== The class of decision problems solvable by an [[#nl|NL]] machine such that <ol> <li>The number of accepting paths on input x is f(x), and</li> <li>The answer is 'yes' if and only if R(x,f(x))=1, where R is some predicate computable in [[#l|L]].</li> </ol> Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that LogFew is contained in [[#modkl|Mod<sub>k</sub>L]] for all k>1. ---- ===== <span id="logfewnl" style="color:red">LogFewNL</span>: Logspace-Bounded [[#fewp|FewP]] ===== Same as [[#fewp|FewP]] but for logspace-bounded (i.e. [[#nl|NL]]) machines. Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that LogFewNL is contained in [[#modzkl|ModZ<sub>k</sub>L]] for all k>1. ---- ===== <span id="lognp" style="color:red">LOGNP</span>: Logarithmically-Restricted [[#np|NP]] ===== The class of decision problems expressible in logical form as <ul> The set of I for which there exists a subset S={s<sub>1</sub>,...,s<sub>log n</sub>} of {1,...,n} of size log n, such that for all x there exists y such that for all j, the predicate &phi;(I,s<sub>j</sub>,x,y,j) holds. Here x and y are logarithmic-length strings, or equivalently polynomially bounded numbers, and &phi; is computable in [[#p|P]]. </ul> LOGNP<sub>0</sub> is the subclass in which &phi; is a first-order predicate without quantifiers and x and y are bounded lists of indices of input bits. LOGNP is also the closure of LOGNP<sub>0</sub> under many-one reduction. The motivation is that the analogue of LOGNP<sub>0</sub> without the logarithmic bound on |S| is [[#soe|SO-E]], which by Fagin's theorem equals [[#np|NP]] [[zooref#fag74|[Fag74]]]. Defined in [[zooref#py96|[PY96]]], where it was also shown that the following problem is complete for LOGNP under many-one reductions: <ul> <i>Vapnik-Chervonenkis (V-C) Dimension.</i> Given a family F of subsets of a set U, find a subset of S of U of maximum cardinality, such that every subset of S can be written as the intersection of S with some set in F. </ul> Contains [[#logsnp|LOGSNP]], and is contained in [[#betap|&#946;P]] (indeed &#946;<sub>2</sub>P). ---- ===== <span id="logsnp" style="color:red">LOGSNP</span>: Logarithmically-Restricted [[#snp|SNP]] ===== The class of decision problems expressible in logical form as <ul> The set of I for which there exists a subset S={s<sub>1</sub>,...,s<sub>log n</sub>} of {1,...,n} of size log n, such that for all x there exists j such that the predicate &phi;(I,s<sub>j</sub>,x,j) holds. Here x and y are logarithmic-length strings, or equivalently polynomially bounded numbers, and &phi; is computable in [[#p|P]]. </ul> LOGSNP<sub>0</sub> is the subclass in which &phi; is a first-order predicate without quantifiers and x is a bounded lists of indices of input bits. LOGSNP is also the closure of LOGSNP<sub>0</sub> under many-one reduction. See [[#lognp|LOGNP]] and [[#snp|SNP]] for the motivation. Defined in [[zooref#py96|[PY96]]]. Contained in [[#lognp|LOGNP]], and therefore [[#qplin|QPLIN]]. If [[#p|P]] = LOGSNP, then for every constructible f(n) &gt; n, [[#ntime|NTIME]](f(n)) is contained in [[#dtime|DTIME]](g(n)<sup>sqrt(g(n))</sup>), where g(n) = O(f(n) logf(n)) [[zooref#fk97|[FK97]]]. ---- ===== <span id="l/poly" style="color:red">L/poly</span>: Nonuniform Logarithmic Space ===== Has the same relation to [[#l|L]] as [[#ppoly|P/poly]] does to [[#p|P]]. Equals [[#pbp|PBP]] [[zooref#cob66|[Cob66]]]. Contains [[#sl|SL]] [[zooref#akl79|[AKL+79]]]. ---- ===== <span id="lwpp" style="color:red">LWPP</span>: Length-Dependent Wide [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then the difference of these numbers equals a function f(|x|) computable in polynomial time (i.e. [[#fp|FP]]). Here |x| is the length of the input x, and polynomial time'' means polynomial in |x|, the length of x, rather than the length of |x|.</li> </ol> Defined in [[zooref#ffk94|[FFK94]]], where it was also shown that LWPP is low for [[#pp|PP]] and [[#cequalsp|C<sub>=</sub>P]]. (I.e. adding LWPP as an oracle does not increase the power of these classes.) Contained in [[#wpp|WPP]] and [[#awpp|AWPP]]. Contains [[#spp|SPP]]. Also, contains the [[Complexity_Garden#graph_isomorphism|graph isomorphism]] problem [[zooref#kst92|[KST92]]]. Contains a whole litter of problems for solvable black-box groups: group intersection, group factorization, coset intersection, and double-coset membership [[zooref#vin04|[Vin04]]] ---- ===== <span id="ma" style="color:red">MA</span>: Merlin-Arthur ===== The class of decision problems solvable by a <i>Merlin-Arthur protocol</i>, which goes as follows. Merlin, who has unbounded computational resources, sends Arthur a polynomial-size purported proof that the answer to the problem is "yes." Arthur must verify the proof in [[#bpp|BPP]] (i.e. probabilistic polynomial-time), so that <ol> <li>If the answer is "yes," then there exists a proof such that Arthur accepts with probability at least 2/3.</li> <li>If the answer is "no," then for all proofs Arthur accepts with probability at most 1/3.</li> </ol> An alternative definition requires that if the answer is "yes," then there exists a proof such that Arthur accepts with certainty. However, the definitions with one-sided and two-sided error can be shown to be equivalent (exercise for the Zoo visitor). Contains [[#np|NP]] and [[#existsbpp|&#8707;BPP]], and is contained in [[#am|AM]] and in [[#qma|QMA]]. Also contained in [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]]. There exists an oracle relative to which [[#bqp|BQP]] is not in [[#ma|MA]] [[zooref#wat00|[Wat00]]]. Equals [[#np|NP]] under a derandomization assumption. See also: [[#mae|MA<sub>E</sub>]], [[#maexp|MA<sub>EXP</sub>]]. ---- ===== <span id="maprime" style="color:red">MA'</span>: Sparse [[#ma|MA]] ===== The subclass of [[#ma|MA]] such that for each input size n, there is a sparse set S<sub>n</sub> that Merlin's proof string always belongs to (no matter what the input is). Defined in [[zooref#kst93|[KST93]]], where it is also observed that if [[Complexity_Garden#graph_isomorphism|graph isomorphism]] is in [[#ppoly|P/poly]], then the complement of [[Complexity_Garden#graph_isomorphism|graph isomorphism]] is in MA'. ---- ===== <span id="mac0" style="color:red">MAC<sup>0</sup></span>: Majority of [[#ac0|AC<sup>0</sup>]] ===== Same as [[#ac0|AC<sup>0</sup>]], except now we're allowed a single unbounded-fanin majority gate at the root. Defined in [[zooref#jks02|[JKS02]]]. MAC<sup>0</sup> is strictly contained in [[#tc0|TC<sup>0</sup>]] [[zooref#abf94|[ABF+94]]]. ---- ===== <span id="mae" style="color:red">MA<sub>E</sub></span>: Exponential-Time [[#ma|MA]] With Linear Exponent ===== Same as [[#ma|MA]], except now Arthur is [[#e|E]] instead of polynomial-time. If MA<sub>E</sub> = [[#nee|NEE]] then [[#ma|MA]] = [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="maexp" style="color:red">MA<sub>EXP</sub></span>: Exponential-Time [[#ma|MA]] ===== Same as [[#ma|MA]], except now Arthur is [[#exp|EXP]] instead of polynomial-time, and the message from Merlin can be exponentially long. There is a problem in MA<sub>EXP</sub> that does not have polynomial-size circuits [[zooref#bft98|[BFT98]]]. On the other hand, there is an oracle relative to which every problem in MA<sub>EXP</sub> does have polynomial-size circuits. [[zooref#mvw99|[MVW99]]] considered the best circuit lower bound obtainable for a problem in MA<sub>EXP</sub>, using current techniques. They found that this bound is <i>half-exponential</i>: i.e. a function f such that f(f(n))=2<sup>n</sup>. Such functions exist, but are not expressible using standard asymptotic notation. ---- ===== <span id="mal" style="color:red">mAL</span>: Monotone [[#al|AL]] ===== Defined in [[zooref#gs90|[GS90]]]. Equals [[#mp|mP]] by definition. ---- ===== <span id="maxnp" style="color:red">MaxNP</span>: Maximization [[#np|NP]] ===== Has the same relation to [[#np|NP]] as [[#maxsnp|MaxSNP]] does to [[#snp|SNP]]. Contains [[#maxpb|MaxPB]]. The closure of MaxNP under [[#ptas|PTAS]] reduction is [[#apx|APX]] [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. ---- ===== <span id="maxpb" style="color:red">MaxPB</span>: [[#maxnp|MaxNP]] Polynomially Bounded ===== The subclass of [[#maxnp|MaxNP]] problems for which the cost function is guaranteed always to be bounded by a polynomial. [[#minpb|MinPB]] can be defined similarly. Defined in [[zooref#kt94|[KT94]]]. The closure of MaxPB under [[#ptas|PTAS]] reductions equals [[#npopb|NPOPB]] [[zooref#cks99|[CKS+99]]]. ---- ===== <span id="maxsnp" style="color:red">MaxSNP</span>: Maximization [[#snp|SNP]] ===== The class of optimization problems reducible by an "L-reduction" to a problem in [[#maxsnp0|MaxSNP<sub>0</sub>]]. (<i>Note:</i> 'L' stands for linear -- this is <i>not</i> the same as an [[#l|L]] reduction! For more details see [[zooref#py88|[PY88]]].) Defined in [[zooref#py88|[PY88]]], where the following was also shown: <ul> <li>Max3SAT is MaxSNP-complete. (Max3SAT is the problem of finding an assignment that maximizes the number of satisfied clauses in a CNF formula with at most 3 literals per clause.)</li> <li>Any problem in MaxSNP can be approximated to within a fixed ratio.</li> </ul> The closure of MaxSNP under [[#ptas|PTAS]] reduction is [[#apx|APX]] [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. ---- ===== <span id="maxsnp0" style="color:red">MaxSNP<sub>0</sub></span>: Generating Class of MaxSNP ===== The class of function problems expressible as "find a relation such that the set of k-tuples for which a given [[#snp|SNP]] predicate holds has maximum cardinality." For example (see [[zooref#pap94|[Pap94]]]), the Max-Cut problem can be expressed as follows: <ul> Given a graph G, find a subset S of vertices that maximizes the number of pairs (u,v) of vertices such that u is in S, and v is not in S, and G has an edge from u to v. </ul> Defined in [[zooref#py88|[PY88]]]. ---- ===== <span id="mconl" style="color:red">mcoNL</span>: Complement of [[#mnl|mNL]] ===== Defined in [[zooref#gs90|[GS90]]], where it was also shown that mcoNL does not equal [[#mnl|mNL]]. See also: [[#ml|mL]]. ---- ===== <span id="minpb" style="color:red">MinPB</span>: MinNP Polynomially Bounded ===== Same as [[#maxpb|MaxPB]] but for minimization instead of maximization problems. ---- ===== <span id="mip" style="color:red">MIP</span>: Multi-Prover Interactive Proof ===== Same as [[#ip|IP]], except that now the verifier can exchange messages with many provers, not just one. The provers cannot communicate with each other during the execution of the protocol, so the verifier can "cross-check" their assertions (as with suspects in separate interrogation rooms). Defined in [[zooref#bgk88|[BGK+88]]]. Let MIP[k] be the class of decision problems for which a "yes" answer can be verified with k provers. Then for all k&gt;2, MIP[k] = MIP = MIP [[zooref#bgk88|[BGK+88]]]. MIP equals [[#nexp|NEXP]] [[zooref#bfl91|[BFL91]]]; this is a famous non-relativizing result. ---- ===== <span id="mipstar21" style="color:red">MIP*[2,1]</span>: 2-Prover, 1-Round [[#mip|MIP]] With Quantum Provers ===== Same as [[#mip|MIP]], except that now only one round is allowed, and the two provers can share arbitrarily many entangled qubits. The verifier is classical, as are all messages between the provers and verifier. Defined in [[zooref#cht04|[CHT+04]]], where evidence was given suggesting that MIP* does not "obviously" equal [[#nexp|NEXP]]. By contrast, MIP[2,1], the corresponding class without entanglement, equals [[#nexp|NEXP]]. Indeed, the relationship between MIP* and [[#mip|MIP]] = [[#nexp|NEXP]] is completely unknown -- either could contain the other, or they could be incomparable. It is also unknown whether increasing the number of provers or rounds changes MIP*[2,1]. Contains [[#xormipstar21|XOR-MIP*[2,1]]]. ---- ===== <span id="mipexp" style="color:red">MIP<sub>EXP</sub></span>: Exponential-Time Multi-Prover Interactive Proof ===== The exponential-time analogue of [[#mip|MIP]]. In the unrelativized world, equals [[#neexp|NEEXP]]. There exists an oracle relative to which MIP<sub>EXP</sub> equals the intersection of [[#ppoly|P/poly]], [[#pnp|P<sup>NP</sup>]], and [[#parityp|&#8853;P]] [[zooref#bft98|[BFT98]]]. ---- ===== <span id="mkp" style="color:red">(M<sub>k</sub>)P</span>: Acceptance Mechanism by Monoid M<sub>k</sub> ===== A <i>monoid</i> is a set with an associative operation and an identity element (so it's like a group, except that it need not have inverses). Then (M<sub>k</sub>)P is the class of decision problems solvable by an [[#np|NP]] machine with the following acceptance mechanism. The i<sup>th</sup> computation path (under some lexicographic ordering) outputs an element m<sub>i</sub> of M<sub>k</sub>. Then the machine accepts if and only if m<sub>1</sub>m<sub>2</sub>...m<sub>s</sub> is the identity (where s is the number of paths). Defined by Hertrampf [[zooref#her97|[Her97]]], who also showed the following (in the special case M is a group): <ul> <li>If G is any nonsolvable group (for example S<sub>5</sub>, the symmetric group on 5 elements), then (G)P = [[#pspace|PSPACE]].</li> <li>(Z<sub>k</sub>)P = [[#comodkp|coMod<sub>k</sub>P]], where Z<sub>k</sub> is the cyclic group on k elements.</li> <li>If |G|=k, then (G)P contains [[#comodkp|coMod<sub>k</sub>P]].</li> </ul> ---- ===== <span id="ml" style="color:red">mL</span>: Monotone [[#l|L]] ===== The class of decision problems solvable by a family of monotone log-width polynomial-size leveled circuits. (A <i>leveled</i> circuit is one where gates on each level can depend only on the level immediately below it.) Defined in [[zooref#gs90|[GS90]]], who raise as an open problem to define a uniform version of mL. Strictly contains [[#mnc1|mNC<sup>1</sup>]] [[zooref#gs91|[GS91]]]. Contained in (nonuniform versions of) [[#mnl|mNL]] and [[#mconl|mcoNL]]. ---- ===== <span id="mmsnp" style="color:red">MMSNP</span>: Monadic Monotone [[#snp|SNP]] ===== Defined in [[zooref#fv93|[FV93]]] as a subclass of [[#snp|SNP]], where the second order existentially quantified variables are sets (monadic) and any relations in the first-order part occur negated (monotone). Further, no inequalities can occur in the first-order part. MMSNP seems to obey dichotomy, by excluding Ladner languages. This is still open but widely believed. Dropping any of the restrictions monotone/monadic/without inequalities allows Ladner languages unless P = NP, since any problem in NP is polynomial time equivalent to a problem in each of these broader classes. MMSNP therefore seems to be a maximal fragment of NP where Ladner languages are excluded. Every constraint satisfaction problem is expressible in MMSNP, and there is a polynomial time Turing reduction from every MMSNP query to finitely many constraint satisfaction problems. MMSNP therefore seems to capture the class of constraint satisfaction problems. ---- ===== <span id="mnc1" style="color:red">mNC<sup>1</sup></span>: Monotone [[#nc1|NC<sup>1</sup>]] ===== The class of decision problems solvable by a family of monotone [[#nc1|NC<sup>1</sup>]] circuits (i.e. AND and OR gates only). A uniformity condition could also be imposed. Defined in [[zooref#gs90|[GS90]]]. Strictly contained in [[#mnl|mNL]] [[zooref#kw88|[KW88]]], and indeed in [[#ml|mL]] [[zooref#gs91|[GS91]]]. Strictly contains [[#mtc0|mTC<sup>0</sup>]] [[zooref#yao89|[Yao89]]]. ---- ===== <span id="mnl" style="color:red">mNL</span>: Monotone [[#nl|NL]] ===== See [[#mp|mP]] for the definition of a monotone nondeterministic Turing machine, due to [[zooref#gs90|[GS90]]]. mNL is the class of decision problems solvable by a monotone nondeterministic log-space Turing machine. mNL does not equal [[#mconl|mcoNL]] [[zooref#gs90|[GS90]]], in contrast to the case for [[#nl|NL]] and [[#conl|coNL]]. Also, mNL strictly contains [[#mnc1|mNC<sup>1</sup>]] [[zooref#kw88|[KW88]]]. See also: [[#ml|mL]]. ---- ===== <span id="mnp" style="color:red">mNP</span>: Monotone [[#np|NP]] ===== The class of decision problems for which a 'yes' answer can be verified in [[#mp|mP]] (that is, monotone polynomial-time). The monotonicity requirement applies only to the input bits, not to the bits that are guessed nondeterministically. So, in the corresponding circuit, one can have NOT gates so long as they depend only on the nondeterministic guess bits. Defined in [[zooref#gs90|[GS90]]], where it was also shown that mNP is 'trivial': that is, it contains exactly the monotone problems in [[#np|NP]]. Strictly contains [[#mp|mP]] [[zooref#raz85|[Raz85]]]. ---- ===== <span id="modkl" style="color:red">Mod<sub>k</sub>L</span>: Mod-k [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#modkp|Mod<sub>k</sub>P]] does to [[#p|P]]. For any prime k, Mod<sub>k</sub>L contains [[#sl|SL]] [[zooref#kw93|[KW93]]]. For any prime k, Mod<sub>k</sub>L<sup>ModkL</sup> = Mod<sub>k</sub>L [[zooref#hrv00|[HRV00]]]. For any k>1, contains [[#logfew|LogFew]] [[zooref#bdh92|[BDH+92]]]. ---- ===== <span id="modkp" style="color:red">Mod<sub>k</sub>P</span>: Mod-k Polynomial-Time ===== For any k&gt;1: The class of decision problems solvable by an [[#np|NP]] machine such that the number of accepting paths is divisible by k, if and only if the answer is "no." Mod<sub>2</sub>P is more commonly known as [[#parityp|&#8853;P]] "parity-P." For every k, Mod<sub>k</sub>P contains [[Complexity_Garden#graph_isomorphism|graph isomorphism]] [[zooref#ak02|[AK02]]]. Defined in [[zooref#ch89|[CH89]]], [[zooref#her90|[Her90]]]. [[zooref#her90|[Her90]]] and [[zooref#bg92|[BG92]]] showed that Mod<sub>k</sub>P is the set of unions of languages in Mod<sub>p</sub>P for each prime p that divides k. In particular, if p is prime, then Mod<sub>p</sub>P = Mod<sub>p^m</sub>P for all positive integers m. A further fact is that Mod<sub>p</sub>P is closed under union, intersection, and complement for p prime. On the other hand, if k is not a prime power, then there exists an oracle relative to which Mod<sub>k</sub>P is not closed under intersection or complement [[zooref#bbr94|[BBR94]]]. For prime p, there exists an oracle relative to which Mod<sub>p</sub>P does not contain [[#eqp|EQP]] [[zooref#gv02|[GV02]]]. ---- ===== <span id="modp" style="color:red">ModP</span>: [[#modkp|Mod<sub>k</sub>P]] With Arbitrary k ===== The class of decision problems solvable by a [[#modkp|Mod<sub>k</sub>P]] machine where k can vary depending on the input. The only requirement is that 0<sup>k</sup> be computable in polynomial time. Defined in [[zooref#kt96|[KT96]]], where it was also shown that ModP is contained in [[#ampmp|AmpMP]]. ---- ===== <span id="modzkl" style="color:red">ModZ<sub>k</sub>L</span>: Restricted [[#modkl|Mod<sub>k</sub>L]] ===== The class of decision problems solvable by a nondeterministic logspace Turing machine, such that <ol> <li>If the answer is "yes," then the number of accepting paths is not congruent to 0 mod k.</li> <li>If the answer is "no," then there are no accepting paths.</li> </ol> Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that ModZ<sub>k</sub>L contains [[#logfewnl|LogFewNL]] for all k>1. Contained in [[#modkl|Mod<sub>k</sub>L]] and in [[#nl|NL]]. ---- ===== <span id="mp" style="color:red">mP</span>: Monotone [[#p|P]] ===== The definition of this class, due to [[zooref#gs90|[GS90]]], is not obvious. First, a <i>monotone nondeterministic Turing machine</i> is one such that, whenever it can make a transition with a 0 on its input tape, it can also make that same transition with a 1 on its input tape. (This restriction does not apply to the work tape.) A <i>monotone alternating Turing machine</i> is subject to the restriction that it can only reference an input bit x by, "there exists a z at most x," or "for all z at least x." Then applying the result of [[zooref#cks81|[CKS81]]] that [[#p|P]] = [[#al|AL]], mP is defined to be [[#mal|mAL]]: the class of decision problems solvable by a monotone alternating log-space Turing machine. Actually there's a caveat: A monotone Turing machine or circuit can first negate the <i>entire</i> input, then perform a monotone computation. That way it becomes meaningful to talk about whether a monotone complexity class is closed under complement. Strictly contained in [[#mnp|mNP]] [[zooref#raz85|[Raz85]]]. Deciding whether a bipartite graph has a perfect matching, despite being both a monotone problem and in [[#p|P]], requires monotone circuits of superpolynomial size [[zooref#raz85b|[Raz85b]]]. Letting MONO be the class of monotone problems, it follows that mP is strictly contained in MONO &#8745; [[#p|P]]. See also: [[#mnc1|mNC<sup>1</sup>]], [[#ml|mL]], [[#mnl|mNL]], [[#mconl|mcoNL]]. ---- ===== <span id="mp2" style="color:red">MP</span>: Middle-Bit [[#p|P]] ===== The class of decision problems such that for some [[#sharpp|#P]] function f, the answer on input x is 'yes' if and only if the middle bit of f(x) is 1. Defined in [[zooref#gkr95|[GKR+95]]]. Contains [[#ampmp|AmpMP]] and [[#ph|PH]]. MP with [[#modp|ModP]] oracle equals MP with [[#sharpp|#P]] oracle [[zooref#kt96|[KT96]]]. ---- ===== <span id="mpc" style="color:red">MPC</span>: Monotone Planar Circuits ===== The class of decision problems solvable by a family of <i>monotone stratified planar circuits</i> (a uniformity condition may also be imposed). Such a circuit can contain only AND and OR gates of bounded fanin. It must be embeddable in the plane with no wires crossing. Furthermore, the input bits can only be accessed at the bottom level, where they are listed in order (x<sub>1</sub>,...,x<sub>n</sub>). Defined in [[zooref#dc89|[DC89]]]. [[zooref#blm99|[BLM+99]]] showed that we can assume without loss of generality that the circuit has width n and depth n<sup>3</sup>. ---- ===== <span id="mppoly" style="color:red">mP/poly</span>: Monotone [[#ppoly|P/poly]] ===== The class of decision problems solvable by a nonuniform family of polynomial-size Boolean circuits with only AND and OR gates, no NOT gates. (Or rather, following the definitions of [[zooref#gs90|[GS90]]], the entire input can be negated as long as there are no other negations.) More straightforward to define than [[#mp|mP]]. ---- ===== <span id="mtc0" style="color:red">mTC<sup>0</sup></span>: Monotone [[#tc0|TC<sup>0</sup>]] ===== The class of decision problems solvable by a family of monotone [[#tc0|TC<sup>0</sup>]] circuits (i.e. constant-depth, polynomial-size, AND, OR, and threshold gates, but no NOT gates). A uniformity condition could also be imposed. Defined in [[zooref#gs90|[GS90]]]. Strictly contained in [[#mnc1|mNC<sup>1</sup>]] [[zooref#yao89|[Yao89]]]. ---- ===== <span id="nauxpdap" style="color:red">NAuxPDA<sup>p</sup></span>: Nondeterministic Auxiliary Pushdown Automata ===== The class of problems solvable by nondeterministic logarithmic-space and polynomial-time Turing machines with auxiliary pushdown. Equals [[#logcfl|LOGCFL]] [[zooref#sud78|[Sud78]]]. ---- ===== <span id="nc" style="color:red">NC</span>: Nick's Class ===== (Named in honor of Nick Pippenger.) NC<sup>i</sup> is the class of decision problems solvable by a nonuniform family of Boolean circuits, with polynomial size, depth O(log<sup>i</sup>(n)), and fan-in 2. Then NC is the union of NC<sup>i</sup> over all nonnegative i. Also, NC equals the union of [[#ptwk|PT/WK]](log<sup>k</sup>n, n<sup>k</sup>)/poly over all constants k. NC<sup>i</sup> is contained in [[#ac|AC]]<sup>i</sup>; thus, NC = [[#ac|AC]]. Contains [[#nl|NL]]. Generalizations include [[#rnc|RNC]] and [[#qnc|QNC]]. [[zooref#in96|[IN96]]] construct a candidate pseudorandom generator in NC based on the subset sum problem. For a random oracle A, (NC<sup>i</sup>)<sup>A</sup> is strictly contained in (NC<sup>i+1</sup>)<sup>A</sup>, and uniform NC<sup>A</sup> is strictly contained in P<sup>A</sup>, with probability 1 [[zooref#mil92|[Mil92]]]. ---- ===== <span id="nc0" style="color:red">NC<sup>0</sup></span>: Level 0 of [[#nc|NC]] ===== By definition, a decision problem in NC<sup>0</sup> can depend on only a constant number of bits of the input. Thus, NC<sup>0</sup> usually refers to <i>functions</i> computable by constant-depth, bounded-fanin circuits. There is a family of permutations computable by a uniform family of NC<sup>0</sup> circuits that is [[#p|P]]-hard to invert [[zooref#has88|[Has88]]]. Recently [[zooref#aik04|[AIK04]]] solved a longstanding open problem by showing that there exist pseudorandom generators and one-way functions in NC<sup>0</sup>, based on (for example) the hardness of [[Complexity_Garden#integer_factorization|factoring]]. Specifically, in these generators every bit of the output depends on only 4 input bits. Whether the dependence can be reduced to 3 bits under the same cryptographic assumptions is open, but [[zooref#aik04|[AIK04]]] have some partial results in this direction. It is known that the dependence cannot be reduced to 2 bits. ---- ===== <span id="nc1" style="color:red">NC<sup>1</sup></span>: Level 1 of [[#nc|NC]] ===== See [[#nc|NC]] for definition. [[zooref#kv94|[KV94]]] give a family of functions that is computable in NC<sup>1</sup>, but not efficiently learnable unless there exists an efficient algorithm for factoring Blum integers. Was shown to equal 5-[[#kpbp|PBP]] [[zooref#bar89|[Bar89]]]. On the other hand, width 5 is necessary unless NC<sup>1</sup> = [[#acc0|ACC<sup>0</sup>]] [[zooref#bt88|[BT88]]]. As an application of this result, NC<sup>1</sup> can be simulated on a quantum computer with three qubits, one initialized to a pure state and the remaining two in the maximally mixed state [[zooref#asv00|[ASV00]]]. Surprisingly, [[zooref#amp02|[AMP02]]] showed that only a <i>single</i> qubit is needed to simulate NC<sup>1</sup> - i.e. that NC<sup>1</sup> is contained in 2-[[#eqbp|EQBP]]. (Complex amplitudes are needed for this result.) Is contained in [[#l|L]] [[zooref#bor77|[Bor77]]]. Contains [[#tc0|TC<sup>0</sup>]]. NC<sup>1</sup> contains the integer division problem [[zooref#bch86|[BCH86]]], even if an [[#l|L]]-uniformity condition is imposed [[zooref#cdl01|[CDL01]]]. U<sub>E<sup>*</sup></sub>-uniform NC<sup>1</sup> is equal to [[#alogtime|ALOGTIME]] [[zooref#ruz81|[RUZ81]]]. ---- ===== <span id="nc2" style="color:red">NC<sup>2</sup></span>: Level 2 of [[#nc|NC]] ===== See [[#nc|NC]] for definition. Contains [[#nl|NL]]. ---- ===== <span id="ne" style="color:red">NE</span>: Nondeterministic [[#e|E]] ===== Nondeterministic exponential time with linear exponent (i.e. [[#ntime|NTIME]](2<sup>O(n)</sup>)). [[#p|P]]<sup>NE</sup> = [[#np|NP]]<sup>NE</sup> [[zooref#hem89|[Hem89]]]. Contained in [[#nexp|NEXP]]. ---- ===== <span id="nearlyp" style="color:red">Nearly-[[#p|P]]</span>: Languages Superpolynomially Close to P ===== The set of languages L such that for every k, there is a language L_k in P that differs from L on at most 2^n/n^k inputs of length n. Discussed in [[zooref#ns05|[NS05]]] and implicitly defined in [[zooref#yam99|[Yam99]]]. ---- ===== <span id="nepoly" style="color:red">NE/poly</span>: Nonuniform [[#ne|NE]] ===== Contains [[#cone|coNE]], just as [[#nexppoly|NEXP/poly]] contains [[#conexp|coNEXP]]. ---- ===== <span id="nee" style="color:red">NEE</span>: Nondeterministic [[#ee|EE]] ===== Nondeterministic double-exponential time with linear exponent (i.e. [[#ntime|NTIME]](2<sup>2^O(n)</sup>)). If [[#mae|MA<sub>E</sub>]] = NEE then [[#ma|MA]] = [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#ikw01|[IKW01]]]. Contained in [[#neexp|NEEXP]]. ---- ===== <span id="neee" style="color:red">NEEE</span>: Nondeterministic [[#eee|EEE]] ===== Nondeterministic triple-exponential time with linear exponent. ---- ===== <span id="neexp" style="color:red">NEEXP</span>: Nondeterministic [[#eexp|EEXP]] ===== Nondeterministic double-exponential time (i.e. [[#ntime|NTIME]](2<sup>2^p(n)</sup>) for p a polynomial). Equals [[#mipexp|MIP<sub>EXP</sub>]] (unrelativized). ---- ===== <span id="nexp" style="color:red">NEXP</span>: Nondeterministic [[#exp|EXP]] ===== Nondeterministic exponential time (i.e. [[#ntime|NTIME]](2<sup>p(n)</sup>) for p a polynomial). Equals [[#mip|MIP]] [[zooref#bfl91|[BFL91]]] (but not relative to all oracles). NEXP is in [[#ppoly|P/poly]] if and only if NEXP = [[#ma|MA]] [[zooref#ikw01|[IKW01]]]. [[zooref#ki02|[KI02]]] show the following: <ul> <li>If [[#p|P]] = [[#rp|RP]], then NEXP is not computable by polynomial-size arithmetic circuits.</li> <li>If [[#p|P]] = [[#bpp|BPP]] and if checking whether a Boolean circuit computes a function that is close to a low-degree polynomial over a finite field is in [[#p|P]], then NEXP is not in [[#ppoly|P/poly]].</li> <li>If NEXP is in [[#ppoly|P/poly]], then matrix permanent is NEXP-complete.</li> </ul> Does not equal [[#np|NP]] [[zooref#sfm78|[SFM78]]]. Does not equal [[#exp|EXP]] if and only if there is a sparse set in [[#np|NP]] that is not in [[#p|P]]. There exists an oracle relative to which [[#exp|EXP]] = NEXP but still [[#p|P]] does not equal [[#np|NP]] [[zooref#dek76|[Dek76]]]. The theory of reals with addition (see [[#expspace|EXPSPACE]]) is hard for NEXP [[zooref#fr74|[FR74]]]. ---- ===== <span id="nexppoly" style="color:red">NEXP/poly</span>: Nonuniform [[#nexp|NEXP]] ===== Contains [[#conexp|coNEXP]] (folklore result reported in [[http://weblog.fortnow.com/|Fortnow's weblog]]). ---- ===== <span id="nipzk" style="color:red">NIPZK</span>: Non-Interactive [[#pzk|PZK]] ===== Defined in [[zooref#m08|[M08]]] based on [[zooref#ddp98|[DDPY98]]],[[zooref#bfm88|[BFM88]]]. Contained in [[#pzk|PZK]]. [[zooref#m08|[M08]]] showed a complete promise-problem for NIPZK, called <i>Unifrom</i> (UN). Instances in UN are circuits with n+1 output bits. The first n bits represent the uniform distribution, and the last bit is 1 with probability at least 2/3. For instances not in UN, when the last bit is 1, at most 1/3 of the strings of length n can appear as the output of the circuit. The problem is to decide which is the case. ---- ===== <span id="niqszk" style="color:red">NIQSZK</span>: Non-Interactive [[#qszk|QSZK]] ===== Has the same relation to [[#qszk|QSZK]] as [[#niszk|NISZK]] does to [[#szk|SZK]]. Defined in [[zooref#kob02|[Kob02]]], where it was also shown that the following promise problem is complete for NIQSZK. Given a quantum circuit, we are promised that the state it prepares (when run on the all-0 state, and tracing out non-output qubits) has trace distance either at most 1/3 or at least 2/3 from the maximally mixed state. The problem is to output "no" in the former case and "yes" in the latter. NIQPZK can be defined similarly. ---- ===== <span id="niszk" style="color:red">NISZK</span>: Non-Interactive [[#szk|SZK]] ===== Defined in [[zooref#ddp98|[DDP+98]]]. Contained in [[#szk|SZK]]. [[zooref#gsv99|[GSV99]]] showed the following: <ul> <li>If [[#szk|SZK]] does not equal [[#bpp|BPP]] then NISZK does not equal [[#bpp|BPP]].</li> <li>NISZK equals [[#szk|SZK]] if and only if NISZK is closed under complement.</li> <li>NISZK has natural complete promise problems:</li> <ul> <li><i>Statistical Distance from Uniform (SDU)</i>: Given a circuit, consider the distribution over outputs when the circuit is given a uniformly random n-bit string. We're promised that the trace distance between this distribution and the uniform distribution is either at most 1/3 or at least 2/3. The problem is to output "yes" in the former case and "no" in the latter.</li> <li><i>Entropy Approximation (EA)</i>: Now we're promised that the entropy of the circuit's output distribution is either at least k+1 or at most k-1. The problem is to output "yes" in the former case and "no" in the latter.</li> </ul> </ul> NIPZK can be defined similarly. ---- ===== <span id="niszkh" style="color:red">NISZK<sub>h</sub></span>: [[#niszk|NISZK]] With Limited Help ===== The non-interactive analogue of [[#szkh|SZK<sub>h</sub>]]. Defined in [[zooref#bg03|[BG03]]], where the following was also shown: <ul> <li>NISZK<sub>h</sub> contains [[#niszk|NISZK]] and is contained in [[#szk|SZK]].</li> <li>[[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] is in NISZK<sub>h</sub>.</li> <li>The following problem is complete for NISZK<sub>h</sub>: Given two functions from {0,1}<sup>n</sup> to {0,1}<sup>n</sup> (specified by circuits), decide whether their ranges are almost equal or almost disjoint, given that one of these is the case.</li> </ul> The quantum lower bound for the set comparison problem in [[zooref#aar02|[Aar02]]] implies an oracle relative to which NISZK<sub>h</sub> is not in [[#bqp|BQP]]. ---- ===== <span id="nl" style="color:red">NL</span>: Nondeterministic Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#np|NP]] does to [[#p|P]]. In a breakthrough result, was shown to equal [[#conl|coNL]] [[zooref#imm88|[Imm88]]] [[zooref#sze87|[Sze87]]]. (Though contrast to [[#mnl|mNL]].) Is contained in [[#logcfl|LOGCFL]] [[zooref#sud78|[Sud78]]], as well as [[#nc2|NC<sup>2</sup>]]. Is contained in [[#ulpoly|UL/poly]] [[zooref#ra00|[RA00]]]. Deciding whether a bipartite graph has a perfect matching is hard for NL [[zooref#kuw86|[KUW86]]]. ---- ===== <span id="nlpoly" style="color:red">NL/poly</span>: Nonuniform [[#nl|NL]] ===== Has the same relation to [[#nl|NL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Is contained in [[#paritylpoly|&#8853;L/poly]] [[zooref#gw96|[GW96]]], as well as [[#sac1|SAC<sup>1</sup>]]. Equals [[#ulpoly|UL/poly]] [[zooref#ra00|[RA00]]]. ---- ===== <span id="nlog" style="color:red">NLOG</span>: [[#nl|NL]] With Nondeterministic Oracle Tape ===== Same as [[#nl|NL]] -- but if there's an oracle, then NLOG can make queries nondeterministically on a polynomial-size, one-way oracle tape. ([[#nl|NL]], by contrast, can use nondeterministic transitions only on the worktape; oracle queries have to be deterministic.) See [[zooref#ll76|[LL76]]] or [[zooref#hck88|[HCK+88]]] for more information. Although NLOG is contained in [[#p|P]], there exists an oracle relative to which that is not the case. This illustrates that care is needed when defining oracle access mechanisms. ---- ===== <span id="nlin" style="color:red">NLIN</span>: Nondeterministic [[#lin|LIN]] ===== Has the same relation to [[#lin|LIN]] as [[#np|NP]] does to [[#p|P]]. ---- ===== <span id="none" style="color:red">NONE</span>: The Empty Class ===== The class that does not contain any languages. (It might not surprise you that I put this one in at the suggestion of a mathematician...) Is the opposite of [[#all|ALL]], but does not equal the complement [[#all|coALL]] = [[#all|ALL]]. Is closed under polynomial-time Turing reductions :-). Equals [[#sparse|SPARSE]] &#8745; [[#cosparse|coSPARSE]] and [[#tally|TALLY]] &#8745; [[#tally|coTALLY]]. ---- ===== <span id="np" style="color:red">NP</span>: Nondeterministic Polynomial-Time ===== The class of dashed hopes and idle dreams. More formally: an "NP machine" is a nondeterministic polynomial-time Turing machine. Then NP is the class of decision problems solvable by an NP machine such that <ol> <li>If the answer is "yes," at least one computation path accepts.</li> <li>If the answer is "no," all computation paths reject.</li> </ol> Equivalently, NP is the class of decision problems such that, if the answer is "yes," then there is a proof of this fact, of length polynomial in the size of the input, that can be verified in [[#p|P]] (i.e. by a deterministic polynomial-time algorithm). On the other hand, if the answer is "no," then the algorithm must declare invalid any purported proof that the answer is "yes." For example, the [[Complexity_Garden#sat|SAT]] problem is to decide whether a given Boolean formula has any satisfying truth assignments. [[Complexity_Garden#sat|SAT]] is in NP, since a "yes" answer can be proved by just exhibiting a satisfying assignment. A decision problem is NP-complete if (1) it is in NP, and (2) any problem in NP can be reduced to it (under some notion of reduction). The class of NP-complete problems is sometimes called [[#npc|NPC]]. That NP-complete problems exist is immediate from the definition. The seminal result of Cook [[zooref#coo71|[Coo71]]], Karp [[zooref#kar72|[Kar72]]], and Levin [[zooref#lev73|[Lev73]]] is that many <i>natural</i> problems (that have nothing to do with Turing machines) are NP-complete. The first such problem to be shown NP-complete was [[Complexity_Garden#sat|SAT]] [[zooref#coo71|[Coo71]]]. Other classic NP-complete problems include: <ul> <li>'''3-Colorability''': Given a graph, can each vertex be colored red, green, or blue so that no two neighboring vertices have the same color?</li> <li>'''Hamiltonian Cycle''': Given a graph, is there a cycle that visits each vertex exactly once?</li> <li>'''Traveling Salesperson''': Given a set of n cities, and the distance between each pair of cities, is there a route that visits each city exactly once before returning to the starting city, and has length at most T?</li> <li>'''Maximum Clique''': Given a graph, are there k vertices all of which are neighbors of each other?</li> <li>'''Subset Sum''': Given a collection of integers, is there a subset of the integers that sums to exactly x?</li> </ul> For many, many more NP-complete problems, see [[zooref#gj79|[GJ79]]]. NP contains [[#p|P]]. I've discovered a marvelous proof that NP and [[#p|P]] are unequal, but this web page is too small to contain it. Too bad, since otherwise I'd be eligible for $1,000,000 [[zooref#cmi00|[CMI00]]]. There exists an oracle relative to which [[#p|P]] and NP are unequal [[zooref#bgs75|[BGS75]]]. Indeed, [[#p|P]] and NP are unequal relative to a random oracle with probability 1 [[zooref#bg81|[BG81]]] (see [[zooref#afm01|[AFM01]]] for a novel take on this result). Though random oracle results are not always indicative about the unrelativized case [[zooref#ccg94|[CCG+94]]]. There even exists an oracle relative to which the [[#p|P]] versus NP problem is outside the usual axioms of set theory [[zooref#hh76|[HH76]]]. If we restrict to <i>monotone</i> classes, [[#mp|mP]] is strictly contained in [[#mnp|mNP]] [[zooref#raz85|[Raz85]]]. Perhaps the most important insight anyone has had into [[#p|P]] versus NP is to be found in [[zooref#rr97|[RR97]]]. There the authors show that no 'natural proof' can separate [[#p|P]] from NP (or more precisely, place NP outside of [[#ppoly|P/poly]]), unless secure pseudorandom generators do not exist. A proof is 'natural' if it satisfies two conditions called <i>constructivity</i> and <i>largeness</i>; essentially all lower bound techniques known to date satisfy these conditions. To obtain unnatural proof techniques, some people suspect we need to relate [[#p|P]] versus NP to heavy-duty 'traditional' mathematics, for instance algebraic geometry. See [[zooref#ms02|[MS02]]] (and the survey article [[zooref#reg02|[Reg02]]]) for a development of this point of view. For more on [[#p|P]] versus NP (circa 1992) see [[zooref#sip92|[Sip92]]]. For an opinion poll, see [[zooref#gas02|[Gas02]]]. If [[#p|P]] equals NP, then NP equals its complement [[#conp|coNP]]. Whether NP equals [[#conp|coNP]] is also open. NP and [[#conp|coNP]] can be extended to the polynomial hierarchy [[#ph|PH]]. The set of decision problems in NP, but not in [[#p|P]] or [[#npc|NPC]], is sometimes called [[#npi|NPI]]. If [[#p|P]] does not equal NP then [[#npi|NPI]] is nonempty [[zooref#lad75|[Lad75]]]. Probabilistic generalizations of NP include [[#ma|MA]] and [[#am|AM]]. If NP is in [[#coam|coAM]] (or [[#bpp|BPP]]) then [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]] [[zooref#bhz87|[BHZ87]]]. [[#ph|PH]] also collapses to [[#sigma2p|&#931;<sub>2</sub>P]] if NP is in [[#ppoly|P/poly]] [[zooref#kl82|[KL82]]]. There exist oracles relative to which NP is not in [[#bqp|BQP]] [[zooref#bbb97|[BBB+97]]]. An alternate characterization is NP = [[#pcp|PCP]](log n, O(1)) [[zooref#alm98|[ALM+98]]]. Also, [[zooref#fag74|[Fag74]]] gave a logical characterization of NP, which leads to the subclass [[#snp|SNP]]. ---- ===== <span id="npc" style="color:red">NPC</span>: [[#np|NP]]-Complete ===== The class of decision problems such that (1) they're in [[#np|NP]] and (2) every problem in [[#np|NP]] is reducible to them (under some notion of reduction). In other words, the hardest problems in [[#np|NP]]. Two notions of reduction from problem A to problem B are usually considered: <ol> <li><i>Karp</i> or <i>many-one</i> reductions. Here a polynomial-time algorithm is given as input an instance of problem A, and must produce as output an instance of problem B.</li> <li><i>Turing</i> reductions, in this context also called <i>Cook</i> reductions. Here the algorithm for problem B can make arbitrarily many calls to an oracle for problem A.</li> </ol> Some examples of NP-complete problems are discussed under the entry for [[#np|NP]]. The classic reference on NPC is [[zooref#gj79|[GJ79]]]. Unless [[#p|P]] = [[#np|NP]], NPC does not contain any sparse problems: that is, problems such that the number of 'yes' instances of size n is upper-bounded by a polynomial in n [[zooref#mah82|[Mah82]]]. A famous conjecture [[zooref#bh77|[BH77]]] asserts that all NP-complete problems are polynomial-time isomorphic -- i.e. between any two problems, there is a one-to-one and onto Karp reduction. If that's true, the NP-complete problems could be interpreted as mere "relabelings" of one another. NP-complete problems are <i>p-superterse</i> unless [[#p|P]] = [[#np|NP]] [[zooref#bks95|[BKS95]]]. This means that, given k Boolean formulas F<sub>1</sub>,...,F<sub>k</sub>, if you can rule out even <i>one</i> of the 2<sup>k</sup> possibilities in polynomial time (e.g., "if F<sub>1</sub>,...,F<sub>k-1</sub> are all unsatisfiable then F<sub>k</sub> is satisfiable"), then [[#p|P]] = [[#np|NP]]. ---- ===== <span id="npc2" style="color:red">NP<sub>C</sub></span>: [[#np|NP]] Over The Complex Numbers ===== An analog of [[#np|NP]] for Turing machines over a complex number field. Defined in [[zooref#bcs97|[BCS+97]]]. It is unknown whether [[#pc|P<sub>C</sub>]] = NP<sub>C</sub>, nor are implications known among this question, [[#pr2|P<sub>R</sub>]] versus [[#npr|NP<sub>R</sub>]], and [[#p|P]] versus [[#np|NP]]. However, [[zooref#ckk95|[CKK+95]]] show that if [[#ppoly|P/poly]] does not equal [[#nppoly|NP/poly]] then [[#pc|P<sub>C</sub>]] does not equal NP<sub>C</sub>. [[zooref#bcs97|[BCS+97]]] show the following striking result. For a positive integer n, let t(n) denote the minimum number of additions, subtractions, and multiplications needed to construct n, starting from 1. If for every sequence {n<sub>k</sub>} of positive integers, t(n<sub>k</sub> k!) grows faster than polylogarithmically in k, then [[#pc|P<sub>C</sub>]] does not equal NP<sub>C</sub>. See also [[#vnp|VNP<sub>k</sub>]]. ---- ===== <span id="npcc" style="color:red">NP<sup>cc</sup></span>: Communication Complexity [[#np|NP]] ===== The analogue of [[#pcc|P<sup>cc</sup>]] for nondeterministic communication complexity. Both communication bits and nondeterministic guess bits count toward the complexity. Does not equal [[#pcc|P<sup>cc</sup>]] or [[#conpcc|coNP<sup>cc</sup>]] because of the EQUALITY problem. Also, does not contain [[#bppcc|BPP<sup>cc</sup>]] because of that problem. Defined in [[zooref#bfs86|[BFS86]]]. Contained in [[#phcc|PH<sup>cc</sup>]]. ---- ===== <span id="npi" style="color:red">NPI</span>: [[#np|NP]]-Intermediate ===== Sometimes used to denote the set of decision problems in [[#np|NP]] that are neither NP-complete (that is, in [[#npc|NPC]]) nor in [[#p|P]]. Is thought to contain (for example) decision versions of factoring and [[Complexity_Garden#graph_isomorphism|graph isomorphism]]. Is nonempty if [[#p|P]] does not equal [[#np|NP]] [[zooref#lad75|[Lad75]]]. Indeed, under this assumption, it contains an infinite number of distinct polynomial-time equivalence classes. ---- ===== <span id="npiconp" style="color:red">NP &#8745; coNP</span> ===== The class of problems in both [[#np|NP]] and [[#conp|coNP]]. Contains [[Complexity_Garden#integer_factorization|factoring]] [[zooref#pra75|[Pra75]]]. Contains [[Complexity_Garden#graph_isomorphism|graph isomorphism]] under the assumption that some language in [[#ne|NE]] &#8745; [[#cone|coNE]] requires nondeterministic circuits of size 2<sup>&#937;(n)</sup> ([[zooref#mv99|[MV99]]], improving [[zooref#km99|[KM99]]]). (A nondeterministic circuit C has two inputs, x and y, and accepts on x if there exists a y such that C(x,y)=1.) Is not believed to contain complete problems. ---- ===== <span id="npiconppoly" style="color:red">(NP &#8745; coNP)/poly</span>: Nonuniform [[#npiconp|NP &#8745; coNP]] ===== Together with [[#nppoly|NP/poly &#8745; coNP/poly]], has the same relation to [[#npiconp|NP &#8745; coNP]] as [[#ppoly|P/poly]] has to [[#p|P]]. A language in (NP &#8745; coNP)/poly is defined by a single language in [[#npiconp|NP &#8745; coNP]] which is then modified by advice. A language in [[#nppoly|NP/poly &#8745; coNP/poly]] comes from two possibly different languages in [[#np|NP]] and [[#conp|coNP]] which become the same with good advice. There is an oracle relative to which [[#nppoly|NP/poly &#8745; coNP/poly]], indeed NP/1 &#8745; coNP/1, is not contained in (NP &#8745; coNP)/poly [[zooref#ffk93|[FFK+93]]]. Recently they improved this to NP/1 &#8745; coNP [[zooref#ff..|[FF..]]]. If [[#np|NP]] is contained in (NP &#8745; coNP)/poly, then [[#ph|PH]] collapses to [[#s2p|S<sub>2</sub>P]]<sup>[[#npiconp|NP &#8745; coNP]]</sup> [[zooref#cch01|[CCH+01]]]. ---- ===== <span id="nplog" style="color:red">NP/log</span>: [[#np|NP]] With Logarithmic Advice ===== Same as [[#nppoly|NP/poly]], except that now the advice string is logarithmic-size. ---- ===== <span id="npmv" style="color:red">NPMV</span>: [[#np|NP]] Multiple Value ===== The class of all (possibly partial, possibly multivalued) functions computed by an [[#np|NP]] machine as follows: ignore the rejecting paths, and consider any output of an accepting path to be "one of the outputs." Contains [[#npsv|NPSV]] and [[#npmvt|NPMV<sub>t</sub>]]. Defined in [[zooref#bls84|[BLS84]]]. Contrast with [[#fnp|FNP]]. ---- ===== <span id="npmvsel" style="color:red">NPMV-sel</span>: [[#npmv|NPMV]] Selective ===== Has the same relation to [[#npmv|NPMV]] as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npmvt" style="color:red">NPMV<sub>t</sub></span>: [[#npmv|NPMV]] Total ===== The class of all (possibly multivalued) [[#npmv|NPMV]] functions that are total (that is, defined for every input). ---- ===== <span id="npmvtsel" style="color:red">NPMV<sub>t</sub>-sel</span>: [[#npmvt|NPMV<sub>t</sub>]] Selective ===== Has the same relation to [[#npmvt|NPMV<sub>t</sub>]] as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npo" style="color:red">NPO</span>: [[#np|NP]] Optimization ===== The class of function problems of the form, "Find any n-bit string x that maximizes a cost function C(x), where C is computable in [[#fp|FP]] (i.e. polynomial-time)." Defined in [[zooref#acg99|[ACG+99]]]. Contains [[#apx|APX]] and [[#npopb|NPOPB]]. ---- ===== <span id="npopb" style="color:red">NPOPB</span>: [[#npo|NPO]] Polynomially Bounded ===== The subclass of [[#npo|NPO]] problems for which the cost function is guaranteed always to be bounded by a polynomial in n (the input size). See [[zooref#acg99|[ACG+99]]]. NPOPB equals the closure of [[#maxpb|MaxPB]] under [[#ptas|PTAS]] reductions [[zooref#cks99|[CKS+99]]]. ---- ===== <span id="nppoly" style="color:red">NP/poly</span>: Nonuniform [[#np|NP]] ===== Has the same relation to [[#np|NP]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contains [[#am|AM]]. On the other hand, if NP/poly contains [[#conp|coNP]] then [[#ph|PH]] collapses to the third level. NP/poly-natural proofs cannot show that circuit families are outside [[#ppoly|P/poly]], under a pseudorandomness assumption [[zooref#rud97|[Rud97]]]. ---- ===== <span id="nppsamp" style="color:red">(NP,P-samplable)</span>: Average [[#np|NP]] With Samplable Distributions ===== See [[#avgp|AvgP]] for basic notions of average-case complexity. (NP,P-samplable) is the same as [[#distnp|DistNP]], except that the distribution &#956; only needs to be <i>samplable</i> in polynomial time. &#956;'s cumulative density function does not need to be computable in polynomial time. Any problem complete for [[#distnp|DistNP]] is also complete for (NP,P-samplable) [[zooref#il90|[IL90]]]. ---- ===== <span id="npr" style="color:red">NP<sub>R</sub></span>: [[#np|NP]] Over The Reals ===== An analog of [[#np|NP]] for Turing machines over a real number field. Defined in [[zooref#bcs97|[BCS+97]]]. It is unknown whether [[#pr2|P<sub>R</sub>]] = NP<sub>R</sub>, nor are implications known among this question, [[#pc|P<sub>C</sub>]] versus [[#npc2|NP<sub>C</sub>]], and [[#p|P]] versus [[#np|NP]]. Also, in contrast to the case of [[#npc2|NP<sub>C</sub>]], it is an open problem to show that [[#ppoly|P/poly]] distinct from [[#nppoly|NP/poly]] implies [[#pr2|P<sub>R</sub>]] distinct from NP<sub>R</sub>. The difference is that in the real case, a comparison (or greater-than) operator is available, and it is not known how much power this yields in comparison to the complex case. See also [[#vnp|VNP<sub>k</sub>]]. ---- ===== <span id="npspace" style="color:red">NPSPACE</span>: Nondeterministic [[#pspace|PSPACE]] ===== Equals [[#pspace|PSPACE]] [[zooref#sav70|[Sav70]]]. On the other hand, this result does not relativize if we allow strings of unbounded length to be written to the oracle tape. In particular, there exists an oracle relative to which NPSPACE is not contained in [[#exp|EXP]] [[zooref#gtw91|[GTW+91]]]. ---- ===== <span id="npsv" style="color:red">NPSV</span>: [[#np|NP]] Single Value ===== The class of [[#npmv|NPMV]] functions that are single-valued (i.e., such that every accepting path outputs the same value). Defined in [[zooref#bls84|[BLS84]]]. Contains [[#npsvt|NPSV<sub>t</sub>]]. [[#p|P]] = [[#np|NP]] if and only if [[#fp|FP]] = NPSV. ---- ===== <span id="npsvsel" style="color:red">NPSV-sel</span>: [[#npsv|NPSV]] Selective ===== Has the same relation to href="#npsv">NPSV as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npsvt" style="color:red">NPSV<sub>t</sub></span>: [[#npsv|NPSV]] Total ===== The class of all [[#npsv|NPSV]] functions that are total (that is, defined on every input). Contained in [[#npmvt|NPMV<sub>t</sub>]]. ---- ===== <span id="npsvtsel" style="color:red">NPSV<sub>t</sub>-sel</span>: [[#npsvt|NPSV<sub>t</sub>]] Selective ===== Has the same relation to [[#npsvt|NPSV<sub>t</sub>]] as [[#psel|P-Sel]] does to [[#p|P]]. Also known as NP-sel. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="nqp" style="color:red">NQP</span>: Nondeterministic Quantum Polynomial-Time ===== The class of decision problems solvable by a QTM in polynomial time such that a particular '|Accept&gt;' state has nonzero amplitude at the end of the computation, if and only if the answer is 'yes.' Since it has an exact amplitude condition, NQP has the same technical caveats as [[#eqp|EQP]]. Or it would, except that it turns out to equal [[#cocequalsp|coC<sub>=</sub>P]] [[zooref#fgh98|[FGH+98]]]. Defined in [[zooref#adh97|[ADH97]]]. Contrast with [[#qma|QMA]]. ---- ===== <span id="nspace" style="color:red">NSPACE(f(n))</span>: Nondeterministic f(n)-Space ===== Same as [[#npspace|NPSPACE]], but with f(n)-space (for some constructible function f) rather than polynomial-space machines. Contained in [[#dspace|DSPACE]](f(n)<sup>2</sup>) [[zooref#sav70|[Sav70]]], and indeed [[#revspace|RevSPACE]](f(n)<sup>2</sup>) [[zooref#cp95|[CP95]]]. NSPACE(n<sup>k</sup>) is strictly contained in NSPACE(n<sup>k+&#949;</sup>) for &#949;&gt;0 [[zooref#iba72|[Iba72]]] (actually the hierarchy theorem is stronger than this, but pretty technical to state). ---- ===== <span id="nt" style="color:red">NT</span>: Near-Testable ===== The class of decision problems such that whether the answer on input x agrees with the answer on input x-1 (that is, the lexicographic predecessor of x) is solvable in polynomial time. The Turing machine has to decide agreement or disagreement without access to the answer for x-1. Is contained in [[#e|E]], [[#ntstar|NT*]], and [[#parityp|&#8853;P]]. Defined in [[zooref#ghj91|[GHJ+91]]] to study [[#parityp|&#8853;P]]-complete problems. They show that [[#p|P]], NT, [[#ntstar|NT*]], and [[#parityp|&#8853;P]] are either all equal or strictly nested. In particular, they differ with probability 1 relative to a random oracle. ---- ===== <span id="ntstar" style="color:red">NT*</span>: Near-Testable With Forest Ordering ===== Defined like NT, but with a more general ordering on inputs. A problem L is in NT* if, first, there is a partially defined predecessor function pred(x) in [[#fp|FP]] that organizes the space of inputs into a forest. The size of the lineage of each x must also be bounded by 2<sup>poly(|x|)</sup>. Second, if L(x) is the Boolean answer to L on input x, then L(x)+L(pred(x)) is computable in polynomial time; or if pred(x) does not exist, L(x) is computable in polynomial time. Defined in [[zooref#ghj91|[GHJ+91]]]. Contains [[#nt|NT]] and is contained in [[#parityp|&#8853;P]]. The inclusions are either both strict or both equalities (whence [[#parityp|&#8853;P]] = [[#p|P]] as well). ---- ===== <span id="ntime" style="color:red">NTIME(f(n))</span>: Nondeterministic f(n)-Time ===== Same as [[#np|NP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. The Nondeterministic Time Hierarchy Theorem: If f and g are time-constructible and f(n+1)=o(g), then NTIME(f(n)) does not equal NTIME(g(n)) [[zooref#sfm78|[SFM78]]] (this is actually stronger than the hierarchy theorem for [[#dtime|DTIME]]). NTIME(n) strictly contains [[#dtime|DTIME(n)]] [[zooref#pps83|[PPS+83]]] (this result does not work for arbitrary f(n)). For any constructible superpolynomial f, NTIME(f(n)) with [[#np|NP]] oracle is not in [[#ppoly|P/poly]] [[zooref#kan82|[Kan82]]]. ---- ===== <span id="ocq" style="color:red">OCQ</span>: One Clean Qubit ===== The class of problems solvable by a [[#bqp|BQP]] machine in which a single qubit is initialized to the '0' state, and the remaining qubits are initialized to the maximally mixed state. (This definition is not known to be robust, so one also needs to specify a gate set.) We also need to stipulate that there are no "strong measurements" -- intermediate measurements on which later operations are conditioned -- since otherwise we can do all of [[#bqp|BQP]] by first initializing the computer to the all-0 state. Parker and Plenio [[zooref#pp00|[PP00]]] failed to appreciate this point. Defined by [[zooref#asv00|[ASV00]]] (though they didn't use the name OCQ), who also showed that if OCQ = [[#bqp|BQP]], something other than gate-by-gate simulation will be needed to show this. ---- ===== <span id="optp" style="color:red">OptP</span>: Optimum Polynomial-Time ===== The class of functions computable by taking the maximum of the output values over all accepting paths of an [[#np|NP]] machine. Defined in [[zooref#kre88|[Kre88]]]. Contrast with [[#fnp|FNP]]. ---- ===== <span id="p" style="color:red">P</span>: Polynomial-Time ===== The class that started it all. The class of decision problems solvable in polynomial time by a Turing machine. (See also [[#fp|FP]], for function problems.) Defined in [[zooref#edm65|[Edm65]]], [[zooref#cob64|[Cob64]]], [[zooref#rab60|[Rab60]]], and other seminal early papers. Contains some highly nontrivial problems, including linear programming [[zooref#kha79|[Kha79]]] and finding a maximum matching in a general graph [[zooref#edm65|[Edm65]]]. Contains the problem of testing whether an integer is prime [[zooref#aks02|[AKS02]]], an important result that improved on a proof requiring an assumption of the generalized Riemann hypothesis [[zooref#mil76|[Mil76]]]. A decision problem is P-complete if it is in P, and if every problem in P can be reduced to it in [[#l|L]] (logarithmic space). The canonical P-complete problem is <i>circuit evaluation</i>: given a Boolean circuit and an input, decide what the circuit outputs when given the input. Important subclasses of P include [[#l|L]], [[#nl|NL]], [[#nc|NC]], and [[#sc|SC]]. P is contained in [[#np|NP]], but whether they're equal seemed to be an open problem when I last checked. Efforts to generalize P resulted in [[#bpp|BPP]] and [[#bqp|BQP]]. The nonuniform version is [[#ppoly|P/poly]], the monotone version is [[#mp|mP]], and versions over the real and complex number fields are [[#pr2|P<sub>R</sub>]] and [[#pc|P<sub>C</sub>]] respectively. ---- ===== <span id="plog" style="color:red">P/log</span>: [[#p|P]] With Logarithmic Advice ===== Same as [[#ppoly|P/poly]], except that the advice string for input size n can have length at most logarithmic in n, rather than polynomial. Strictly contained in [[#iclogpoly|IC[log,poly]]]. If [[#np|NP]] is contained in P/log then [[#p|P]] = [[#np|NP]]. ---- ===== <span id="ppoly" style="color:red">P/poly</span>: Nonuniform Polynomial-Time ===== The class of decision problems solvable by a family of polynomial-size Boolean circuits. The family can be <i>nonuniform</i>; that is, there could be a completely different circuit for each input length. Equivalently, P/poly is the class of decision problems solvable by a polynomial-time Turing machine that receives an 'advice string,' that depends only on the size n of the input, and that itself has size upper-bounded by a polynomial in n. Contains [[#bpp|BPP]] by the progenitor of derandomization arguments [[zooref#adl78|[Adl78]]] [[zooref#kl82|[KL82]]]. By extension, BPP/poly, BPP/mpoly, and BPP/rpoly all equal P/poly. (By contrast, there is an oracle relative to which [[#bpplog|BPP/log]] does not equal [[#bppmlog|BPP/mlog]], while [[#bppmlog|BPP/mlog]] and [[#bpprlog|BPP/rlog]] are not equal relative to any oracle.) [[zooref#kl82|[KL82]]] showed that, if P/poly contains [[#np|NP]], then [[#ph|PH]] collapses to the second level, [[#sigma2p|&#931;<sub>2</sub>P]]. They also showed: <ul> <li>If [[#pspace|PSPACE]] is in P/poly then [[#pspace|PSPACE]] equals [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]].</li> <li>If [[#exp|EXP]] is in P/poly then [[#exp|EXP]] = [[#sigma2p|&#931;<sub>2</sub>P]].</li> </ul> It was later shown that, if [[#np|NP]] is contained in P/poly, then [[#ph|PH]] collapses to [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#kw98|[KW98]]] and indeed [[#s2p|S<sub>2</sub>P]] [[zooref#cai01|[Cai01]]]. This seems close to optimal, since there exists an oracle relative to which the collapse cannot be improved to [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#wil85|[Wil85]]]. If [[#np|NP]] is not contained in P/poly, then [[#p|P]] does not equal [[#np|NP]]. Much of the effort toward separating [[#p|P]] from [[#np|NP]] is based on this observation. However, a 'natural proof' as defined by [[zooref#rr97|[RR97]]] cannot be used to show [[#np|NP]] is outside P/poly, if there is any pseudorandom generator in P/poly that has hardness 2<sup>&#937;(n^&#949;)</sup> for some &#949;&gt;0. If [[#np|NP]] is contained in P/poly, then [[#ma|MA]] = [[#am|AM]] [[zooref#aks95|[AKS+95]]] The monotone version of P/poly is [[#mppoly|mP/poly]]. P/poly has measure 0 in [[#e|E]] with [[#sigma2p|&#931;<sub>2</sub>P]] oracle [[zooref#may94b|[May94b]]]. Strictly contains [[#iclogpoly|IC[log,poly]]] and [[#plog|P/log]]. ---- ===== <span id="psharpp" style="color:red">P<sup>#P</sup></span>: [[#p|P]] With [[#sharpp|#P]] Oracle ===== I decided this class is so important that it deserves an entry of its own, apart from [[#sharpp|#P]]. Contains [[#ph|PH]] [[zooref#tod89|[Tod89]]], and is contained in [[#pspace|PSPACE]]. Equals [[#ppp2|P<sup>PP</sup>]] (exercise for the visitor). ---- ===== <span id="psharpp1" style="color:red">P<sup>#P</sup></span>: [[#p|P]] With Single Query To [[#sharpp|#P]] Oracle ===== Contains [[#ph|PH]] [[zooref#tod89|[Tod89]]]. ---- ===== <span id="pac0" style="color:red">PAC<sup>0</sup></span>: Probabilistic [[#ac0|AC<sup>0</sup>]] ===== The Political Action Committee for computational complexity research. The class of problems for which there exists a [[#diffac0|DiffAC<sup>0</sup>]] function f such that the answer is "yes" on input x if and only if f(x)>0. Equals [[#tc0|TC<sup>0</sup>]] and [[#cequalsac0|C<sub>=</sub>AC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="pbp" style="color:red">PBP</span>: Polynomial-Size Branching Program ===== Same as [[#kpbp|k-PBP]] but with no width restriction. Equals [[#l/poly|L/poly]] [[zooref#cob66|[Cob66]]]. Contains [[#pobdd|P-OBDD]], [[#bpdp|BP<sub>d</sub>(P)]]. ---- ===== <span id="kpbp" style="color:red">k-PBP</span>: Polynomial-Size Width-k Branching Program ===== A <i>branching program</i> is a directed acyclic graph with a designated start vertex. Each (non-sink) vertex is labeled by the name of an input bit, and has two outgoing edges, one of which is followed if that input bit is 0, the other if the bit is 1. A sink vertex can be either an 'accept' or a 'reject' vertex. The <i>size</i> of the branching program is the number of vertices. The branching program has <i>width k</i> if the vertices can be sorted into levels, each with at most k vertices, such that each edge goes from a level to the one immediately after it. Then k-PBP is the class of decision problems solvable by a family of polynomial-size, width-k branching programs. (A uniformity condition may also be imposed.) k-PBP equals (nonuniform) [[#nc1|NC<sup>1</sup>]] for constant k at least 5 [[zooref#bar89|[Bar89]]]. On the other hand, 4-PBP is in [[#acc0|ACC<sup>0</sup>]] [[zooref#bt88|[BT88]]]. Contained in k-[[#eqbp|EQBP]], as well as [[#pbp|PBP]]. See also [[#bpdp|BP<sub>d</sub>(P)]]. ---- ===== <span id="pc" style="color:red">P<sub>C</sub></span>: Polynomial-Time Over The Complex Numbers ===== An analog of [[#p|P]] for Turing machines over a complex number field. Defined in [[zooref#bcs97|[BCS+97]]]. See also [[#pr2|P<sub>R</sub>]], [[#npc2|NP<sub>C</sub>]], [[#npr|NP<sub>R</sub>]], [[#vp|VP<sub>k</sub>]]. ---- ===== <span id="pcc" style="color:red">P<sup>cc</sup></span>: Communication Complexity [[#p|P]] ===== In a two-party communication complexity problem, Alice and Bob have n-bit strings x and y respectively, and they wish to evaluate some Boolean function f(x,y) using as few bits of communication as possible. P<sup>cc</sup> is the class of (infinite families of) f's, such that the amount of communication needed is only O(polylog(n)), even if Alice and Bob are restricted to a deterministic protocol. Is strictly contained in [[#npcc|NP<sup>cc</sup>]] and in [[#bppcc|BPP<sup>cc</sup>]] because of the EQUALITY problem. Equals [[#npcc|NP<sup>cc</sup>]] &#8745; [[#npcc|coNP<sup>cc</sup>]]. Defined in [[zooref#bfs86|[BFS86]]]. ---- ===== <span id="pcd" style="color:red">PCD(r(n),q(n))</span>: Probabilistically Checkable Debate ===== The class of decision problems decidable by a <i>probabilistically checkable debate system</i>, as follows. Two debaters B and C alternate writing strings on a "debate tape," with B arguing that the answer is "yes" and C arguing the answer is "no." Then a polynomial-time verifier flips O(r(n)) random coins and makes O(q(n)) <i>nonadaptive</i> queries to the debate tape (meaning that they depend only on the input and the random coins, not the results of previous queries). The verifier then outputs an answer, which should be correct with high probability. Defined in [[zooref#cfl93|[CFL+93]]], who also showed that PCD(log n, 1) = [[#pspace|PSPACE]]. This result was used to show that certain problems are [[#pspace|PSPACE]]-hard even to approximate. Contained in [[#gpcd|GPCD]](r(n),q(n)). ---- ===== <span id="pclose" style="color:red">P-Close</span>: Problems Close to [[#p|P]] ===== The class of decision problems solvable by a polynomial-time algorithm that outputs the wrong answer on only a sparse (that is, polynomially-bounded) set of instances. Defined in [[zooref#yes83|[Yes83]]]. Contains [[#almostp|Almost-P]] and is contained in [[#ppoly|P/poly]] [[zooref#sch86|[Sch86]]]. ---- ===== <span id="pcp" style="color:red">PCP(r(n),q(n))</span>: Probabilistically Checkable Proof ===== The class of decision problems such that a "yes" answer can be verified by a <i>probabilistically checkable proof</i>, as follows. The verifier is a polynomial-time Turing machine with access to O(r(n)) uniformly random bits. It has random access to a <i>proof</i> (which might be exponentially long), but can query only O(q(n)) bits of the proof. Then we require the following: <ol> <li>If the answer is "yes," there exists a proof such that the verifier accepts with certainty.</li> <li>If the answer is "no," then for all proofs the verifier rejects with probability at least 1/2 (over the choice of the O(r(n)) random bits).</li> </ol> Defined in [[zooref#as98|[AS98]]]. By definition [[#np|NP]] = PCP(0,poly(n)). [[#mip|MIP]] = PCP(poly(n),poly(n)). PCP(r(n),q(n)) is contained in [[#ntime|NTIME]](2<sup>O(r(n))</sup>q(n) + poly(n)). [[#np|NP]] = PCP(log n, log n) [[zooref#as98|[AS98]]]. In fact, [[#np|NP]] = PCP(log n, 1) [[zooref#alm98|[ALM+98]]]! On the other hand, if [[#np|NP]] is contained in PCP(o(log n), o(log n)), then [[#p|P]] = [[#np|NP]] [[zooref#fgl91|[FGL+91]]]. Also, even though there exists an oracle relative to which [[#np|NP]] = [[#exp|EXP]] [[zooref#hel84|[Hel84]]], if we could show there exists an oracle relative to which PCP(log n, 1) = [[#exp|EXP]], then we'd have proved [[#p|P]] not equal to [[#np|NP]] [[zooref#for94|[For94]]]. Another weird oracle fact: since [[#np|NP]] does not equal [[#nexp|NEXP]] [[zooref#sfm78|[SFM78]]], PCP(0,log n) does not equal PCP(0,poly(n)). However, there exist oracles relative to which the latter inequality is false [[zooref#hcc92|[HCC+92]]]. ---- ===== <span id="permup" style="color:red">PermUP</span>: Self-Permuting [[#up|UP]] ===== The class of languages L in [[#up|UP]] such that the mapping from an input x to the unique witness for x is a permutation of L. Contains [[#p|P]]. Defined in [[zooref#ht03|[HT03]]], where it was also shown that the closure of PermUP under polynomial-time one-to-one reductions is [[#up|UP]]. On the other hand, they show that if PermUP = [[#up|UP]] then [[#e|E]] = [[#ue|UE]]. See also: [[#selfnp|SelfNP]]. ---- ===== <span id="pexp" style="color:red">PEXP</span>: Probabilistic Exponential-Time ===== Has the same relation to [[#exp|EXP]] as [[#pp|PP]] does to [[#p|P]]. Is not contained in [[#ppoly|P/poly]] [[zooref#bft98|[BFT98]]]. ---- ===== <span id="pf" style="color:red">PF</span>: Alternate Name for [[#fp|FP]] ===== ---- ===== <span id="pfchk" style="color:red">PFCHK(t(n))</span>: Proof-Checker ===== The class of decision problems solvable in time O(t(n)) by a nondeterministic Turing machine, as follows. The machine is given oracle access to a <i>proof string</i> of unbounded length. <ul> <li>If the answer is "yes," then there exists a value of the proof string such that all computation paths accept.</li> <li>If the answer is "no," then for all values of the proof string, there exists a computation path that rejects.</li> </ul> Credited in [[zooref#for94|[For94]]] to S. Arora, R. Impagliazzo, and U. Vazirani. An interesting question is whether [[#np|NP]] = PFCHK(log n) relative to all possible oracles. Fortnow [[zooref#for94|[For94]]] observes that the answer depends on what oracle access mechanism is used. ---- ===== <span id="ph" style="color:red">PH</span>: Polynomial-Time Hierarchy ===== Let &#916;<sub>0</sub>P = &#931;<sub>0</sub>P = &#928;<sub>0</sub>P = [[#p|P]]. Then for i&gt;0, let <ul> <li>&#916;<sub>i</sub>P = [[#p|P]] with &#931;<sub>i-1</sub>P oracle.</li> <li>&#931;<sub>i</sub>P = [[#np|NP]] with &#931;<sub>i-1</sub>P oracle.</li> <li>&#928;<sub>i</sub>P = [[#conp|coNP]] with &#931;<sub>i-1</sub>P oracle.</li> </ul> Then PH is the union of these classes for all nonnegative constant i. PH can also be defined using alternating quantifiers: it's the class of problems of the form, "given an input x, does there exist a y such that for all z, there exists a w ... such that &phi;(x,y,z,w,...)," where y,z,w,... are polynomial-size strings and &phi; is a polynomial-time computable predicate. It's not totally obvious that this is equivalent to the first definition, since the first one involves adaptive [[#np|NP]] oracle queries and the second one doesn't, but it is. Defined in [[zooref#sto76|[Sto76]]]. Contained in [[#p|P]] with a [[#pp|PP]] oracle [[zooref#tod89|[Tod89]]]. Contains [[#bpp|BPP]] [[zooref#lau83|[Lau83]]]. Relative to a random oracle, PH is strictly contained in [[#pspace|PSPACE]] with probability 1 [[zooref#cai86|[Cai86]]]. Furthermore, there exist oracles separating any &#931;<sub>i</sub>P from &#931;<sub>i+1</sub>P. On the other hand, it is unknown whether &#931;<sub>i</sub>P is strictly contained in &#931;<sub>i+1</sub>P relative to a <i>random</i> oracle with probability 1 (see [[zooref#has87|[Has87]]]). Book [[zooref#boo94|[Boo94]]] shows that if PH collapses relative to a random oracle with probability 1, then it collapses unrelativized. For a compendium of problems complete for different classes of the Polynomial Hierarchy see [[zooref#sch02a|[Sch02a]]] and [[zooref#sch02b|[Sch02b]]]. ---- ===== <span id="phcc" style="color:red">PH<sup>cc</sup></span>: Communication Complexity [[#ph|PH]] ===== The obvious generalization of [[#npcc|NP<sup>cc</sup>]] and [[#conpcc|coNP<sup>cc</sup>]] to a nondeterministic hierarchy. It is unknown whether &#931;<sub>2</sub><sup>cc</sup> equals &#928;<sub>2</sub><sup>cc</sup>. Defined in [[zooref#bfs86|[BFS86]]], where it was also shown (among other things) that [[#bppcc|BPP<sup>cc</sup>]] is contained in &#931;<sub>2</sub><sup>cc</sup> &#8745; &#928;<sub>2</sub><sup>cc</sup>. ---- ===== <span id="phi2p" style="color:red">&#934;<sub>2</sub>P</span>: Second Level of the Symmetric Hierarchy, Alternative Definition ===== The class of problems for which there exists a polynomial-time predicate P(x,y,z) such that for all x, if the answer on input x is "yes," then <ol> <li>For all y, there exists a z for which P(x,y,z).</li> <li>For all z, there exists a y for which P(x,y,z).</li> </ol> Contained in [[#sigma2p|&#931;<sub>2</sub>P]] and [[#pi2p|&#928;<sub>2</sub>P]]. Defined in [[zooref#can96|[Can96]]], where it was also observed that &#934;<sub>2</sub>P = [[#s2p|S<sub>2</sub>P]]. ---- ===== <span id="php" style="color:red">PhP</span>: Physical Polynomial-Time ===== Defined by Valiant [[zooref#val03|[Val03]]] to be "the class of physically constructible polynomial resource computers" (characterizing what "can be computed in the physical world in practice"). There he says that PhP contains [[#p|P]] and [[#bpp|BPP]], but that it is open whether PhP contains [[#bqp|BQP]], since no scalable quantum computing proposal has been demonstrated beyond reasonable doubt. For what it's worth, the present zookeeper has more qualms about admitting [[#dtime|DTIME]](n<sup>1000</sup>) into PhP than [[#bqtime|BQTIME]](n<sup>2</sup>). It is very possible that the total number of bits or bit tranisitions that can be witnessed by any one observer in the universe is finite. (Recent observations of the cosmological constant combined with plausible fundamental physics yields a bound of 10<sup>k</sup> with k in the low hundreds.) In practice, less than 10<sup>50</sup> bits and less than 10<sup>80</sup> bit transitions are available for human use. (This is combining the number of atoms in the Earth with the number of signals that they can exchange in a millenium.) The present veterinarian concurs that PhP is an unhealthy animal, although it is valid to ask whether [[#bqp|BQP]] is a realistic class. ---- ===== <span id="pi2p" style="color:red">&#928;<sub>2</sub>P</span>: [[#conp|coNP]] With [[#np|NP]] Oracle ===== Complement of [[#sigma2p|&#931;<sub>2</sub>P]]. Along with [[#sigma2p|&#931;<sub>2</sub>P]], comprises the second level of [[#ph|PH]], the polynomial hierarchy. For any fixed k, there is a problem in &#928;<sub>2</sub>P &#8745; [[#sigma2p|&#931;<sub>2</sub>P]] that cannot be solved by circuits of size n<sup>k</sup> [[zooref#kan82|[Kan82]]]. ---- ===== <span id="pinc" style="color:red">PINC</span>: Polynomial Ignorance of Names of Classes ===== (Actually, I've since been informed that PINC means "Incremental Polynomial-Time.") The class of function problems, f:{0,1}<sup>n</sup>-&gt;{0,1}<sup>m</sup>, such that the k<sup>th</sup> output bit is computable in time polynomial in n and k. Defined in [[zooref#jy88|[JY88]]]. Contained in [[#pio|PIO]]. This containment is strict, since if m=2<sup>n</sup> (say), then computing the first bit of f(x) might be [[#exp|EXP]]-complete. ---- ===== <span id="pio" style="color:red">PIO</span>: Polynomial Input Output ===== The class of function problems, f:{0,1}<sup>n</sup>-&gt;{0,1}<sup>m</sup>, such that f(x) is computable in time polynomial in n and m. Allows us to discuss whether a function is "efficiently computable" or not, even if the output is too long to write down in polynomial time. Defined in [[zooref#yan81|[Yan81]]]. Strictly contains [[#pinc|PINC]]. ---- ===== <span id="pk" style="color:red">P<sup>K</sup></span>: [[#p|P]] With Kolmogorov-Complexity Oracle ===== [[#p|P]] equipped with an oracle that, given a string x, returns the length of the shortest program that outputs x. A similar class was defined in [[zooref#abk02|[ABK+02]]], where it was also shown that P<sup>K</sup> contains [[#pspace|PSPACE]]. It is not known whether P<sup>K</sup> contains all of [[#r|R]], or even any recursive problem not in [[#pspace|PSPACE]]. See also: [[#bppkt|BPP<sup>KT</sup>]]. ---- ===== <span id="pkc" style="color:red">PKC</span>: Perfect Knowledge Complexity ===== Has the same relation to [[#pzk|PZK]] as [[#skc|SKC]] does to [[#szk|SZK]]. Defined in [[zooref#gp91|[GP91]]]. ---- ===== <span id="pl" style="color:red">PL</span>: Probabilistic [[#l|L]] ===== Has the same relation to [[#l|L]] that [[#pp|PP]] has to [[#p|P]]. Contains [[#bpl|BPL]]. PL<sup>PL</sup> = PL (see [[zooref#ho02|[HO02]]]). ---- ===== <span id="pl1" style="color:red">PL<sub>1</sub></span>: Polynomially-Bounded L<sub>1</sub> Spectral Norm ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that the sum of absolute values of Fourier coefficients of f is bounded by a polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PL<sub>1</sub> is contained in [[#pt1|PT<sub>1</sub>]] (and this inclusion is strict). ---- ===== <span id="plinfinity" style="color:red">PL<sub>&#8734;</sub></span>: Polynomially-Bounded L<sub>&#8734;</sub><sup>-1</sup> Spectral Norm ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that the maximum of |&alpha;|<sup>-1</sup>, over all Fourier coefficients &alpha; of f, is upper-bounded by a polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PL<sub>&#8734;</sub> contains [[#pt1|PT<sub>1</sub>]] (and this inclusion is strict). ---- ===== <span id="plf" style="color:red">PLF</span>: Polynomial Leaf ===== Defined in [[zooref#pap90|[Pap90]]]. I believe it's the same as [[#ppa|PPA]]. ---- ===== <span id="pll" style="color:red">PLL</span>: Polynomial Local Lemma ===== The class of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the Lov&aacute;sz Local Lemma. Defined in [[zooref#pap94b|[Pap94b]]]. ---- ===== <span id="pls" style="color:red">PLS</span>: Polynomial Local Search ===== The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "every finite directed acyclic graph has a sink." More precisely, for each input, there's a finite set of <i>solutions</i> (i.e. strings), and a polynomial-time algorithm that computes a <i>cost</i> for each solution, and a <i>neighboring solution</i> of lower cost provided that one exists. Then the problem is to return any solution that has cost less than or equal to all of its neighbors. (In other words, a local optimum.) (<i>Note:</i> In the Zookeeper's humble opinion, PLS <i>should</i> have been defined as follows: there exist polynomial-time algorithms that compute the cost of a solution, and the set of <i>all</i> neighbors of a given solution, not just a single solution of lower cost. Of course we'd require that every solution has only polynomially many neighbors. The two definitions are not obviously equivalent, and it's conceivable that knowing all the neighbors would be helpful -- for example, in simulated annealing one sometimes makes uphill moves.) Defined in [[zooref#jpy88|[JPY88]]], [[zooref#py88|[PY88]]]. There exists an oracle relative to which PLS is not contained in [[#fbqp|FBQP]] [[zooref#aar03|[Aar03]]]. Also, there exist oracles relative to which PLS is not contained in [[#ppa|PPA]] [[zooref#bm04|[BM04]]], and [[#ppa|PPA]] and [[#ppp|PPP]] are not contained in PLS [[zooref#mor01|[Mor01]]]. Whether PLS is not in [[#ppp|PPP]] relative to some oracle remains open. [[zooref#ct07|[CT07]]] conjecture that if [[#ppad|PPAD]] is in [[#p|P]], then [[#pls|PLS]] is in [[#p|P]]. ---- ===== <span id="pnp" style="color:red">P<sup>NP</sup></span>: [[#p|P]] With Oracle Access To [[#np|NP]] ===== See [[#delta2p|&#916;<sub>2</sub>P]]. ---- ===== <span id="pparnp" style="color:red">P<sup>||NP</sup></span>: [[#p|P]] With Parallel Queries To [[#np|NP]] ===== Equals [[#pnplog|P<sup>NP[log]</sup>]] ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). ---- ===== <span id="pnpk" style="color:red">P<sup>NP[k]</sup></span>: [[#p|P]] With k [[#np|NP]] Queries(for constant k) ===== Equals [[#p|P]] with 2<sup>k</sup>-1 parallel queries to [[#np|NP]] (i.e. queries that do not depend on the outcomes of previous queries) ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). If P<sup>NP</sup> = P<sup>NP</sup>, then P<sup>NP</sup> = [[#pnplog|P<sup>NP[log]</sup>]] and indeed [[#ph|PH]] collapses to &Delta;<sub>3</sub>P (attributed in [[zooref#har87b|[Har87b]]] to J. Kadin). ---- ===== <span id="pnplog" style="color:red">P<sup>NP[log]</sup></span>: [[#p|P]] With Log [[#np|NP]] Queries ===== The class of decision problems solvable by a [[#p|P]] machine, that can make O(log n) queries to an [[#np|NP]] oracle (where n is the length of the input). Equals [[#pparnp|P<sup>&#124;&#124;NP</sup>]], the class of decision problems solvable by a [[#p|P]] machine that can make polynomially many <i>nonadaptive</i> queries to an [[#np|NP]] oracle (i.e. queries that do not depend on the outcomes of previous queries) ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). P<sup>NP[log]</sup> is contained in [[#pp|PP]] [[zooref#bhw89|[BHW89]]]. Determining the winner in an election system proposed in 1876 by Charles Dodgson (a.k.a. Lewis Carroll) has been shown to be complete for P<sup>NP[log]</sup> [[zooref#hhr97|[HHR97]]]. Contains [[#pnpk|P<sup>NP[k]</sup>]] for all constants k. ---- ===== <span id="pnplog2" style="color:red">P<sup>NP[log^2]</sup></span>: [[#p|P]] With Log<sup>2</sup> [[#np|NP]] Queries ===== Same as [[#pnplog|P<sup>NP[log]</sup>]], except that now log<sup>2</sup> queries can be made. The model-checking problem for a certain temporal logic is P<sup>NP[log^2]</sup>-complete [[zooref#sch03|[Sch03]]]. For all k, [[#p|P]] with log<sup>k</sup> adaptive queries to [[#np|NP]] coincides with [[#p|P]] with log<sup>k+1</sup> nonadaptive queries [[zooref#cs92|[CS92]]]. ---- ===== <span id="pobdd" style="color:red">P-OBDD</span>: Polynomial-Size Ordered Binary Decision Diagram ===== An <i>ordered binary decision diagram (OBDD)</i> is a branching program (see [[#kpbp|k-PBP]]), with the additional constraint that if x<sub>i</sub> is queried before x<sub>j</sub> on any path, then i&lt;j. Then P-OBDD is the class of decision problems solvable by polynomial-size OBDD's. Contained in [[#pbp|PBP]], as well as [[#bppobdd|BPP-OBDD]]. ---- ===== <span id="podn" style="color:red">PODN</span>: Polynomial Odd Degree Node ===== The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "every finite graph has an even number of odd-degree nodes." Equals [[#ppa|PPA]] [[zooref#pap90|[Pap90]]]. ---- ===== <span id="polyl" style="color:red">polyL</span>: Polylogarithmic Space ===== Equals [[#dspace|DSPACE]]((log n)<sup>c</sup>). In contrast to [[#l|L]], which is contained in [[#p|P]], it is not known if polyL is contained in [[#p|P]] or vice versa. On the other hand, we do know that polyL does not equal [[#p|P]], since (for example) polyL does not have complete problems under many-to-one logspace reductions. ---- ===== <span id="postbqp" style="color:red">PostBQP</span>: [[#bqp|BQP]] With Postselection ===== A class inspired by the proverb, "if at first you don't succeed, try, try again." Formally, the class of decision problems solvable by a [[#bqp|BQP]] machine such that <ul> <li>If the answer is 'yes' then the second qubit has at least 2/3 probability of being measured 1, <i>conditioned</i> on the first qubit having been measured 1.</li> <li>If the answer is 'no' then the second qubit has at most 1/3 probability of being measured 1, conditioned on the first qubit having been measured 1.</li> <li>On any input, the first qubit has a nonzero probability of being measured 1.</li> </ul> Defined in [[zooref#aar05b|[Aar05b]]], where it is also shown that PostBQP equals [[#pp|PP]]. [[zooref#aar05b|[Aar05b]]] also gives the following alternate characterizations of PostBQP (and therefore of [[#pp|PP]]): <ul> <li>The quantum analogue of [[#bpppath|BPP<sub>path</sub>]].</li> <li>The class of problems solvable in quantum polynomial time if we allow arbitrary linear operations (not just unitary ones). Before measuring, we divide all amplitudes by a normalizing factor to make the probabilities sum to 1.</li> <li>The class of problems solvable in quantum polynomial time if we take the probability of measuring a basis state with amplitude &alpha; to be not |&alpha;|<sup>2</sup> but |&alpha;|<sup>p</sup>, where p is an even integer greater than 2. (Again we need to divide all amplitudes by a normalizing factor to make the probabilities sum to 1.)</li> </ul> ---- ===== <span id="pp" style="color:red">PP</span>: Probabilistic Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes' then at least 1/2 of computation paths accept.</li> <li>If the answer is 'no' then less than 1/2 of computation paths accept.</li> </ol> Defined in [[zooref#gil77|[Gil77]]]. PP is closed under union and intersection [[zooref#brs91|[BRS91]]] (this was an open problem for 14 years). Contains [[#pnplog|P<sup>NP[log]</sup>]] [[zooref#bhw89|[BHW89]]]. Equals PP<sup>[[#bpp|BPP]]</sup> [[zooref#kst89b|[KST+89b]]] as well as [[#postbqp|PostBQP]] [[zooref#aar05b|[Aar05b]]]. However, there exists an oracle relative to which PP does not contain [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#bei94|[Bei94]]]. [[#ph|PH]] is in [[#ppp2|P<sup>PP</sup>]] [[zooref#tod89|[Tod89]]]. [[#bqp|BQP]] is low for PP; i.e. PP<sup>BQP</sup> = PP [[zooref#fr98|[FR98]]]. For a random oracle A, PP<sup>A</sup> is strictly contained in [[#pspace|PSPACE]]<sup>A</sup> with probability 1 [[zooref#abf94|[ABF+94]]]. For any fixed k, there exists a language in PP that does not have circuits of size n<sup>k</sup> [[zooref#vin04b|[Vin04b]]]. Indeed, there exists a language in PP that does not even have quantum circuits of size n<sup>k</sup> with quantum advice [[zooref#aar06|[Aar06]]]. By contrast, there exists an oracle relative to which PP has linear-size circuits [[zooref#aar06|[Aar06]]]. PP can be generalized to the counting hierarchy [[#ch|CH]]. ---- ===== <span id="pppoly" style="color:red">PP/poly</span>: Nonuniform [[#pp|PP]] ===== Contains [[#bqpqpoly|BQP/qpoly]] [[zooref#aar04b|[Aar04b]]]. If PP/poly = [[#ppoly|P/poly]] then [[#pp|PP]] is contained in [[#ppoly|P/poly]]. Indeed this is true with any syntactically defined class in place of [[#pp|PP]]. An implication is that any unrelativized separation of [[#bqpqpoly|BQP/qpoly]] from [[#bqpmpoly|BQP/mpoly]] would imply that [[#pp|PP]] does not have polynomial-size circuits. ---- ===== <span id="ppa" style="color:red">PPA</span>: Polynomial Parity Argument ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "all graphs of maximum degree 2 have an even number of leaves." More precisely, there's a polynomial-time algorithm that, given any string, computes its 'neighbor' strings (of which there are at most two). Then given a leaf string (i.e. one with only one neighbor), the problem is to output another leaf string. As an example, suppose you're given a cubic graph (one where every vertex has degree 3), and a Hamiltonian cycle H on that graph. Then by making a sequence of modifications to H (albeit possibly exponentially many), it is always possible to find a second Hamilton cycle (see [[zooref#pap94|[Pap94]]]). So this problem is in PPA. Another problem in PPA is finding an Arrow-Debreu equilibrium, given the goods and utility functions of traders in a marketplace. Contained in [[#tfnp|TFNP]]. Contains [[#ppad|PPAD]]. There exist oracles relative to which PPA does not contain [[#pls|PLS]] [[zooref#bm04|[BM04]]] and [[#ppp|PPP]] [[zooref#bce95|[BCE+95]]]. There also exists an oracle relative to which PPA is not contained in [[#ppp|PPP]] [[zooref#bce95|[BCE+95]]]. ---- ===== <span id="ppad" style="color:red">PPAD</span>: Polynomial Parity Argument (Directed) ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. Same as [[#ppa|PPA]], except now the graph is directed, and we're asked to find either a source or a sink. Contained in [[#ppa|PPA]] and [[#ppads|PPADS]]. NASH, the problem of finding a Nash equilibrium in a normal form game of two or more players with specified utilities, is in PPAD [[zooref#pap94b|[Pap94b]]], and proved to be complete for PPAD with four players in [[zooref#dgp05|[DGP05]]], and shortly after extended to the case of three players [[zooref#dp05|[DP05]]] and independently [[zooref#cd05|[CD05]]]. Computing an &#949;-Nash Equilibrium for any number of players is also PPAD-complete. There exists an oracle relative to which [[#ppp|PPP]] is not contained in PPAD [[zooref#bce95|[BCE+95]]]. ---- ===== <span id="ppads" style="color:red">PPADS</span>: Polynomial Parity Argument (Directed, Sink) ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. Same as [[#ppa|PPA]], except now the graph is directed, and we're asked to find a sink. Contained in [[#ppp|PPP]]. Contains [[#ppad|PPAD]]. ---- ===== <span id="ppp" style="color:red">PPP</span>: Polynomial Pigeonhole Principle ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the Pigeonhole Principle. More precisely, we're given a Boolean circuit, that maps n-bit strings to n-bit strings. The problem is to return <i>either</i> an input that maps to 0<sup>n</sup>, <i>or</i> two inputs that map to the same output. Contained in [[#tfnp|TFNP]]. Contains [[#ppads|PPADS]]. [[zooref#bce95|[BCE+95]]] give oracles relative to which PPP is not contained in [[#ppa|PPA]] and [[#ppad|PPAD]], and [[#ppa|PPA]] is not contained in PPP. [[zooref#mor01|[Mor01]]] gives an oracle relative to which PPP is not contained in [[#pls|PLS]]. Whether [[#pls|PLS]] is not contained in PPP relative to some oracle remains open. ---- ===== <span id="ppp2" style="color:red">P<sup>PP</sup></span>: [[#p|P]] With [[#pp|PP]] Oracle ===== A level of the counting hierarchy [[#ch|CH]]. It is not known whether there exists an oracle relative to which P<sup>PP</sup> does not equal [[#pspace|PSPACE]]. Contains [[#pp|PP]]<sup>[[#ph|PH]]</sup> [[zooref#tod89|[Tod89]]]. Equals [[#psharpp|P<sup>#P</sup>]] (exercise for the visitor). Since the permanent of a matrix is [[#sharpp|#P]]-complete [[zooref#val79|[Val79]]], Toda's theorem implies that any problem in the polynomial hierarchy can be solved by computing a sequence of permanents. ---- ===== <span id="pquery" style="color:red">PQUERY</span>: PSPACE With Polynomial Queries ===== The class of decision problems solvable in polynomial space using at most a polynomial number of queries to the oracle. Thus, PQUERY = [[#pspace|PSPACE]], but PQUERY<sup>A</sup> does not equal [[#pspace|PSPACE]]<sup>A</sup> for some oracles A. Defined in [[zooref#kur83|[Kur83]]], where it was actually put forward as a serious argument (!!) against believing relativization results. ---- ===== <span id="ppspace" style="color:red">PPSPACE</span>: Probabilistic [[#pspace|PSPACE]] ===== Same as [[#ipp|IPP]], except that [[#ipp|IPP]] uses private coins while PPSPACE uses public coins. Can also be defined as a probabilistic version of [[#pspace|PSPACE]]. Equals [[#pspace|PSPACE]]. Defined in [[zooref#pap83|[Pap83]]]. ---- ===== <span id="pr" style="color:red">PR</span>: Primitive Recursive Functions ===== Basically, the class of functions definable by recursively building up arithmetic functions: addition, multiplication, exponentiation, tetration, etc. What's <i>not</i> allowed is to "diagonalize" a whole series of such functions to produce an even faster-growing one. Thus, the Ackermann function was proposed in 1928 as an example of a recursive function that's not primitive recursive, showing that PR is strictly contained in [[#r|R]]. Alternatively, the PR functions are exactly those functions that can be computed via programs in any reasonable, idealized ALGOL-like programming language where only <i>definite</i> loops are allowed, that is, loops where the number of iterations is specified before the loop starts (so FOR-loops are okay but not WHILE- or REPEAT-loops), and recursive calls are not allowed. An interesting difference is that PR functions can be explicitly enumerated, whereas functions in [[#r|R]] cannot be (since otherwise the halting problem would be decidable). That is, PR is a "syntactic" class whereas [[#r|R]] is "semantic." On the other hand, we can "enumerate" any [[#re|RE]] set by a PR function in the following sense: given an input (M,k), where M is a Turing machine and k is an integer, if M halts within k steps then output M; otherwise output nothing. Then the union of the outputs, over all possible inputs (M,k), is exactly the set of M that halt. PR strictly contains [[#elementary|ELEMENTARY]]. ---- ===== <span id="pr2" style="color:red">P<sub>R</sub></span>: Polynomial-Time Over The Reals ===== An analog of [[#p|P]] for Turing machines over a real number field. Defined in [[zooref#bcs97|[BCS+97]]]. See also [[#pc|P<sub>C</sub>]], [[#npc2|NP<sub>C</sub>]], [[#npr|NP<sub>R</sub>]], [[#vp|VP<sub>k</sub>]]. ---- ===== <span id="prhspace" style="color:red">Pr<sub>H</sub>SPACE(f(n))</span>: Unbounded-Error Halting Probabilistic f(n)-Space ===== Has the same relation to [[#dspace|DSPACE]](f(n)) as [[#pp|PP]] does to [[#p|P]]. The Turing machine has to halt on every input <i>and</i> every setting of the random tape. Equals [[#prspace|PrSPACE]](f(n)) [[zooref#jun85|[Jun85]]]. ---- ===== <span id="promisebpp" style="color:red">PromiseBPP</span>: Promise-Problem [[#bpp|BPP]] ===== Same as [[#promiserp|PromiseRP]], but for [[#bpp|BPP]] instead of [[#rp|RP]]. Defined in [[zooref#bf99|[BF99]]]. ---- ===== <span id="promisebqp" style="color:red">PromiseBQP</span>: Promise-Problem [[#bqp|BQP]] ===== Same as [[#promisebqp|PromiseBQP]], but for [[#bqp|BQP]] instead of [[#bpp|BPP]]. If PromiseBQP = [[#promisep|PromiseP]] then [[#bqpmpoly|BQP/mpoly]] = [[#ppoly|P/poly]]. ---- ===== <span id="promisep" style="color:red">PromiseP</span>: Promise-Problem [[#p|P]] ===== The class of promise problems solvable by a [[#p|P]] machine. ---- ===== <span id="promiserp" style="color:red">PromiseRP</span>: Promise-Problem [[#rp|RP]] ===== The class of promise problems solvable by an [[#rp|RP]] machine. I.e., the machine must accept with probability at least 1/2 for "yes" inputs, and with probability 0 for "no" inputs, but could have acceptance probability between 0 and 1/2 for inputs that do not satisfy the promise. Defined in [[zooref#bf99|[BF99]]], where it was also shown that [[#bpp|BPP]] is in [[#rp|RP]]<sup>PromiseRP</sup> (i.e. with a single oracle query to PromiseRP). Contained in [[#promisebpp|PromiseBPP]]. ---- ===== <span id="prspace" style="color:red">PrSPACE(f(n))</span>: Unbounded-Error Probabilistic f(n)-Space ===== Has the same relation to [[#dspace|DSPACE]](f(n)) as [[#pp|PP]] does to [[#p|P]]. The Turing machine has to halt with probability 1 on every input. Contained in [[#dspace|DSPACE]](f(n)<sup>2</sup>) [[zooref#bcp83|[BCP83]]]. Equals [[#prhspace|Pr<sub>H</sub>SPACE]](f(n)) [[zooref#jun85|[Jun85]]]. ---- ===== <span id="psel" style="color:red">P-Sel</span>: P-Selective Sets ===== The class of decision problems for which there's a polynomial-time algorithm with the following property. Whenever it's given two instances, a "yes" and a "no" instance, the algorithm can always decide which is the "yes" instance. Defined in [[zooref#sel79|[Sel79]]], where it was also shown that if [[#np|NP]] is contained in P-Sel then [[#p|P]] = [[#np|NP]]. There exist P-selective sets that are not recursive (i.e. not in [[#r|R]]). ---- ===== <span id="psk" style="color:red">PSK</span>: Polynomial Sink ===== Yeah, I'm told that's what the S and K stand for. Go figure. The class of total function problems definable as follows: given a directed graph of indegree and outdegree at most 1, and given a source, find a sink. Defined in [[zooref#pap90|[Pap90]]]. Equals [[#ppads|PPADS]]. ---- ===== <span id="pspace" style="color:red">PSPACE</span>: Polynomial-Space ===== The class of decision problems solvable by a Turing machine in polynomial space. Equals [[#npspace|NPSPACE]] [[zooref#sav70|[Sav70]]], [[#ap|AP]] [[zooref#cks81|[CKS81]]], [[#ip|IP]] [[zooref#sha90|[Sha90]]], and, assuming the existence of one-way functions, [[#czk|CZK]] [[zooref#bgg90|[BGG+90]]]. Contains [[#p|P]] with [[#sharpp|#P]] oracle. A canonical PSPACE-complete problem is [[Complexity_Garden#qbf|QBF]]. Relative to a random oracle, PSPACE strictly contains [[#ph|PH]] with probability 1 [[zooref#cai86|[Cai86]]]. PSPACE has a complete problem that is both downward self-reducible and random self-reducible [[zooref#tv02|[TV02]]]. It is the largest class with such a complete problem. Contained in [[#exp|EXP]]. There exists an oracle relative to which this containment is proper [[zooref#dek76|[Dek76]]]. ---- ===== <span id="pspacepoly" style="color:red">PSPACE/poly</span>: [[#pspace|PSPACE]] With Polynomial-Size Advice ===== Contains [[#qmaqpoly|QMA/qpoly]] [[zooref#aar06b|[Aar06b]]]. ---- ===== <span id="pt1" style="color:red">PT<sub>1</sub></span>: Polynomial Threshold Functions ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that f(x)=sgn(p(x)), where p is a polynomial having a number of terms polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PT<sub>1</sub> contains [[#pl1|PL<sub>1</sub>]] (and this inclusion is strict), and that PT<sub>1</sub> is contained in [[#plinfinity|PL<sub>&#8734;</sub>]] (and this inclusion is strict). ---- ===== <span id="ptape" style="color:red">PTAPE</span>: Archaic for [[#pspace|PSPACE]] ===== ---- ===== <span id="ptas" style="color:red">PTAS</span>: Polynomial-Time Approximation Scheme ===== The subclass of [[#npo|NPO]] problems that admit an <i>approximation scheme</i> in the following sense. For any &#949;&gt;0, there is a polynomial-time algorithm that is guaranteed to find a solution whose cost is within a 1+&#949; factor of the optimum cost. (However, the exponent of the polynomial might depend strongly on &#949;.) Contains [[#fptas|FPTAS]], and is contained in [[#apx|APX]]. As an example, the Traveling Salesman Problem in the Euclidean plane is in PTAS [[zooref#aro96|[Aro96]]]. Defined in [[zooref#acg99|[ACG+99]]]. ---- ===== <span id="ptwk" style="color:red">PT/WK(f(n),g(n))</span>: Parallel Time f(n) / Work g(n) ===== The class of decision problems solvable by a uniform family of Boolean circuits with depth upper-bounded by f(n) and size (number of gates) upper-bounded by g(n). The union of PT/WK(log<sup>k</sup>n, n<sup>k</sup>) over all constants k equals [[#nc|NC]]. ---- ===== <span id="pzk" style="color:red">PZK</span>: Perfect Zero Knowledge ===== Same as [[#szk|SZK]], but now the two distributions must be <i>identical</i>, not merely statistically close. (The "two distributions" are (1) the distribution over Arthur's view of his interaction with Merlin, conditioned on Arthur's random coins, and (2) the distribution over views that Arthur can <i>simulate</i> without Merlin's help.) Contained in [[#szk|SZK]]. See also: [[#czk|CZK]]. ---- ===== <span id="q" style="color:red">Q</span>: Quasi-Realtime Languages ===== The class of problems solvable by a nondeterministic multitape Turing machine in linear time. Defined in [[zooref#bg69|[BG69]]], where it was shown that Q equals the class of problems solvable by a nondeterministic multitape Turing machine in exactly n steps (as opposed to O(n) steps). Contains [[#gcsl|GCSL]]. ---- ===== <span id="qac0" style="color:red">QAC<sup>0</sup></span>: Quantum [[#ac0|AC<sup>0</sup>]] ===== The class of decision problems solvable by a family of constant-depth, polynomial-size quantum circuits. Here each layer of the circuit is a tensor product of one-qubit gates and Toffoli gates, or is a tensor product of controlled-NOT gates. A uniformity condition may also be imposed. Defined in [[zooref#moo99|[Moo99]]]. Contains [[#ac0|AC<sup>0</sup>]], and is contained in [[#qacwf0|QAC<sub>f</sub><sup>0</sup>]]. ---- ===== <span id="qac0m" style="color:red">QAC<sup>0</sup>[m]</span>: Quantum [[#ac0m|AC<sup>0</sup>[m]]] ===== Same as [[#qac0|QAC<sup>0</sup>]], except that now Mod-m gates are also allowed. A Mod-m gate computes whether the sum of a given set of bits is congruent to 0 modulo m, and exclusive-OR's the answer into another bit. Defined in [[zooref#moo99|[Moo99]]]. ---- ===== <span id="qacc0" style="color:red">QACC<sup>0</sup></span>: Quantum [[#acc0|ACC<sup>0</sup>]] ===== Same as [[#qac0m|QAC<sup>0</sup>[m]]], except that Mod-m gates are allowed for any m. Defined in [[zooref#moo99|[Moo99]]]. [[zooref#ghp00|[GHP00]]] showed that QACC<sup>0</sup> equals [[#qac0m|QAC<sup>0</sup>[p]]] for any prime p. ---- ===== <span id="qacwf0" style="color:red">QAC<sub>f</sub><sup>0</sup></span>: [[#qac0|QAC<sup>0</sup>]] With Fanout ===== Same as [[#qac0|QAC<sup>0</sup>]], except that an additional "quantum fanout" gate is available, which CNOT's a qubit into arbitrarily many target qubits in a single step. Defined in [[zooref#moo99|[Moo99]]], where it was also shown that QAC<sub>f</sub><sup>0</sup> = [[#qac0m|QAC<sup>0</sup>]] = [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="qam" style="color:red">QAM</span>: Quantum [[#am|AM]] ===== The class of decision problems for which a "yes" answer can be verified by a public-coin quantum [[#am|AM]] protocol, as follows. Arthur generates a uniformly random (classical) string and sends it to Merlin. Merlin responds with a polynomial-size quantum certificate, on which Arthur can perform any [[#bqp|BQP]] operation. The completeness and soundness requirements are the same as for [[#am|AM]]. Defined by Marriott and Watrous [[zooref#mw05|[MW05]]]. Contains [[#qma|QMA]] and is contained in [[#qip2|QIP]] and BP&#149;[[#pp|PP]] (and therefore [[#pspace|PSPACE]]). ---- ===== <span id="qcfl" style="color:red">QCFL</span>: Quantum [[#cfl|CFL]] ===== The class of decision problems recognized by quantum context-free languages, which are defined in [[zooref#mc00|[MC00]]]. The authors also showed that QCFL does not equal [[#cfl|CFL]]. ---- ===== <span id="qcma" style="color:red">QCMA</span>: Quantum Classical [[#ma|MA]] ===== The class of decision problems for which a "yes" answer can be verified by a <i>quantum</i> computer with access to a <i>classical</i> proof. Also known as the subclass of of QMA with classical witnesses. Contains [[#ma|MA]], and is contained in [[#qma|QMA]]. Given a black-box group G and a subgroup H, the problem of testing non-membership in H has polynomial QCMA query complexity [[zooref#ak06|[AK06]]]. See [[zooref#ak06|[AK06]]] for a "quantum oracle separation" between QCMA and [[#qma|QMA]]. No classical oracle separation between QCMA and [[#qma|QMA]] is currently known. ---- ===== <span id="qh" style="color:red">QH</span>: Query Hierarchy Over [[#np|NP]] ===== QH<sub>k</sub> is defined to be P<sup>NP[k]</sup>; that is, [[#p|P]] with k queries to an [[#np|NP]] oracle (where k is a constant). Then QH is the union of QH<sub>k</sub> over all nonnegative k. QH = [[#bh|BH]] [[zooref#wag88|[Wag88]]]; thus, either both hierarchies are infinite or both collapse to some finite level. ---- ===== <span id="qip" style="color:red">QIP</span>: Quantum [[#ip|IP]] ===== The class of decision problems such that a "yes" answer can be verified by a <i>quantum interactive proof</i>. Here the verifier is a [[#bqp|BQP]] (i.e. quantum polynomial-time) algorithm, while the prover has unbounded computational resources (though cannot violate the linearity of quantum mechanics). The prover and verifier exchange a polynomial number of messages, which can be quantum states. Thus, the verifier's and prover's states may become entangled during the course of the protocol. Given the verifier's algorithm, we require that <ol> <li>If the answer is "yes," then the prover can behave in such a way that the verifier accepts with probability at least 2/3.</li> <li>If the answer is "no," then however the prover behaves, the verifier rejects with probability at least 2/3.</li> </ol> Let QIP[k] be QIP where the prover and verifier are restricted to exchanging k messages (with the prover going last). Defined in [[zooref#wat99|[Wat99]]], where it was also shown that [[#pspace|PSPACE]] is in QIP. Subsequently [[zooref#kw00|[KW00]]] showed that for all k&gt;3, QIP[k] = QIP = QIP. QIP is contained in [[#exp|EXP]] [[zooref#kw00|[KW00]]]. QIP(1) is more commonly known as [[#qma|QMA]]. See also: [[#qip2|QIP]], [[#qszk|QSZK]]. ---- ===== <span id="qip2" style="color:red">QIP</span>: 2-Message Quantum [[#ip|IP]] ===== See [[#qip|QIP]] for definition. Contains [[#qszk|QSZK]] [[zooref#wat02|[Wat02]]]. ---- ===== <span id="qma" style="color:red">QMA</span>: Quantum [[#ma|MA]] ===== The class of decision problems such that a "yes" answer can be verified by a 1-message quantum interactive proof. That is, a [[#bqp|BQP]] (i.e. quantum polynomial-time) verifier is given a quantum state (the "proof"). We require that <ol> <li>If the answer is "yes," then there exists a state such that verifier accepts with probability at least 2/3.</li> <li>If the answer is "no," then for all states the verifier rejects with probability at least 2/3.</li> </ol> QMA = [[#qip|QIP]](1). Defined in [[zooref#wat00|[Wat00]]], where it is also shown that <i>group non-membership</i> is in QMA. That is: let G be a group, whose elements are represented by polynomial-size strings. We're given a "black box" that correctly multiplies and inverts elements of G. Then given elements g and h<sub>1</sub>,...,h<sub>k</sub>, we can verify in QMA that g is not in the subgroup generated by h<sub>1</sub>,...,h<sub>k</sub>. Based on this, [[zooref#wat00|[Wat00]]] gives an oracle relative to which [[#ma|MA]] is strictly contained in QMA. Kitaev and Watrous (unpublished) showed QMA is contained in [[#pp|PP]]. Combining that result with [[zooref#ver92|[Ver92]]], one can obtain an oracle relative to which [[#am|AM]] is not in QMA. Kitaev ([[zooref#ksv02|[KSV02]]], see also [[zooref#an02|[AN02]]]) showed that the following problem is complete for QMA: <ul> '''5-Local Hamiltonians.''' Given an n-qubit Hilbert space, as well as a collection H<sub>1</sub>,...,H<sub>k</sub> of Hamiltonians (i.e. Hermitian positive semidefinite matrices), each of which acts on at most 5 qubits of the space. Also given reals a,b such that b-a = &Theta;(1/poly(n)). Decide whether the smallest eigenvalue of H=H<sub>1</sub>+...+H<sub>k</sub> is less than a or greater than b, promised that one of these is the case. Subsequently Kempe and Regev [[zooref#kr03|[KR03]]] showed that even 3-Local Hamiltonians is QMA-complete. A subsequent paper by Kempe, Kitaev, and Regev [[zooref#kkr04|[KKR04]]], has hit rock bottom (assuming [[#p|P]] does not equal QMA), by showing '''<font color="red">2</font>'''-local Hamiltonians QMA-complete. </ul> Compare to [[#nqp|NQP]]. If QMA = [[#pp|PP]] then [[#pp|PP]] contains [[#ph|PH]] [[zooref#vya03|[Vya03]]]. This result uses the fact that QMA is contained in [[#a0pp|A<sub>0</sub>PP]]. Approximating the ground state energy of a system composed of a line of quantum particles is QMA-complete [[zooref#agk07|[AGK07]]]. See also: [[#qcma|QCMA]], [[#qmaqpoly|QMA/qpoly]], [[#qszk|QSZK]], [[#qma2|QMA(2)]], [[#qma-plus|QMA-plus]]. ---- ===== <span id="qma-plus" style="color:red">QMA-plus</span>: [[#qma|QMA]] With Super-Verifier ===== Same as [[#qma|QMA]], except now the verifier can directly obtain the <i>probability</i> that a given observable of the certificate state, if measured, would equal 1. (In the usual model, by contrast, one can only sample an observable.) Defined in [[zooref#ar03|[AR03]]], where it was also shown that QMA-plus = [[#qma|QMA]]. ---- ===== <span id="qma2" style="color:red">QMA(2)</span>: Quantum [[#ma|MA]] With Multiple Certificates ===== Same as [[#qma|QMA]], except that now the verifier is given <i>two</i> polynomial-size quantum certificates, which are guaranteed to be unentangled. Defined in [[zooref#kmy01|[KMY01]]]. It is unknown whether QMA(k) = QMA(2) for all k>2, and also whether QMA(2) = [[#qma|QMA]]. ---- ===== <span id="qma1" style="color:red">QMA<sub>1</sub></span>: One Sided [[#qma|QMA]] ===== Same as [[#qma|QMA]] except that for a "yes" instance, there exists a state that is accepted with probability 1. Defined in [[zooref#bra06|[Bra06]]]. It was shown there that Quantum k-SAT is QMA<sub>1</sub>-complete for any $k \geq 4$. It was also shown there that Quantum 2-SAT is in P, and the status of Quantum 3-SAT still remains unknown. ---- ===== <span id="qmalog" style="color:red">QMA<sub>log</sub></span>: [[#qma|QMA]] With Logarithmic-Size Proofs ===== Same as [[#qma|QMA]] except that the quantum proof has O(log n) qubits instead of a polynomial number. Equals [[#bqp|BQP]] [[zooref#mw05|[MW05]]]. ---- ===== <span id="qmam" style="color:red">QMAM</span>: Quantum Merlin-Arthur-Merlin Public-Coin Interactive Proofs ===== The class of decision problems for which a "yes" answer can be verified by a public-coin quantum MAM protocol, as follows. Merlin sends a polynomial-size quantum state to Arthur. Arthur then flips some classical coins (in fact, he only has to flip <i>one</i> without loss of generality) and sends the outcome to Merlin. At this stage Arthur is not yet allowed to perform any quantum operations. Merlin then sends Arthur another quantum state. Finally, Arthur performs a [[#bqp|BQP]] operation on both of the states simultaneously, and either accepts or rejects. The completeness and soundness requirements are the same as for [[#am|AM]]. Also, Merlin's messages might be entangled. Defined by Marriott and Watrous [[zooref#mw05|[MW05]]], who also showed that QMAM = [[#qip|QIP]](3) = [[#qip|QIP]]. Hence QMAM contains [[#pspace|PSPACE]]. ---- ===== <span id="qmaqpoly" style="color:red">QMA/qpoly</span>: [[#qma|QMA]] With Polynomial-Size Quantum Advice ===== Is contained in [[#pspacepoly|PSPACE/poly]] [[zooref#aar06b|[Aar06b]]]. ---- ===== <span id="qmip" style="color:red">QMIP</span>: Quantum Multi-Prover Interactive Proofs ===== The quantum generalization of [[#mip|MIP]], and the multi-prover generalization of [[#qip|QIP]]. A quantum multi-prover interactive proof system is the same as a classical one, except that all messages and verifier computations are quantum. As in [[#mip|MIP]], there is no communication among the provers; however, the provers share unlimited prior entanglement. The number of provers and number of rounds can both be polynomial in n. Defined in [[zooref#km02|[KM02]]]. Fascinatingly, no relationship between QMIP and [[#nexp|NEXP]] is known. We don't know whether allowing the provers unlimited prior entanglement makes the class more powerful, less powerful, or both! ---- ===== <span id="qmiple" style="color:red">QMIP<sub>le</sub></span>: Quantum Multi-Prover Interactive Proofs With Limited Prior Entanglement ===== Same as [[#qmip|QMIP]], except that now the provers share only a polynomial number of EPR pairs, instead of an unlimited number. Defined in [[zooref#km02|[KM02]]], where it was also shown that QMIP<sub>le</sub> is contained in [[#nexp|NEXP]] = [[#qmipne|QMIP<sub>ne</sub>]]. ---- ===== <span id="qmipne" style="color:red">QMIP<sub>ne</sub></span>: Quantum Multi-Prover Interactive Proofs With No Prior Entanglement ===== Same as [[#qmip|QMIP]], except that now the provers have no prior entanglement. Defined in [[zooref#km02|[KM02]]], where it was also shown that QMIP<sub>ne</sub> = [[#nexp|NEXP]]. Thus, QMIP<sub>ne</sub> contains [[#qmiple|QMIP<sub>le</sub>]]. ---- ===== <span id="qnc" style="color:red">QNC</span>: Quantum [[#nc|NC]] ===== The class of decision problems solvable by polylogarithmic-depth quantum circuits with bounded probability of error. (A uniformity condition may also be imposed.) Has the same relation to [[#nc|NC]] as [[#bqp|BQP]] does to [[#p|P]]. [[zooref#cw00|[CW00]]] showed that [[Complexity_Garden#integer_factorization|factoring]] is in [[#zpp|ZPP]] with a QNC oracle. Is incomparable with [[#bpp|BPP]] as far as anyone knows. See also: [[#rnc|RNC]]. ---- ===== <span id="qnc0" style="color:red">QNC<sup>0</sup></span>: Quantum [[#nc0|NC<sup>0</sup>]] ===== Constant-depth quantum circuits without fanout gates. Defined in [[zooref#spa02|[Spa02]]]. Contained in [[#qncf0|QNC<sub>f</sub><sup>0</sup>]]. ---- ===== <span id="qncf0" style="color:red">QNC<sub>f</sub><sup>0</sup></span>: Quantum [[#nc0|NC<sup>0</sup>]] With Unbounded Fanout ===== Constant-depth quantum circuits with unbounded-fanout gates. Defined in [[zooref#spa02|[Spa02]]]. Contains [[#qnc0|QNC<sup>0</sup>]], and is contained in [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="qnc1" style="color:red">QNC<sup>1</sup></span>: Quantum [[#nc1|NC<sup>1</sup>]] ===== Same as [[#qnc|QNC]]<sup>1</sup>, but for the exact rather than bounded-error case. In contrast to [[#nc1|NC<sup>1</sup>]], it is not clear how to simulate QNC<sup>1</sup> on a quantum computer in which one qubit is initialized to a pure state, and the remaining qubits are in the maximally mixed state [[zooref#asv00|[ASV00]]]. See also [[zooref#mn02|[MN02]]]. ---- ===== <span id="qp" style="color:red">QP</span>: Quasipolynomial-Time ===== Equals [[#dtime|DTIME]](2<sup>polylog(n)</sup>). ---- ===== <span id="qplin" style="color:red">QPLIN</span>: Linear Quasipolynomial-Time ===== Equals [[#dtime|DTIME]](n<sup>O(log n)</sup>). Has the same relationship to [[#qp|QP]] that [[#e|E]] does to [[#exp|EXP]]. ---- ===== <span id="qpspace" style="color:red">QPSPACE</span>: Quasipolynomial-Space ===== Equals [[#dspace|DSPACE]](2<sup>polylog(n)</sup>). According to [[zooref#bg94|[BG94]]], Beigel and Feigenbaum and (independently) Krawczyk showed that QPSPACE is not contained in [[#check|Check]]. ---- ===== <span id="qrg" style="color:red">QRG</span>: Quantum Refereed Games ===== Same as [[#rg|RG]], except that now the verifier is a [[#bqp|BQP]] machine, and can exchange polynomially many quantum messages with the competing provers. The two provers are computationally unbounded, but must obey the laws of quantum mechanics. Also, we can assume without loss of generality that the provers share no entanglement, because adversaries gain no advantage by sharing information. Defined in [[zooref#gut05|[Gut05]]], where it was also shown that QRG is contained in [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]]. QRG trivially contains [[#rg|RG]] (and hence [[#exp|EXP]]), as well as [[#sqg|SQG]]. ---- ===== <span id="qs2p" style="color:red">QS<sub>2</sub>P</span>: Quantum [[#s2p|S<sub>2</sub>P]] ===== The class of problems for which there exists a [[#bqp|BQP]] machine M such that: <ul> <li>If the answer is "yes," then there exists a quantum state &rho; such that for all quantum states &sigma;, M(&rho;,Ï) accepts with probability at least 2/3.</li> <li>If the answer is "no," then there exists a &sigma; such that for all &rho;, M(&rho;,&sigma;) rejects with probability at least 2/3.</li> </ul> In other words, it's the same as [[#sqg|SQG]], but without communication from the verifier back to the provers. Contains [[#qma|QMA]] (and indeed [[#p|P]]<sup>[[#qma|QMA]]</sup>), and is contained in [[#sqg|SQG]] and hence [[#exp|EXP]]. ---- ===== <span id="qszk" style="color:red">QSZK</span>: Quantum Statistical Zero-Knowledge ===== A quantum analog of [[#szk|SZK]] (or more precisely [[#hvszk|HVSZK]]). Arthur is a [[#bqp|BQP]] (i.e. quantum) verifier who can exchange quantum messages with Merlin. So Arthur and Merlin's states may become entangled during the course of the protocol. Arthur's "view" of his interaction with Merlin is taken to be the sequence of mixed states he has, over all steps of the protocol. The zero-knowledge requirement is that each of these states must have trace distance at most (say) 1/10 from a state that Arthur could prepare himself (in [[#bqp|BQP]]), without help from Merlin. Arthur is assumed to be an honest verifier. Defined in [[zooref#wat02|[Wat02]]], where the following was also shown: <ul> <li>QSZK is contained in [[#pspace|PSPACE]].</li> <li>QSZK is closed under complement.</li> <li>Any protocol can be parallelized to consist of two messages, so that QSZK is in [[#qip2|QIP]].</li> <li>One can assume without loss of generality that protocols are public-coin, as for [[#szk|SZK]].</li> <li>QSZK has a natural complete promise problem, called <i>Quantum State Distinguishability</i> (QSD). We are given quantum circuits Q<sub>0</sub> and Q<sub>1</sub>. Let &#961;<sub>0</sub> and &#961;<sub>1</sub> be the mixed states they produce respectively, when run on the all-0 state (and when non-output qubits are traced out). We are promised that the trace distance between &#961;<sub>0</sub> and &#961;<sub>1</sub> is either at most &#945; or at least &#946;, where &#945; and &#946; are constants in [0,1] satisfying &#945; &lt; &#946;<sup>2</sup>. The problem is to decide which of these is the case.</li> </ul> ---- ===== <span id="r" style="color:red">R</span>: Recursive Languages ===== The class of decision problems solvable by a Turing machine. Often identified with the class of 'effectively computable' functions (the <i>Church-Turing thesis</i>). Defined in [[zooref#tur36|[Tur36]]], [[zooref#chu41|[Chu41]]], and other seminal early papers. Equals [[#re|RE]] &#8745; [[#core|coRE]]. Strictly contains [[#pr|PR]], the primitive recursive functions (see [[zooref#kle71|[Kle71]]]). ---- ===== <span id="rbqp" style="color:red">RBQP</span>: Strict Quantum [[#rp|RP]] ===== The class of problems in [[#np|NP]] whose witnesses are in [[#fbqp|FBQP]]. For example, the set of square-free numbers is in coRBQP using only the fact that [[Complexity_Garden#integer_factorization|factoring]] is in [[#fbqp|FBQP]]. (Even without a proof that the factors are prime, the factorization proves that there is a square divisor.) Contains [[#rp|RP]] and [[#zbqp|ZBQP]], and is contained in [[#bqp|BQP]] and [[#rqp|RQP]]. Defined here to clarify [[#eqp|EQP]]; see also [[#zbqp|ZBQP]]. ---- ===== <span id="re" style="color:red">RE</span>: Recursively Enumerable Languages ===== The class of decision problems for which a 'yes' answer can be verified by a Turing machine in a finite amount of time. (If the answer is 'no,' on the other hand, the machine might never halt.) Equivalently, the class of decision problems for which a Turing machine can list all the 'yes' instances, one by one (this is what 'enumerable' means). A problem C is complete for RE if (1) C is in RE and (2) any problem in RE can be reduced to C by a Turing machine. Actually there are two types of reduction: M-reductions (for <i>many-one</i>), in which a single instance of the original problem is mapped to an instance of C, and T-reductions (for <i>Turing</i>), in which an algorithm for the original problem can make arbitrarily many calls to an oracle for C. RE-complete sets are also called <i>creative</i> sets for some reason. The canonical RE-complete problem is the <i>halting problem</i>: i.e., given a Turing machine, does it halt when started on a blank tape? The famous unsolvability of the halting problem [[zooref#tur36|[Tur36]]] implies that [[#r|R]] does not equal RE. Also, RE does not equal [[#core|coRE]]. RE and [[#core|coRE]] can be generalized to the <i>arithmetic hierarchy</i> [[#ah|AH]]. There are problems in RE that are neither RE-complete under T-reductions, nor in [[#r|R]] [[zooref#fri57|[Fri57]]] [[zooref#muc56|[Muc56]]]. This is the resolution of <i>Post's problem</i> [[zooref#pos44|[Pos44]]]. Indeed, RE contains infinitely many nonequivalent 'T-degrees.' (A T-degree is a class of problems, all of which can be T-reduced to one another.) The structure of the T-degrees has been studied in more detail than you can possibly imagine [[zooref#sho99|[Sho99]]]. ---- ===== <span id="reg" style="color:red">REG</span>: Regular Languages ===== The class of decision problems solvable by deterministic finite automata (DFA's). Equals the class solvable by nondeterministic finite automata (NDFA's). Equals [[#dspace|DSPACE]](O(1)) [[zooref#she59|[She59]]], which equals [[#dspace|DSPACE]](o(log log n)) [[zooref#hls65|[HLS65]]]. Includes, i.e., "Is the parity of the input odd?," but not "Are the majority of bits in the input 1's?" This is sometimes expressed as "finite automata can't count." Contained in [[#nc1|NC<sup>1</sup>]]. See e.g. [[zooref#koz97|[Koz97]]], [[zooref#gur89|[Gur89]]] for basic results on regular languages. ---- ===== <span id="revspace" style="color:red">RevSPACE(f(n))</span>: Reversible f(n)-Space ===== The class of decision problems solvable in space O(f(n)) by a reversible Turing machine (a deterministic Turing machine for which every configuration has at most one immediate predecessor). Was shown to equal [[#dspace|DSPACE]](f(n)) [[zooref#lmt97|[LMT97]]]. ---- ===== <span id="rg" style="color:red">RG</span>: Refereed Games ===== The class of problems solvable by a probabilistic polynomial-time verifier who can exchange a polynomial number of messages with two competing, computationally-unbounded provers -- one trying to convince the verifier that the answer is "yes," the other that the answer is "no." Note that the verifier can hide information from the provers. Public-coin RG amounts to [[#saptime|SAPTIME]], which equals [[#pspace|PSPACE]] [[zooref#pap83|[Pap83]]]. RG is in [[#exp|EXP]] relative to any oracle [[zooref#km92|[KM92]]]; they are equal, unrelativized [[zooref#fk97b|[FK97b]]]. Contains [[#rg1|RG]], and is contained in [[#qrg|QRG]]. See also [[#pcd|PCD]], [[#gpcd|GPCD]]. ---- ===== <span id="rg1" style="color:red">RG</span>: One-Round Refereed Games ===== Same as [[#rg|RG]], except that now the verifier can exchange only a single round of messages with the two provers. A <i>round</i> consists of private messages from the verifier to the provers, followed by private responses from the provers to the verifier. Since the queries are private, they may as well be parallel; likewise the responses. This makes RG a symmetric class, indeed a randomized analogue of [[#s2p|S<sub>2</sub>P]]. RG is contained in [[#pspace|PSPACE]], and they are equal, unrelativized [[zooref#fk97b|[FK97b]]]. Contains [[#s2p|S<sub>2</sub>P]] and is contained in [[#sqg|SQG]]. ---- ===== <span id="rhl" style="color:red">R<sub>H</sub>L</span>: Randomized Halting Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#rp|RP]] does to [[#p|P]]. The randomized machine must halt for every input <i>and</i> every setting of the random tape. Contains undirected reachability (is there a path from vertex u to vertex v in an undirected graph?) [[zooref#akl79|[AKL+79]]]. Contained in [[#rl|RL]]. ---- ===== <span id="rhspace" style="color:red">R<sub>H</sub>SPACE(f(n))</span>: One-Sided Error Halting Probabilistic f(n)-Space ===== Has the same relation to [[#bphspace|BP<sub>H</sub>SPACE(f(n))]] as [[#rp|RP]] does to [[#bpp|BPP]]. ---- ===== <span id="rl" style="color:red">RL</span>: Randomized Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#rp|RP]] does to [[#p|P]]. The randomized machine must halt with probability 1 on any input. It must also run in polynomial time (since otherwise we would just get [[#nl|NL]]). Contains [[#rhl|R<sub>H</sub>L]]. Contained in [[#sc|SC]] [[zooref#nis92|[Nis92]]]. [[zooref#rtv05|[RTV05]]] give strong evidence that RL = [[#l|L]]. ---- ===== <span id="rnc" style="color:red">RNC</span>: Randomized [[#nc|NC]] ===== Has the same relation to [[#nc|NC]] as [[#rp|RP]] does to [[#p|P]]. Contains the maximum matching problem for bipartite graphs [[zooref#mvv87|[MVV87]]]. Contained in [[#qnc|QNC]]. See also: [[#cornc|coRNC]]. ---- ===== <span id="rp" style="color:red">RP</span>: Randomized Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' at least 1/2 of computation paths accept.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ah87|[AH87]]]. For other problems in RP, see the standard text on randomized algorithms, [[zooref#mr95|[MR95]]]. See also: [[#corp|coRP]], [[#zpp|ZPP]], [[#bpp|BPP]]. ---- ===== <span id="rpp" style="color:red">RPP</span>: Restricted Pseudo Polynomial-Time ===== The class of decision problems (x,m) (where x is an input of length |x|=n and m is an integer parameter), that are solvable by a nondeterministic (i.e. [[#np|NP]]) machine in poly(n+m) time and O(m+log n) space simultaneously. Defined in [[zooref#mon80|[Mon80]]]. See also [[#fpt|FPT]]. ---- ===== <span id="rqp" style="color:red">RQP</span>: One-sided Error Extension of [[#eqp|EQP]] ===== The class of questions that can be answered by a QTM that accepts with probability 0 when the true answer is no, and accepts with probability at least 1/2 when the true answer is yes. Since one of the probabilities has to vanish, RQP has the same technical caveats as [[#eqp|EQP]]. Contains [[#zqp|ZQP]] and [[#rbqp|RBQP]], and is contained in [[#bqp|BQP]]. ---- ===== <span id="rspace" style="color:red">RSPACE(f(n))</span>: Randomized f(n)-Space ===== Same as [[#rl|RL]], but for O(f(n))-space instead of logarithmic-space. Contained in [[#nspace|NSPACE(f(n))]] and [[#bpspace|BPSPACE(f(n))]]. ---- ===== <span id="s2p" style="color:red">S<sub>2</sub>P</span>: Second Level of the Symmetric Hierarchy ===== The class of decision problems for which there is a polynomial-time predicate P such that, on input x, <ol> <li>If the answer is 'yes,' then there exists a y such that for all z, P(x,y,z) is true.</li> <li>If the answer is 'no,' then there exists a z such that for all y, P(x,y,z) is false.</li> </ol> Note that this differs from [[#sigma2p|&#931;<sub>2</sub>P]] in that the quantifiers in the second condition are reversed. Less formally, S<sub>2</sub>P is the class of one-round games in which a prover and a disprover submit simultaneous moves to a deterministic, polynomial-time referee. In [[#sigma2p|&#931;<sub>2</sub>P]], the disprover moves first. Defined in [[zooref#rs98|[RS98]]], where it was also shown that S<sub>2</sub>P contains [[#ma|MA]] and [[#delta2p|&#916;<sub>2</sub>P]]. Defined independently in [[zooref#can96|[Can96]]]. Contained in [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#cai01|[Cai01]]]. ---- <table border="3"><tr><td> ===== <span id="s2exppnp" style="color:red">S<sub>2</sub>-EXP&#149;P<sup>NP</sup></span>: Don't Ask ===== One of the caged classes of the Complexity Zoo. Has been implicated in a collapse scandal involving [[#ampolylog|AM[polylog]]], [[#conp|coNP]], and [[#eh|EH]]. </td></tr></table> ---- ===== <span id="sac" style="color:red">SAC</span>: Semi-Unbounded-Fanin [[#ac|AC]] ===== SAC<sup>k</sup> is the class of decision problems solvable by a family of depth-O(log<sup>k</sup>n) circuits with unbounded-fanin OR & bounded-fanin AND gates. Negations are only allowed at the input level. A uniformity condition may also be imposed. Defined by [[zooref#bcd89|[BCD+89]]], who also showed that SAC<sub>k</sub> is closed under complement for every k&gt;0. ---- ===== <span id="sac0" style="color:red">SAC<sup>0</sup></span>: Semi-Unbounded-Fanin [[#ac0|AC<sup>0</sup>]] ===== See [[#sac|SAC]] for definition. Not closed under complement [[zooref#bcd89|[BCD+89]]]. ---- ===== <span id="sac1" style="color:red">SAC<sup>1</sup></span>: Semi-Unbounded-Fanin [[#ac1|AC<sup>1</sup>]] ===== See [[#sac|SAC]] for definition. Equals [[#logcfl|LOGCFL]]/poly [[zooref#ven91|[Ven91]]]. Contained in [[#paritysac1|&#8853;SAC<sup>1</sup>]] [[zooref#gw96|[GW96]]]. ---- ===== <span id="saptime" style="color:red">SAPTIME</span>: Stochastic Alternating Polynomial-Time ===== The class of problems solvable by a polynomial-time Turing machine with three kinds of quantifiers: existential, universal, and randomized. Defined in [[zooref#pap83|[Pap83]]], where it was also observed that SAPTIME = [[#pspace|PSPACE]]. ---- ===== <span id="sbp" style="color:red">SBP</span>: Small Bounded-Error Probability ===== The class of decision problems for which the following holds. There exists a [[#sharpp|#P]] function f and an [[#fp|FP]] function g such that, for all inputs x, <ol> <li>If the answer is "yes" then f(x) &gt; g(x).</li> <li>If the answer is "no" then f(x) &lt; g(x)/2.</li> </ol> Defined in [[zooref#bgm02|[BGM02]]], where the following was also shown: <ul> <li>SBP contains [[#ma|MA]], [[#wapp|WAPP]], and [[#existsbpp|&#8707;BPP]].</li> <li>SBP is contained in [[#am|AM]] and [[#bpppath|BPP<sub>path</sub>]].</li> <li>There exists an oracle relative to which SBP is not contained in [[#sigma2p|&#931;<sub>2</sub>P]].</li> <li>SBP is closed under union.</li> </ul> ---- ===== <span id="sc" style="color:red">SC</span>: Steve's Class ===== (Named in honor of Stephen Cook.) The class of decision problems solvable by a Turing machine that simultaneously uses polynomial time and polylogarithmic space. Note that SC might be smaller than [[#p|P]] &#8745; [[#polyL|polyL]], since for the latter, it suffices to have two separate algorithms: one polynomial-time and the other polylogarithmic-space. Deterministic context-free languages (DCFL's) can be recognized in SC [[zooref#coo79|[Coo79]]]. SC contains [[#rl|RL]] and [[#bpl|BPL]] [[zooref#nis92|[Nis92]]]. SC equals [[#dtisp|DTISP]](poly,polylog) by definition. ---- ===== <span id="se" style="color:red">SE</span>: Subexponentially-Solvable Search Problems ===== The class of [[#fnp|FNP]] search problems solvable in O(2<sup>&epsilon;n</sup>) time for every &epsilon;&gt;0. Defined in [[zooref#ipz01|[IPZ01]]], who also gave reductions showing that if any of k-SAT, k-colorability, k-set cover, clique, or vertex cover is in SE, then all of them are. ---- ===== <span id="seh" style="color:red">SEH</span>: Strong Exponential Hierarchy ===== The union of [[#ne|NE]], [[#np|NP]]<sup>[[#ne|NE]]</sup>, [[#np|NP]]<sup>[[#np|NP]]^[[#ne|NE]]</sup>, and so on. Is called "strong" to contrast it with the ordinary Exponential Hierarchy [[#eh|EH]]. Note that we would get the same class if we replaced [[#ne|NE]] by [[#nexp|NEXP]]. SEH collapses to [[#p|P]]<sup>[[#ne|NE]]</sup> [[zooref#hem89|[Hem89]]] There exists an oracle relative to which SEH is not contained in [[#eh|EH]] [[zooref#hem89|[Hem89]]]. [[#eh|EH]] and SEH are incomparable for all anyone knows. ---- ===== <span id="selfnp" style="color:red">SelfNP</span>: Self-Witnessing [[#np|NP]] ===== The class of languages L in [[#np|NP]] such that the union, over all x in L, of the set of valid witnesses for x equals L itself. Defined in [[zooref#ht03|[HT03]]], where it was shown that the closure of SelfNP under polynomial-time many-one reductions is [[#np|NP]]. They also show that if SelfNP = [[#np|NP]], then [[#e|E]] = [[#ne|NE]]; and that SAT is contained in SelfNP. See also: [[#permup|PermUP]]. ---- ===== <span id="sfk" style="color:red">SF<sub>k</sub></span>: Width-k Bottleneck Turing Machines ===== The class of decision problems solvable by a k-bottleneck Turing machine. This is a machine that, after a polynomial amount of time, erases everything on the tape except for a single k-valued "safe-storage". There's also a counter recording the number of erasings, which is in effect a non-deterministic witness. For example, SF<sub>2</sub> contains both [[#parityp|&#8853;P]] and [[#np|NP]] by using the counter as a witness. Defined in [[zooref#cf91|[CF91]]], where it was also shown that SF<sub>5</sub> = [[#pspace|PSPACE]]. The complexity of SF<sub>2</sub>, SF<sub>3</sub>, and SF<sub>4</sub> was studied in [[zooref#ogi94|[Ogi94]]] and [[zooref#her97|[Her97]]]. The following result of those authors is among the caged beasts of the Complexity Zoo: <table border="3"> <tr><td> SF<sub>4</sub> is contained in BP [[#parityp|&#8853;P]]<sup>[[#modkp|Mod_3P]] ^ [[#parityp|&#8853;P]] ^ [[#modkp|Mod_3P]] ^ [[#parityp|&#8853;P]]</sup> </td></tr> </table> (Here the BP operator means that one makes the class into a bounded-error probabilistic class, the same way one makes [[#p|P]] into [[#bpp|BPP]] and [[#np|NP]] into [[#am|AM]].) ---- ===== <span id="sigma2p" style="color:red">&#931;<sub>2</sub>P</span>: [[#np|NP]] With [[#np|NP]] Oracle ===== Complement of [[#pi2p|&#928;<sub>2</sub>P]]. Along with [[#pi2p|&#928;<sub>2</sub>P]], comprises the second level of [[#ph|PH]], the polynomial hierarchy. [[zooref#uma98|[Uma98]]] has shown that the following problems are complete for &#931;<sub>2</sub>P: <ul> <li><i>Minimum equivalent DNF.</i> Given a DNF formula F and integer k, is there a DNF formula equivalent to F with k or fewer occurences of literals?</li> <li><i>Shortest implicant.</i> Given a formula F and integer k, is there a conjunction of k or fewer literals that implies F? (Note that this problem cannot be &#931;<sub>2</sub>P-complete for <i>DNF</i> formulas unless &#931;<sub>2</sub>P equals [[#betap|&beta;P]]<sup>[[#np|NP]]</sup>.)</li> </ul> For any fixed k, there is a problem in &#931;<sub>2</sub>P &#8745; [[#pi2p|&#928;<sub>2</sub>P]] that cannot be solved by circuits of size n<sup>k</sup> [[zooref#kan82|[Kan82]]]. ---- ===== <span id="skc" style="color:red">SKC</span>: Statistical Knowledge Complexity ===== A hierarchy of generalizations of [[#szk|SZK]], in which Arthur is allowed to gain <i>some</i> information from his interaction with Merlin. Defined in [[zooref#gp91|[GP91]]]. There are several variants (which we only describe roughly), including: <ul> <li>'''SKC<sub>hint</sub>(k(n)): Hint sense.''' The simulator can reproduce Arthur's view of the protocol if given a hint string of size k(n).</li> <li>'''SKC<sub>hint</sub>(k(n)): Strict oracle sense.''' The simulator can reproduce Arthur's view if allowed k(n) queries to an oracle O.</li> <li>'''SKC<sub>avg</sub>(k(n)): Average oracle sense.''' For each input, the <i>expected</i> number of queries the simulator makes to oracle O is at most k(n).</li> <li>'''SKC<sub>ent</sub>(k(n)): Entropy sense.''' Defined in [[zooref#abv95|[ABV95]]]. For each input, the expectation (over Arthur's random coins) of -log(P) is at most k(n), where P is the probability that the view output by the simulator equals the view resulting from the actual protocol.</li> </ul> See also: [[#pkc|PKC]]. ---- ===== <span id="sl" style="color:red">SL</span>: Symmetric Logarithmic-Space ===== The class of problems solvable by a nondeterministic Turing machine in logarithmic space, such that <ol> <li>If the answer is 'yes,' one or more computation paths accept.</li> <li>If the answer is 'no,' all paths reject.</li> <li>If the machine can make a nondeterministic transition from configuration A to configuration B, then it can also transition from B to A. (This is what 'symmetric' means.)</li> </ol> Defined in [[zooref#lp82|[LP82]]]. The reachability problem (is there a path from vertex s to vertex t?) for undirected graphs is complete for SL, under [[#l|L]]-reduction. SL contains [[#l|L]], and is contained in [[#nl|NL]]. It follows from [[zooref#akl79|[AKL+79]]] that SL is contained in [[#l/poly|L/poly]]. [[zooref#kw93|[KW93]]] showed that SL is contained in [[#parityl|&#8853;L]], as well as [[#modkl|Mod<sub>k</sub>L]] for every prime k. SL is also contained in [[#dspace|DSPACE]](log<sup>3/2</sup>n) [[zooref#nsw92|[NSW92]]], and indeed in [[#dspace|DSPACE]](log<sup>4/3</sup>n) [[zooref#atw00|[ATW+00]]]. [[zooref#nt95|[NT95]]] showed that SL equals [[#cosl|coSL]], and furthermore that SL<sup>SL</sup> = SL (that is, the symmetric logspace hierarchy collapses). The story ends with the remarkable result that SL = [[#l|L]] (even relative to an oracle) [[zooref#rei04|[Rei04]]]. ---- ===== <span id="slicewisepspace" style="color:red">SLICEWISE PSPACE</span>: Parametrized [[#pspace|PSPACE]] ===== The parameterized version of [[#pspace|PSPACE]]. Same as [[#fpt|FPT]], except that now on input (x,k) (k a parameter), the <i>space</i> used must be f(k)p(|x|), where p is a polynomial. If [[#p|P]] = [[#pspace|PSPACE]], then [[#fpt|FPT]] = SLICEWISE PSPACE. Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="snp" style="color:red">SNP</span>: Strict [[#np|NP]] ===== [[zooref#fag74|[Fag74]]] showed that [[#np|NP]] is precisely the class of decision problems reducible to a graph-theoretic property expressible in second-order existential logic. For example (see [[zooref#pap94|[Pap94]]]), the property "graph G has a Hamiltonian path" is expressible as <ul> There exists a relation P(u,v) on vertices of G, such that P(u,u) is false, and for all distinct u,v either P(u,v) or P(v,u), and P(u,v) and P(v,w) implies P(u,w), and if P(u,w) and there does not exist a v for which P(u,v) and P(v,w), then there is an edge from u to w. </ul> (Here the relation P(u,v) defines a <i>total order</i> on vertices, such that any two consecutive vertices must be adjacent.) Then SNP is the class of decision problems reducible to a graph-theoretic predicate with <i>only</i> universal quantifiers over vertices, no existential quantifiers. As an example, k-SAT (CNF satisfiability with at most k literals per clause, for k a constant) is in SNP. But general SAT is not in SNP, basically because we're not allowed to say, "There exists a literal in this clause that satisfies the clause." Contains [[#mmsnp|MMSNP]]. See also: [[#maxsnp|MaxSNP]]. ---- ===== <span id="soe" style="color:red">SO-E</span>: Second Order Existential ===== The class of decision problems for which a "yes" answer is expressible by a proposition with second-order existential quantifiers followed by a first-order formula. See [[zooref#imm98|[Imm98]]] for a full definition. SO-E = [[#np|NP]] [[zooref#fag74|[Fag74]]]. Contains [[#fo|FO]](poly(n)). ---- ===== <span id="sp" style="color:red">SP</span>: Semi-Efficient Parallel ===== The class of problems in [[#p|P]] for which the best parallel algorithm (using a polynomial number of processors) is faster than the best serial algorithm by a factor of &Omega;(n<sup>&epsilon;</sup>) for some &epsilon;&gt;0. Defined in [[zooref#krs90|[KRS90]]]. SP is also an alternate name for [[#xpuniform|XP<sub>uniform</sub>]] ---- ===== <span id="spanp" style="color:red">span-P</span>: Span Polynomial-Time ===== The class of functions computable as |S|, where S is the set of output values returned by the accepting paths of an [[#np|NP]] machine. Defined in [[zooref#kst89|[KST+89]]], where it is also shown that span-P contains [[#sharpp|#P]] and [[#optp|OptP]]; and that span-P = [[#sharpp|#P]] if and only if [[#up|UP]] = [[#np|NP]]. ---- ===== <span id="sparse" style="color:red">SPARSE</span>: Sparse Languages ===== The class of decision problems for which the number of 'yes' instances of size n is upper-bounded by a polynomial in n. If SPARSE intersects [[#npc|NPC]] then [[#p|P]] = [[#np|NP]] [[zooref#mah82|[Mah82]]]. Contains [[#tally|TALLY]]. ---- ===== <span id="spl" style="color:red">SPL</span>: Stoic [[#pl|PL]] ===== Has the same relation to [[#pl|PL]] as [[#spp|SPP]] does to [[#pp|PP]]. Contains the maximum matching and perfect matching problems under a pseudorandom assumption [[zooref#arz99|[ARZ99]]]. Contains [[#ul|UL]]. Contained in [[#cequalsl|C<sub>=</sub>L]] and [[#modkl|Mod<sub>k</sub>L]]. Equals the set of problems low for [[#gapl|GapL]]. ---- ===== <span id="spp" style="color:red">SPP</span>: Stoic [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then these numbers differ by 2.</li> </ol> (A technicality: If the total number of paths is even then the numbers can't differ by 1.) Defined in [[zooref#ffk94|[FFK94]]], where it was also shown that SPP is low for [[#pp|PP]], [[#cequalsp|C<sub>=</sub>P]], [[#modkp|Mod<sub>k</sub>P]], and SPP itself. (I.e. adding SPP as an oracle does not increase the power of these classes.) Independently defined in [[zooref#oh93|[OH93]]], who called the class XP. Contained in [[#lwpp|LWPP]], [[#cequalsp|C<sub>=</sub>P]], and [[#wpp|WPP]] among other classes. Contains [[#fewp|FewP]]; indeed, [[#fewp|FewP]] is low for SPP, so that SPP<sup>[[#fewp|FewP]]</sup> = SPP [[zooref#ffk94|[FFK94]]]. Contains the problem of deciding whether a graph has any [[Complexity_Garden#graph_automorphism|nontrivial automorphisms]] [[zooref#kst92|[KST92]]]. Indeed, contains [[Complexity_Garden#graph_isomorphism|graph isomorphism]] [[zooref#ak02|[AK02]]]. Contains a whole gaggle of problems for solvable black-box groups: solvability testing, membership testing, subgroup testing, normality testing, order verification, nilpotetence testing, group isomorphism, and group intersection [[zooref#vin04|[Vin04]]] [[zooref#ak02|[AK02]]] also showed that the Hidden Subgroup Problem for permutation groups, of interest in quantum computing, is in [[#fp|FP]]<sup>SPP</sup>. ---- ===== <span id="sqg" style="color:red">SQG</span>: Short Quantum Games ===== Same as [[#qrg|QRG]], except that now the verifier can exchange only a single round of quantum messages with the two provers. The verifier may process the yes-prover's response before sending a message to the no-prover (compare with [[#rg1|RG]], wherein the verifier's messages must be sent to the provers in parallel). Defined in [[zooref#gw05|[GW05]]], where it was also shown that SQG contains [[#qip|QIP]]. SQG is contained in [[#exp|EXP]] [[zooref#gut05|[Gut05]]], as well as in [[#qrg|QRG]]. SQG trivially contains [[#qs2p|QS<sub>2</sub>P]]. ---- ===== <span id="subexp" style="color:red">SUBEXP</span>: Deterministic Subexponential-Time ===== The intersection of [[#dtime|DTIME]](2<sup>n^&epsilon;</sup>) over all &epsilon;>0. (Note that the algorithm used may vary with &epsilon;.) ---- ===== <span id="symp" style="color:red">symP</span>: Alternate Name for [[#s2p|S<sub>2</sub>P]] ===== ---- ===== <span id="szk" style="color:red">SZK</span>: Statistical Zero Knowledge ===== The class of decision problems for which a "yes" answer can be verified by a <i>statistical zero-knowledge proof protocol</i>. In such a protocol, we have a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier, Arthur, and a prover, Merlin, who has unbounded computational resources. By sending messages back and forth with Merlin, Arthur must become convinced (with high probability) that the answer is "yes," <i>without learning anything else about the problem</i> (statistically). What does that mean? For each choice of random coins, Arthur has a "view" of his entire interaction with Merlin, consisting of his random coins as well as all messages sent back and forth. Then the distribution over views resulting from interaction with Merlin has to be statistically close to a distribution that Arthur could generate himself (in polynomial-time), without interacting with Merlin. (Here "statistically close" means that, say, the trace distance is at most 1/10.) The most famous example of such a protocol is for [[Complexity_Garden#graph_isomorphism|<i>graph nonisomorphism</i>]]. Given two graphs G and H, Arthur can pick one of the graphs (each with probability 1/2), permute its vertices randomly, send the resulting graph to Merlin, and ask, "Which graph did I start with, G or H?" If G and H are non-isomorphic, Merlin can always answer correctly (since he can use exponential time), but if they're isomorphic, he can answer correctly with probability at most 1/2. Thus, if Merlin always gives the correct answer, Arthur becomes convinced the graphs are not isomorphic. On the other hand, Arthur already <i>knew</i> which graph (G or H) he started with, so he could simulate his entire view of the interaction himself, without Merlin's help. If that sounds like a complicated definition, well, it is. But it turns out that SZK has extremely nice properties. [[zooref#oka96|[Oka96]]] showed that: <ul> <li>SZK is closed under complement. I.e. Arthur can verify in zero-knowledge that two graphs <i>are</i> isomorphic, not only that they aren't.</li> <li>We can assume without loss of generality that the whole interaction consists of a constant number of messages.</li> <li>Amazingly, we can also assume without loss of generality that the protocol is <i>public-coin</i>. I.e. Arthur doesn't need to hide any of his random bits, as he did in the graph nonisomorphism protocol above, but can just send them all to Merlin!</li> <li>Finally, we can assume without loss of generality that the verifier (Arthur) is <i>honest</i>. A dishonest verifier would be one that tries to learn something about the problem (violating the zero-knowledge requirement) by deviating from the protocol.</li> </ul> Subsequently, [[zooref#sv97|[SV97]]] showed that SZK has a natural complete promise problem, called <i>Statistical Difference (SD)</i>. Given two polynomial-size circuits, C<sub>0</sub> and C<sub>1</sub>, let D<sub>0</sub> and D<sub>1</sub> be the distributions over their respective outputs when they're given as input a uniformly random n-bit string. We're promised that D<sub>0</sub> and D<sub>1</sub> have trace distance either at most 1/3 or at least 2/3; the problem is to decide which is the case. <i>Note:</i> The constants 1/3 and 2/3 can be amplified to 2<sup>-poly(n)</sup> and 1-2<sup>-poly(n)</sup> respectively. But it is crucial that (2/3)<sup>2</sup> &gt; 1/3. Another complete promise problem for SZK is <i>Entropy Difference (ED)</i> [[zooref#gv99|[GV99]]]. Here we're promised that either H(D<sub>0</sub>)&gt;H(D<sub>1</sub>)+1 or H(D<sub>1</sub>)&gt;H(D<sub>0</sub>)+1, where the distributions D<sub>0</sub> and D<sub>1</sub> are as above, and H denotes Shannon entropy. The problem is to determine which is the case. If any hard-on-average language is in SZK, then one-way functions exist [[zooref#ost91|[Ost91]]]. Zero-knowledge proofs were first studied in [[zooref#gmw91|[GMW91]]], [[zooref#gmr89|[GMR89]]]. Contains [[#pzk|PZK]] and [[#niszk|NISZK]], and is contained in [[#am|AM]] &#8745; [[#coam|coAM]], as well as [[#czk|CZK]] and [[#qszk|QSZK]]. There exists an oracle relative to which SZK is not in [[#bqp|BQP]] [[zooref#aar02|[Aar02]]]. Contained in [[#dqp|DQP]] [[zooref#aar02b|[Aar02b]]]. ---- ===== <span id="szkh" style="color:red">SZK<sub>h</sub></span>: [[#szk|SZK]] With Limited Help ===== The class of decision problems for which a "yes" answer can be verified by a statistical zero-knowledge proof protocol, and the prover and verifier both have access to a string computed by a trusted probabilistic polynomial-time third party with access to the input. Defined in [[zooref#bg03|[BG03]]], where it was also shown that SZK<sub>h</sub> = [[#szk|SZK]]. Contains [[#niszkh|NISZK<sub>h</sub>]]. ---- ===== <span id="tally" style="color:red">TALLY</span>: Tally Languages ===== The class of decision problems for which every 'yes' instance has the form 0<sup>n</sup> (i.e. inputs are encoded in unary). If TALLY intersects [[#npc|NPC]] then [[#p|P]] = [[#np|NP]] [[zooref#mah82|[Mah82]]]. Contained in [[#sparse|SPARSE]]. ---- ===== <span id="tc0" style="color:red">TC<sup>0</sup></span>: Constant-Depth Threshold Circuits ===== The class of decision problems solvable by polynomial-size, constant-depth circuits with unbounded fanin, which can use AND, OR, and NOT gates (as in [[#ac0|AC<sup>0</sup>]]) as well as <i>threshold</i> gates. A threshold gate returns 1 if at least half of its inputs are 1, and 0 otherwise. A uniformity requirement is sometimes also placed. TC<sup>0</sup> contains [[#acc0|ACC<sup>0</sup>]], and is contained in [[#nc1|NC<sup>1</sup>]]. TC<sup>0</sup> circuits of depth 3 are strictly more powerful than TC<sup>0</sup> circuits of depth 2 [[zooref#hmp93|[HMP+93]]]. TC<sup>0</sup> circuits of depth 3 and quasipolynomial size can simulate all of [[#acc0|ACC<sup>0</sup>]] [[zooref#yao90|[Yao90]]]. [[zooref#nr97|[NR97]]] give a candidate pseudorandom function family computable in TC<sup>0</sup>, that is secure assuming a subexponential lower bound on the hardness of [[Complexity_Garden#integer_factorization|factoring]]. (See also [[zooref#nrr01|[NRR01]]] for an improvement of this construction, as well as [[zooref#kha93|[Kha93]]].) One implication is that, assuming such a bound, there is no <i>natural proof</i> in the sense of [[zooref#rr97|[RR97]]] separating TC<sup>0</sup> from [[#ppoly|P/poly]]. (It is important for this that a <i>function family</i>, and not just a candidate pseudorandom <i>generator</i>, is computable in TC<sup>0</sup>.) Another implication is that functions in TC<sup>0</sup> are likely to be difficult to learn. The permanent of a 0-1 matrix cannot be computed in <i>uniform</i> TC<sup>0</sup> [[zooref#all99|[All99]]]. In a breakthrough result [[zooref#hes01|[Hes01]]] (building on [[zooref#bch86|[BCH86]]] and [[zooref#cdl01|[CDL01]]]), integer division was shown to be in [[#l|L]]-uniform TC<sup>0</sup>. Indeed division is <i>complete</i> for this class under [[#ac0|AC<sup>0</sup>]] reductions. ---- ===== <span id="tfnp" style="color:red">TFNP</span>: Total Function [[#np|NP]] ===== The class of function problems of the following form: <ul> Given an input x and a polynomial-time predicate F(x,y), output any y satisfying F(x,y). (Such a y is promised to exist.) </ul> Can be considered as the functional analogue of NP &#8745; coNP. Defined in [[zooref#mp91|[MP91]]]. Contained in [[#fnp|FNP]]. Subclasses include [[#ppa|PPA]], [[#ppp|PPP]], and [[#pls|PLS]]. ---- ===== <span id="theta2p" style="color:red">&#920;<sub>2</sub>P</span>: Alternate name for [[#pnplog|P<sup>NP[log]</sup>]] ===== ---- ===== <span id="treebqp" style="color:red">TreeBQP</span>: [[#bqp|BQP]] Restricted To Tree States ===== The class of languages accepted by a [[#bqp|BQP]] machine subject to the constraint that at every time step t, the machine's state is exponentially close to a <i>tree state</i> -- that is, a state expressible by a polynomial-size tree of additions and tensor products (together with complex constants and |0&gt; and |1&gt; leaf nodes). More formally, a uniform classical polynomial-time algorithm generates a sequence of gates g<sup>(1)</sup>, ... ,g<sup>(p(n))</sup>. Each g<sup>(t)</sup> can be either be selected from some finite universal basis of unitary gates (the choice turns out not to matter), or can be a 1-qubit measurement. When we perform a measurement, the state evolves to one of two possible pure states, with the usual probabilities, rather than to a mixed state. We require that the final gate g<sup>(p(n))</sup> is a measurement of the first qubit. If at least one intermediate state was more than distance 2<sup>-&Omega;(n)</sup> away from the nearest state of tree size at most p(n), then the outcome of the final measurement is chosen adversarially; otherwise it is given by the usual Born probabilities. The measurement must return 1 with probability at least 2/3 if the input is in the language, and with probability at most 1/3 otherwise. Contains [[#bpp|BPP]], and is contained in [[#bqp|BQP]]. Defined in [[zooref#aar03b|[Aar03b]]], where it was also shown that TreeBQP is contained in the third level of [[#ph|PH]], which might provide weak evidence that TreeBQP does not equal [[#bqp|BQP]]. ---- ===== <span id="treeregular" style="color:red">TREE-REGULAR</span>: Regular Tree-Valued Languages ===== Same as [[#reg|REG]], except that now the inputs are <i>trees</i> (say, binary trees) instead of strings. Each vertex is labeled with a symbol from a fixed alphabet. Evaluation begins at the leaves and proceeds to the root. The state of the finite automaton at each vertex v is a function of (1) the states at v's children (if any), and (2) the symbol at v. The tree is in the language if and only if the automaton is in an 'accept' state at the root. See [[zooref#koz92|[Koz92]]] for example. ---- ===== <span id="uap" style="color:red">UAP</span>: Unambiguous Alternating Polynomial-Time ===== Same as [[#ap|AP]], except we are promised that each existential quantifier has at most one 'yes' path, and each universal quantifier has at most one 'no' path. Contains [[#up|UP]]. Defined in [[zooref#nr98|[NR98]]], where it was also shown that, even though [[#ap|AP]] = [[#pspace|PSPACE]], it is unlikely that the same is true for UAP, since UAP is contained in [[#spp|SPP]]. [[zooref#cgr04|[CGR+04]]] have also shown that UAP<sup>UAP</sup> = UAP, and that UAP contains [[Complexity_Garden#graph_isomorphism|Graph Isomorphism]] problem. ---- ===== <span id="ucc" style="color:red">UCC</span>: Unique Connected Component ===== The class of problems reducible in [[#l|L]] to the problem of whether an undirected graph has a unique connected component. See [[zooref#ag00|[AG00]]] for more information. Contained in [[#sl|SL]]. See also [[#coucc|coUCC]]. ---- ===== <span id="ul" style="color:red">UL</span>: Unambiguous [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#up|UP]] does to [[#p|P]]. If UL = [[#nl|NL]], then [[#fnl|FNL]] is contained in [[#sharpl|#L]] [[zooref#aj93|[AJ93]]]. ---- ===== <span id="ulpoly" style="color:red">UL/poly</span>: Nonuniform [[#ul|UL]] ===== Has the same relation to [[#ul|UL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Equals [[#nlpoly|NL/poly]] [[zooref#ra00|[RA00]]]. (A corollary is that UL/poly is closed under complement). Note that in UL/poly, the witness must be unique even for bad advice. UL/mpoly (as in [[#bqpmpoly|BQP/mpoly]]) is a more natural definition, but this is a moot distinction here because [[zooref#ra00|[RA00]]] show that they both equal [[#nlpoly|NL/poly]]. ---- ===== <span id="ue" style="color:red">UE</span>: Unambiguous Exponential-Time With Linear Exponent ===== Has the same relation to [[#e|E]] as [[#up|UP]] does to [[#p|P]]. ---- ===== <span id="up" style="color:red">UP</span>: Unambiguous Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' exactly one computation path accepts.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> "Worst-case" one-way functions exist if and only if [[#p|P]] does not equal UP ([[zooref#gs88|[GS88]]] and independently [[zooref#ko85|[Ko85]]]). "Worst-case" one-way permutations exist if and only if [[#p|P]] does not equal UP &#8745; [[#coup|coUP]] [[zooref#ht03|[HT03]]]. Note that these are weaker than the one-way functions and permutations that are needed for cryptographic applications. There exists an oracle relative to which [[#p|P]] is strictly contained in UP is strictly contained in [[#np|NP]] [[zooref#rac82|[Rac82]]]; indeed, these classes are distinct with probability 1 relative to a random oracle [[zooref#bei89|[Bei89]]]. [[#np|NP]] is contained in [[#rp|RP]]<sup>Promise-UP</sup> [[zooref#vv86|[VV86]]]. On the other hand, [[zooref#bbf98|[BBF98]]] give an oracle relative to which [[#p|P]] = UP but still [[#p|P]] does not equal [[#np|NP]]. UP is not known or believed to contain complete problems. [[zooref#sip82|[Sip82]]], [[zooref#hh86|[HH86]]] give oracles relative to which UP has no complete problems. ---- ===== <span id="us" style="color:red">US</span>: Unique Polynomial-Time ===== The all-American counting class. The class of decision problems solvable by an [[#np|NP]] machine such that the answer is 'yes' if and only if exactly one computation path accepts. In contrast to [[#up|UP]], a machine can legally have more than one accepting path - that just means that the corresponding input is not in the language. Defined in [[zooref#bg82|[BG82]]]. Contains [[#conp|coNP]]. ---- ===== <span id="vck" style="color:red">VC<sub>k</sub></span>: Verification Class With A Circuit of Depth K ===== <ul> <li> For k = 0, VC<sub>0</sub> is the class of compressible languages. <li> For k = 1, VC<sub>1</sub> is the class of languages that have local verification: they can be verified by testing only a small part of the instance. (Small means polynomial in the witness length and the log of the instance length.) <li> For k &ge; 2, VC<sub>k</sub> is the class of languages that can be verified by a circuit of depth k, with size polynomial in the witness length and instance length. </ul> VC<sub>0</sub> &sube; VC<sub>OR</sub> &sube; VC<sub>1</sub> &sube; VC<sub>2</sub> &sube; VC<sub>3</sub> &hellip; Introduced in [[zooref#hn06|[HN06]]]; see there for formal definitions. ---- ===== <span id="vcor" style="color:red">VC<sub>or</sub></span>: Verification Class With OR ===== The class of languages that have verification presentable as the OR of m instances of SAT, each of size n. (m is the witness length of an instance and n is the instance length.) Introduced in [[zooref#hn06|[HN06]]]. See also [[#vck|VC<sub>k</sub>]]. ---- ===== <span id="vnc" style="color:red">VNC<sub>k</sub></span>: Valiant [[#nc|NC]] Over Field k ===== Has the same relation to [[#vp|VP<sub>k</sub>]] as [[#nc|NC]] does to [[#p|P]]. More formally, the class of [[#vp|VP<sub>k</sub>]] problems computable by a straight-line program of depth polylogarithmic in n. Surprisingly, VNC<sub>k</sub> = [[#vp|VP<sub>k</sub>]] for any k [[zooref#vsb83|[VSB+83]]]. ---- ===== <span id="vnp" style="color:red">VNP<sub>k</sub></span>: Valiant [[#np|NP]] Over Field k ===== A superclass of [[#vp|VP<sub>k</sub>]] in Valiant's algebraic complexity theory, but not <i>quite</i> the analogue of [[#np|NP]]. A problem is in VNP<sub>k</sub> if there exists a polynomial p with the following properties: <ul> <li>p is computable in [[#vp|VP<sub>k</sub>]]; that is, by a polynomial-size straight-line program.</li> <li>The inputs to p are constants c<sub>1</sub>,...,c<sub>m</sub>,e<sub>1</sub>,...,e<sub>h</sub> and indeterminates X<sub>1</sub>,...,X<sub>n</sub> over the base field k.</li> <li>When p is summed over all 2<sup>h</sup> possible assignments of {0,1} to each of e<sub>1</sub>,...,e<sub>h</sub>, the result is some specified polynomial q.</li> </ul> Originated in [[zooref#val79b|[Val79b]]]. If the field k has characteristic greater than 2, then the permanent of an n-by-n matrix of indeterminates is VNP<sub>k</sub>-complete under a type of reduction called p-projections ([[zooref#val79b|[Val79b]]]; see also [[zooref#bur00|[Bur00]]]). A central conjecture is that for all k, [[#vp|VP<sub>k</sub>]] is not equal to VNP<sub>k</sub>. B&uuml;rgisser [[zooref#bur00|[Bur00]]] shows that if this were false then: <ul> <li>If k is finite, [[#nc2|NC<sup>2</sup>]]/poly = [[#ppoly|P/poly]] = [[#nppoly|NP/poly]] = [[#ph|PH]]/poly.</li> <li>If k has characteristic 0, then assuming the Generalized Riemann Hypothesis (GRH), [[#nc|NC]]<sup>3</sup>/poly = [[#ppoly|P/poly]] = [[#nppoly|NP/poly]] = [[#ph|PH]]/poly, and [[#sharpp|#P]]/poly = [[#fp|FP]]/poly.</li> </ul> In both cases, [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]]. ---- ===== <span id="vp" style="color:red">VP<sub>k</sub></span>: Valiant [[#p|P]] Over Field k ===== The class of efficiently-solvable problems in Valiant's algebraic complexity theory. More formally, the input consists of constants c<sub>1</sub>,...,c<sub>m</sub> and indeterminates X<sup>1</sup>,...,X<sub>n</sub> over a base field k (for instance, the complex numbers or Z<sub>2</sub>). The desired output is a collection of polynomials over the X<sub>i</sub>'s. The complexity is the minimum number of pairwise additions, subtractions, and multiplications needed by a straight-line program to produce these polynomials. VP<sub>k</sub> is the class of problems whose complexity is polynomial in n. (Hence, VP<sub>k</sub> is a nonuniform class, in contrast to [[#pc|P<sub>C</sub>]] and [[#pr2|P<sub>R</sub>]].) Originated in [[zooref#val79b|[Val79b]]]; see [[zooref#bur00|[Bur00]]] for more information. Contained in [[#vnp|VNP<sub>k</sub>]] and [[#vqp|VQP<sub>k</sub>]], and contains [[#vnc|VNC<sub>k</sub>]]. ---- ===== <span id="vqp" style="color:red">VQP<sub>k</sub></span>: Valiant [[#qp|QP]] Over Field k ===== Has the same relation to [[#vp|VP<sub>k</sub>]] as [[#qp|QP]] does to [[#p|P]]. Originated in [[zooref#val79b|[Val79b]]]. The determinant of an n-by-n matrix of indeterminates is VQP<sub>k</sub>-complete under a type of reduction called qp-projections (see [[zooref#bur00|[Bur00]]] for example). It is an open problem whether the determinant is [[#vp|VP<sub>k</sub>]]-complete. ---- ===== <span id="w1" style="color:red">W</span>: Weighted Analog of [[#np|NP]] ===== The class of decision problems of the form (x,k) (k a parameter), that are <i>fixed-parameter reducible</i> to the following: <ul> '''Weighted 3SAT:''' Given a 3SAT formula, does it have a satisfying assignment of Hamming weight k? </ul> A fixed-parameter reduction is a Turing reduction that takes time at most f(k)p(|x|), where f is an arbitrary function and p is a polynomial. Also, if the input is (x,k), then all Weighted 3SAT instances the algorithm queries about must have the form <x',k'> where k' is at most k. Contains [[#fpt|FPT]]. Defined in [[zooref#df99|[DF99]]], where the following is also shown: <ul> <li>If [[#fpt|FPT]] = W then [[#np|NP]] is contained in [[#dtime|DTIME]](2<sup>o(n)</sup>).</li> </ul> W can be generalized to [[#wt|W[t]]]. ---- ===== <span id="wapp" style="color:red">WAPP</span>: Weak Almost-Wide [[#pp|PP]] ===== The class of decision problems for which there exists a [[#sharpp|#P]] function f, a polynomial p, and an &epsilon; &gt; 0, such that for all inputs x, <ol> <li>If the answer is "yes" then 2<sup>p(|x|)</sup> &ge; f(x) &gt; (1+&epsilon;) 2<sup>p(|x|)-1</sup>.</li> <li>If the answer is "no" then 0 &le; f(x) &lt; (1-&epsilon;) 2<sup>p(|x|)-1</sup>.</li> </ol> Defined in [[zooref#bgm02|[BGM02]]], where it is also shown that WAPP is contained in [[#awpp|AWPP]] and [[#sbp|SBP]]. ---- ===== <span id="wp" style="color:red">W[P]</span>: Weighted Circuit Satisfiability ===== The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted Circuit-SAT:''' Given a Boolean circuit C (with no restriction on depth), does C have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#wsat|W[SAT]]]. ---- ===== <span id="wpp" style="color:red">WPP</span>: Wide [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then their difference exactly equals a function f(x) computable in polynomial time (i.e. [[#fp|FP]]).</li> </ol> Defined in [[zooref#ffk94|[FFK94]]]. Contained in [[#cequalsp|C<sub>=</sub>P]] &#8745; [[#cocequalsp|coC<sub>=</sub>P]], as well as [[#awpp|AWPP]]. Contains [[#spp|SPP]] and [[#lwpp|LWPP]]. ---- ===== <span id="wsat" style="color:red">W[SAT]</span>: Weighted Satisfiability ===== The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted SAT:''' Given a Boolean formula F (with no restriction on depth), does F have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#wt|W[t]]] for every t, and is contained in [[#wp|W[P]]]. ---- ===== <span id="wstar" style="color:red">W[*]</span>: Union of W[t]'s ===== The union of [[#wt|W[t]]] over all t. ---- ===== <span id="wt" style="color:red">W[t]</span>: Nondeterministic Fixed-Parameter Hierarchy ===== A generalization of [[#w1|W]]. The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted Weft-t Depth-h Circuit-SAT:''' Given a Boolean circuit C, with a mixture of fanin-2 and unbounded-fanin gates. The number unbounded-fanin gates along any path to the root is at most t, and the total depth (fanin-2 and unbounded-fanin) is at most h. Does C have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contained in [[#wsat|W[SAT]]] and in [[#wstart|W<sup>*</sup>[t]]]. ---- ===== <span id="wstart" style="color:red">W<sup>*</sup>[t]</span>: [[#wt|W[t]]] With Parameter-Dependent Depth ===== Same as [[#wt|W[t]]], except that now the circuit depth can depend on the parameter k rather than being constant. (The number of unbounded-fanin gates along any path to the root is still at most t.) W<sup>*</sup> = [[#wt|W]] [[zooref#dft96|[DFT96]]], and W<sup>*</sup> = [[#wt|W]] [[zooref#df97|[DF97]]], but the problem is open for larger t. ---- ===== <span id="xormipstar21" style="color:red">XOR-MIP*[2,1]</span>: [[#mipstar21|MIP*[2,1]]] With 1-Bit Proofs ===== Same as [[#mipstar21|MIP*[2,1]]], but with the further restriction that both provers send only a single bit to the verifier, and the verifier's output is a function of the exclusive-OR of those bits. There should exist 0&lt;a&lt;b&lt;1 such that if the answer is "yes", then for some responses of the provers the verifier accepts with probability at least b, while if the answer is "no", then for all responses of the provers the verifier accepts with probability at most a. Defined by [[zooref#cht04|[CHT+04]]], whose motivation was a connection to the Bell and CHSH inequalities of quantum physics. XOR-MIP*[2,1] is contained in [[#nexp|NEXP]] [[zooref#cht04|[CHT+04]]]. ---- ===== <span id="xp" style="color:red">XP</span>: Fixed-Parameter Tractable for Each Parameter ===== The class of decision problems of the form (x,k) (k a parameter) that are solvable in time O(|x|<sup>f(k)</sup>) for some function f. The algorithm used may depend on k. Defined in [[zooref#df99|[DF99]]]. Contains [[#xpuniform|XP<sub>uniform</sub>]]. Strictly contains [[#fpt|FPT]] (by diagonalization). ---- ===== <span id="xpuniform" style="color:red">XP<sub>uniform</sub></span>: Uniform [[#xp|XP]] ===== Same as [[#xp|XP]] except that the algorithm used must be the same for each k (though it can take k as input). Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="yacc" style="color:red">YACC</span>: Yet Another Complexity Class ===== A term of derision, used against a complexity class. ---- ===== <span id="yp" style="color:red">YP</span>: Your Polynomial-Time or Yaroslav-Percival ===== The class of decision problems for which there exists a polynomial-time machine M such that: <ul> <li>For all input sizes n, there exists a polynomial-size advice string s<sub>n</sub> such that M(x,s<sub>n</sub>) outputs the correct answer for all inputs x of size n.</li> <li>For all inputs x and advice strings s, M(x,s) outputs either the correct answer or "I don't know."</li> </ul> Defined in a [http://www.blogger.com/comment.g?blogID=17392898&postID=114560148725169634 recent post] of the blog [http://www.scottaaronson.com/blog/ Shtetl-Optimized]. See there for an explanation of the class's name. Contains [[#zpp|ZPP]] by the same argument that places [[#bpp|BPP]] in [[#ppoly|P/poly]]. Also contains [[#p|P]] with [[#tally|TALLY]] &#8745; [[#np|NP]] &#8745; [[#conp|coNP]] oracle. Is contained in [[#npiconp|NP &#8745; coNP]] and [[#ypp|YPP]]. ---- ===== <span id="ypp" style="color:red">YPP</span>: Yaroslav [[#bpp|BPP]] ===== The probabilistic analogue of [[#yp|YP]]; it is to YP what [[#ma|MA]] is to [[#np|NP]]. Formally, the class of decision problems for which there exists a syntactic [[#bpp|BPP]] machine M such that: <ul> <li>For all input sizes n, there exists a polynomial-size advice string a<sub>n</sub> such that for all inputs x of size n, M(x,a<sub>n</sub>) outputs the correct answer with probability at least 2/3.</li> <li>For all inputs x and advice strings a, the probability that M(x,a) outputs the incorrect answer is at most 1/3. In other words, the sum of the probabilities of the correct answer and "I don't know" is at least 2/3.</li> </ul> To amplify a YPP machine, one can run it multiple times, then accept if a majority of runs accept, reject if a majority reject, and otherwise output "I don't know." Contains [[#bpp|BPP]] and [[#yp|YP]], and is contained in [[#ma|MA]] and [[#ppoly|P/poly]]. ---- ===== <span id="yqp" style="color:red">YQP</span>: Yaroslav [[#bqp|BQP]] ===== Is to [[#ypp|YPP]] as [[#bqp|BQP]] is to [[#bpp|BPP]], and [[#qma|QMA]] is to [[#ma|MA]]. The machine is now a quantum computer and the advice is a quantum state |&psi;_n&gt;. Contains [[#bqp|BQP]] and [[#ypp|YPP]], and is contained in [[#qma|QMA]] and [[#bqpqpoly|BQP/qpoly]]. ---- ===== <span id="zbqp" style="color:red">ZBQP</span>: Strict Quantum [[#zpp|ZPP]] ===== Defined as [[#rbqp|RBQP &#8745; coRBQP]]. Equivalently, the class of problems in [[#npiconp|NP &#8745; coNP]] such that both positive and negative witnesses are in [[#fbqp|FBQP]]. For example, the language of square-free numbers is in ZBQP, because [[Complexity_Garden#integer_factorization|factoring]] is in [[#fbqp|FBQP]] and a factorization can be certified in [[#zpp|ZPP]] (indeed in [[#p|P]], by [[zooref#aks02|[AKS02]]]). Unlike [[#eqp|EQP]] or [[#zqp|ZQP]], ZBQP would generalize [[#zpp|ZPP]] in practice if quantum computers existed, in the sense that it provides proven answers. Contains [[#zpp|ZPP]] and is contained in [[#rqp|RBQP]] and [[#zqp|ZQP]]. Also, ZBQP<sup>ZBQP</sup> = ZBQP. Defined here to clarify [[#eqp|EQP]] and [[#zqp|ZQP]]. ---- ===== <span id="zpe" style="color:red">ZPE</span>: Zero-Error Probabilistic [[#e|E]] ===== Same as [[#zpp|ZPP]], but with 2<sup>O(n)</sup>-time instead of polynomial-time. ZPE = [[#ee|EE]] if and only if [[#zpp|ZPP]] = [[#exp|EXP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="zpp" style="color:red">ZPP</span>: Zero-Error Probabilistic Polynomial-Time ===== Defined as [[#rp|RP]] &#8745; [[#corp|coRP]]. The class of problems solvable by randomized algorithms that <i>always</i> return the correct answer, and whose <i>expected</i> running time (on any input) is polynomial. Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ss77|[SS77]]] [[zooref#ah87|[AH87]]]. In contrast to [[#bpp|BPP]] and [[#rp|RP]], it is not known whether showing ZPP = [[#p|P]] requires proving superpolynomial circuit lower bounds [[zooref#ki02|[KI02]]]. There exists an oracle relative to which ZPP = [[#exp|EXP]] [[zooref#hel84|[Hel84]]]. ---- ===== <span id="zptime" style="color:red">ZPTIME(f(n))</span>: Zero-Error Probabilistic f(n)-Time ===== Same as [[#zpp|ZPP]], but with O(f(n))-time instead of polynomial-time. For any constructible superpolynomial f, ZPTIME(f(n)) with [[#np|NP]] oracle is not contained in [[#ppoly|P/poly]] [[zooref#kw98|[KW98]]]. ---- ===== <span id="zqp" style="color:red">ZQP</span>: Zero-Error Extension Of [[#eqp|EQP]] ===== The class of questions that can be answered by a QTM that answers yes, no, or "maybe". If the correct answer is yes, then P[no] = 0, and vice-versa; and the probability of maybe is at most 1/2. Since some of the probabilities have to vanish, ZQP has the same technical caveats as [[#eqp|EQP]]. Defined independently in [[zooref#bw03|[BW03]]] and in [[zooref#nis02|[Nis02]]]. Contains [[#eqp|EQP]] and [[#zbqp|ZBQP]] and is contained in [[#bqp|BQP]]. Equals [[#rqp|RQP &#8745; coRQP]]. There is an oracle such that ZQP<sup>ZQP</sup> is larger than ZQP [[zooref#bw03|[BW03]]]; c.f. with [[#zbqp|ZBQP]]. ---- [[Category:Computational Complexity]] [[Category:Quantum Information]] Complexity Zoo Acknowledgments 1960 5535 2005-08-26T01:53:58Z John Stockton 2 ''This page contains acknowledgments for the [[Complexity Zoo]] which was originally created at http://www.complexityzoo.com/ by [[Scott Aaronson]].'' <hr> *''[[Scott Aaronson]]'s original acknowledgments (circa August 2005):'' I thank Esteve del Acebo, [[Dorit Aharanov]], Eric Allender, Simon Anders, Jesse Andrews, Luis Antu&ntilde;es, Albert Atserias, Hugue Blier, Chris Bourke, Amit Chakrabarti, Hana Chockler, Derrick Coetzee, Matthew Cook, Alex Fabrikant, Craig Feinstein, [[Lance Fortnow]], Oded Goldreich, Lee Graham, Xiaoyang Gu, Dan Gutfreund, Satoshi Hada, Mitchell Harris, John Hitchcock, [[Julia Kempe]], Hirotada Kobayashi, Leszek Kolodziejczyk, [[Andrew J. Landahl]], James Lee, Troy Lee, Daniel Marx, Gatis Midrijanis, David Molnar, Cris Moore, Elchanan Mossel, Rana Mourad, Alan Nash, Gabriel Nivasch, Periklis Papakonstantinou, Dan Pless, Chris Pollett, Jibran Rashid, [[Oded Regev]], Hein R&ouml;hrig, Mugizi Rwebangira, Cem Say, Philippe Schnoebelen, [[Barbara Terhal]], Luca Trevisan, N. V. Vinodchandran, Qut Walters, [[John Watrous]], Hoeteck Wee, Ryan Williams, [[Ronald de Wolf]], Shengyu Zhang, and Standa Zivny for helpful comments. I especially thank Lane Hemaspaandra and Bodo Manthey for sending me a great deal of relevant information; Bill Gasarch for preparing a summary of communication complexity classes; [[Lawrence Ip]] for suggesting the 'table of contents' and pronunciation guide; and Alex Halderman for helping me set up the domain name. *''Acknowledgments for transferring the zoo to the qwiki:'' [[John K. Stockton]] (not [http://www.nba.com/playerfile/john_stockton/?nav=page him]), [[Kevin L. McHale]] (not [http://www.nba.com/history/players/mchale_summary.html him]) for scripting, and [[Kevin Birnbaum]] (not [http://en.wikipedia.org/wiki/Jesus Him]) for the idea to steal the zoo... [[Category:Computational Complexity]] Complexity Zoo Exhibit 1965 7873 2006-11-24T12:38:39Z John Stockton 2 Reverted edits by [[Special:Contributions/Myspacer|Myspacer]] ([[User_talk:Myspacer|Myspacer]]); changed back to last version by [[User:Kredit|Kredit]] ''This page is an exhibit of the [[Complexity Zoo]] which was originally created at http://www.complexityzoo.com/ by [[Scott Aaronson]].'' <hr> <b>Special [[Complexity Zoo]] Exhibit:</b> Classes of Quantum States and Probability Distributions 24 classes and counting! A whole new phylum of the Complexity kingdom has recently been identified. This phylum consists of classes, not of problems or languages, but of <i>quantum states</i> and <i>probability distributions</i>. Well, actually, infinite <i>families</i> of states and distributions, one for each number of bits n. Admittedly, computer scientists have been talking about the complexity of sampling from probability distributions for years, but they haven't tended to organize those distributions into <i>classes</i> designated by <i>inscrutable sequences of capital letters</i>. This needs to change. The present Zookeeper has [http://www.cs.berkeley.edu/~aaronson/mlin.ps started] the analogous project for quantum states; indeed, he puts the classes below in a special exhibit to avoid the appearance of favoritism toward his own classes in the main Zoo. <hr> [[#ampp|AmpP]] - [[#basis|Basis]] - [[#circuit|Circuit]] - [[#dist|Dist]] - [[#fpaus|FPAUS]] - [[#mixed|Mixed]] - [[#motree|MOTree]] - [[#otree|OTree]] - [[#probp|ProbP]] - [[#psip|&Psi;P]] - [[#pure|Pure]] - [[#samplable|Samplable]] - [[#separable|Separable]] - [[#sum1|&Sigma;<sub>1</sub>]] - [[#sum2|&Sigma;<sub>2</sub>]] - [[#sum3|&Sigma;<sub>3</sub>]] - [[#sum4itensor4|&Sigma;<sub>4</sub> intersect Tensor<sub>4</sub>]] - [[#tensor1|Tensor<sub>1</sub>]] - [[#tensor2|Tensor<sub>2</sub>]] - [[#tensor3|Tensor<sub>3</sub>]] - [[#tree|Tree]] - [[#treesize|TreeSize(f(n))]] - [[#tsh|TSH]] - [[#vidal|Vidal]] <hr> <b><font color="red"><span id="ampp"></span>AmpP</font>: States with Polytime-Computable Amplitudes</b> <br>The class of [[#pure|Pure]] quantum state families |&psi;<sub>n</sub>&gt; = &Sigma;<sub>x</sub>&alpha;<sub>x</sub>|x&gt; such that for all n,b, there exists a classical circuit of size p(n+b) that outputs &alpha;<sub>x</sub> to b bits of precision given x as input, for some polynomial p. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where the following was also shown: <ul> <li>If [[Complexity Zoo#bqp|BQP]] = [[Complexity Zoo#psharpp|P<sup>#P</sup>]] then AmpP is contained in [[#psip|&Psi;P]]. <li>If AmpP is contained in [[#psip|&Psi;P]] then [[Complexity Zoo#np|NP]] is contained in [[Complexity Zoo#bqpslashpoly|BQP/poly]]. <li>If [[Complexity Zoo#p|P]] = [[Complexity Zoo#psharpp|P<sup>#P</sup>]] then [[#psip|&Psi;P]] = AmpP. <li>If [[#psip|&Psi;P]] is contained in AmpP then [[Complexity Zoo#bqp|BQP]] is contained in [[Complexity Zoo#pslashpoly|P/poly]]. </ul> AmpP contains [[#circuit|Circuit]] and [[#tree|Tree]], and is contained in [[#pure|Pure]]. <b><font color="red"><span id="basis"></span>Basis</font>: Computational Basis States</b> <br>The class of quantum state families of the form |x&gt; where x is an n-bit string. <br>The zeroth level of [[#tsh|TSH]]. <br>Equals [[#pure|Pure]] intersect [[#dist|Dist]]. <b><font color="red"><span id="circuit"></span>Circuit</font>: Circuit States</b> <br>A generalization of [[#tree|Tree]], where we allow amplitudes to be computed by polynomial-size multilinear <i>circuits</i> rather than just multilinear formulas. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where it was also observed that Circuit contains [[#vidal|Vidal]] (indeed, strictly contains it). <br>Contained in [[#ampp|AmpP]]. <b><font color="red"><span id="dist"></span>Dist</font>: Classical Probability Distributions</b> <br>The class of classical probability distribution families over n-bit strings. <br>Contains [[#basis|Basis]], and is contained in [[#mixed|Mixed]]. <b><font color="red"><span id="fpaus"></span>FPAUS</font>: Fully-Polynomial Almost-Uniform Samplable</b> <br>The class of probability distribution families D<sub>n</sub> over n-bit strings such that (1) D<sub>n</sub> is the uniform distribution over some subset, and (2) there exists a uniform probabilistic algorithm, running in time polynomial in n and log(1/&delta;), that outputs a sample from a distribution at most &delta; from D<sub>n</sub> in variation distance. <br>See [[Zoo References#jw04|[JW04]]] for more information. <b><font color="red"><span id="mixed"></span>Mixed</font>: Mixed Quantum States</b> <br>The class of mixed quantum state families of n qubits. <br>Contains [[#pure|Pure]] and [[#dist|Dist]]. <b><font color="red"><span id="motree"></span>MOTree</font>: Manifestly Orthogonal Tree States</b> <br>The class of quantum state families in [[#tree|Tree]] representable by polynomial-size trees in which all additions are of states that are mutually <i>manifestly orthogonal</i>. Two states of n qubits, &Sigma;<sub>x</sub>&alpha;<sub>x</sub>|x&gt; and &Sigma;<sub>x</sub>&beta;<sub>x</sub>|x&gt;, are manifestly orthogonal if &alpha;<sub>x</sub>&beta;<sub>x</sub>=0 for all x. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where the following was also shown: <ul> <li>MOTree is <i>strictly</i> contained in [[#tree|Tree]]. Indeed, MOTree does not contain [[#sum2|&Sigma;<sub>2</sub>]]. <li>MOTree strictly contains [[#tensor2|Tensor<sub>2</sub>]]. </ul> <b><font color="red"><span id="otree"></span>OTree</font>: Orthogonal Tree States</b> <br>The class of quantum state families in [[#tree|Tree]] representable by polynomial-size trees in which all additions are of mutually orthogonal states. <br>Contains [[#motree|MOTree]]. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where it was also shown that OTree is contained in [[#psip|&Psi;P]]. <br>Showing a separation between [[#tree|Tree]] and OTree remains an excellent open problem. <b><font color="red"><span id="probp"></span>ProbP</font>: Distributions With Polytime-Computable Probabilities</b> <br> <b><font color="red"><span id="psip"></span>&Psi;P</font>: Pure States Preparable by Polynomial-Size Circuits</b> <br>The class of [[#pure|Pure]] quantum state families |&psi;<sub>n</sub>&gt; such that for all n and &epsilon;&gt;0, there exists a quantum circuit of size p(n+log(1/&epsilon;)) that maps the all-0 state to a state some subsystem of which has trace distance at most 1-&epsilon; from |&psi;<sub>n</sub>&gt;, for some polynomial p. Because of the Solovay-Kitaev Theorem (see [[Zoo References#nc00|[NC00]]]), the definition of &Psi;P is invariant under the choice of universal gate set. <br>The following was shown in [[Zoo References#aar03b|[Aar03b]]]: <ul> <li>&Psi;P is not contained in [[#tree|Tree]]. <li>[[#otree|OTree]] is contained (indeed strictly contained) in &Psi;P. <li>If [[Complexity Zoo#bqp|BQP]] = [[Complexity Zoo#psharpp|P<sup>#P</sup>]] then [[#ampp|AmpP]] is contained in &Psi;P. <li>If [[#ampp|AmpP]] is contained in h&Psi;P then [[Complexity Zoo#np|NP]] is contained in [[Complexity Zoo#bqp/poly|BQP/poly]]. <li>If [[Complexity Zoo#p|P]] = [[Complexity Zoo#psharpp|P<sup>#P</sup>]] then &Psi;P = [[#ampp|AmpP]]. <li>If &Psi;P is contained in [[#ampp|AmpP]] then [[Complexity Zoo#bqp|BQP]] is contained in [[Complexity Zoo#p/poly|P/poly]]. </ul> Whether [[#tree|Tree]] is contained in &Psi;P remains an intriguing open problem. <b><font color="red"><span id="pure"></span>Pure</font>: Pure Quantum States</b> <br>The class of quantum state families of n qubits that have the form &Sigma;<sub>x</sub>&alpha;<sub>x</sub>|x&gt;; that is, that cannot be written as a nontrivial probability distribution over two other quantum states. <br>Contains [[#basis|Basis]], and is contained in [[#mixed|Mixed]]. <b><font color="red"><span id="samplable"></span>Samplable</font>: Polytime-Samplable Distributions</b> <br> <b><font color="red"><span id="separable"></span>Separable</font>: Separable Mixed States</b> <br>The class of [[#mixed|Mixed]] quantum state families of n qubits that can be written as a probability distribution over [[#tensor1|Tensor<sub>1</sub>]] states. <br>A well-known open problem asks whether a quantum computer that is in a separable state at every time step can be simulated in [[Complexity Zoo#bpp|BPP]], or alternatively, whether such a computer can simulate [[Complexity Zoo#bqp|BQP]]. <b><font color="red"><span id="sum1"></span>&Sigma;<sub>1</sub></font>: First Sum Class in [[#tsh|TSH]]</b> <br>The class of [[#pure|Pure]] quantum state families that can be written as superpositions over a polynomial number of computational basis states. <br>Strictly contains [[#basis|Basis]], and is strictly contained in [[#sum2|&Sigma;<sub>2</sub>]] and [[#tensor2|Tensor<sub>2</sub>]]. <b><font color="red"><span id="sum2"></span>&Sigma;<sub>2</sub></font>: Second Sum Class in [[#tsh|TSH]]</b> <br>The class of [[#pure|Pure]] quantum state families that can be written as superpositions over a polynomial number of [[#separable|Separable]] (or equivalently [[#tensor1|Tensor<sub>1</sub>]]) states. <br>Strictly contains [[#sum1|&Sigma;<sub>1</sub>]] and [[#tensor1|Tensor<sub>1</sub>]], and is strictly contained in [[#sum3|&Sigma;<sub>3</sub>]] and [[#tensor3|Tensor<sub>3</sub>]]. <b><font color="red"><span id="sum3"></span>&Sigma;<sub>3</sub></font>: Third Sum Class in [[#tsh|TSH]]</b> <br>The class of [[#pure|Pure]] quantum state families that can be written as superpositions over a polynomial number of [[#tensor2|Tensor<sub>2</sub>]] states. <br>Strictly contains [[#sum2|&Sigma;<sub>2</sub>]] and [[#tensor2|Tensor<sub>2</sub>]], and is contained in [[#sum4itensor4|&Sigma;<sub>4</sub>intersect Tensor<sub>4</sub>]] (strict containment is not yet known for this and higher levels of [[#tsh|TSH]]). <b><font color="red"><span id="sum4itensor4"></span>&Sigma;<sub>4</sub>intersect Tensor<sub>4</sub></font>: Intersection of Fourth Levels of [[#tsh|TSH]]</b> <br>Does not equal [[#tensor3|Tensor<sub>3</sub>]] [[Zoo References#aar03b|[Aar03b]]]. <b><font color="red"><span id="tensor1"></span>Tensor<sub>1</sub></font>: First Tensor Class in [[#tsh|TSH]]</b> <br>Equals [[#separable|Separable]] intersect [[#pure|Pure]]. <br>Strictly contains [[#basis|Basis]], and is strictly contained in [[#sum2|&Sigma;<sub>2</sub>]] and [[#tensor2|Tensor<sub>2</sub>]]. <b><font color="red"><span id="tensor2"></span>Tensor<sub>2</sub></font>: Second Tensor Class in [[#tsh|TSH]]</b> <br>The class of [[#pure|Pure]] quantum state families that can be written as a tensor product of [[#sum1|&Sigma;<sub>1</sub>]] states. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where the following was also shown: <ul> <li>Tensor<sub>2</sub> is strictly contained in [[#tensor3|Tensor<sub>3</sub>]], [[#sum3|&Sigma;<sub>3</sub>]], and [[#motree|MOTree]]. <li>Tensor<sub>2</sub> is not contained in [[#vidal|Vidal]]. </ul> <b><font color="red"><span id="tensor3"></span>Tensor<sub>3</sub></font>: Third Tensor Class in [[#tsh|TSH]]</b> <br>The class of [[#pure|Pure]] quantum state families that can be written as a tensor product of [[#sum2|&Sigma;<sub>2</sub>]] states. <br>Strictly contains [[#sum2|&Sigma;<sub>2</sub>]] and [[#tensor2|Tensor<sub>2</sub>]], and is strictly contained in [[#sum4itensor4|&Sigma;<sub>4</sub> intersect Tensor<sub>4</sub>]] [[Zoo References#aar03b|[Aar03b]]]. <b><font color="red"><span id="tree"></span>Tree</font>: Tree States</b> <br>The class of [[#pure|Pure]] quantum state families {|&psi;<sub>n</sub>&gt;} such that TS(|&psi;<sub>n</sub>&gt;)=O(p(n)) for some polynomial p, where TS, or <i>tree size</i>, is defined as follows. <br>A <i>quantum state tree</i> is a rooted tre where each leaf vertex is labeled with either |0&gt; or |1&gt;, and each non-leaf vertex is labeled with either + or Tensor. Each vertex v is also labeled with a subset S(v) of {1,...,n} such that <ol> <li>If v is a leaf then |S(v)|=1. <li>If v is the root then S(v)={1,...,n}. <li>If v is a + gate and w is a child of v, then S(w)=S(v). <li>If v is a Tensor gate and w<sub>1</sub>,...,w<sub>k</sub> are the children of v, then S(w<sub>1</sub>),...,S(w<sub>k</sub>) are pairwise disjoint and form a partition of S(v). </ol> Finally, if v is a + gate, then the outgoing edges of v are labeled with complex numbers. For each v, the subtree rooted at v represents a quantum state in the obvious way (we require this state to be normalized for each v). <br>The tree size TS(|&psi;&gt;) is then the minimum size of a tree representing |&psi;&gt;, where size means number of vertices. <br>Defined in [[Zoo References#aar03b|[Aar03b]]], where the following was also shown: <ul> <li>[[#psip|&Psi;P]] is not contained in Tree. <li>Tree strictly contains [[#motree|MOTree]]. <li>Any state family in Tree can be represented by trees of polynomial size and logarithmic depth. <li>Most quantum states cannot even be well-approximated by states of subexponential tree size. </ul> Contains [[#otree|OTree]] and [[#tsh|TSH]], and is contained in [[#circuit|Circuit]]. <b><font color="red"><span id="treesize"></span>TreeSize(f(n))</font>: Pure Quantum States of Tree Size O(f(n))</b> <br>The class of [[#pure|Pure]] quantum state families that have O(f(n)) tree size in the sense of [[Zoo References#aar03b|[Aar03b]]]. So for example, [[#tree|Tree]] equals the union over all k of TreeSize(n<sup>k</sup>). <br>TreeSize(n<sup>O(log n)</sup>) contains [[#vidal|Vidal]] [[Zoo References#aar03b|[Aar03b]]]. <b><font color="red"><span id="tsh"></span>TSH</font>: Tensor-Sum Hierarchy</b> <br>The class of quantum state families in [[#tree|Tree]] represented by trees of polynomial size and constant depth, where the depth is just the maximum length of a path from the root to a leaf. <br>The levels of TSH are [[#tensor1|Tensor<sub>1</sub>]], [[#tensor2|Tensor<sub>2</sub>]], [[#tensor3|Tensor<sub>3</sub>]], ... (corresponding to trees whose root vertex is Tensor), and [[#sum1|&Sigma;<sub>1</sub>]], [[#sum2|&Sigma;<sub>2</sub>]], [[#sum3|&Sigma;<sub>3</sub>]], ... (corresponding to trees whose root vertex is +). (We have Tensor<sub>0</sub> = &Sigma;<sub>0</sub> = [[#basis|Basis]].) <br>Whether TSH = [[#tree|Tree]] and whether TSH is contained in [[#psip|&Psi;P]] remain intriguing open problems. <b><font color="red"><span id="vidal"></span>Vidal</font>: States of Polynomially-Bounded Schmidt Rank</b> <br>The class of [[#pure|Pure]] quantum state families that are polynomially entangled in the sense of Vidal [[Zoo References#vid03|[Vid03]]]. More precisely, given a partition of {1,...,n} into A and B, let &chi;<sub>A</sub>(|&psi;<sub>n</sub>&gt;) be the minimum k for which |&psi;<sub>n</sub>&gt; can be written as &Sigma;<sub>i=1 to k</sub>&alpha;<sub>i</sub>|&phi;<sub>i</sub><sup>A</sup>&gt;Tensor|&phi;<sub>i</sub><sup>B</sup>&gt;, where |&phi;<sub>i</sub><sup>A</sup>&gt; and |&phi;<sub>i</sub><sup>B</sup>&gt; are states of qubits in A and B respectively. (&chi;<sub>A</sub>(|&psi;<sub>n</sub>&gt; is known as the <i>Schmidt rank</i>.) Let &chi;(|&psi;<sub>n</sub>&gt;) = max<sub>A</sub>&chi;<sub>A</sub>(&psi;<sub>n</sub>&gt;). Then |&psi;<sub>n</sub>&gt; is contained in Vidal if and only if &chi;(|&psi;<sub>n</sub>&gt; is at most p(n) for some polynomial p. <br>[[Zoo References#vid03|[Vid03]]] shows that, if a quantum computer is in Vidal at every time step, then it can be simulated classically with only polynomial slowdown. <br>[[Zoo References#aar03b|[Aar03b]]] observes the following: <ul> <li>Vidal is strictly contained in [[#circuit|Circuit]] and in [[#treesize|TreeSize]](n<sup>O(log n)</sup>). <li>Vidal strictly contains [[#sum2|&Sigma;<sub>2</sub>]]. <li>Vidal does not contain [[#tensor2|Tensor<sub>2</sub>]]. [[Category:Computational Complexity]] [http://www.parteien-online.de/finanzen/ratenkredit/ top] Complexity Zoo Glossary 1963 46705 2012-06-07T16:58:52Z Tejsin 12580 /* L */ __NOTOC__ {{Simple-Alpha-Menu|{{CZ-Navbar}} ---- }} <i>"Now you too can speak Theorese!"</i> On this page I've collected terms that appear (or don't appear) throughout the Complexity Zoo, and that theoretical computer scientists tend to use without defining them, assuming everyone just knows what they mean. The list is by no means comprehensive-- if you find something missing or in error, let someone know or jump in and help out! ---- ===== A ===== <font color="red"><b>adaptive:</b></font> Each question you ask (say to an oracle) can depend on the answers to the previous questions. If A and B are complexity classes, then A<sup>B</sup> is the class of languages decidable by an A machine that can make adaptive queries to a B oracle. {{Term|alphabet|Typically denoted $\Sigma$, an alphabet is a finite set of characters. Common examples include $\{a, b, \dots, z\}$ and $\{0, 1\}$.}} <font color="red"><b>asymptotic:</b></font> Concerning the rate at which a function grows, ignoring constant factors. For example, if an algorithm uses 3n+5 steps on inputs of size n, we say its running time is "asymptotically linear" - emphasizing that the linear dependence on n is what's important, not the 3 or the 5. ===== B ===== <font color="red" id="block sensitivity"><b>block sensitivity:</b></font> Given a Boolean function $f:\{0,1\}^n\to\{0,1\}$, the block sensitivity $\mathrm{bs}^X(f)$ of an input $X=x_1\dots x_n$ is the maximum number of disjoint blocks $B$ of variables such that $f(X)$ does not equal $f\left(X^{(B)}\right)$, where $X^{(B)}$ denotes $X$ with the variables in $B$ flipped. Then $\mathrm{bs}(f)$ is the maximum of $\mathrm{bs}^X(f)$ over all $X$. Defined by Nisan in 1991. See also [[#sensitivity|sensitivity]], [[#certificate-complexity|certificate complexity]]. <font color="red"><b>Blum integer:</b></font> A product of two distinct primes, both of which are congruent to 3 mod 4. <font color="red"><b>Boolean formula:</b></font> A circuit in which each gate has fanout 1. <font color="red"><b>Boolean function:</b></font> Usually, a function $f:\{0,1\}^n\to\{0,1\}$, that takes an $n$-bit string as input and produces a bit as output. ===== C ===== <font color="red" id="certificate-complexity"><b>certificate complexity:</b></font> Given a Boolean function $f:\{0,1\}^n\to\{0,1\}$, the certificate complexity $C^X(f)$ of an input $X=x_1\dots x_n$ is the minimum size of a set $S$ of variables such that $f(Y)=f(X)$ whenever $Y$ agrees with $X$ on every variable in $S$. Then $C(f)$ is the maximum of $C^X(f)$ over all $X$. See also [[#block-sensitivity|block sensitivity]]. [[Image:Example-circuit.png|thumb|200px|right|Example of a Boolean [[#circuit|circuit]] of [[#depth|depth]] 4 that checks if two 2-bit strings are different.]] <font color="red" id="circuit"><b>circuit:</b></font> To engineers, a "circuit" is a closed loop. But in theoretical computer science, a circuit never has loops: instead, it starts with an input, then applies a sequence of simple operations (or gates) to produce an output. For example, an OR gate outputs 1 if either of its input bits are 1, and 0 otherwise. The output of a gate can then be used as an input to other gates. <font color="red"><b>closure:</b></font> The closure of a set $S$ under some operations, is the set of everything you can get by starting with $S$, then repeatedly applying the operations. For instance, the closure of the set $\{1\}$ under addition and subtraction is the set of integers. <font color="red" id="cnf"><b>CNF:</b></font> Conjunctive Normal Form. A special kind of Boolean formula, consisting of an AND of ORs of negated or non-negated literals. For instance: $(a\vee\neg b)\wedge(b\vee\neg c\vee d)$. See also [[#dnf|DNF]]. <font color="red"><b>collapse:</b></font> An infinite sequence (hierarchy) of complexity classes <i>collapses</i> if all but finitely many of them are actually equal to each other. <font color="red"><b>complement:</b></font> The complement of a language is the set of all instances not in the language. The complement of a complexity class consists of the complement of each language in the class. (Not the set of all languages not in the class!) <font color="red"><b>complete:</b></font> A problem is complete for a complexity class if (1) it's in the class, and (2) everything in the class can be reduced to it (under some notion of reduction). So, if you can solve the complete problems for some class, then you can solve every problem in the class. The complete problems are the hardest. <font color="red"><b>constructible:</b></font> Basically, a function $f$ is 'constructible' if it's nondecreasing, and if, given an input $x$, $f(\left\vert x\right\vert)$ can be computed in time linear in $\left\vert x\right\vert+f(\left\vert x\right\vert)$. Informally, constructible functions are those that are sufficiently well-behaved to appear as complexity bounds. This is a technical notion that is almost never needed in practice. ===== D ===== <font color="red"><b>decision problem:</b></font> A problem for which the desired answer is a single bit (1 or 0, yes or no). For simplicity, theorists often restrict themselves to talking about decision problems. <font color="red"><b>decision tree:</b></font> A (typically) binary tree where each non-leaf vertex is labeled by a query, each edge is labeled by a possible answer to the query, and each leaf is labeled by an output (typically yes or no). A decision tree represents a function in the obvious way. <font color="red"><b>decision tree complexity:</b></font> Given a Boolean function $f:\{0,1\}^n\to\{0,1\}$, the decision tree complexity $D(f)$ of $f$ is the minimum height of a decision tree representing $f$ (where height is the maximum length of a path from the root to a leaf). Also called deterministic query complexity. <font color="red"><b>depth:</b></font> When referring to a circuit, the maximum number of gates along any path from an input to the output. (Note that circuits never contain loops.) <font color="red"><b>deterministic:</b></font> Not randomized. <font color="red"><b>DNF:</b></font> Disjunctive Normal Form. A Boolean formula consisting of an OR and ANDs of negated or non-negated literals. For instance: $(a\wedge c)\vee(b\wedge\neg c)$. See also [[#cnf|CNF]]. <font color="red" id="downward-self-reducible"><b>downward self-reducible:</b></font> A problem is downward self-reducible if an oracle for instances of size $n-1$ enables one to solve instances of size $n$. ===== E ===== <font color="red"><b>equivalence class:</b></font> A maximal set of objects that can all be transformed to each other by some type of transformation. ===== F ===== <font color="red"><b>family:</b></font> Usually an infinite sequence of objects, one for each input size n. For example, a "family of circuits." <font color="red"><b>fanin:</b></font> The maximum number of input wires that any gate in a circuit can have. A "bounded fanin" circuit is one in which each gate has a constant number of input wires (often assumed to be 2). <font color="red"><b>fanout:</b></font> The maximum number of output wires any gate in a circuit can have. When talking about "circuits," one usually assumes unbounded fanout unless specified otherwise. <font color="red"><b>finite automaton:</b></font> An extremely simple model of computation. In the most basic form, a machine reads an input string once, from left to right. At any step, the machine is in one of a finite number of states. After it reads an input character (symbol), it transitions to a new state, determined by its current state as well as the character it just read. The machine outputs 'yes' or 'no' based on its state when it reaches the end of the input. <font color="red"><b>FOCS:</b></font> IEEE Symposium on Foundations of Computer Science (held every fall). <font color="red"><b>function problem:</b></font> A problem where the desired output is not necessarily a single bit, but could belong to a set with more than 2 elements. Contrast with decision problem. <font color="red"><b>formula:</b></font> A circuit where each gate has fanout 1. ===== G ===== <font color="red"><b>gate:</b></font> A basic component used to build a circuit. Usually performs some elementary logical operation: for example, an AND gate takes a collection of input bits, and outputs a '1' bit if all the input bits are '1', and a '0' bit otherwise. See also fanin, fanout. ===== H ===== {{Term|id=hamming-distance|Hamming distance|Given two bit strings $x,y\in\{0,1\}^n$ for some $n$, their Hamming distance $d(x,y)$ is the number of bits that are different between the two strings. This function satisfies the properties of a metric on the vectorspace $\{0,1\}^n$, since it is non-negative, is symmetric, satisfies $d(x,x)=0$ and the satisfies the triangle inequality. }} {{Term|id=hamming-weight|Hamming weight|Given a bit string $x\in\{0,1\}^*$, the Hamming weight of $x$ is the number of non-zero bits. Equivalently, the Hamming weight of $x$ is the Hamming distance $d(x,\mathbf{0})$ between $x$ and a string of all zeros having the same length. }} <font color="red"><b>hard:</b></font> A problem is hard for a class if everything in the class can be reduced to it (under some notion of reduction). If a problem is in a class <i>and</i> hard for the class, then it's complete for the class. Beware; hard and complete are not synonyms! ===== I ===== <font color="red"><b>instance:</b></font> A particular case of a problem. ===== L ===== {{Term|language|Another term for [[#D|decision problem]] (but only a total decision problem, not a promise decision problem). An instance is in a language, if and only if the answer to the decision problem is "yes." An alternate characterization of a language is as a set of [[#word|words]] over an alphabet $\Sigma$: $L\subseteq \Sigma^*$. This is equivalent since determining membership in $L$ is a decision problem called the characteristic function of $L$. A simple example of a language is ODD, the set of all strings over $\{0,1\}$ which end in 1.}} <font color="red" id="lasvegas-algorithm"><b>Las Vegas algorithm:</b></font> A zero-error randomized algorithm, i.e. one that always returns the correct answer, but whose running time is a random variable. The term was introduced by Babai in 1979. Contrast [http://www.cheatcodesforsime3.com/ with] Monte Carlo. <font color="red" id="low"><b>low:</b></font> A complexity class C is low for D if D<sup>C</sup> = D; that is, adding C as an oracle does not increase the power of D. C is <i>self-low</i> if C<sup>C</sup> = C. <font color="red" id="lower bound"><b>lower bound:</b></font> A result showing that a function grows <i>at least</i> at a certain asymptotic rate. Thus, a lower bound on the complexity of a problem implies that any algorithm for the problem requires <i>at least</i> a certain amount of resources. Lower bounds are much harder to come by than upper bounds. ===== M ===== <font color="red"><b>many-one reduction:</b></font> A reduction from problem A to problem B, in which an algorithm converts an instance of A into an instance of B having the same answer. Also called a Karp reduction. (Contrast with Turing reduction.) <font color="red"><b>monotone:</b></font> A function is monotone (or monotonic) if, when one increases any of the inputs, the output never decreases (it can only increase or stay the same). A Boolean circuit is monotone if it consists only of AND and OR gates, no NOT gates. <font color="red" id="gap"><b>monotone-nonmonotone gap:</b></font> A Boolean function has a monotone-nonmonotone gap if it has nonmonotone Boolean circuits (using AND, OR, and NOT gates) that are smaller than any monotone Boolean circuits (without NOT gates) for it. <font color="red"><b>Monte Carlo algorithm:</b></font> A bounded-error randomized algorithm, i.e. one that returns the correct answer only with some specified probability. The error probability can be either one-sided or two-sided. (In physics and engineering, the term refers more broadly to any algorithm based on random sampling.) The term was introduced by Metropolis and Ulam around 1945. Contrast with Las Vegas. <font color="red"><b>nondeterministic machine:</b></font> A hypothetical machine that, when faced with a choice, is able to make all possible choices at once - i.e. to branch off into different 'paths.' In the end, the results from all the paths must be combined somehow into a single answer. One can obtain dozens of different models of computation, depending on the exact way this is stipulated to happen. For example, an {{zcls|n|np}} machine answers 'yes' if <i>any</i> of its paths answer 'yes.' By contrast, a {{zcls|p|pp}} machine answers 'yes' if the <i>majority</i> of its paths answer 'yes.' <font color="red"><b>non-negligible:</b></font> A probability is non-negligible if it's greater than $1/p(n)$ for some polynomial $p$, where $n$ is the size of the input. <font color="red"><b>nonuniform:</b></font> This means that a different algorithm can be used for each input size. Boolean circuits are a nonuniform model of computation -- one might have a circuit for input instances of size 51, that looks completely different from the circuit for instances of size 50. ===== O ===== <font color="red"><b>o ("little-oh"):</b></font> For a function $f(n)$ to be $o(g(n))$ means that $f(n)$ is $O(g(n))$ and is not $\Omega(g(n))$ (i.e. $f(n)$ grows more slowly than $g(n)$). <font color="red"><b>O ("big-oh"):</b></font> For a function $f(n)$ to be $O(g(n))$ means that for some nonnegative constant $k$, $f(n)$ is less than $kg(n)$ for all sufficiently large $n$. <font color="red"><b>&Omega; (Omega):</b></font> For a function $f(n)$ to be $\Omega(g(n))$ means that for some nonnegative constant $k$, $f(n)$ is greater than $kg(n)$ for all sufficiently large $n$. <font color="red" id="oracle"><b>oracle:</b></font> Also called "black box." An imaginary device that solves some computational problem immediately. <br><i>Note:</i> An oracle is specified by the answers it gives to every possible question you could ask it. So in some contexts, 'oracle' is more or less synonymous with 'input' - but usually an input so long that the algorithm can only examine a small fraction of it. <font color="red" id="ospeedup"><b>O-optimal or O-speedup:</b></font> Informally, an O-optimal algorithm is one that is optimal in big-O notation. More formally, an algorithm A accepting a language L is O-optimal if for any other A' accepting L, there exists a constant $c$ such that for all inputs $x$: $time_A(x)\leq c(|x|+time_{M'}(x))$. A language with no O-optimal A is said to have O-speedup. See [[Speedup]]. ===== P ===== <font color="red"><b>path:</b></font> A single sequence of choices that could be made by a nondeterministic machine. {{Term|id=p-measure|''p''-measure|A game-theoretic reformulation of the classical Lebesgue measure, whose full definition is too long to fit here; please see the survey paper by Lutz, {{zcite|Lut93}}, wherein the term is formally defined. The measure is useful in proving [[#zeroone-law|zero-one laws]]. Also known as "Lutz's ''p''-measure."}} <font color="red"><b>polylogarithmic:</b></font> $(\log(n))^c$, where $c$ is a constant. Also an adverb ("polylogarithmically"). <font color="red"><b>polynomial:</b></font> To mathematicians, a polynomial in $n$ is a sum of multiples of nonnegative integer powers of $n$: for example, $3n^2-8n+4$. To computer scientists, on the other hand, polynomial often means <i>upper-bounded</i> by a polynomial: so $n+\log(n)$, for example, is "polynomial." Also an adverb ("polynomially"). A function that grows polynomially is considered to be 'reasonable,' unlike, say, one that grows exponentially. {{Term|post-selection|The process of accepting or rejecting an input conditioned on some random event occurring in a desired fashion. For example, guessing the solution to an NP-complete problem then killing yourself if the solution was incorrect could be viewed as an anthropic form of post-selection, as in any universes in which you are still alive, your random choice of a solution was correct. This intuition leads to classes such as {{zcls|b|bpppath|BPP<sub>path</sub>}} and {{zcls|p|postbqp|PostBQP}}.}} <font color="red"><b>problem:</b></font> A function from inputs to outputs, which we want an algorithm to compute. A crossword puzzle is not a problem; it's an <i>instance</i>. The set of <i>all</i> crossword puzzles is a problem. ''See also:'' [[#decision-problem|decision problem]], [[#language|language]]. {{Term|id=promise-problem|promise problem|A problem for which the input is guaranteed to have a certain property. I.e. if an input doesn't have that property, then we don't care what the algorithm does when given that input.}} <font color="red" id="pspeedup"><b>p-optimal or p-speedup:</b></font> (aka polynomially optimal or polynomial speedup) A Turing machine $M$ accepting a language $L$ is polynomially optimal if for any other $M'$ accepting $L$, there exists a polynomial $p$ such that for all inputs $x$: $\mathrm{time}_M(x)\leq p(|x|,\mathrm{time}_{M'}(x))$. A language with no p-optimal $M$ is said to have p-speedup. p-optimal was defined by Krajicek and Pudlak [[zooref#kp89|[KP89]]]; see also Messner [[zooref#mes99|[Mes99]]]. <font color="red" id="puniform"><b>P-uniform or P-nonuniform:</b></font> A family of Boolean circuits is P-uniform if a Turing machine given input string $1^n$ (1 repeated n times) can output the member of the family with $n$ inputs in time polynomial in n. A ''problem'' is P-nonuniform if no family of minimal Boolean circuits for the problem is P-uniform. ===== Q ===== <font color="red"><b>quantum:</b></font> Making use of quantum-mechanical superposition, which is a particular kind of parallel and very fast nondeterministic algorithmic processing that collapses to one value (usually the answer to a problem instance) when its output is observed, captured, or used. If you don't know what that means, well, I can't explain it in this sentence (try lectures [http://www.scottaaronson.com/democritus/lec9.html 9] and [http://www.scottaaronson.com/democritus/lec10.html 10] from the [http://www.scottaaronson.com/democritus/default.html Democritus course] taught by the Zookeeper). But it has nothing to do with the original meaning of the word 'quantum' (i.e. a discrete unit). <font color="red"><b>quasipolynomial:</b></font> $O(2^{\log^c n})$, for some constant c. ===== R ===== <font color="red"><b>random access:</b></font> This means that an algorithm can access any element x<sub>i</sub> of a sequence immediately (by just specifying i). It doesn't have to go through x<sub>1</sub>,...,x<sub>i-1</sub> first. Note that this has nothing directly to do with randomness. <font color="red"><b>randomized:</b></font> Making use of randomness (as in 'randomized algorithm'). This is probably an unfortunate term, since it doesn't imply that one starts with something deterministic and then 'randomizes' it. See also Monte Carlo and Las Vegas. <font color="red" id="random-self-reducible"><b>random self-reducible:</b></font> A problem is random self-reducible if the ability to solve a large fraction of instances enables one to solve <i>all</i> instances. For example, the discrete logarithm problem is random self-reducible. <font color="red" id="reduction"><b>reduction:</b></font> A result of the form, "Problem A is at least as hard as Problem B." This is generally shown by giving an algorithm that transforms any instance of Problem B into an instance of Problem A. <font color="red"><b>relativize:</b></font> To add an oracle. We say a complexity class inclusion (or technique) is <i>relativizing</i> if it works relative to all oracles. Since there exist oracles A,B such that {{zcls|p|p}}<sup>A</sup> = {{zcls|n|np}}<sup>A</sup> and {{zcls|p|p}}<sup>B</sup> does not equal {{zcls|n|np}}<sup>B</sup> {{zcite|BGS75}}, any technique that resolves {{zcls|p|p}} versus {{zcls|n|np}} will need to be nonrelativizing. ===== S ===== <font color="red"><b>satisfiability (SAT):</b></font> One of the central problems in computer science. The problem is, given a Boolean formula, does there exist a setting of variables that <i>satisfies</i> the formula (that is, makes it evaluate to true)? For example, $(a\vee b)\wedge(\neg a\vee\neg b)$ is satisfiable: $a=\mathrm{true}$, $b=\mathrm{false}$ and $a=\mathrm{false}$, $b=\mathrm{true}$ are both satisfying assignments. But $(a\vee b) \wedge (\neg a) \wedge (\neg b)$ is unsatisfiable. ''See also'': [[Complexity Garden#sat|Garden entry on satisfiability]]. <font color="red"><b>self-reducible:</b></font> A problem is self-reducible if an oracle for the decision problem enables one to solve the associated function problem efficiently. For example, {{zcls|n|npc|NP-complete}} problems are self-reducible. See also: [[#downward-self-reducible|downward self-reducible]], [[#random-self-reducible|random self-reducible]]. <font color="red" id="sensitivity"><b>sensitivity:</b></font> Given a Boolean function {{bfunc}}, the sensitivity $s^X(f)$ of an input $X=x_1\dots x_n$ is the number of variables such that flipping them changes the value of $f(X)$. Then $s(f)$ is the maximum of $s^X(f)$ over all $X$. <font color="red"><b>size:</b></font> When referring to a string, the number of bits. When referring to a circuit, the number of gates. <font color="red"><b>space:</b></font> The amount of memory used by an algorithm (as in space complexity). <font color="red"><b>STOC:</b></font> ACM Symposium on Theory of Computing (held every spring). <font color="red"><b>string:</b></font> A sequence of 1s and 0s. (See, it's not just physicists who plumb Nature's deepest secrets -- we computer scientists theorize about strings as well!)<br><i>Note</i>: For simplicity, one usually assumes that every character in a string is either 1 or 0, but strings over larger alphabets can also be considered. <font color="red"><b>subexponential:</b></font> Growing slower (as a function of n) than any exponential function. Depending on the context, this can either mean $2^{o(n)}$ (so that the Number Field Sieve factoring algorithm, which runs in about $2^{n^{1/3}}$ time, is "subexponential"); or $2^{o(n^{\epsilon})}$ for every $\epsilon>0$. <font color="red"><b>superpolynomial:</b></font> Growing faster (as a function of $n$) than any polynomial in $n$. This is <i>not</i> the same as exponential: for example, $n^{\log n}$ is superpolynomial, but not exponential. ===== T ===== <font color="red"><b>tape:</b></font> The memory used by a Turing machine. <font color="red"><b>&Theta; (Theta):</b></font> For a function $f(n)$ to be $\Theta(g(n))$ means that $f(n) = O(g(n))$ and $f(n) = \Omega(g(n))$ (i.e. they grow at the same rate). <font color="red"><b>tight bound:</b></font> An upper bound that matches the lower bound, or vice versa. I.e. the best possible bound for a function. <font color="red"><b>total:</b></font> A total function is one that is defined on every possible input. <font color="red"><b>truth table:</b></font> A table of all $2^n$ possible inputs to a Boolean function, together with the corresponding outputs. <font color="red"><b>truth table reduction:</b></font> A Turing reduction in which the oracle queries must be nonadaptive. <font color="red"><b>Turing reduction:</b></font> A reduction from problem A to problem B, in which the algorithm for problem A can make queries to an oracle for problem B. (Contrast with many-one reduction.) ===== U ===== <font color="red"><b>unary:</b></font> An inefficient encoding system, in which the integer n is denoted by writing n 1's in sequence. <font color="red"><b>uniform:</b></font> A single algorithm is used for all input lengths. For example, Turing machines are a uniform model of computation -- one just has to design a single Turing machine for multiplication, and it can multiply numbers of any length. (Contrast with the circuit model.) <font color="red"><b>upper bound:</b></font> A result showing that a function grows <i>at most</i> at a certain asymptotic rate. For example, any algorithm for a problem yields an upper bound on the complexity of the problem. ===== W ===== <font color="red"><b>with high probability (w.h.p.):</b></font> Usually this means with probability at least 2/3 (or any constant greater than 1/2). If an algorithm is correct with 2/3 probability, one can make the probability of correctness as high as one wants by just repeating several times and taking a majority vote.<br><i>Note</i>: Sometimes people say "high probability" when they mean "non-negligible probability." {{Term|word|Given an [[#alphabet|alphabet]] $\Sigma$, a word is a string $w \in \Sigma^*$. That is, a string of characters drawn from $\Sigma$. Using the alphabet $\Sigma = \{a, b, \dots, z\}$, some valid words include $word$, $science$, $foobar$ and $fotmewwi$.}} ===== X ===== ===== Y ===== ===== Z ===== {{Term|id=zeroone-law|zero-one law|Any theorem which specifies that the probability of an event is either zero or one is known as a zero-one law.}} [[Category:Computational Complexity]] Complexity Zoo Introduction 1962 23614 2012-02-08T00:56:31Z Joshuaherman 5631 Broken links. ''This page is an introduction to the [[Complexity Zoo]] which was originally created at http://www.complexityzoo.com/ by [[Scott Aaronson]].'' <hr> I created the Complexity Zoo with three audiences in mind. First, me. Before my zookeeping foray, I spent a week trying to put {{zcls|a|am}} outside {{zcls|q|qma}} relative to an oracle, only to learn that this followed trivially from two known results: that of Vereshchagin [[Zoo References#ver92|[Ver92]]] that {{zcls|a|am}} is outside {{zcls|p|pp}} relative to an oracle, and that of Kitaev and Watrous (unpublished, but mentioned in [[Zoo References#wat00|[Wat00]]]) that {{zcls|q|qma}} is in {{zcls|p|pp}}. What to do next? One option would be to work on putting {{zcls|s|szk}} outside {{zcls|q|qma}} relative to an oracle. But instead I decided that, before hoisting one more brick onto the vast edifice of complexity, I'd do well to take stock of what was already known. Some theorists seem able to hold in their minds, in one instant, the results of every FOCS, STOC, and Complexity paper ever published. Not every proof, of course - but those can be looked up if one knows the results and to whom they're due. I am not one of those theorists. The sprawling web of known relations among complexity classes - containments, oracle separations, random oracle separations, lowness results, the occasional inequality - is not fixed in my memory like the English language. And so it's largely for my own benefit that I recorded a chunk of what's known in one unwieldy HTML file. The second audience is other theorists and theory students, who might find the Zoo to have a few advantages as a reference. First, inspired by Eric Weisstein's famed [http://mathworld.wolfram.com World of Mathematics], it links liberally between entries. Second, it can be updated regularly - much of its current content is not yet in any book as far as I know. Third, it takes a democratic approach to complexity classes, with big hitters like {{zcls|n|np}} listed alongside the lesser-known {{zcls|m|mal|mAL}}, {{zcls|p|podn}}, and {{zcls|q|qacc0|QACC<sub>0</sub>}}. Any class is fair game so long as something nontrivial has been said about it in the literature. The third audience comprises programmers, mathematicians, physicists, and anyone else who bumps into complexity classes occasionally. With this audience in mind I've kept the writing informal; those who need a precise definition of a class should consult the references. I hope that non-theorists, even if they don't understand everything, will at least find some amusement in the many exotic beasts that complexity theory has uncovered. Comments, corrections, and additions (of classes, results, references...) are most welcome; send to aaronson at ias dot edu. ==Recommended Further Reading== *[[Zoo References#pap94|<i>Computational Complexity</i>]] (1994) by C. H. Papadimitriou. The standard text, and an ideal starting place for beginners. *[[Zoo References#joh90|"A Catalog of Complexity Classes"]] (1990) by D. S. Johnson (Chapter 2 in the <i>Handbook of Theoretical Computer Science</i>, Volume A). Close in spirit to the Zoo. *[[Zoo References#ho02|<i>The Complexity Theory Companion</i>]] (2002), by L. A. Hemaspaandra and M. Ogihara. A lively guide to structural complexity. Has a "Rogues' Gallery" of classes at the end, including such obscure zoo denizens as [[Complexity Zoo:U#us|US]] and [[Complexity Zoo:S#sfk|SF<sub>k</sub>]] (though Prof. Hemaspaandra emphasizes to me that the book is "<i>mostly</i> about [[Complexity Zoo#np|NP]], [[Complexity Zoo#ph|PH]], etc. - pretty normal, standard stuff"). *Lance Fortnow's [http://fortnow.com/lance/complog/ Computational Complexity Web Log]. Includes a 'Complexity Class of the Week.' ==Other Theory Compendia== *[[Zoo References#gj79"|<i>Computers and Intractability: A Guide to the Theory of NP-Completeness</i>]] (1979) by M. R. Garey and D. S. Johnson. *[http://www.nada.kth.se/~viggo/wwwcompendium/ A Compendium of NP Optimization Problems], web site by P. Crescenzi and V. Kann et al. *[http://public.research.att.com/~dsj/columns/ NP-Completeness Columns by D. S. Johnson], review articles published in Journal of Algorithms and ACM Trans. Algorithms [[Category:Computational Complexity]] Complexity Zoo Pronunciation Guide 1964 11839 2008-11-27T14:44:55Z Scott Aaronson 102 ''This page is a pronunciation guide for the [[Complexity Zoo]] which was originally created at http://www.complexityzoo.com/ by [[Scott Aaronson]].'' <hr> Unfortunately, there are no accepted conventions for pronouncing the names of rarer complexity classes. Usually the safest bet is just to spell out a whole acronym; even when vowels are present, this is easier than wrapping one's tongue around (say) [[Complexity Zoo:P#podn|PODN]] or [[Complexity Zoo:N#niszk|NISZK]]. The major exceptions are words and word prefixes, which are pronounced as such: for example, co, mod, log, lin, few, poly, exp, gap, time, space, amp, av, sel, sat. Also, the "TAS" in [[Complexity Zoo:P#ptas|PTAS]], [[Complexity Zoo:F#fptas|FPTAS]], and [[Complexity Zoo:E#eptas|EPTAS]] is generally pronounced "tahz." As for symbols, the "&oplus;" of [[Complexity Zoo:Symbols#parityl|&oplus;L]] is pronounced "parity"; while the "#" of [[Complexity Zoo:Symbols#sharpp|#P]] is pronounced "sharp" (some textbooks also list "pound" or "number" as acceptable, but I've never heard the latter two used in real life (<i>update:</i> Leslie Ann Goldberg tells me that in Britain, they say both "number-P" and "hash-P")). The "/" of [[Complexity Zoo:P#pslashpoly|P/poly]] is pronounced "slash." The act of subscripting is left unvocalized, so that [[Complexity Zoo:M#modkp|Mod<sub>k</sub>P]] is "mod-k-p" rather than "mod-sub-k-p." Superscripting, on the other hand, ''is'' vocalized: [[Complexity Zoo:P#pnp|P<sup>NP</sup>]] is "P to the NP" (but not "P to the NP power" - it's an oracle, for Godsakes). Finally, [[Lance Fortnow]] has informed me that [[Complexity Zoo:C#cequalsp|C<sub>=</sub>P]] and its cousin [[Complexity Zoo:C#cequalsl|C<sub>=</sub>L]] are pronounced "C equals P" and "C equals L" respectively. This could lead to confusion in sentences such as [[Complexity Zoo:C#conqp|coNQP]] equals C equals P." [[Category:Computational Complexity]] Complexity Zoo References 1961 80356 2012-08-01T14:12:44Z Martin Schwarz 1807 added [IV12] __NOTOC__ {{Simple-Alpha-Menu|{{CZ-Navbar}} ---- }} <!-- don't delete blank lines above this.. they're there for spacing reasons --> ===== A ===== <span id="aar02" style="color:maroon">[Aar02]</span> S. Aaronson. Quantum lower bound for the collision problem, <i>Proceedings of ACM STOC'2002</i>, pp. 635-642, 2002. arXiv:[http://arxiv.org/abs/quant-ph/0111102 quant-ph/0111102]. <span id="aar03" style="color:maroon">[Aar03]</span> S. Aaronson. Lower bounds for local search by quantum arguments, <i>Proceedings of ACM STOC 2004</i>. arXiv:[http://arxiv.org/abs/quant-ph/0307149 quant-ph/0307149], ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-057/ TR03-057]. <span id="aar03b" style="color:maroon">[Aar03b]</span> S. Aaronson. Multilinear formulas and skepticism of quantum computing, <i>Proceedings of ACM STOC 2004</i>. arXiv:[http://arxiv.org/abs/quant-ph/0311039 quant-ph/0311039], ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-079/ TR03-079]. <span id="aar04b" style="color:maroon">[Aar04b]</span> S. Aaronson. Limitations of quantum advice and one-way communication, <i>Proceedings of IEEE Complexity 2004</i>, pp. 320-332, 2004. arXiv:[http://arxiv.org/abs/quant-ph/0402095 quant-ph/0402095], ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR04-026/ TR04-026]. <span id="aar05" style="color:maroon">[Aar05]</span> S. Aaronson. Quantum computing and hidden variables, <i>Physical Review A</i> 71:032325, March 2005. arXiv:[http://arxiv.org/abs/quant-ph/0408035 quant-ph/0408035]. <span id="aar05b" style="color:maroon">[Aar05b]</span> S. Aaronson. Quantum computing, postselection, and probabilistic polynomial-time, <i>Proceedings of the Royal Society A</i>, 461(2063):3473-3482, 2005. arXiv:[http://arxiv.org/abs/quant-ph/0412187 quant-ph/0412187]. <span id="aar05c" style="color:maroon">[Aar05c]</span> S. Aaronson. NP-complete problems and physical reality. <i>ACM SIGACT News</i>, March 2005 [http://arxiv.org/abs/quant-ph/0502072 quant-ph/0502072]. <span id="aar06" style="color:maroon">[Aar06]</span> S. Aaronson. Oracles are subtle but not malicious, <i>Proceedings of IEEE Complexity 2006</i>, 2006. arXiv:[http://arxiv.org/abs/cs.CC/0504048 cs.CC/0504048], ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR05-040/ TR05-040]. <span id="aar06b" style="color:maroon">[Aar06b]</span> S. Aaronson. QMA/qpoly is contained in PSPACE/poly: de-Merlinizing quantum protocols, <i>Proceedings of IEEE Complexity 2006</i>, 2006. arXiv:[http://arxiv.org/abs/quant-ph/0510230 quant-ph/0510230]. <span id="ak06" style="color:maroon">[AK06]</span> S. Aaronson and G. Kuperberg. Quantum versus classical proofs and advice, submitted, 2006. arXiv:[http://arxiv.org/abs/quant-ph/0604056 quant-ph/0604056]. <span id="ab00" style="color:maroon">[AB00]</span> E. Allender and D. A. M. Barrington. Uniform Circuits for Division: Consequences and Problems. J. Comput. System Sci. 65 (2002), no. 4, 695--716. ECCC [http://eccc.uni-trier.de/eccc-reports/2000/TR00-65/ TR00-65], 2000. {{Reference |id=abd08 |tag=ABD+08 |authors=S. Aaronson, S. Beigi, A. Drucker, et al |title=The power of unentanglement |journal=Electronic Colloquium on Computational Complexity |srcdetail=ECCC Report TR08-051, accepted on May 02, 2008 |link=[http://eccc.hpi-web.de/eccc-reports/2008/TR08-051/index.html http://eccc.hpi-web.de/eccc-reports/2008/TR08-051/index.html] }} <span id="abf94" style="color:maroon">[ABF+94]</span> J. Aspnes, R. Beigel, M. L. Furst, and S. Rudich. The expressive power of voting polynomials, <i>Combinatorica</i> 14(2):135-148, 1994. [http://www.cs.yale.edu/~aspnes/stoc91voting.ps http://www.cs.yale.edu/~aspnes/stoc91voting.ps] <span id="abk02" style="color:maroon">[ABK+02]</span> E. Allender, H. Buhrman, M. Kouck&yacute;, D. van Melkebeek, and D. Ronneburger. Power from random strings, <i>Proceedings of IEEE FOCS'2002</i>, pp. 669-678, 2002. ECCC [http://eccc.uni-trier.de/eccc-reports/2002/TR02-028/ TR02-028]. <span id="abl98" style="color:maroon">[ABL98]</span> A. Ambainis, D. M. Barrington, and H. L&ecirc;Thanh. On counting AC<sup>0</sup> circuits with negative constants, <i>Proceedings of MFCS (Mathematical Foundations of Computer Science)</i>, pp. 419-427, 1998. ECCC [http://eccc.uni-trier.de/eccc-reports/1998/TR98-020/ TR98-020]. <span id="abo99" style="color:maroon">[ABO99]</span> E. Allender, R. Beals, and M. Ogihara. The complexity of matrix rank and feasible systems of linear equations, <i>Computational Complexity</i> 8(2):99-126, 1999. ECCC [http://eccc.uni-trier.de/eccc-reports/1996/TR96-024/ TR96-024], DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1997/97-40.html TR 97-40]. <span id="abv95" style="color:maroon">[ABV95]</span> W. Aiello, M. Bellare, and R. Venkatesan. Knowledge on the average - perfect, statistical, and logarithmic, <i>Proceedings of ACM STOC'95</i>, 1995. <span id="acg99" style="color:maroon">[ACG+99]</span> G. Ausiello, P. Crescenzi, G. Gambosi, V. Kann, A. Marchetti-Spaccamela, and M. Protasi. <i>Complexity and Approximation: Combinatorial optimization problems and their approximability properties</i>, Springer-Verlag, 1999. See also "A compendium of NP optimization problems" (P. Crescenzi and V. Kann, eds.), [http://www.nada.kth.se/~viggo/wwwcompendium/ http://www.nada.kth.se/~viggo/wwwcompendium/]. <span id="adh97" style="color:maroon">[ADH97]</span> L. Adleman, J. DeMarrais, and M. Huang. Quantum computability, <i>SIAM Journal on Computing</i> 26:1524-1540, 1997. <span id="adl78" style="color:maroon">[Adl78]</span> L. Adleman. Two theorems on random polynomial time. FOCS 78. <span id="afm01" style="color:maroon">[AFM01]</span> L. Antu&ntilde;es, L. Fortnow, and D. van Melkebeek. Computational depth, <i>Proceedings of IEEE Complexity'01</i>, pp. 266-273, 2001. [http://people.cs.uchicago.edu/~fortnow/papers/depth.ps http://people.cs.uchicago.edu/~fortnow/papers/depth.ps] <span id="ag00" style="color:maroon">[AG00]</span> C. Alvarez and R. Greenlaw. A compendium of problems complete for symmetric logarithmic space, <i>Journal of Computational Complexity</i> 9:73-95, 2000. ECCC [http://eccc.uni-trier.de/eccc-reports/1996/TR96-039/ TR96-039]. <span id="agh90" style="color:maroon">[AGH90]</span> W. Aiello, S. Goldwasser, and J. H&aring;stad. On The Power Of Interaction. Combinatorica 10 (1990), no. 1, 3--25. <span id="agk07" style="color:maroon">[AGK07]</span> D. Aharonov, D. Gottesman, and J. Kempe;stad. The power of quantum systems on a line. FOCS 2007. {{Reference |tag=Agr01 |authors=Agrawal, Manindra |title=For completeness, sublogarithmic space is no space |journal=Information Processing Letters (82), 2001-2002 |srcdetail=iss. 6, 321-325 |link=http://www.cse.iitk.ac.in/~manindra/isomorphism/sublog-completeness.pdf }} {{Reference |id=Ajt83 |tag=AJT83 |authors=M. Ajtai |title=Σ-1-1-Formulae on finite structures |journal=Annals of Pure and Applied Logic (24), 1983 |srcdetail=1-48 }} <span id="ah87" style="color:maroon">[AH87]</span> L. Adleman and M. Huang. Recognizing primes in random polynomial time, <i>Proceedings of ACM STOC'87</i>, pp. 462-470, 1987. <span id="ah87b" style="color:maroon">[AH87b]</span> W. Aiello and J. H&aring;stad. Perfect zero-knowledge languages can be recognized in two rounds, <i>Proceedings of IEEE FOCS 1987</i>, pp. 439-448, 1987. <span id="aik04" style="color:maroon">[AIK04]</span> B. Applebaum, Y. Ishai, and E. Kushilevitz. Cryptography in NC<sup>0</sup>, <i>Proceedings of IEEE FOCS 2004</i>. [http://www.cs.technion.ac.il/~yuvali/pubs/AIK04.ps http://www.cs.technion.ac.il/~yuvali/pubs/AIK04.ps]. <span id="aj93" style="color:maroon">[AJ93]</span> C. Alvarez and B. Jenner. A very hard log-space counting class, <i>Theoretical Computer Science</i> 107:3-30, 1993. <span id="ak02" style="color:maroon">[AK02]</span> V. Arvind and P. Kurur. Graph isomorphism is in SPP, ECCC [http://eccc.uni-trier.de/eccc-reports/2002/TR02-037/ TR02-037], 2002. <span id="ak06" style="color:maroon">[AK06]</span> S. Aaronson and G. Kuperberg. Quantum Versus Classical Proofs and Advice. arXiv:[http://arxiv.org/quant-ph/0604056 quant-ph/0604056], 2006. <span id="ak96" style="color:maroon">[AK96]</span> F. Ablayev and M. Karpinski. On the power of randomized branching programs, <i>Proceedings of the International Colloquium on Automata, Languages, and Programming (ICALP)</i>, Springer-Verlag 1099, pp. 348-356, 1996. ECCC [http://eccc.uni-trier.de/eccc-reports/1995/TR95-054/ TR95-054], DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1996/96-46.html TR 96-46]. <span id="akl79" style="color:maroon">[AKL+79]</span> R. Aleliunas, R. M. Karp, R. J. Lipton, L. Lov&aacute;sz, and C. Rackoff. Random walks, traversal sequences, and the complexity of maze problems, <i>Proceedings of IEEE FOCS'79</i>, pp. 218-223, 1979. {{Reference |tag=AKR+03 |authors=E. Allender, M. Koucký, D. Ronneburger, et al |title=Derandomization and distinguishing complexity |journal=Proceedings of the 18th Annual IEEE Conference on Computational Complexity |srcdetail=209-220 }} {{Reference |tag=AKS94 |authors=V. Arvind, J. Köbler and R. Schuler |title=On helping and interactive proof systems |journal=Algorithms and Computation: 5th International Symposium |srcdetail=137-145 }} <span id="aks02" style="color:maroon">[AKS02]</span> M. Agrawal, N. Kayal, and N. Saxena. Primes is in P, Annals of Mathematics, 160 (2004), 781-793. [http://www.cse.iitk.ac.in/primality.pdf http://www.cse.iitk.ac.in/primality.pdf]. <span id="aks95" style="color:maroon">[AKS+95]</span> V. Arvind, J. K&ouml;bler, U. Sch&ouml;ning, and R. Schuler. If NP has polynomial-size circuits, then MA=AM, <i>Theoretical Computer Science</i> 137, 1995. [http://www.informatik.hu-berlin.de/Institut/struktur/algorithmenII/Papers/ma-am.ps.gz http://www.informatik.hu-berlin.de/Institut/struktur/algorithmenII/Papers/ma-am.ps.gz] <span id="all96" style="color:maroon">[All96]</span> E. Allender. Circuit complexity before the dawn of the new millennium, <i>Proceedings of the 16th Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FST&amp;TCS)</i>, Lecture Notes in Computer Science 1180, pp. 1-18, 1996. DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1997/97-49.html TR 97-49]. <span id="all99" style="color:maroon">[All99]</span> E. Allender. The permanent requires large uniform threshold circuits, <i>Chicago Journal of Theoretical Computer Science</i> 7, 1999. DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1997/97-51.html TR 97-51]. <span id="alm98" style="color:maroon">[ALM+98]</span> S. Arora, C. Lund, R. Motwani, M. Sudan, and M. Szegedy. Proof verification and hardness of approximation problems, <i>Journal of the ACM</i> 45(3):501-555, 1998. ECCC [http://eccc.uni-trier.de/eccc-reports/1998/TR98-008/ TR98-008]. {{Reference |id=am04 |tag=AM04 |title=Visibly Pushdown Languages |authors=R. Alur and P. Madhusudan |journal=Proceedings of ACM STOC'04, 2004. |srcdetail=202-211 }} {{Reference |id=am09 |tag=AM09 |title=Adding Nesting Structure to Words. |authors=R. Alur and P. Madhusudan |journal=Journal of the ACM 56(3) |srcdetail=Article 16, May 2009 }} <span id="amp02" style="color:maroon">[AMP02]</span> F. Ablayev, C. Moore, and C. Pollett. Quantum and stochastic branching programs of bounded width, <i>Proceedings of the International Colloquium on Automata, Languages, and Programming (ICALP)</i>, 2002. arXiv:[http://arxiv.org/abs/quant-ph/0201139 quant-ph/0201139], ECCC [http://eccc.uni-trier.de/eccc-reports/2002/TR02-013/ TR02-013]. <span id="ams06" style="color:maroon">[AMS06]</span> N. Alon, D. Moshkovitz, and S. Safra. Algorithmic construction of sets for k-restrictions, <i>ACM Transactions on Algorithms (TALG)</i> 2(2): 153–177, 2006. [http://dx.doi.org/10.1145/1150334.1150336 doi:10.1145/1150334.1150336] <span id="an02" style="color:maroon">[AN02]</span> D. Aharonov and T. Naveh. Quantum NP - a survey, arXiv:[http://arxiv.org/abs/quant-ph/0210077 quant-ph/0210077]. <span id="ap95" style="color:maroon">[AP95]</span> G. Ausiello and M. Protasi Local search, reducibility, and approximability of NP optimization problems, <i>Information Processing Letters</i> 54:73-79, 1995. <span id="ar01" style="color:maroon">[AR01]</span> M. Alekhnovich and A. A. Razborov. Resolution is not automatizable unless W[P] is tractable, <i>Proceedings of IEEE FOCS'01</i>, pp. 210-219, 2001. <span id="ar03" style="color:maroon">[AR03]</span> D. Aharonov and O. Regev. A lattice problem in quantum NP, arXiv:[http://arxiv.org/abs/quant-ph/0307220 quant-ph/0307220]. <span id="ar88" style="color:maroon">[AR88]</span> E. Allender and R. Rubinstein. P-printable sets, <i>SIAM Journal on Computing</i> 17(6):1193-1202, 1988. <span id="aro96" style="color:maroon">[Aro96]</span> S. Arora. Polynomial time approximation scheme for Euclidean TSP and other geometric problems, <i>Proceedings of IEEE FOCS'96</i>, pp. 2-11, 1996. [http://www.cs.princeton.edu/~arora/pubs/tsp1.ps http://www.cs.princeton.edu/~arora/pubs/tsp1.ps] <span id="arz99" style="color:maroon">[ARZ99]</span> E. Allender, K. Reinhardt, and S. Zhou. Isolation, matching, and counting: uniform and nonuniform upper bounds, <i>Journal of Computer and System Sciences</i> 59:164-181, 1999. [http://www.cs.rutgers.edu/pub/allender/matching.pdf http://www.cs.rutgers.edu/pub/allender/matching.pdf]. <span id="as94" style="color:maroon">[AS94]</span> E. Allender and M. Strauss. Measure on small complexity classes with applications for BPP, <i>Proceedings of IEEE FOCS'94</i>, pp. 807-818, 1994. ECCC [http://eccc.uni-trier.de/eccc-reports/1994/TR94-004/ TR94-004], DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1994/94-18.html TR 94-18]. <span id="as98" style="color:maroon">[AS98]</span> S. Arora and M. Safra. Probabilistic checking of proofs: a new characterization of NP, <i>Journal of the ACM</i> 45(1):70-122, 1998. [http://www.cs.princeton.edu/~arora/pubs/as.ps http://www.cs.princeton.edu/~arora/pubs/as.ps]. <span id="asv00" style="color:maroon">[ASV00]</span> A. Ambainis, L. Schulman, and U. Vazirani. Quantum computing with highly mixed states, <i>Proceedings of ACM STOC'2000</i>, pp. 705-714, 2000. arXiv:[http://arxiv.org/abs/quant-ph/0003136 quant-ph/0003136]. <span id="atw00" style="color:maroon">[ATW+00]</span> R. Armoni, A. Ta-Shma, A. Wigderson, and S. Zhou. An O(log(n)<sup>4/3</sup>) algorithm for (s,t) connectivity in undirected graphs, <i>Journal of the ACM</i> 47(2):294-311, 2000. [http://whiteboard.cs.tau.ac.il/~amnon/Papers/ATWZ.jacm00.pdf http://whiteboard.cs.tau.ac.il/~amnon/Papers/ATWZ.jacm00.pdf] {{Reference |tag=AV04 |title=Abelian permutation group problems and logspace counting classes |authors=V. Arvind and T. C. Vijayaraghavan |journal=Proceedings of the 19th IEEE Conference on Computational Complexity |srcdetails=204-214, 2004 }} <span id="aw90" style="color:maroon">[AW90]</span> E. Allender and K. W. Wagner. Counting hierarchies: polynomial time and constant depth circuits, <i>Bulletin of the EATCS</i> 40, February 1990. [http://people.cs.uchicago.edu/~fortnow/beatcs/column40.ps http://people.cs.uchicago.edu/~fortnow/beatcs/column40.ps]. ===== B ===== <span id="babai85" style="color:maroon">[Bab85]</span> L. Babai. Trading Group Theory for Randomness. In <i>17th STOC</i>, pages 421--429, 1985. <span id="bab87" style="color:maroon">[Bab87]</span> L. Babai. Random oracles separate PSPACE from the polynomial-time hierarchy. Information Processing Letters, 26 (1987) 51-53. <span id="bar02" style="color:maroon">[Bar02]</span> B. Barak. A probabilistic-time hierarchy theorem for "slightly non-uniform" algorithms, <i>Proceedings of RANDOM'2002</i>, 2002. [http://www.math.weizmann.ac.il/~/boaz/Papers/bptime.ps http://www.math.weizmann.ac.il/~/boaz/Papers/bptime.ps] <span id="bar89" style="color:maroon">[Bar89]</span> D. A. M. Barrington. Bounded-width polynomial-size branching programs can recognize exactly those languages in NC<sub>1</sub>, <i>Journal of Computer and System Sciences</i> 38:150-164, 1989. <span id="baz95" style="color:maroon">[Baz95]</span> C. Bazgan. Approximation de probl&egrave;mes d'optimisation et de fonctions totales de NP, PhD thesis, INRIA, Orsay, France, 1998. [http://l1.lamsade.dauphine.fr/~bazgan/Papers/these.ps http://l1.lamsade.dauphine.fr/~bazgan/Papers/these.ps] <span id="bb92" style="color:maroon">[BB92]</span> A. Berthiaume and G. Brassard. The quantum challenge to structural complexity theory. Proceedings of Structure in Complexity Theory, 1992, 132--137. <span id="bbb97" style="color:maroon">[BBB+97]</span> C. H. Bennett, E. Bernstein, G. Brassard, and U. Vazirani. Strengths and weaknesses of quantum computing, <i>SIAM Journal on Computing</i>, 26(5):1510-1523, 1997. arXiv:[http://arxiv.org/abs/quant-ph/9701001 quant-ph/9701001]. <span id="bbf98" style="color:maroon">[BBF98]</span> R. Beigel, H. Buhrman, and L. Fortnow. NP might not be as easy as detecting unique solutions, <i>Proceedings of ACM STOC'98</i>, pp. 203-208, 1998. [http://people.cs.uchicago.edu/~fortnow/papers/newiso.ps http://people.cs.uchicago.edu/~fortnow/papers/newiso.ps]. <span id="bbr94" style="color:maroon">[BBR94]</span> D. A. M. Barrington, R. Beigel, and S. Rudich. Representing Boolean functions as polynomials modulo composite integers, <i>Computational Complexity</i>, 4:367-382, 1994. [http://www.cis.temple.edu/~beigel/papers/bbr-mods-cc.html http://www.cis.temple.edu/~beigel/papers/bbr-mods-cc.html]. <span id="bbs86" style="color:maroon">[BBS86]</span> J. Balc&aacute;zar, R. Book, and U. Sch&ouml;ning. Sparse sets, lowness, and highness, <i>SIAM Journal on Computing</i> 15:739-747, 1986. <span id="bce95" style="color:maroon">[BCE+95]</span> P. Beame, S. Cook, J. Edmonds, R. Impagliazzo, and T. Pitassi. The relative complexity of NP search problems, <i>Proceedings of ACM STOC'95</i>, pp. 303-314, 1995. [http://www.cs.washington.edu/homes/beame/search.ps http://www.cs.washington.edu/homes/beame/search.ps] <span id="bch86" style="color:maroon">[BCH86]</span> P. Beame, S. Cook, and J. Hoover. Log depth circuits for division and related problems, <i>SIAM Journal on Computing</i> 15:994-1003, 1986 [http://www.cs.washington.edu/homes/beame/papers/division.ps http://www.cs.washington.edu/homes/beame/papers/division.ps]. <span id="bcg92" style="color:maroon">[BCG+92]</span> S. Ben-David, B. Chor, O. Goldreich, and M. Luby. On the theory of average case complexity, <i>Journal of Computer and System Sciences</i> 44(2):193-219, 1992. [http://www.cs.technion.ac.il/~shai/aver.pdf http://www.cs.technion.ac.il/~shai/aver.pdf] <span id="bcs97" style="color:maroon">[BCS+97]</span> L. Blum, F. Cucker, M. Shub, and S. Smale. <i>Complexity and Real Computation</i>, Springer-Verlag, 1997. <span id="bcd89" style="color:maroon">[BCD+89]</span> A. Borodin, S. A. Cook, P. W. Dymond, W. L. Ruzzo, and M. L. Tompa. Two applications of inductive counting for complementation problems, <i>SIAM Journal on Computing</i> 18:559-578, 1989. <span id="bcp83" style="color:maroon">[BCP83]</span> A. Borodin, S. A. Cook, and N. Pippenger. Parallel computations for well-endowed rings and space-bounded probabilistic machines, <i>Information and Control</i> 58:113-136, 1983. <span id="bd99" style="color:maroon">[BD99]</span> H. Buhrman and W. van Dam. Bounded quantum query complexity, <i>Proceedings of IEEE Complexity'99</i>, pp. 149-156, 1999. arXiv:[http://arxiv.org/abs/quant-ph/9903035 quant-ph/9903035]. <span id="bdg88" style="color:maroon">[BDG88]</span> J. L. Balc&aacute;zar, J. D&iacute;az, and J. Gabarr&oacute; Structural complexity 1 <span id="bdh92" style="color:maroon">[BDH+92]</span> G. Buntrock, C. Damm, U. Hertrampf, and Ch. Meinel. Structure and importance of logspace-MOD-classes, <i>Mathematical Systems Theory</i> 25:223-237, 1992. [http://www.num.math.uni-goettingen.de/damm/papers/BDHM92.ps.gz http://www.num.math.uni-goettingen.de/damm/papers/BDHM92.ps.gz]. <span id="bei89" style="color:maroon">[Bei89]</span> R. Beigel. On the relativized power of additional accepting paths, <i>Proceedings of IEEE Complexity'89</i>, pp. 216-224, 1989. [http://www.cis.temple.edu/~beigel/papers/ukp-structures.PS.gz http://www.cis.temple.edu/~beigel/papers/ukp-structures.PS.gz]. <span id="bei94" style="color:maroon">[Bei94]</span> R. Beigel. Perceptrons, PP, and the polynomial hierarchy, <i>Computational Complexity</i> 4:339-349, 1994. [http://www.cis.temple.edu/~beigel/papers/delta2p-cc.PS.gz http://www.cis.temple.edu/~beigel/papers/delta2p-cc.PS.gz]. <span id="ber80" style="color:maroon">[Ber80]</span> L. Berman. The complexity of logical theories, <i>Theoretical Computer Science</i> 11:71-78, 1980. <span id="bf92" style="color:maroon">[BF92]</span> R. Beigel and J. Feigenbaum. On Being Incoherent Without Being Very Hard. Comput. Complexity 2 (1992), no. 1, 1--17 [http://www.cis.temple.edu/~beigel/papers/bf-coherent-cc.html http://www.cis.temple.edu/~beigel/papers/bf-coherent-cc.html] <span id="bf99" style="color:maroon">[BF99]</span> H. Buhrman and L. Fortnow. One-sided versus two-sided randomness, <i>Proceedings of the 16th Symposium on Theoretical Aspects of Computer Science (STACS)</i>, pp. 100-109, 1999. [http://people.cs.uchicago.edu/~fortnow/papers/rpvsbpp.ps http://people.cs.uchicago.edu/~fortnow/papers/rpvsbpp.ps]. {{Reference |tag=BF03 |authors=R. Beigel |title=Are Cook and Karp ever the same? |journal=Proceedings of the 18th Annual IEEE Conference on Computational Complexity |srcdetail=333-336 }} <span id="bfl91" style="color:maroon">[BFL91]</span> L. Babai, L. Fortnow, and C. Lund. Nondeterministic exponential time has two-prover interactive protocols, <i>Computational Complexity</i> 1:3-40, 1991. [http://people.cs.uchicago.edu/~fortnow/papers/mip2.ps http://people.cs.uchicago.edu/~fortnow/papers/mip2.ps]. <span id="bfm88" style="color:maroon">[BFM88]</span> M. Blum, P. Feldman, and S. Micali. Non-interactive zero-knowledge proofs and their applications, <i>Proceedings of the 20th STOC, ACM</i>, 1988. <span id="bfs86" style="color:maroon">[BFS86]</span> L. Babai, P. Frankl, and J. Simon. Complexity classes in communication complexity theory, <i>Proceedings of IEEE FOCS'86</i>, pp. 337-347, 1986. <span id="bft98" style="color:maroon">[BFT98]</span> H. Buhrman, L. Fortnow, and T. Thierauf. Nonrelativizing separations, <i>Proceedings of IEEE Complexity'98</i>, pp. 8-12, 1998. [http://people.cs.uchicago.edu/~fortnow/papers/nonrel.ps http://people.cs.uchicago.edu/~fortnow/papers/nonrel.ps]. <span id="bgs75" style="color:maroon">[BGS75]</span> T. Baker, J. Gill, and R. Solovay. Relativizations of the P=?NP question, <i>SIAM Journal on Computing</i> 4:431-442, 1975. <span id="bh77" style="color:maroon">[BH77]</span> L. Berman and J. Hartmanis. On isomorphism and density of NP and other complete sets, <i>SIAM Journal on Computing</i> 6:305-322, 1977. <span id="bg03" style="color:maroon">[BG03]</span> M. Ben-Or and D. Gutfreund. Trading help for interaction in statistical zero-knowledge proofs, <i>J. Cryptology</i> 16 (2003), no. 2, 95--116. [http://www.cs.huji.ac.il/~danig/pubs/help_interaction.ps http://www.cs.huji.ac.il/~danig/pubs/help_interaction.ps] <span id="bg69" style="color:maroon">[BG69]</span> R. Book and S. Greibach. Quasi-realtime languages, <i>Proceedings of ACM STOC</i> pp. 15-18, 1969. http://portal.acm.org/citation.cfm?id=800169.805416 <span id="bg81" style="color:maroon">[BG81]</span> C. H. Bennett and J. Gill. Relative to a random oracle A, P<sup>A</sup> != NP<sup>A</sup> != coNP<sup>A</sup> with probability 1, <i>SIAM Journal on Computing</i>, 10(1):96-113, 1981. DOI:[http://dx.doi.org/10.1137/0210008 10.1137/0210008] <span id="bg92" style="color:maroon">[BG92]</span> R. Beigel and J. Gill. Counting classes: thresholds, parity, mods, and fewness, <i>Theoretical Computer Science</i> 103(1):3-23, 1992. [http://www.cis.temple.edu/~beigel/papers/bg-mods-tcs.PS.gz http://www.cis.temple.edu/~beigel/papers/bg-mods-tcs.PS.gz]. <span id="bg98" style="color:maroon">[BG98]</span> R. Beigel and J. Goldsmith. Downward separation fails catastrophically for limited nondeterminism classes, <i>SIAM Journal on Computing</i> 17(5):1420-1429, 1998. [http://www.cis.temple.edu/~beigel/papers/bg-beta-draft.PS.gz http://www.cis.temple.edu/~beigel/papers/bg-beta-draft.PS.gz]. <span id="bg94" style="color:maroon">[BG94]</span> M. Bellare and S. Goldwasser. The complexity of decision versus search, <i>SIAM Journal on Computing</i> 23(1):91-119, 1994. [http://www.cs.ucsd.edu/users/mihir/papers/compip.pdf http://www.cs.ucsd.edu/users/mihir/papers/compip.pdf] <span id="bgg90" style="color:maroon">[BGG+90]</span> M. Ben-Or, O. Goldreich, S. Goldwasser, J. H&aring;stad, J. Kilian, S. Micali, and P. Rogaway. Everything provable is provable in zero-knowledge, <i>Advances in Cryptology: CRYPTO'88</i> (S. Goldwasser, ed.), Lecture Notes in Computer Science 403, Springer-Verlag, pp. 37-56, 1990. <span id="bgk88" style="color:maroon">[BGK+88]</span> M. Ben-Or, S. Goldwasser, J. Kilian, and A. Wigderson. Multi-prover interactive proofs: how to remove intractability, <i>Proceedings of ACM STOC'88</i>, pp. 113-131, 1988. <span id="bg82" style="color:maroon">[BG82]</span> A. Blass and Y. Gurevich. On the unique satisfiability problem, <i>Information and Control</i> 55(1-3):80-88, 1982. <span id="bgm02" style="color:maroon">[BGM02]</span> E. B&ouml;hler, C. Gla&szlig;er, and D. Meister. Error-bounded probabilistic computations between MA and AM, Mathematical foundations of computer science 2003, 249--258. [http://haegar.informatik.uni-wuerzburg.de/users/glasser/publications/sbp-ma-am-tr.pdf http://haegar.informatik.uni-wuerzburg.de/users/glasser/publications/sbp-ma-am-tr.pdf] <span id="bgr93" style="color:maroon">[BGR93]</span> Burchard von Braunmühl, Romain Gengler, Robert Rettinger. The alternation hierarchy for sublogarithmic space is infinite, Computational Complexity, v.3 n.3, p.207-230, July 1993 [doi>10.1007/BF01271368] [http://portal.acm.org/citation.cfm?id=218886] <span id="bh91" style="color:maroon">[BH91]</span> S. R. Buss and L. Hay. On truth-table reducibility to SAT, <i>Information and Computation</i> 91(1):86-102, 1991. <span id="bh97" style="color:maroon">[BH97]</span> C. Berg and J. H&aring;stad. On the BPP hierarchy problem, Technical Report TRITA-NA-9702, Royal Institute of Technology, Sweden, 1997. [ftp://ftp.nada.kth.se/pub/documents/Theory/Christer-Berg/bpp.ps ftp://ftp.nada.kth.se/pub/documents/Theory/Christer-Berg/bpp.ps]. {{Reference |tag=BH08 |title=NP-Hard sets are exponentially eense unless NP is contained in coNP/poly |journal=Electronic Colloquium on Computational Complexity |authors=H. Buhrman and J. Hitchcock |srcdetail=ECCC Report TR08-022, accepted on Mar 11, 2008 |link=[http://eccc.hpi-web.de/eccc-reports/2008/TR08-022/index.html http://eccc.hpi-web.de/eccc-reports/2008/TR08-022/index.html] }} <span id="bhr00" style="color:maroon">[BHR00]</span> B. Borchert, L. Hemaspaandra, and J. Rothe. Restrictive Acceptance Suffices for Equivalence Problems. LMS J. Comput. Math. 3 (2000), 86--95 arXiv:[http://arxiv.org/cs.CC/9907041 cs.CC/9907041]. <span id="bhw89" style="color:maroon">[BHW89]</span> R. Beigel, L. Hemachandra, and G. Wechsung. On the power of probabilistic polynomial time, <i>Proceedings of IEEE Complexity'89</i>, pp. 225-230, 1989. <span id="bhz87" style="color:maroon">[BHZ87]</span> R. B. Boppana, J. H&aring;stad, and S. Zachos. Does co-NP have short interactive proofs?, <i>Information Processing Letters</i> 25:127-132, 1987. <span id="bk89" style="color:maroon">[BK89]</span> M. Blum and S. Kannan. Designing programs that check their work, <i>Proceedings of ACM STOC'89</i>, 1989. <span id="bkl00" style="color:maroon">[BKL+00]</span> D. A. M. Barrington, P. Kadau, K.-J. Lange, and P. McKenzie. On the complexity of some problems on groups input as multiplication tables, [http://www-fs.informatik.uni-tuebingen.de/~lange/Arbeiten/fologlog/bklm/neu.ps.gz http://www-fs.informatik.uni-tuebingen.de/~lange/Arbeiten/fologlog/bklm/neu.ps.gz] <i>Proceedings of IEEE Complexity'2000</i>, 2000. <span id="bks95" style="color:maroon">[BKS95]</span> R. Beigel, M. Kummer, and F. Stephan. Approximable sets, <i>Information and Computation</i> 120(2):304-314, 1995. [http://www.cis.temple.edu/~beigel/papers/bks-queries2-ic.PS.gz http://www.cis.temple.edu/~beigel/papers/bks-queries2-ic.PS.gz]. <span id="blm98" style="color:maroon">[BLM+98]</span> D. A. M. Barrington, C.-J. Lu, P. B. Miltersen, and S. Skyum. Searching constant width mazes captures the AC<sup>0</sup> hierarchy, <i>Proceedings of the 1998 Symposium of Theoretical Aspects of Computer Science (STACS'98)</i>, 1998. ECCC [http://eccc.uni-trier.de/eccc-reports/1997/TR97-044/ TR97-044]. <span id="blm99" style="color:maroon">[BLM+99]</span> D. A. M. Barrington, C.-J. Lu, P. B. Miltersen, and S. Skyum. On monotone planar circuits, <i>Proceedings of IEEE Complexity'99</i>, 1999. [http://www.brics.dk/~bromille/Papers/mpc.ps http://www.brics.dk/~bromille/Papers/mpc.ps] <span id="bls84" style="color:maroon">[BLS84]</span> R. Book, T. Long, and A. Selman. Quantitative relativizations of complexity classes, <i>SIAM Journal on Computing</i> 13(3):461-487, 1984. <span id="blu67" style="color:maroon">[Blu67]</span> M. Blum. A Machine-Independent Theory of the Complexity of Recursive Functions. <i>J. ACM</i> 14: 322-336, 1967. <span id="bm04" style="color:maroon">[BM04]</span> J. Buresh-Oppenheim and T. Morioka. Relativized NP search problems and propositional proof systems, <i>Proceedings of IEEE Complexity 2004</i>, pp. 54-67, 2004. ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-084/ TR03-084]. <span id="bm88" style="color:maroon">[BM88]</span> L. Babai and S. Moran. Arthur-Merlin games: a randomized proof system, and a hierarchy of complexity classes, <i>Journal of Computer and Systems Sciences</i> 36:254-276, 1988. <span id="boo72" style="color:maroon">[Boo72]</span> R. Book. On languages accepted in polynomial time, <i>SIAM Journal on Computing</i> 1(4):281-287, 1972. <span id="boo74" style="color:maroon">[Boo74]</span> R. Book. Comparing complexity classes, <i>Journal of Computer and System Sciences</i> 3(9):213-229, 1974. <span id="boo94" style="color:maroon">[Boo94]</span> R. Book. On collapsing the polynomial-time hierarchy, <i>Information Processing Letters</i> 52(5):235-237, 1994. <span id="bor77" style="color:maroon">[Bor77]</span> A. Borodin. On relating time and space to size and depth, <i>SIAM Journal on Computing</i> 6:733-744, 1977. <span id="bra77" style="color:maroon">[Bra77]</span> F.-J. Brandenburg. On one-way auxiliary pushdown automata, <i>Proceedings of the Third GI-Conference on Theoretical Computer Science</i>, Springer LNCS vol. 48, pp. 132-144, 1977. <span id="bra79" style="color:maroon">[Bra79]</span> G. Brassard. A note on the complexity of cryptography <i>IEEE Transactions on Information Theory</i>, 25(2):232-233, 1979. <span id="bra06" style="color:maroon">[Bra06]</span> S. Bravyi. Efficient algorithm for a quantum analogue of 2-SAT, arXiv:[http://arxiv.org/abs/quant-ph/0602108v1 quant-ph/0602108v1], 2006. <span id="brs91" style="color:maroon">[BRS91]</span> R. Beigel, N. Reingold, and D. A. Spielman. PP is closed under intersection, <i>Proceedings of ACM STOC'91</i>, pp. 1-9, 1991. [http://www.cis.temple.edu/~beigel/papers/brs-pp-jcss.PS.gz http://www.cis.temple.edu/~beigel/papers/brs-pp-jcss.PS.gz]. <span id="bru90" style="color:maroon">[Bru90]</span> J. Bruck. Harmonic analysis of polynomial threshold functions, SIAM J. Discrete Math., 3 (1990) 168-177. <span id="bs00" style="color:maroon">[BS00]</span> B. Borchert and F. Stephan. Looking for an Analogue of Rice's Theorem in Circuit Complexity Theory. MLQ Math. Log. Q. 46 (2000), no. 4, 489--504 [http://math.uni-heidelberg.de/logic/bb/papers/Rice.ps http://math.uni-heidelberg.de/logic/bb/papers/Rice.ps] <span id="bs90" style="color:maroon">[BS90]</span> J. Bruck and R. Smolensky. Polynomial threshold functions, AC<sup>0</sup> functions and spectral norms, <i>Proceedings of IEEE FOCS'90</i>, pp. 632-641, 1990. <span id="bs90b" style="color:maroon">[BS90b]</span> R. B. Boppana and M. Sipser. The complexity of finite functions. chapter in <i>Handbook of Theoretical Computer Science</i>, Volume A (J. van Leeuwen, editor), Elsevier, 1990. <span id="bsf02" style="color:maroon">[BSF02]</span> A. Ben-Hur, H. T. Siegelmann, and S. Fishman. A theory of complexity for continuous time systems, <i>Journal of Complexity</i> 18(1):51-86, 2002. [http://cmgm.stanford.edu/~asab/Papers/dds2.ps.gz http://cmgm.stanford.edu/~asab/Papers/dds2.ps.gz] <span id="bt04" style="color:maroon">[BT04]</span> H. Buhrman and L. Torenvliet. Separating complexity classes using structural properties, <i>Proceedings of IEEE Complexity 2004</i>, pp. 130-138, 2004. [http://staff.science.uva.nl/~leen/PAPERS/superrobustsets.pdf http://staff.science.uva.nl/~leen/PAPERS/superrobustsets.pdf] {{Reference |tag=BT06 |authors=A. Bogdanov and L. Trevisan |title=Average-Case Complexity |journal=ECCC Report TR06-073 |srcdetail=Revision 01, accepted on Fri Sep 29 22:13:11 2006 }} <span id="bt88" style="color:maroon">[BT88]</span> D. A. M. Barrington and D. Th&eacute;rien. Finite monoids and the fine structure of NC<sup>1</sup>, <i>Journal of the ACM</i> 35(4):941-952, 1988. <span id="bur00" style="color:maroon">[Bur00]</span> P. B&uuml;rgisser. <i>Completeness and Reduction in Algebraic Complexity Theory</i>, Springer Series in Algorithms and Computation in Mathematics, Volume 7, 2000. {{Reference |tag=Buss93 |authors = Buss, Samuel R. |title = Algorithms for Boolean formula evaluation and for tree-contraction |journal=Proof Theory, Complexity, and Arithmetic, P. Clote and J. Krajicek (eds) |srcdetail=Oxford University Press, 1993, pp. 95-115 |link=http://math.ucsd.edu/~sbuss/ResearchWeb/Boolean3/index.html }} <span id="bv97" style="color:maroon">[BV97]</span> E. Bernstein and U. Vazirani. Quantum complexity theory, <i>SIAM Journal on Computing</i>, 26(5):1411-1473, 1997. [http://www.cs.berkeley.edu/~vazirani/bv.ps http://www.cs.berkeley.edu/~vazirani/bv.ps] <span id="bvw98" style="color:maroon">[BVW98]</span> R. Book, H. Vollmer, and K. W. Wagner. Probabilistic type-2 operators and "almost"-classes, <i>Computational Complexity</i> 7(3):265-289, 1998. <span id="bvw07" style="color:maroon">[BVW07]</span> H. Burhman, N. Vereshchajin, R. de Wolf. On computation and communication with small bias. <i>Proceedings of IEEE Conference on Computational Complexity 2007</i> 24-32, 2007. <span id="bw03" style="color:maroon">[BW03]</span> H. Buhrman and R. de Wolf. Quantum Zero-Error Algorithms Cannot be Composed, Information Processing Letters, 87(2):79-84, 2003. arXiv:[http://arxiv.org/abs/quant-ph/0211029 quant-ph/0211029]. ===== C ===== <span id="cai01" style="color:maroon">[Cai01]</span> J.-Y. Cai. S<sub>2</sub>P is contained in ZPP<sup>NP</sup>, <i>Proceedings of IEEE FOCS'2001</i>, pp. 620-629, 2001. <span id="cai86" style="color:maroon">[Cai86]</span> J.-Y. Cai. With probability one, a random oracle separates PSPACE from the polynomial hierarchy, <i>Proceedings of ACM STOC'86</i>, pp. 21-29, 1986. <span id="cai87" style="color:maroon">[Cai87]</span> J. Cai. Probability one separation of the Boolean hieararchy, Lecture Notes in Computer Science, vol 247, p148-158, 1987. <span id="can96" style="color:maroon">[Can96]</span> R. Canetti. More on BPP and the polynomial-time hierarchy, <i>Information Processing Letters</i> 57:237-241, 1996. <span id="cc93" style="color:maroon">[CC93]</span> L. Cai and J. Chen. On fixed-parameter tractability and approximability of NP-hard optimization problems, <i>Proceedings of ISTCS'93 - Israel Symposium on Theory of Computing and Systems</i>, pp. 118-126, 1993. <span id="cc97" style="color:maroon">[CC97]</span> L. Cai and J. Chen. On fixed-parameter tractability and approximability of NP optimization problems, <i>Journal of Computer and System Sciences</i> 54(3):465-474, 1997. <span id="ccd03" style="color:maroon">[CCD+03]</span> A. M. Childs, R. Cleve, E. Deotto, E. Farhi, S. Gutmann, and D. A. Spielman. Exponential algorithmic speedup by quantum walk, <i>Proceedings of ACM Symposium on Theory of Computing</i>, pp. 59-68, 2003. arXiv:[http://arxiv.org/abs/quant-ph/0209131 quant-ph/0209131]. <span id="ccg94" style="color:maroon">[CCG+94]</span> R. Chang, B. Chor, O. Goldreich, J. Hartmanis, J. H&aring;stad, D. Ranjan, and P. Rohatgi. The random oracle hypothesis is false, <i>Journal of Computer and System Sciences</i> 49(1):24-39, 1994. <span id="cch01" style="color:maroon">[CCH+01]</span> J.-Y. Cai, V. Chakaravarthy, L. Hemaspaandra, and M. Ogihara. Some Karp-Lipton-type theorems based on S<sub>2</sub>, University of Rochester Computer Science Technical Report TR-759, November 2001. <span id="cd05" style="color:maroon">[CD05]</span> X. Chen and X. Deng 3-NASH is PPAD-Complete, online: [http://eccc.uni-trier.de/eccc-reports/2005/TR05-134/Paper.pdf http://eccc.uni-trier.de/eccc-reports/2005/TR05-134/Paper.pdf], nov. 2005. <span id="cdl01" style="color:maroon">[CDL01]</span> A. Chiu, G. Davida, and B. Litow. Division in logspace-uniform NC<sub>1</sub>, <i>Theoretical Informatics and Applications</i> 35(3):259, 2001. <span id="cf91" style="color:maroon">[CF91]</span> J.-Y. Cai and M. Furst. PSPACE survives constant-width bottlenecks, <i>International Journal of Foundations of Computer Science</i> 2(1):67-76, 1991. {{Reference |id=cf07 |tag=CP07 |title=On parameterized path and chordless path problems |authors=Y. Chen and J. Flum |journal=Proceedings of the IEEE Conference on Computational Complexity 2007 |srcdetail=250-263 }} {{Reference |tag=CFL83 |title=Unbounded fan-in circuits and associative functions |authors=A. Chandra, S. Fortune, R. Lipton |journal=Proceedings of the fifteenth annual ACM symposium on Theory of computing |srcdetail=52-60, 1983 }} <span id="cfl93" style="color:maroon">[CFL+93]</span> A. Condon, J. Feigenbaum, C. Lund, and P. Shor. Probabilistically checkable debate systems and approximation algorithms for PSPACE-hard functions (extended abstract), <i>Proceedings of ACM STOC'93</i>, pp. 305-314, 1993. <span id="cgh88" style="color:maroon">[CGH+88]</span> J.-Y. Cai, T. Gundermann, J. Hartmanis, L. Hemachandra, V. Sewelson, K. Wagner, and G. Wechsung. The Boolean hierarchy I: structural properties, <i>SIAM Journal on Computing</i> 17:1232-1252, 1988. Part II: applications in 18:95-111, 1989. <span id="cgr04" style="color:maroon">[CGR+04]</span> M. Crasmaru, C. Gla&szlig;er, K. W. Regan, and S. Sengupta. A protocol for serializing unique strategies, submitted, 2004. [http://www.cse.buffalo.edu/faculty/regan/papers/ps/CGRS03.ps http://www.cse.buffalo.edu/faculty/regan/papers/ps/CGRS03.ps]. <span id="ch89" style="color:maroon">[CH89]</span> J.-Y. Cai and L. A. Hemachandra. On the power of parity polynomial time, <i>Proceedings of the Symposium on Theoretical Aspects of Computer Science (STACS)</i>, Lecture Notes in Computer Science 349, pp. 229-240, Springer, 1989. <span id="cht04" style="color:maroon">[CHT+04]</span> R. Cleve, P. H&oslash;yer, B. Toner, and J. Watrous. Consequences and limits of nonlocal strategies, <i>Proceedings of IEEE Complexity</i>, pp. 236-249, 2004. arXiv:[http://arxiv.org/abs/quant-ph/0404076 quant-ph/0404076]. <span id="chu41" style="color:maroon">[Chu41]</span> A. Church. The calculi of lambda-conversion, <i>Annals of Mathematical Studies</i> 6, Princeton Univ. Press, 1941. {{Reference |tag=CIK+03 |title=The complexity of Unique $k$-SAT: An isolation lemma for $k$-CNFs. |authors=C. Calabro, R. Impagliazzo, V. Kabanets, et al |journal=Proceedings of the IEEE Conference on Computational Complexity 2003 |srcdetail=135-141 }} <span id="ckk95" style="color:maroon">[CKK+95]</span> F. Cucker, M. Karpinski, P. Koiran, T. Lickteig, and K. Werther. On real Turing machines that toss coins, <i>Proceedings of ACM STOC'95</i>, pp. 335-342, 1995. <span id="cks81" style="color:maroon">[CKS81]</span> A. K. Chandra, D. C. Kozen, and L. J. Stockmeyer. Alternation, <i>Journal of the ACM</i> 28:114-133, 1981. <span id="cks99" style="color:maroon">[CKS+99]</span> P. Crescenzi, V. Kann, R. Silvestri, and L. Trevisan. Structure in approximation classes, <i>SIAM Journal on Computing</i> 28:1759-1782, 1999. ECCC [http://eccc.uni-trier.de/eccc-reports/1996/TR96-066/ TR96-066]. <span id="cksu05" style="color:maroon">[CKSU05]</span> H. Cohn, R. Kleinberg, B. Szegedy, and C. Umans. Group-theoretic Algorithms for Matrix Multiplication. <i>Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science (FOCS)</i> 379-388, 2005. <span id="cm01" style="color:maroon">[CM01]</span> M. Cryan and P. B. Miltersen. On pseudorandom generators in NC<sup>0</sup>, <i>Proceedings of the 26th International Symposium on Mathematical Foundations of Computer Science (MFCS)</i>, pp. 272-284, 2001. {{Reference |tag=CMTV98 |title=Nondeterministic NC1 computation |authors=Caussinus, Herv&eacute; and McKenzie, Pierre and Th&eacute;rien, Denis and Vollmer, Heribert |journal=J. Comput. Syst. Sci. |srcdetail=200-212, 1998 }} <span id="cmi00" style="color:maroon">[CMI00]</span> Clay Mathematics Institute. The P versus NP problem (a millennium prize problem), with official problem description by S. Cook, [http://www.claymath.org/prizeproblems/pvsnp.htm http://www.claymath.org/prizeproblems/pvsnp.htm], 2000. <span id="cns99" style="color:maroon">[CNS99]</span> J.-Y. Cai, A. P. Nerurkar, and D. Sivakumar. Hardness and hierarchy theorems for probabilistic quasi-polynomial time, <i>Proceedings of ACM STOC'99</i>, pp. 726-735, 1999. <span id="cob64" style="color:maroon">[Cob64]</span> A. Cobham. The intrinsic computational difficulty of functions, <i>Proceedings of the 1964 Congress on Logic, Mathematics and the Methodology of Science</i>, pp. 24-30, 1964. <span id="cob66" style="color:maroon">[Cob66]</span> A. Cobham. The recognition problem for the set of perfect squares, <i>Proceedings of the 7th Symposium on Switching and Automata Theory</i>, pp. 78-87, 1966. <span id="con73" style="color:maroon">[Con73]</span> R. Constable. Type 2 computational complexity, <i>Proceedings of ACM STOC'73</i>, pp. 108­-121, 1973. <span id="con92" style="color:maroon">[Con92]</span> A. Condon. The complexity of stochastic games, <i>Information and Computation</i> 96(2):203-224, 1992. <span id="coo71" style="color:maroon">[Coo71]</span> S. A. Cook. The complexity of theorem-proving procedures, <i>Proceedings of ACM STOC'71</i>, pp. 151-158, 1971. <span id="coo71b" style="color:maroon">[Coo71b]</span> S. A. Cook. Characterizations of pushdown machines in terms of time-bounded computers, <i>Journal of the ACM</i> 18(1):4-18, 1971. <span id="coo79" style="color:maroon">[Coo79]</span> S. A. Cook. Deterministic CFL's are accepted simultaneously in polynomial time and log squared space, <i>Proceedings of ACM STOC'79</i>, pp. 338-345, 1979. <span id="coo85" style="color:maroon">[Coo85]</span> S. A. Cook. A taxonomy of problems with fast parallel algorithms, <i>Information and Control</i> 64:2-22, 1985. <span id="cp95" style="color:maroon">[CP95]</span> P. Crescenzi and C. Papadimitriou. Reversible simulation of space-bounded computations, <i>Theoretical Computer Science</i> 143:159-165, 1995. {{Reference |id=cp07 |tag=CP07 |title=Bounded queries and the NP Machine Hypothesis. |authors=R. Chang and S. Purini |journal=Proceedings of the IEEE Conference on Computational Complexity 2007 |srcdetail=52-59 }} <span id="cr96" style="color:maroon">[CR96]</span> S. Chaudhuri and J. Radhakrishnan. Deterministic Restrictions in Circuit Complexity, <i>Proceedings of ACM STOC 1996</i>, pp. 30-36, 1996. <span id="cs92" style="color:maroon">[CS92]</span> J. Castro and C. Seara. Characterizations of some complexity classes between &#920;<sub>2</sub><sup>p</sup> and &#916;<sub>2</sub><sup>p</sup>, <i>Proceedings of STACS 1992</i>, pp. 305-317, 1992. <span id="ct94" style="color:maroon">[CT94]</span> P. Crescenzi and L. Trevisan. An approximation scheme preserving reducibility and its applications, <i>Proceedings of 14th Annual Conference on Foundations of Software Technology and Theoretical Computer Computer Science (FSTTCS)</i>, pp. 330-341, Lecture Notes in Computer Science 880, Springer-Verlag, 1994. <span id="ct97" style="color:maroon">[CT97]</span> M. Cesati and L. Trevisan. On the efficiency of polynomial time approximation schemes, ECCC [http://eccc.uni-trier.de/eccc-reports/1997/TR97-001/ TR97-001], 1997. <span id="ct07" style="color:maroon">[CT07]</span> Xi Chen and Shang-Hua Teng. Paths beyond local search: A nearly tight bound for randomized fixed-point computation. FOCS 2007. <span id="cw82" style="color:maroon">[CW82]</span> D. Coppersmith and S. Winograd. On the Asymptotic Complexity of Matrix Multiplication. <i>SIAM J. Comput.</i> 11(3): 472-492,1982. {{Reference |tag=CW90 |title=Matrix multiplication via arithmetic progressions |journal=Journal of Symbolic Computation |srcdetail=9:251–280, 1990 |authors=D. Coppersmith and S. Winograd }} <span id="cw00" style="color:maroon">[CW00]</span> R. Cleve and J. Watrous. Fast parallel circuits for the quantum Fourier transform, <i>Proceedings of IEEE Focs'2000</i>, pp. 526-536, 2000. arXiv:[http://arxiv.org/abs/quant-ph/0006004 quant-ph/0006004]. ===== D ===== <span id="dam90" style="color:maroon">[Dam90]</span> C. Damm. Problems complete for L, <i>Information Processing Letters</i> 36:247-250, 1990. <span id="dc89" style="color:maroon">[DC89]</span> P. W. Dymond and S. Cook. Complexity theory of parallel time and hardware, <i>Information and Computation</i> 80:205-226, 1989. <span id="ddp98" style="color:maroon">[DDP+98]</span> A. De Santis, G. Di Crescenzo, G. Persiano, and M. Yung. Image density is complete for non-interactive SZK, <i>Proceedings of the 25th International Colloquium on Automata, Languages, and Programming (ICALP)</i>, Lecture Notes in Computer Science, pp. 784-795, 1998. (Note: Some results in the paper were later retracted.) <span id="dek76" style="color:maroon">[Dek76]</span> M. I. Dekhtyar. On the relativization of deterministic and nondeterministic complexity classes, <i>Mathematical Foundations of Computer Science</i>, pp. 255-259, Springer LNCS 45, 1976. <span id="df97" style="color:maroon">[DF97]</span> R. G. Downey and M. R. Fellows. Threshold dominating sets and an improved characterization of W, <i>Theoretical Computer Science</i> 189, 1997. <span id="df99" style="color:maroon">[DF99]</span> R. G. Downey and M. R. Fellows. <i>Parameterized Complexity</i>, Springer-Verlag Monographs in Computer Science, 1999. <span id="dft96" style="color:maroon">[DFT96]</span> R. G. Downey, M. R. Fellows, and U. Taylor. On the parameteric complexity of relational database queries and a sharper characterization of W, <i>Combinatorics, Complexity, and Logic</i>, Proceedings of DMTCS'96, Springer-Verlag, pp. 194-213, 1996. <span id="dgp05" style="color:maroon">[DGP05]</span> C. Daskalakis, P. W. Goldberg, and C. H. Papadimitriou The Complexity of Computing a Nash Equilibrium, online: [http://www.cs.berkeley.edu/~christos/papers/ppad.ps ppad.ps], sep. 2005. <span id="dhi02" style="color:maroon">[DHI02]</span> W. van Dam, S. Hallgren, and L. Ip. Quantum algorithms for hidden shift problems, arXiv:[http://arxiv.org/abs/quant-ph/0211140 quant-ph/0211140], 2002. <span id="dp05" style="color:maroon">[DP05]</span> C. Daskalakis and C. H. Papadimitriou The Complexity of Computing a Nash Equilibrium, online: [http://www.cs.berkeley.edu/~christos/papers/3players.pdf 3players.pdf], nov. 2005. {{Reference-ECCC |tag=DP08 |year=2008 |date=Feb 28 |eccc-num=TR08-014 |authors=M. David and T. Pitassi |title=Separating NOF communication complexity classes RP and NP }} <span id="dw86" style="color:maroon">[DW86]</span> E. Dahlhaus and M. K. Warmuth. Membership for growing context-sensitive grammars is polynomial, <i>Journal of Computer and System Sciences</i> 33:456-472, 1986. ===== E ===== <span id="edm65" style="color:maroon">[Edm65]</span> J. Edmonds. Paths, trees, and flowers, <i>Canadian Journal of Mathematics</i> 17(3):449-467, 1965. <span id="ey07" style="color:maroon">[EY07]</span> K. Etessami and M. Yannakakis. On the Complexity of Nash Equilibria and Other Fixed Points. Unpublished. Paths, trees, and flowers, <i>Canadian Journal of Mathematics</i> 17(3):449-467, 1965. ===== F ===== <span id="fag73" style="color:maroon">[Fag73]</span> R. Fagin. Contributions to the Model Theory of Finite Strucutres, <i>Ph.D. Thesis (1973), U.C. Berkeley</i> <span id="fag74" style="color:maroon">[Fag74]</span> R. Fagin. Generalized first-order spectra and polynomial-time recognizable sets, <i>Complexity of Computation</i> (R. M. Karp, ed.), SIAM-AMS Proceedings Vol. 7, 1974. <span id="fen02" style="color:maroon">[Fen02]</span> S. Fenner. PP-lowness and a simple definition of AWPP, <i>Theory Comput. Syst.</i> 36 (2003), no. 2, 199--212. ECCC [http://eccc.uni-trier.de/eccc-reports/2002/TR02-036/ TR02-036]. <span id="ff.." style="color:maroon">[FF..]</span> S. Fenner, L. Fortnow, Unpublished. <span id="ffk93" style="color:maroon">[FFK+93]</span> S. Fenner, L. Fortnow, S. Kurtz, and L. Li. An oracle builder's toolkit, <i>Proceedings of Structure in Complexity Theory</i>, pages 120-131, 1993. [http://people.cs.uchicago.edu/~fortnow/papers/obt.ps http://people.cs.uchicago.edu/~fortnow/papers/obt.ps]. <span id="ffk94" style="color:maroon">[FFK94]</span> S. Fenner, L. Fortnow, and S. Kurtz. Gap-definable counting classes, <i>Journal of Computer and System Sciences</i> 48(1):116-148, 1994. [http://people.cs.uchicago.edu/~fortnow/papers/gaps.ps http://people.cs.uchicago.edu/~fortnow/papers/gaps.ps]. <span id="fg02" style="color:maroon">[FG02]</span> J. Flum and M. Grohe. The parameterized complexity of counting problems, <i>Proceedings of IEEE FOCS'2002</i>, 2002. <span id="fgh98" style="color:maroon">[FGH+98]</span> S. Fenner, F. Green, S. Homer, and R. Pruim. Quantum NP is hard for PH, <i>Proceedings of the Sixth Italian Conference on Theoretical Computer Science</i>, World-Scientific, pp. 241-252, 1998. arXiv:[http://arxiv.org/abs/quant-ph/9812056 quant-ph/9812056]. <span id="fgl91" style="color:maroon">[FGL+91]</span> U. Feige, S. Goldwasser, L. Lov&aacute;sz, S. Safra, and M. Szegedy. Approximating clique is almost NP-complete, <i>Proceedings of IEEE FOCS'91</i>, pp. 2-12, 1991. <span id="fgmsz89" style="color:maroon">[FGM+89]</span> M. Furer, O. Goldreich, Y. Mansour, M. Sipser, and S. Zachos. On Completeness and Soundness in Interactive Proof Systems. In <i>Advances in Computing Research: a research annual</i>, Vol.~5 (Randomness and Computation, S. Micali, ed.), pages 429--442, 1989. <span id="fie98" style="color:maroon">[Fie98]</span> U. Feige. A threshold of ln(n) for approximating set cover. <i>Journal of the ACM (JACM)</i>, 45(4): 634--652, 1998. [http://dx.doi.org/10.1145/285055.285059 doi:10.1145/285055.285059] <span id="fk05" style="color:maroon">[FK05]</span> L. Fortnow and A. Klivans. NP with small advice, <i>Proceedings of IEEE Complexity'2005</i>, pp. 228-234, 2005. [http://people.cs.uchicago.edu/~fortnow/papers/fk.ps http://people.cs.uchicago.edu/~fortnow/papers/fk.ps]. <span id="fk97" style="color:maroon">[FK97]</span> U. Feige and J. Kilian. Limited versus polynomial nondeterminism, <i>Chicago Journal of Theoretical Computer Science</i> Article 1, 1997. <span id="fk97b" style="color:maroon">[FK97b]</span> U. Feige and J. Kilian. Making games short, <i>Proceedings of ACM STOC'1997</i>, pp. 506-516, 1997. <span id="for94" style="color:maroon">[For94]</span> L. Fortnow. The role of relativization in complexity theory, <i>Bulletin of the EATCS</i> 52, February 1994. [http://people.cs.uchicago.edu/~fortnow/papers/relative.ps http://people.cs.uchicago.edu/~fortnow/papers/relative.ps]. <span id="fr74" style="color:maroon">[FR74]</span> M. J. Fischer and M. O. Rabin. Super-exponential complexity of Presburger arithmetic, <i>Complexity of Computation</i> (R. M. Karp, ed.), SIAM-AMS Symposium on Applied Mathematics, 1974. <span id="fr98" style="color:maroon">[FR98]</span> L. Fortnow and J. D. Rogers. Complexity limitations on quantum computation, <i>Proceedings of IEEE Complexity'98</i>, pp. 202-209, 1998. arXiv:[http://arxiv.org/abs/cs.CC/9811023 cs.CC/9811023]. <span id="fri57" style="color:maroon">[Fri57]</span> R. M. Friedberg. Two recursively enumerable sets of incomparable degrees of unsolvability, <i>Proceedings of the National Academy of Sciences</i>, 43:236-238, 1957. [http://www.pubmedcentral.nih.gov/picrender.fcgi?artid=528418&amp;blobtype=pdf http://www.pubmedcentral.nih.gov/picrender.fcgi?artid=528418&amp;blobtype=pdf]. <span id="frs88" style="color:maroon">[FRS88]</span> L. Fortnow, J. Rompel, and M. Sipser. On the power of multiprover interactive protocols, <i>Proceedings of IEEE Complexity'88</i>, 1988. [http://people.cs.uchicago.edu/~fortnow/papers/mip.ps http://people.cs.uchicago.edu/~fortnow/papers/mip.ps]. <span id="fs04" style="color:maroon">[FS04]</span> L. Fortnow and R. Santhanam. Hierarchy theorems for probabilistic polynomial time, <i>Proceedings of IEEE FOCS'2004</i>, 2004. [http://people.cs.uchicago.edu/~fortnow/papers/probhier.ps http://people.cs.uchicago.edu/~fortnow/papers/probhier.ps]. <span id="fs88" style="color:maroon">[FS88]</span> L. Fortnow and M. Sipser. Are there interactive protocols for co-NP languages? Inform. Process. Lett. 28 (1988), no. 5, 249--251. [http://cs-www.uchicago.edu/~fortnow/papers/conpipl.ps http://cs-www.uchicago.edu/~fortnow/papers/conpipl.ps] <span id="fss84" style="color:maroon">[FSS84]</span> M. Furst, J. Saxe, and M. Sipser. Parity, circuits, and the polynomial hierarchy, <i>Mathematical Systems Theory</i> 17:13-27, 1984. <span id="fur07" style="color:maroon">[Fur07]</span> M. Furer. Fast Integer Multiplication, STOC, 2007. <span id="fv93" style="color:maroon">[FV93]</span> T. Feder and M. Y. Vardi. Monotone monadic SNP and constraint satisfaction, <i>Proceedings of the 25th ACM Symposium on Theory of Computing</i>, pp. 612-622, 1993. DOI:[http://doi.acm.org/10.1145/167088.167245 10.1145/167088.167245]. ===== G ===== <span id="gas02" style="color:maroon">[Gas02]</span> William Gasarch. The P=?NP poll, <i>SIGACT News Complexity Theory Column 36</i> (L. A. Hemaspaandra, ed.), 2002. <span id="gas02" style="color:maroon">[Geff91]</span> Viliam Geffert. Nondeterministic computations in sublogarithmic space and space constructibility, <i>SIAM Journal on Computing</i> v. 20 iss. 3, 1991. [http://portal.acm.org/citation.cfm?id=114454&dl=GUIDE&coll=GUIDE&CFID=74222314&CFTOKEN=30698817] <span id="gg66" style="color:maroon">[GG66]</span> S. Ginsburg and S. Greibach. Deterministic context free languages, <i>Information and Control</i> 9:620-648, 1966. <span id="ggk03" style="color:maroon">[GGK03]</span> William Gasarch, Evan Golub and Clyde Kruskal. Constant time parallel sorting: an empirical view, <i>J. Comput. Syst. Sci.</i> 67:63-91, 2003. <span id="ghj91" style="color:maroon">[GHJ+91]</span> J. Goldsmith, L. A. Hemaspaandra, D. Joseph, and P. Young. Near-testable sets. SIAM J. Comput. 20 (1991), no. 3, 506--523 <span id="ghp00" style="color:maroon">[GHP00]</span> F. Green, S. Homer, and C. Pollett. On the complexity of quantum ACC, <i>Proceeedings of IEEE Complexity'2000</i>, pp. 250-262, 2000. See also: F. Green, S. Homer, C. Moore, and S. Pollett. Counting, fanout, and the complexity of quantum ACC, arXiv:[http://arxiv.org/abs/quant-ph/0106017 quant-ph/0106017], 2001. <span id="gil77" style="color:maroon">[Gil77]</span> J. Gill. Computational complexity of probabilistic Turing machines, <i>SIAM Journal on Computing</i> 6(4):675-695, 1977. <span id="gj79" style="color:maroon">[GJ79]</span> M. R. Garey and D. S. Johnson. <i>Computers and Intractability: A Guide to the Theory of NP-Completeness</i>, Freeman, 1979. <span id="gkr95" style="color:maroon">[GKR+95]</span> F. Green, J. K&ouml;bler, K. W. Regan, T. Schwentick, and J. Tor&aacute;n. The power of the middle bit of a #P function, <i>Journal of Computer and System Sciences</i> 50(3):456-467, 1995. <span id="glm96" style="color:maroon">[GLM96]</span> J. Goldsmith, M. A. Levy, and M. Mundhenk. Limited nondeterminism, <i>SIGACT News</i> 27(2):20-29, 1996. [http://cs.engr.uky.edu/~goldsmit/papers/extended.ps http://cs.engr.uky.edu/~goldsmit/papers/extended.ps] <span id="gmr89" style="color:maroon">[GMR89]</span> S. Goldwasser, S. Micali, and C. Rackoff. The knowledge complexity of interactive proof systems, <i>SIAM Journal on Computing</i> 18(1):186-208, 1989. <span id="gmw91" style="color:maroon">[GMW91]</span> O. Goldreich, S. Micali, and A. Wigderson. Proofs that yield nothing but their validity or all languages in NP have zero-knowledge proof systems, <i>Journal of the ACM</i> 38(1):691-729, 1991. {{Reference |tag=GO95 |title=On a class of $O(n^2)$ problems in computational geometry |authors=A. Gajentaan and M. Overmars |journal=Computational Geometry |srcdetail=Volume 5, Issue 3, October 1995, pages 165-185 }} <span id="gol97" style="color:maroon">[Gol97]</span> O. Goldreich. Notes on Levin's theory of average-case complexity, ECCC [http://eccc.uni-trier.de/eccc-reports/1997/TR97-058/ TR97-058]. <span id="gp01" style="color:maroon">[GP01]</span> F. Green and R. Pruim. Relativized separation of EQP from P^NP, Information Processing Letters 80 (2001) 257-260. [http://cs.clarku.edu/~fgreen/papers/eqp.ps http://cs.clarku.edu/~fgreen/papers/eqp.ps] <span id="gp86" style="color:maroon">[GP86]</span> L. Goldschlager and I. Parberry. On the construction of parallel computers from various bases of Boolean functions, <i>Theoretical Computer Science</i> 43(1):43-58, 1986. <span id="gp91" style="color:maroon">[GP91]</span> O. Goldreich and E. Petrank. Quantifying knowledge complexity, <i>Proceedings of IEEE FOCS'91</i>, pp. 59-68, 1991. [http://www.wisdom.weizmann.ac.il/~oded/PS/gp.ps http://www.wisdom.weizmann.ac.il/~oded/PS/gp.ps] <span id="gra92" style="color:maroon">[Grä92]</span> E. Grädel Capturing complexity classes b fragments of second order logic <i>Information and computaiton</i> 119 (1995), 129-135 <span id="gre90" style="color:maroon">[Gre90]</span> F. Green. An oracle separating +P from PP<sup>PH</sup>, Inform. Process. Lett. 37 (1991), no. 3, 149--153. <span id="gre93" style="color:maroon">[Gre93]</span> F. Green. On the power of deterministic reductions to C<sub>=</sub>P, Math. Systems Theory 26 (1993), no. 2, 215--233. <span id="gs86" style="color:maroon">[GS86]</span> S. Goldwasser and M. Sipser. Private coins versus public coins in interactive proof systems, <i>Proceedings of ACM STOC'86</i>, pp. 58-68, 1986. <span id="gs88" style="color:maroon">[GS88]</span> J. Grollman and A. L. Selman. Complexity measures for public-key cryptosystems, <i>SIAM Journal on Computing</i> 17:309-335, 1988. <span id="gs89" style="color:maroon">[GS89]</span> Y. Gurevich and S. Shelah. Nearly Linear Time, <i>Proceedings of LFCS'89</i>, Springer LNCS 363, pp. 108-118, 1989. <span id="gs90" style="color:maroon">[GS90]</span> M. Grigni and M. Sipser. Monotone complexity, <i>Proceedings of LMS Workshop on Boolean Function Complexity</i> (M. S. Paterson, ed.), Durham, Cambridge University Press, 1990. [http://www.mathcs.emory.edu/~mic/papers/4.ps http://www.mathcs.emory.edu/~mic/papers/4.ps] <span id="gs91" style="color:maroon">[GS91]</span> M. Grigni and M. Sipser. Monotone separation of NC<sup>1</sup> from logspace, <i>Proceedings of IEEE Complexity'91</i>, pp. 294-298, 1991. <span id="gss03" style="color:maroon">[GSS+03]</span> C. Gla&szlig;er, A. L. Selman, S. Sengupta, and L. Zhang. Disjoint NP-pairs, ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-011/ TR03-011], 2003. <span id="gst03" style="color:maroon">[GST03]</span> D. Gutfreund, R. Shaltiel, and A. Ta-Shma. Uniform hardness vs. randomness tradeoffs for Arthur-Merlin games, <i>Comput. Complexity</i> 12 (2003), no. 3-4, 85--130. [http://www.cs.huji.ac.il/~danig/pubs/ccc.ps http://www.cs.huji.ac.il/~danig/pubs/ccc.ps]. <span id="gsv99" style="color:maroon">[GSV99]</span> O. Goldreich, A. Sahai, and S. Vadhan. Can statistical zero knowledge be made non-interactive? or on the relationship of SZK and NISZK, ECCC [http://eccc.uni-trier.de/eccc-reports/1999/TR99-013/ TR99-013], 1999. Abstract appeared in CRYPTO'99. <span id="gtw91" style="color:maroon">[GTW+91]</span> R. Gavald&aacute;, L. Torenvliet, O. Watanabe, and J. Balc&aacute;zar. Generalized Kolmogorov complexity in relativized separations, <i>Proceedings of MFCS'91 (Mathematical Foundations of Computer Science)</i>, Springer-Verlag Lecture Notes in Computer Science, vol. 452, pp. 269-276, 1991. <span id="gup95" style="color:maroon">[Gup95]</span> S. Gupta. Closure properties and witness reduction, <i>Journal of Computer and System Sciences</i> 50(3):412-432, 1995. [ftp://ftp.cis.ohio-state.edu/pub/tech-report/1993/TR46.ps.gz ftp://ftp.cis.ohio-state.edu/pub/tech-report/1993/TR46.ps.gz] <span id="gur87" style="color:maroon">[Gur87]</span> Y. Gurevich. Complete and incomplete randomized NP problems, <i>Proceedings of IEEE FOCS'87</i>, pp. 111-117, 1987. <span id="gur89" style="color:maroon">[Gur89]</span> E. Gurari. <i>An Introduction to the Theory of Computation</i>, Computer Science Press, 1989. [http://www.cse.ohio-state.edu/~gurari/theory-bk/theory-bk.html http://www.cse.ohio-state.edu/~gurari/theory-bk/theory-bk.html]. <span id="gut05" style="color:maroon">[Gut05]</span> G. Gutoski. Upper bounds for quantum interactive proofs with competing provers, <i>Proceedings of IEEE Complexity'2005</i>, pp. 334-343, 2005. [http://www.cs.uwaterloo.ca/~gmgutosk/gutoskig_competing.pdf http://www.cs.uwaterloo.ca/~gmgutosk/gutoskig_competing.pdf]. <span id="gv02" style="color:maroon">[GV02]</span> M. de Graaf and P. Valiant. Comparing EQP and MOD<sub>p^k</sub>P using polynomial degree lower bounds, arXiv:[http://arxiv.org/abs/quant-ph/0211179 quant-ph/0211179], 2002. <span id="gv99" style="color:maroon">[GV99]</span> O. Goldreich and S. Vadhan. Comparing entropies in statistical zero-knowledge with applications to the structure of SZK, <i>Proceedings of IEEE Complexity'99</i>, pp. 54-73, 1999. ECCC [http://eccc.uni-trier.de/eccc-reports/1998/TR98-063/ TR98-063]. <span id="gw05" style="color:maroon">[GW05]</span> G. Gutoski and J. Watrous. Quantum interactive proofs with competing provers, <i>Proceedings of STACS'2005</i>, pp. 605-616, Springer-Verlag, 2005. arXiv:[http://arxiv.org/abs/cs.CC/0412102 cs.CC/0412102]. <span id="gw07" style="color:maroon">[GW07]</span> G. Gutoski and J. Watrous. Toward a general theory of quantum games, In <i>Proceedings of the 39th ACM Symposium on Theory of Computing (STOC'07)</i>, pages 565-574, 2007. arXiv:[http://arxiv.org/abs/quant-ph/0611234 quant-ph/0611234]. <span id="gw10" style="color:maroon">[GW10]</span> G. Gutoski and X. Wu. Short quantum games characterize PSPACE, 2010. arXiv:[http://arxiv.org/abs/1011.2787 arXiv:1011.2787]. <span id="gw96" style="color:maroon">[GW96]</span> A. G&aacute;l and A. Wigderson. Boolean complexity classes vs. their arithmetic analogs, <i>Random Structures and Algorithms</i> 9:1-13, 1996. ECCC [http://eccc.uni-trier.de/eccc-reports/1995/TR95-049/ TR95-049]. <span id="gz97" style="color:maroon">[GZ97]</span> O. Goldreich and D. Zuckerman. Another proof that BPP subseteq PH (and more), ECCC [http://eccc.uni-trier.de/eccc-reports/1997/TR97-045/ TR97-045]. ===== H ===== <span id="hal02" style="color:maroon">[Hal02]</span> S. Hallgren. Polynomial-time quantum algorithms for Pell's equation and the principal ideal problem, <i>Proceedings of ACM STOC'2002</i>, 2002. [http://www.cs.caltech.edu/~hallgren/pell.pdf http://www.cs.caltech.edu/~hallgren/pell.pdf]. <span id="har78" style="color:maroon">[Har78]</span> J. Hartmanis. <i>Feasible Computations and Provable Complexity Properties</i>, SIAM, 1978. <span id="har87" style="color:maroon">[Har87]</span> J. Hartmanis. The collapsing hierarchies, <i>Bulletin of the EATCS</i> 33, October 1987. [http://external.nj.nec.com/homepages/fortnow/beatcs/column33.ps http://external.nj.nec.com/homepages/fortnow/beatcs/column33.ps]. <span id="har87b" style="color:maroon">[Har87b]</span> J. Hartmanis. Sparse complete sets for NP and the optimal collapse of the polynomial hierarchy, <i>Bulletin of the EATCS</i> 32, June 1987. [http://external.nj.nec.com/homepages/fortnow/beatcs/column32.ps http://external.nj.nec.com/homepages/fortnow/beatcs/column32.ps]. <span id="has87" style="color:maroon">[Has87]</span> J. H&aring;stad. <i>Computational Limitations for Small-Depth Circuits</i>, MIT Press, 1987. <span id="has88" style="color:maroon">[Has88]</span> J. H&aring;stad. Oneway permutations in NC<sup>0</sup>, <i>Information Processing Letters</i> 26:153-155, 1988. <span id="has90" style="color:maroon">[Has90]</span> J. H&aring;stad. Tensor rank is NP-complete, ''J. Algorithms'', 11(4):644-654, 1990. <span id="has01" style="color:maroon">[Has01]</span> J. H&aring;stad. Some optimal inapproximability results, ''Journal of the ACM'', 48(4):798-3859, 2001. [http://www-sunos4.nada.kth.se/~johanh/optimalinap.ps http://www-sunos4.nada.kth.se/~johanh/optimalinap.ps] <span id="hcc92" style="color:maroon">[HCC+92]</span> J. Hartmanis, R. Chang, S. Chari, D. Ranjan, and P. Rohatgi. Relativization: a revisionistic retrospective, <i>Bulletin of the EATCS</i> 47, June 1992. [http://external.nj.nec.com/homepages/fortnow/beatcs/column47.ps http://external.nj.nec.com/homepages/fortnow/beatcs/column47.ps]. <span id="hck88" style="color:maroon">[HCK+88]</span> J. Hartmanis, R. Chang, J. Kadin, and S. G. Mitchell. Some observations about relativization of space bounded computations, <i>Bulletin of the EATCS</i> 35, June 1988. [http://external.nj.nec.com/homepages/fortnow/beatcs/column35.ps http://external.nj.nec.com/homepages/fortnow/beatcs/column35.ps]. <span id="hel84" style="color:maroon">[Hel84a]</span> H. Heller. Relativized polynomial hierarchies extending two levels, <i>Mathematical Systems Theory</i> 17(2):71-84, 1984. <span id="hel84b" style="color:maroon">[Hel84b]</span> H. Heller. On Relativized Polynomial and Exponential Computations, <i>SIAM Journal on Computing</i> 13(4):717-725, 1984. <span id="hel86" style="color:maroon">[Hel86]</span> H. Heller. On Relativized Exponential and Probabilistic Complexity Classes, Inform. and Control 71 (1986), no. 3, 231--243 <span id="hem89" style="color:maroon">[Hem89]</span> L. Hemachandra. The strong exponential hierarchy collapses, <i>Journal of Computer and System Sciences</i> 39(3):299-322, 1989. <span id="her90" style="color:maroon">[Her90]</span> U. Hertrampf. Relations among MOD-classes, <i>Theoretical Computer Science</i> 74:325-328, 1990. <span id="her97" style="color:maroon">[Her97]</span> U. Hertrampf. Acceptance by transformation monoids (with an application to local self-reductions), <i>Proceedings of IEEE Complexity'97</i>, pp. 213-224, 1997. <span id="hes01" style="color:maroon">[Hes01]</span> W. Hesse. Division is in uniform TC<sup>0</sup>, <i>Proceedings of the International Colloquium on Automata, Languages, and Programming (ICALP)</i>, 2001. [http://www.cs.umass.edu/~whesse/div.ps http://www.cs.umass.edu/~whesse/div.ps] <span id="hh76" style="color:maroon">[HH76]</span> J. Hartmanis and J. Hopcroft. Independence results in computer science, <i>ACM SIGACT News</i> 8(4):13-24, 1976. <span id="hh86" style="color:maroon">[HH86]</span> J. Hartmanis and L. Hemachandra. Complexity classes without machines: on complete languages for UP, <i>Proceedings of ICALP'86</i>, Springer-Verlag Lecture Notes in Computer Science volume 226, pp. 123-135, 1986. <span id="hhh98" style="color:maroon">[HHH98]</span> E. Hemaspaandra, L. Hemaspaandra, and H. Hempel. What's up with downward collapse: using the easy-hard technique to link Boolean and polynomial hierarchy collapses, <i>SIGACT News</i> 29(3):10-22, 1998. arXiv:[http://arxiv.org/abs/cs.CC/9910002 cs.CC/9910002]. <span id="hhk05" style="color:maroon">[HHK+05]</span> L. Hemaspaandra, C. Homan, S. Kosub, and K. Wagner. The complexity of computing the size of an interval, Technical Report TR-856, Department of Computer Science, University of Rochester, 2005. This is an expanded version of [[#hkw01|HKW01]] <span id="hhn95" style="color:maroon">[HHN+95]</span> L. Hemaspaandra, A. Hoene, A. Naik, M. Ogihara, A. Selman, T. Thierauf, and J. Wang. Nondeterministically selective sets, <i>International Journal of Foundations of Computer Science (IJFCS)</i>, 6(4):403-416, 1995. <span id="hhr97" style="color:maroon">[HHR97]</span> E. Hemaspaandra, L. Hemaspaandra, and J. Rothe. Exact analysis of Dodgson elections: Lewis Carroll's 1876 voting system is complete for parallel access to NP, <i>Proceedings of ICALP'97</i>, Springer-Verlag Lecture Notes in Computer Science, 1997. arXiv:[http://arxiv.org/abs/cs.CC/9907036 cs.CC/9907036]. <span id="hht97" style="color:maroon">[HHT97]</span> Y. Han, L. Hemaspaandra, and T. Thierauf. Threshold computation and cryptographic security, <i>SIAM Journal on Computing</i> 26(1):59-78, 1997. <span id="hi02" style="color:maroon">[HI02]</span> W. Hesse and N. Immerman. Complete problems for dynamic complexity classes, <i>Proceedings of Logic in Computer Science (LICS)</i>, 2002. [http://www.cs.umass.edu/~immerman/pub/completeLICS.pdf http://www.cs.umass.edu/~immerman/pub/completeLICS.pdf] <span id="hjv93" style="color:maroon">[HJV93]</span> L. Hemaspaandra, R. Jain, and N. K. Vereshchagin. Banishing robust Turing completeness, <i>International Journal of Foundations of Computer Science</i>, 3-4:245-265, 1993. <span id="hkw01" style="color:maroon">[HKW01]</span> L. Hemaspaandra, S. Kosub, and K. Wagner. The complexity of computing the size of an interval, <i>Proceedings of ICALP'01</i>, Springer-Verlag Lecture Notes in Computer Science, 2001. <span id="hls65" style="color:maroon">[HLS65]</span> J. Hartmanis, P. L. Lewis II, and R. E. Stearns. Hierarchies of memory-limited computations, <i>Proceedings of the 6th Annual IEEE Symposium on Switching Circuit Theory and Logic Design</i>, pp. 179-190, 1965. <span id="hmp93" style="color:maroon">[HMP+93]</span> A. Hajnal, W. Maass, P. Pudl&aacute;k, M. Szegedy, and G. Tur&aacute;n. Threshold circuits of bounded depth, <i>Journal of Computer and System Sciences</i> 46(2):129-154, 1993. <span id="hn06" style="color:maroon">[HN06]</span> D. Harnik and M. Naor. On the compressibility of NP instances and cryptographic applications. <i>Proceedings of the 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS)</i>, 719-728, 2006. [http://www.cs.technion.ac.il/~harnik/Compress.pdf http://www.cs.technion.ac.il/~harnik/Compress.pdf] <span id="hno96" style="color:maroon">[HNO+96]</span> L. Hemaspaandra, A. Naik, M. Ogihara, and A. Selman. Computing solutions uniquely collapses the polynomial hierarchy, <i>SIAM Journal on Computing</i> 25(4):697-708, 1996. ECCC [http://eccc.uni-trier.de/eccc-reports/1996/TR96-027/ TR96-027]. <span id="ho02" style="color:maroon">[HO02]</span> L. Hemaspaandra and M. Ogihara. <i>The Complexity Theory Companion</i>, Springer-Verlag, 2002. See also [http://www.cs.rochester.edu/u/lane/=companion/ http://www.cs.rochester.edu/u/lane/=companion/]. <span id="hpv77" style="color:maroon">[HPV77]</span> J. Hopcroft, W. Paul, and L. Valiant. On time versus space, <i>Journal of the ACM</i> 24(2):332-337, 1977. <span id="hrv00" style="color:maroon">[HRV00]</span> U. Hertrampf, S. Reith, and H. Vollmer. A note on closure properties of logspace MOD classes, <i>Information Processing Letters</i> 75(3):91-93, 2000. [http://www.thi.uni-hannover.de/forschung/publikationen/daten/he-re-vo99.ps.gz http://www.thi.uni-hannover.de/forschung/publikationen/daten/he-re-vo99.ps.gz] <span id="hs65" style="color:maroon">[HS65]</span> J. Hartmanis and R. E. Stearns. On the computational complexity of algorithms, <i>Transactions of the AMS</i> 117:285-305, 1965. <span id="hs92" style="color:maroon">[HS92]</span> S. Homer and A. L. Selman. Oracles for structural properties: the isomorphism problem and public-key cryptography, <i>Journal of Computer and System Sciences</i> 44(2):287-301, 1992. <span id="ht06" style="color:maroon">[HT06]</span> Lauri Hella , José María Turull-Torres Computing queries with higher-order logics <i>Theorical. Comput. Sci.</i> 355 (2006), 197--214. [http://www.sciencedirect.com/science?_ob=ArticleURL&_udi=B6V1G-4J614M7-6&_user=1516330&_coverDate=04%2F11%2F2006&_rdoc=1&_fmt=high&_orig=search&_sort=d&_docanchor=&view=c&_searchStrId=1404146870&_rerunOrigin=google&_acct=C000053443&_version=1&_urlVersion=0&_userid=1516330&md5=6d794cde4e4a89dfa74f13967cdacb08]. <span id="hy84" style="color:maroon">[HY84]</span> J. Hartmanis and Y. Yesha. Computation times of NP sets of different densities, <i>Theoretical Computer Science</i> 34:17-32, 1984. ===== I ===== <span id="iba72" style="color:maroon">[Iba72]</span> O. Ibarra. A note concerning nondeterministic tape complexities, <i>Journal of the ACM</i> 4:608-612, 1972. <span id="ikw01" style="color:maroon">[IKW01]</span> R. Impagliazzo, V. Kabanets, and A. Wigderson. In search of an easy witness: exponential time vs. probabilistic polynomial time, <i>Proceedings of IEEE Complexity'2001</i>, 2001. [http://www.cs.sfu.ca/~kabanets/papers/exp_journal.ps.gz http://www.cs.sfu.ca/~kabanets/papers/exp_journal.ps.gz] <span id="il90" style="color:maroon">[IL90]</span> R. Impagliazzo and L. A. Levin. No better ways to generate hard NP instances than picking uniformly at random, <i>Proceedings of IEEE FOCS'90</i>, pp. 812-821, 1990. {{Reference |tag=IM03 |title=A zero one law for RP |authors=R. Impagliazzo and P. Moser |journal=Proceedings of the 18th Conference on Computational Complexity |srcdetail=48-52. IEEE Computer Society Press, 2003 }} {{Reference |tag=Imp95 |title=A personal view of average-case complexity |authors=R. Impagliazzo |journal=Proceedings of the 10th Conference on Structure in Complexity Theory |srcdetail=134-147. IEEE Computer Society Press, 1995 }} <span id="imm82" style="color:maroon">[Imm82]</span> N. Immerman. Relational queries computable in in polynomial time. <i>14th ACM STOC Symp. (1987), 86-104</i> <span id="imm83" style="color:maroon">[Imm83]</span> N. Immerman. Languages That Capture Complexity Classes <i>15th ACM STOC Symp. (1983), 347-354</i> [http://www.cs.umass.edu/~immerman/pub/capture.pdf] <span id="imm88" style="color:maroon">[Imm88]</span> N. Immerman. Nondeterministic space is closed under complement, <i>SIAM Journal on Computing</i>, 17:935-938, 1988. <span id="imm89" style="color:maroon">[Imm89]</span> N. Immerman. Expressibility and Parallel Complexity <i>SIAM Journal on Computing</i>, 18:625-638, 1989. [http://www.cs.umass.edu/~immerman/pub/parallel.pdf] <span id="imm98" style="color:maroon">[Imm98]</span> N. Immerman. <i>Descriptive Complexity</i>, Springer Graduate Texts in Computer Science, 1998. <span id="imp02" style="color:maroon">[Imp02]</span> R. Impagliazzo. Hardness as randomness: a survey of universal derandomization, <i>Proceedings of the ICM</i>, Beijing, vol. 3, pp. 649-658, 2002. arXiv:[http://arxiv.org/abs/cs.CC/0304040 cs.CC/0304040]. <span id="in96" style="color:maroon">[IN96]</span> R. Impagliazzo and M. Naor. Efficient cryptographic schemes provably as secure as subset sum, <i>Journal of Cryptology</i> 9(4):199-216, 1996. [http://www.wisdom.weizmann.ac.il/~naor/PAPERS/subset.ps.gz http://www.wisdom.weizmann.ac.il/~naor/PAPERS/subset.ps.gz] <span id="ipz01" style="color:maroon">[IPZ01]</span> R. Impagliazzo, R. Paturi, and F. Zane. Which problems have strongly exponential complexity, <i>Journal of Computer and System Sciences</i> 63(4):512-530, 2001. [http://cm.bell-labs.com/cm/ms/who/francis/papers/focs98-subexp.pdf http://cm.bell-labs.com/cm/ms/who/francis/papers/focs98-subexp.pdf]. <span id="is91" style="color:maroon">[IS91]</span> R. Impagliazzo and M. Sudan. Private communication, cited in [#bg94" style="color:maroon">[BG94], 1991. <span id="it89" style="color:maroon">[IT89]</span> R. Impagliazzo and G. Tardos. Decision versus search problems in super-polynomial time, in <i>Proceedings of IEEE FOCS 1989</i>, pp. 222-227, 1989. <span id="iv12" style="color:maroon">[IV12]</span> T. Ito and T. Vidick. A multi-prover interactive proof for NEXP sound against entangled provers, to appear in <i>Proceedings of IEEE FOCS 2012</i> arXiv:[http://arxiv.org/abs/1207.0550 1207.0550]. <span id="iw97" style="color:maroon">[IW97]</span> R. Impagliazzo and A. Wigderson. P=BPP if E requires exponential circuits: derandomizing the XOR lemma, <i>Proceedings of ACM STOC'97</i>, pp. 220-229, 1997. ===== J ===== <span id="jer07" style="color:maroon">[Jeř07]</span> E. Jeřábek. Approximate counting in bounded arithmetic, ''Journal of Symbolic Logic'' 72(3):959–993, 2007. <span id="JJUW09" style="color:maroon">[JJUW09]</span> Rahul Jain, Zhengfeng Ji, Sarvagya Upadhyay, and John Watrous. QIP = PSPACE arXiv:[http://arxiv.org/abs/0907.4737 0907.4737], 2009. <span id="jks02" style="color:maroon">[JKS02]</span> J. C. Jackson, A. R. Klivans, and R. A. Servedio. Learnability beyond AC<sup>0</sup>, <i>Proceedings of ACM STOC'2002</i>, pp. 776-784, 2002. <span id="jl95" style="color:maroon">[JL95]</span> D. W. Juedes and J. H. Lutz. The complexity and distribution of hard problems, <i>SIAM Journal on Computing</i> 24(2):279-295, 1995. [http://www.cs.iastate.edu/~lutz/%3DPAPERS/cdhp.ps http://www.cs.iastate.edu/~lutz/%3DPAPERS/cdhp.ps] <span id="joh90" style="color:maroon">[Joh90]</span> D. S. Johnson. A catalog of complexity classes, chapter 2 in <i>Handbook of Theoretical Computer Science</i>, Volume A (J. van Leeuwen, editor), Elsevier, 1990. <span id="jon98" style="color:maroon">[Jon98]</span> Neil D. Jones Logspace and Ptime Characteried by Programming Languages [ftp://ftp.diku.dk/pub/diku/semantics/papers/D-398.ps.gz] <span id="jpy88" style="color:maroon">[JPY88]</span> D. S. Johnson, C. H. Papadimitriou, and M. Yannakakis. How easy is local search?, <i>Journal of Computer and System Sciences</i> 37:79-100, 1988. <span id="jsv01" style="color:maroon">[JSV01]</span> M. Jerrum, A. Sinclair, and E. Vigoda. A polynomial-time approximation algorithm for the permanent of a matrix with non-negative entries, <i>Proceedings of ACM STOC'2001</i>, pp. 712-721, 2001. ECCC [http://eccc.uni-trier.de/eccc-reports/2000/TR00-079/ TR00-079]. <span id="jun85" style="color:maroon">[Jun85]</span> H. Jung. On probabilistic time and space, <i>Proceedings of 12th International Colloquium on Automata, Languages, and Programming (ICALP)</i>, Lecture Notes in Computer Science, 194:310-317, 1985. <span id="jw04" style="color:maroon">[JW04]</span> M. Jerrum and U. Wagner. <i>Counting, Sampling, and Integrating: Algorithms and Complexity</i>, Chapter 3 (lecture notes labeled as under construction). [http://www.dcs.ed.ac.uk/home/mrj/ETHbook/chap3.ps http://www.dcs.ed.ac.uk/home/mrj/ETHbook/chap3.ps]. <span id="jw09" style="color:maroon">[JW09]</span> Rahul Jain and John Watrous. Parallel approximation of non-interactive zero-sum quantum games. <i>Proceedings of the 24th Annual IEEE Conference on Computational Complexity</i>, pages 243–253, 2009. arXiv:[http://arxiv.org/abs/0808.2775 0808.2775 [quant-ph]]. <span id="jwb03" style="color:maroon">[JWB03]</span> D. Janzing, P. Wocjan, and T. Beth. Cooling and low energy state preparation for 3-local Hamiltonians are FQMA-complete, arXiv:[http://arxiv.org/abs/quant-ph/0303186 quant-ph/0303186], 2003. <span id="jy88" style="color:maroon">[JY88]</span> D. S. Johnson and M. Yannakakis. On generating all maximal independent sets, <i>Information Processing Letters</i> 27(3):119-123, 1988. ===== K ===== <span id="kad88" style="color:maroon">[Kad88]</span> J. Kadin. The polynomial time hierarchy collapses if the Boolean hierarchy collapses, <i>SIAM Journal on Computing</i> 17:1263-1282, 1988. <span id="kan82" style="color:maroon">[Kan82]</span> R. Kannan. Circuit-size lower bounds and non-reducibility to sparse sets, <i>Information and Control</i> 55:40-56, 1982. <span id="kar72" style="color:maroon">[Kar72]</span> R. M. Karp. Reducibility among combinatorial problems, <i>Complexity of Computer Computations</i> (J. W. Thatcher and R. E. Miller, eds.), Plenum Press, 1972. <span id="kar86" style="color:maroon">[Kar86]</span> H. Karloff. A Las Vegas algorithm for maximum matching, <i>Combinatorica</i> 6:387-392, 1986. <span id="kf84" style="color:maroon">[KF84]</span> C. M. R. Kintala and P. Fischer. Refining nondeterminism in relativized complexity classes, <i>SIAM Journal on Computing</i> 13:329-337, 1984. <span id="kha79" style="color:maroon">[Kha79]</span> L. G. Khachiyan. A polynomial algorithm for linear programming, <i>Soviet Math Doklady</i> 20:191-194, 1979. <span id="kha93" style="color:maroon">[Kha93]</span> M. Kharitonov. Cryptographic hardness of distribution-specific learning, <i>Proceedings of ACM STOC'93</i>, pp. 372-381, 1993. <span id="ki02" style="color:maroon">[KI02]</span> V. Kabanets and R. Impagliazzo. Derandomizing polynomial identity tests means proving circuit lower bounds, ECCC [http://eccc.uni-trier.de/eccc-reports/2002/TR02-055/ TR02-055], 2002. <span id="kkr04" style="color:maroon">[KKR04]</span> J. Kempe, A. Kitaev, and O. Regev. The Complexity of the Local Hamiltonian Problem, <i>SIAM Journal of Computing</i>, Vol. 35(5), p. 1070-1097 (2006). arXiv:[http://arxiv.org/abs/quant-ph/0406180 quant-ph/0406180]. <span id="kl82" style="color:maroon">[KL82]</span> R. M. Karp and R. J. Lipton. Turing machines that take advice, <i>Enseign. Math.</i> 28:191-201, 1982. <span id="kle71" style="color:maroon">[Kle71]</span> S. C. Kleene. <i>Introduction to Metamathematics</i>, Elsevier, 1971. <span id="km02" style="color:maroon">[KM02]</span> H. Kobayashi and K. Matsumoto. Quantum multi-prover interactive proof systems with limited prior entanglement, <i>Proceedings of ISAAC'2002</i>, pp. 115-127, 2002. arXiv:[http://arxiv.org/abs/cs.CC/0102013 cs.CC/0102013]. <span id="km92" style="color:maroon">[KM92]</span> D. Koller and N. Megiddo. On the Complexity of Two-person Zero-sum Games in Extensive Form, Games and Economic Behavior 4, 528-552, 1992. [http://theory.stanford.edu/~megiddo/pdf/recall.pdf http://theory.stanford.edu/~megiddo/pdf/recall.pdf] <span id="km99" style="color:maroon">[KM99]</span> A. Klivans and D. van Melkebeek. Graph nonisomorphism has subexponential size proofs unless the polynomial hierarchy collapses, in <i>Proceedings of ACM STOC'99</i>, pp. 659-667, 1999. <span id="kms99" style="color:maroon">[KMS+99]</span> S. Khanna, R. Motwani, M. Sudan, and U. Vazirani. On syntactic versus computational views of approximability, <i>SIAM Journal on Computing</i> 28:164-191, 1999. ECCC [http://eccc.uni-trier.de/eccc-reports/1995/TR95-023/ TR95-023]. <span id="kmy01" style="color:maroon">[KMY01]</span> H. Kobayashi, K. Matsumoto, and T. Yamakami. Quantum certificate verification: single versus multiple quantum certificates, arXiv:[http://arxiv.org/abs/quant-ph/0110006 quant-ph/0110006], 2001. <span id="ko82" style="color:maroon">[Ko82]</span> K. Ko. Some observations on the probabilistic algorithms and NP-hard problems, <i>Information Processing Letters</i> 14(1):39-43, 1982. <span id="ko85" style="color:maroon">[Ko85]</span> K. Ko. On some natural complete operators, <i>Theoretical Computer Science</i> 37(1):1-30, 1985. <span id="kob02" style="color:maroon">[Kob02]</span> H. Kobayashi. Non-interactive quantum statistical and perfect zero-knowledge, arXiv:[http://arxiv.org/abs/quant-ph/0207158 quant-ph/0207158], 2002. <span id="kob89" style="color:maroon">[Kob89]</span> J. K&ouml;bler. <i>Strukturelle Komplexit&auml;t von Anzahlproblemen</i>, PhD thesis, Universit&auml;t Stuttgart, 1989. <span id="koi96" style="color:maroon">[Koi96]</span> P. Koiran. Hilbert's Nullstellensatz is in the polynomial hierarchy, <i>Journal of Complexity</i> 12(4):273-286, 1996, DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1996/96-27.html TR 96-27]. <span id="koz92" style="color:maroon">[Koz92]</span> D. C. Kozen. On the Myhill-Nerode theorem for trees, <i>Bulletin of the EATCS</i> 47:170-173, 1992. <span id="koz97" style="color:maroon">[Koz97]</span> D. C. Kozen. <i>Automata and Computability</i>, Springer-Verlag, 1997. <span id="kp89" style="color:maroon">[KP89]</span> Jan Krajicek and Pavel Pudlak. Propositional Proof Systems, the Consistency of First Order Theories and the Complexity of Computations, <i>J. Symb. Log.</i>, 54:1063-79, 1989. <span id="kr03" style="color:maroon">[KR03]</span> J. Kempe and O. Regev. 3-Local Hamiltonian is QMA-complete, <i>Quantum Inf. Comput.</i>, 3(3):258-264, 2003. arXiv:[http://arxiv.org/abs/quant-ph/0302079 quant-ph/0302079]. <span id="kra.." style="color:maroon">[Kra..]</span> H. Krawczyk. Unpublished. <span id="krc00" style="color:maroon">[KRC00]</span> V. Kabanets, C. Rackoff, and S. A. Cook. Efficiently approximable real-valued functions, ECCC [http://eccc.uni-trier.de/eccc-reports/2000/TR00-034/ TR00-034], 2000. <span id="kre88" style="color:maroon">[Kre88]</span> M. Krentel. The complexity of optimization problems, <i>Journal of Computer and System Sciences</i> 36:490-509, 1988. <span id="krs90" style="color:maroon">[KRS90]</span> C. P. Kruskal, L. Rudolph, and M. Snir. A complexity theory of efficient parallel algorithms, <i>Theoretical Computer Science</i> 71:95-132, 1990. {{Reference |tag=KS05 |authors=N. Kayal and N. Saxena |title=On the ring isomorphism and automorphism problems |journal=Proceedings of the 20th Annual IEEE Conference on Computational Complexity |srcdetail=2-12, 2005}} <span id="kst89" style="color:maroon">[KST+89]</span> J. K&ouml;bler, U. Sch&ouml;ning, and J. Tor&aacute;n. On counting and approximation, <i>Acta Informatica</i> 26:363-379, 1989. <span id="kst89b" style="color:maroon">[KST+89b]</span> J. K&ouml;bler, U. Sch&ouml;ning, S. Toda, and J. Tor&aacute;n. Turing machines with few accepting computations and low sets for PP, <i>Proceedings of IEEE Complexity'89</i>, pp. 208-215, 1989. [http://www.informatik.hu-berlin.de/Forschung_Lehre/algorithmenII/Papers/few.ps.gz http://www.informatik.hu-berlin.de/Forschung_Lehre/algorithmenII/Papers/few.ps.gz] <span id="kst92" style="color:maroon">[KST92]</span> J. K&ouml;bler, U. Sch&ouml;ning, and J. Tor&aacute;n. Graph isomorphism is low for PP, <i>Computational Complexity</i> 2:301-330, 1992. <span id="kst93" style="color:maroon">[KST93]</span> J. K&ouml;bler, U. Sch&ouml;ning, and J. Tor&aacute;n. <i>The Graph Isomorphism Problem: Its Structural Complexity</i>, Birkh&auml;user, 1993. <span id="ksv02" style="color:maroon">[KSV02]</span> A. Kitaev, A. Shen, and M. N. Vyalyi. <i>Classical and Quantum Computation</i>, American Mathematical Society, 2002. <span id="kt94" style="color:maroon">[KT94]</span> P. G. Koliatis and M. N. Thakur. Logical definability of NP optimization problems, <i>Information and Computation</i> 115:321-353, 1994. <span id="kt96" style="color:maroon">[KT96]</span> J. K&ouml;bler and S. Toda. On the power of generalized MOD-classes, <i>Mathematical Systems Theory</i> 29(1):33-46, 1996. [ftp://theorie.informatik.uni-ulm.de/pub/papers/ti/mod.ps.gz ftp://theorie.informatik.uni-ulm.de/pub/papers/ti/mod.ps.gz] <span id="kup09" style="color:maroon">[Kup09]</span> G. Kuperberg. How hard is it to approximate the Jones polynomial?, 2009. arXiv:[http://arxiv.org/abs/0908.0512 quant-ph/0908.0512v1]. <span id="kur64" style="color:maroon">[Kur64]</span> S. Y. Kuroda. Classes of languages and linear-bounded automata, <i>Information and Control</i> 7:207-233, 1964. <span id="kur83" style="color:maroon">[Kur83]</span> S. Kurtz. On the random oracle hypothesis, <i>Information and Control</i> 57:40-47, 1983. <span id="kur85" style="color:maroon">[Kur85]</span> S. Kurtz. On Relativized Exponential and Probabilistic Complexity Classes, <i>Information and Control</i> 71:231-243, 1985. <span id="kuw86" style="color:maroon">[KUW86]</span> R. Karp, E. Upfal, and A. Wigderson. Constructing a perfect matching is in random NC, <i>Combinatorica</i> 6:35-48, 1986. <span id="kv88" style="color:maroon">[KV88]</span> M. Karpinski and R. Verbeek. Randomness, provability, and the separation of Monte Carlo time and space, <i>Lecture Notes in Computer Science</i> 270, pp. 189-207, Springer, 1988. <span id="kv94" style="color:maroon">[KV94]</span> M. Kearns and L. Valiant. Cryptographic limitations on learning Boolean formulae and finite automata, <i>Journal of the ACM</i> 41(1):67-95, 1994. [http://www.cis.upenn.edu/~mkearns/papers/crypto.pdf http://www.cis.upenn.edu/~mkearns/papers/crypto.pdf] <span id="kv96" style="color:maroon">[KV96]</span> M. Karpinski and R. Verbeek. On Randomized Versus Deterministic Computation, Theoret. Comput. Sci. 154 (1996), no. 1, 23--39. ECCC [http://eccc.uni-trier.de/eccc-reports/1995/TR95-021/ TR95-021]. <span id="kw.." style="color:maroon">[KW..]</span> A. Kitaev and J. Watrous. Unpublished. <span id="kw00" style="color:maroon">[KW00]</span> A. Kitaev and J. Watrous. Parallelization, amplification, and exponential time simulation of quantum interactive proof systems, <i>Proceedings of ACM STOC'2000</i>, pp. 608-617, 2000. [http://www.cpsc.ucalgary.ca/~jwatrous/papers/qip2.ps http://www.cpsc.ucalgary.ca/~jwatrous/papers/qip2.ps] <span id="kw88" style="color:maroon">[KW88]</span> M. Karchmer and A. Wigderson. Monotone circuits for connectivity require superlogarithmic depth, <i>Proceedings of ACM STOC'88</i>, pp. 539-550, 1988. <span id="kw93" style="color:maroon">[KW93]</span> M. Karchmer and A. Wigderson. On span programs, <i>Proceedings of IEEE Complexity'93</i>, pp. 102-111, 1993. <span id="kw98" style="color:maroon">[KW98]</span> J. K&ouml;bler and O. Watanabe. New collapse consequences of NP having small circuits, <i>SIAM Journal on Computing</i> 28(1):311-324, 1998. [http://www.informatik.hu-berlin.de/forschung/gebiete/algorithmenII/Publikationen/Papers/collapse.ps.gz http://www.informatik.hu-berlin.de/forschung/gebiete/algorithmenII/Publikationen/Papers/collapse.ps.gz] ===== L ===== <span id="lad75" style="color:maroon">[Lad75]</span> R. Ladner. On the structure of polynomial time reducibility, <i>Journal of the ACM</i> 22:155-171, 1975. <span id="lau83" style="color:maroon">[Lau83]</span> C. Lautemann. BPP and the polynomial time hierarchy, <i>Information Processing Letters</i> 17:215-218, 1983. <span id="lee02" style="color:maroon">[Lee02]</span> T. Lee. Arithmetical definability over finite structures, Mathematical Logic Quarterly, Vol. 49(4), 2003. [http://www.lri.fr/~lee/arith.pdf http://www.lri.fr/~lee/arith.pdf]. <span id="lev73" style="color:maroon">[Lev73]</span> L. A. Levin. Universal search problems (in Russian), <i>Problemy Peredachi Informatsii</i> 9(3):265-266, 1973. <span id="lev86" style="color:maroon">[Lev86]</span> L. A. Levin. Average case complete problems, <i>SIAM Journal on Computing</i>, 15:285-286, 1986. <span id="lfk90" style="color:maroon">[LFK+90]</span> C. Lund, L. Fortnow, H. Karloff, and N. Nisan. Algebraic methods for interactive proofs, <i>Proceedings of IEEE FOCS'90</i>, pp. 1-10, 1990. [http://people.cs.uchicago.edu/~fortnow/papers/ip.ps http://people.cs.uchicago.edu/~fortnow/papers/ip.ps] <span id="li93" style="color:maroon">[Li93]</span> L. Li. <i>On the Counting Functions</i>, PhD thesis, University of Chicago, 1993. {{Reference |tag=LiRe93 |authors=M. Liskiewicz, R. Reischuk |title=The complexity world below logarithmic space |journal=Proceedings of the Structure in Complexity Theory Conference |srcdetail=1993, 64-78 }} <span id="li11" style="color:maroon">[Li11]</span> Y. D. Li. BQP and PPAD, <i>Electronic Colloquium on Computational Complexity</i> TR11-103, 2011. <span id="ll76" style="color:maroon">[LL76]</span> R. Ladner and N. A. Lynch. Relativization of questions about log space computability, <i>Mathematical Systems Theory</i> 10:19-32, 1976. <span id="lmn93" style="color:maroon">[LMN93]</span> N. Linial, Y. Mansour, and N. Nisan. Constant depth circuits, Fourier transform, and learnability, <i>Journal of the ACM</i> 40(3):607-620, 1993. <span id="lmt97" style="color:maroon">[LMT97]</span> K. Lange, P. McKenzie, and A. Tapp. Reversible space equals deterministic space (extended abstract), <i>Proceedings of IEEE FOCS'97</i>, pp. 45-50, 1997. <span id="lp82" style="color:maroon">[LP82]</span> H. R. Lewis and C. H. Papadimitriou. Symmetric space-bounded computation, <i>Theoretical Computer Science</i> 19:161-187, 1982. <span id="ls74" style="color:maroon">[LS74]</span> E. A. Lamagna and J. E. Savage Combinational complexity of some monotone functions, <i>FOCS</i> 140-44, 1974. <span id="lut91" style="color:maroon">[Lut91]</span> J. H. Lutz. An upward measure separation theorem, <i>Theoretical Computer Science</i> 81:127-135, 1991. {{Reference |tag=Lut93 |authors=J. H. Lutz |title=The quantitative structure of exponential time |journal=Proc. 8th Structure in Complexity Theory Conference |srcdetail=(IEEE Comput. Soc. Press, 1993) 158-175 }}[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.1845&rep=rep1&type=pdf] <span id="lv97" style="color:maroon">[LV97]</span> M. Li and P. Vit&aacute;nyi. <i>An Introduction to Kolmogorov Complexity and Its Applications</i> (second edition), Springer, 1997. ===== M ===== <span id="m08" style="color:maroon">[M08]</span> L. Malka. How to achieve perfect simulation, and a complete problem for non-interactive perfect zero-knowledge. <i>IACR 5th Theory of Cryptography Conference (TCC)</i>, 2008. [http://www.cs.uvic.ca/~liorma/publications/NIZK9.pdf]. <span id="mah82" style="color:maroon">[Mah82]</span> S. R. Mahaney. Sparse complete sets for NP: Solution of a conjecture by Berman and Hartmanis, <i>Journal of Computer and System Sciences</i> 25:130-143, 1982. <span id="may94" style="color:maroon">[May94]</span> E. Mayordomo. Almost every set in exponential time is P-bi-immune, <i>Theoretical Computer Science</i> 136(2):487-506, 1994. <span id="may94b" style="color:maroon">[May94b]</span> E. Mayordomo. <i>Contributions to the study of resource-bounded measure</i>, PhD thesis, Universitat Politecnica de Catalunya, 1994. <span id="ms89" style="color:maroon">[MS89]</span> E.W. Mayr and A. Subramanian. The complexity of circuit value and network stability, Proceedings of the Fourth Annual Conference on <i>Structure in Complexity Theory</i>, pp.114-123, 1989. <span id="mc00" style="color:maroon">[MC00]</span> C. Moore and J. P. Crutchfield. Quantum automata and quantum grammars, <i>Theoretical Computer Science</i> 237:275-206, 2000. {{Reference |tag=Mel00 |authors=D. Melkebeek |title=The zero-one law holds for BPP |journal=Theoretical Computer Science |srcdetail=Volume 244, Issues 1-2, 6 August 2000, Pages 283-288 }} <span id="mes99" style="color:maroon">[Mes99]</span> J. Messner. On optimal algorithms and optimal proof systems, <i>Lecture Notes in Computer Science</i> 1563:541-550, 1999. <span id="mil76" style="color:maroon">[Mil76]</span> G. Miller. Riemann's hypothesis and tests for primality, <i>Journal of Computer and System Sciences</i>, 13:300-317, 1976. <span id="mil92" style="color:maroon">[Mil92]</span> P. B. Miltersen. Circuit depth relative to a random oracle, <i>Information Processing Letters</i> 42(6):295-298, 1992. <span id="mn02" style="color:maroon">[MN02]</span> C. Moore and M. Nilsson. Parallel quantum computation and quantum codes, <i>SIAM Journal on Computing</i> 31(3):799-815, 2002. arXiv:[http://arxiv.org/abs/quant-ph/9808027 quant-ph/9808027]. <span id="mon80" style="color:maroon">[Mon80]</span> B. Monien. On a subclass of pseudopolynomial problems, <i>Mathematical Foundations of Computer Science (MFCS'80)</i>, Springer LNCS 88, pp. 414-425, 1980. <span id="moo99" style="color:maroon">[Moo99]</span> C. Moore. Quantum circuits: fanout, parity, and counting, ECCC [http://eccc.uni-trier.de/eccc-reports/1999/TR99-032/ TR99-032]. <span id="mor01" style="color:maroon">[Mor01]</span> T. Morioka. Classification of search problems and their definability in bounded arithmetic, master's thesis, University of Toronto, 2001. ECCC [http://eccc.uni-trier.de/eccc-reports/2001/TR01-082/ TR01-082]. <span id="mp75" style="color:maroon">[MP75]</span> D. E. Muller and F. P. Preparata. Bounds to complexities of networks for sorting and for switching, <i>Journal of the ACM</i> 22:195-201, 1975. <span id="mp91" style="color:maroon">[MP91]</span> N. Megiddo and C. H. Papadimitriou. On total functions, existence theorems, and computational complexity, <i>Theoretical Computer Science</i> 81(2):317-324, 1991. <span id="mr95" style="color:maroon">[MR95]</span> R. Motwani and P. Raghavan. <i>Randomized Algorithms</i>, Cambridge University Press, 1995. <span id="ms02" style="color:maroon">[MS02]</span> K. Mulmuley and M. Sohoni. Geometric complexity theory I: An approach to the P vs. NP and related problems, <i>SIAM Journal on Computing</i> 31(2):496-526, 2002. <span id="muc56" style="color:maroon">[Muc56]</span> A. A. Muchnik. On the unsolvability of the problem of reducibility in the theory of algorithms, <i>Doklady Akademii Nauk SSSR</i> 108:194-197, 1956. <span id="mv99" style="color:maroon">[MV99]</span> P. B. Miltersen and N. V. Vinodchandran. Derandomizing Arthur-Merlin games using hitting sets, <i>Proceedings of IEEE FOCS'99</i>, pp. 71-80, 1999. <span id="mvv87" style="color:maroon">[MVV87]</span> K. Mulmuley, U. V. Vazirani, and V. V. Vazirani. Matching is as easy as matrix inversion, <i>Proceedings of ACM STOC'87</i>, pp. 345-354, 1987. <span id="mvw99" style="color:maroon">[MVW99]</span> P. B. Miltersen, N. V. Vinodchandran, and O. Watanabe. Super-polynomial versus half-exponential circuit size in the exponential hierarchy, <i>Proceedings of the 5th Annual Conference on Computing and Combinatorics (COCOON'99)</i>, pp. 210-220, Lecture Notes in Computer Science 1627, Springer-Verlag, 1999. <span id="mw05" style="color:maroon">[MW05]</span> C. Marriott and J. Watrous. Quantum Arthur-Merlin Games, <i>Computational Complexity</i>, 14(2):122-152, 2005. arXiv:[http://arxiv.org/abs/cs/0506068 cs/0506068]. ===== N ===== <span id="nc00" style="color:maroon">[NC00]</span> M. Nielsen and I. Chuang. <i>Quantum Computation and Quantum Information</i>, Cambridge University Press, 2000. <span id="nhk00" style="color:maroon">[NHK00]</span> M. Nakanishi, K. Hamaguchi, and T. Kashiwabara. Ordered quantum branching programs are more powerful than ordered probabilistic branching programs under a bounded-width restriction, <i>Proceedings of COCOON'2000 (Computing and Combinatorics)</i>, Springer LNCS 1858, pp. 467-476, 2000. <span id="nie02" style="color:maroon">[Nie02]</span> G. Niemann and J. R. Woinowski. The Growing Context-Sensitive Languages Are the Acyclic Context-Sensitive Languages, <i>Developments in Language Theory</i>. LNCS 2295, pp. 197-205. </span> <span id="nis02" style="color:maroon">[Nis02]</span> T. Nishino. Mathematical models of quantum computation, New Gen. Comput. 20 (2002), no 4, 317-337. <span id="nis92" style="color:maroon">[Nis92]</span> N. Nisan. RL is contained in SC, <i>Proceedings of ACM STOC'92</i>, pp. 619-623, 1992. <span id="nr97" style="color:maroon">[NR97]</span> M. Naor and O. Reingold. Number-theoretic constructions of efficient pseudorandom functions, <i>Proceedings of IEEE FOCS'97</i>, pp. 458-467, 1997. <span id="nr98" style="color:maroon">[NR98]</span> R. Niedermeier and P. Rossmanith. Unambiguous computations and locally definable acceptance types, <i>Theoretical Computer Science</i> 194:137-161, 1998. <span id="nrr01" style="color:maroon">[NRR01]</span> M. Naor, O. Reingold, and A. Rosen. Pseudo-random functions and factoring, ECCC [http://eccc.uni-trier.de/eccc-reports/2001/TR01-064/ TR01-064]. <span id="ns05" style="color:maroon">[NS05]</span> A. Nickelsen and B. Schelm. Average-case computations - comparing AvgP, HP, and Nearly-P, <i>Proceedings of IEEE Complexity'2005</i>, pp. 235-242, 2005. [http://www.thi.uni-hannover.de/forschung/publikationen/daten/ni-sc05.pdf http://www.thi.uni-hannover.de/forschung/publikationen/daten/ni-sc05.pdf]. <span id="nsw92" style="color:maroon">[NSW92]</span> N. Nisan, E. Szemer&eacute;di, and A. Wigderson. Undirected connectivity in O(log<sup>1.5</sup>n) space, <i>Proceedings of IEEE FOCS'92</i>, pp. 24-29, 1992. <span id="nt95" style="color:maroon">[NT95]</span> N. Nisan and A. Ta-Shma. Symmetric logspace is closed under complement, <i>Proceedings of ACM STOC'95</i>, pp. 140-146, 1995. ECCC [http://eccc.uni-trier.de/eccc-reports/1994/TR94-003/ TR94-003]. <span id="nw94" style="color:maroon">[NW94]</span> N. Nisan and A. Wigderson. Hardness versus randomness, <i>Journal of Computer and System Sciences</i> 49:149-167, 1994. <span id="ny03" style="color:maroon">[NY03]</span> H. Nishimura and T. Yamakami. Polynomial time quantum computation with advice, arXiv:[http://arxiv.org/abs/quant-ph/0305100 quant-ph/0305100], ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-059/ TR03-059], 2003. <span id="ny03b" style="color:maroon">[NY03b]</span> H. Nishimura and T. Yamakami. An algorithmic argument [http://www.cheatcodesforsim3.com/ for] query complexity lower bounds of advised quantum computation, arXiv:[http://arxiv.org/abs/quant-ph/0312003 quant-ph/0312003], 2003. ===== O ===== <span id="ogi94" style="color:maroon">[Ogi94]</span> M. Ogihara. On serializable languages, <i>International Journal of Foundations of Computer Science</i> 5(3-4):303-318, 1994. <span id="oh93" style="color:maroon">[OH93]</span> M. Ogihara and L. Hemachandra. A complexity theory for feasible closure properties, <i>Journal of Computer and System Sciences</i> 46(3):295-325, 1993. <span id="oka96" style="color:maroon">[Oka96]</span> T. Okamoto. On relationships between statistical zero-knowledge proofs, <i>Proceedings of ACM STOC'96</i>, 1996. <span id="oks94" style="color:maroon">[OKS+94]</span> P. Orponen, K.-I. Ko, U. Sch&ouml;ning, and O. Watanabe. Instance complexity, <i>Journal of the ACM</i> 41:96-121, 1994. <span id="ost91" style="color:maroon">[Ost91]</span> R. Ostrovsky. One-way functions, hard on average problems and statistical zero-knowledge proofs, <i>Proceedings of IEEE Complexity'91</i>, pp. 51-59, 1991. <span id="ow93" style="color:maroon">[OW93]</span> R. Ostrovsky and A. Wigderson. One-way functions are essential for non-trivial zero-knowledge, <i>Proceedings of the 2nd Israel Symposium on Theory of Computing and Systems (ISTCS-93)</i>, 1993. ===== P ===== <span id="pap83" style="color:maroon">[Pap83]</span> C. H. Papadimitriou. Games against nature, <i>Proceedings of IEEE FOCS'83</i>, pp. 446-450, 1983. <span id="pap90" style="color:maroon">[Pap90]</span> C. H. Papadimitriou. On graph-theoretic lemmata and complexity classes, <i>Proceedings of IEEE FOCS'90</i>, pp. 794-801, 1990. <span id="pap94" style="color:maroon">[Pap94]</span> C. H. Papadimitriou. <i>Computational Complexity</i>, Addison-Wesley, 1994. <span id="pap94b" style="color:maroon">[Pap94b]</span> C. H. Papadimitriou. On the complexity of the parity argument and other inefficient proofs of existence, <i>Journal of Computer and System Sciences</i> 48(3):498-532, 1994. {{Reference |tag=Per07 |authors=K. Pervyshev |title=On heuristic time hierarchies |journal=Proceedings of the 22nd Annual IEEE Conference on Computational Complexity |srcdetail=347-357, 2007 }} <span id="pos44" style="color:maroon">[Pos44]</span> E. L. Post. Recursively enumerable sets of positive integers and their decision problems, <i>Bulletin of the American Mathematical Society</i> 50:284-316, 1944. <span id="pp00" style="color:maroon">[PP00]</span> S. Parker and M. B. Plenio. Efficient factorization with a single pure qubit and log N mixed qubits, <i>Physical Review Letters</i> 85:3049, 2000. arXiv:[http://arxiv.org/abs/quant-ph/0001066 quant-ph/0001066]. <span id="pps83" style="color:maroon">[PPS+83]</span> W. J. Paul, N. Pippenger, E. Szemer&eacute;di, and W. T. Trotter. On determinism versus nondeterminism and related problems, <i>Proceedings of IEEE FOCS'83</i>, pp. 429-438, 1983. <span id="pra74" style="color:maroon">[Pra74]</span> V. R. Pratt. The power of negative thinking in multiplying Boolean matrices, <i>STOC '74: Proceedings of the sixth annual ACM Symposium on Theory of Computing</i>, 80-83, 1974. <span id="pra75" style="color:maroon">[Pra75]</span> V. R. Pratt. Every prime has a succinct certificate, <i>SIAM Journal on Computing</i>, 4:214-220, 1975. <span id="pv04" style="color:maroon">[PV04]</span> A. Pavan and N. V. Vinodchandran. [http://ftp.eccc.uni-trier.de/eccc-reports/2004/TR04-053/ TR04-053]. <span id="py84" style="color:maroon">[PY84]</span> C. H. Papadimitriou and M. Yannakakis. The complexity of facets (and some facets of complexity), <i>Journal of Computer and System Sciences</i> 28:244-259, 1984. <span id="py88" style="color:maroon">[PY88]</span> C. H. Papadimitriou and M. Yannakakis. Optimization, approximation, and complexity classes, <i>Proceedings of ACM STOC'88</i>, pp. 229-234, 1988. <span id="py96" style="color:maroon">[PY96]</span> C. H. Papadimitriou and M. Yannakakis. On limited nondeterminism and the complexity of the VC dimension, <i>Journal of Computer and System Sciences</i> 53(2):161-170, 1996. <span id="pz83" style="color:maroon">[PZ83]</span> C. H. Papadimitriou and S. Zachos. Two remarks on the power of counting, <i>Proceedings of the 6th GI Conference in Theoretical Computer Science</i>, Lecture Notes in Computer Science Vol. 145, Springer-Verlag, pp. 269-276, 1983. ===== R ===== <span id="ra00" style="color:maroon">[RA00]</span> K. Reinhardt and E. Allender. Making nondeterminism unambiguous, <i>SIAM Journal on Computing</i> 29:1118-1131, 2000. ECCC [http://eccc.uni-trier.de/eccc-reports/1997/TR97-014/ TR97-014], DIMACS [http://dimacs.rutgers.edu/TechnicalReports/abstracts/1997/97-46.html TR 97-46]. <span id="rab60" style="color:maroon">[Rab60]</span> M. O. Rabin. Degree of difficulty of computing a function and a partial ordering of recursive sets, Tech Report No. 2, Hebrew University, 1960. <span id="rac82" style="color:maroon">[Rac82]</span> C. Rackoff. Relativized questions involving probabilistic algorithms, <i>Journal of the ACM</i> 29(1):261-268, 1982. <span id="raz05" style="color:maroon">[Raz05]</span> R. Raz. Quantum information and the PCP theorem, to appear in <i>Proc. IEEE FOCS</i>, 2005. ECCC [http://www.eccc.uni-trier.de/eccc-reports/2005/TR05-038/index.html TR05-038]. <span id="raz85" style="color:maroon">[Raz85]</span> A. A. Razborov. Lower bounds on the monotone complexity of some Boolean functions, <i>Dokl. Akad. Nauk SSSR</i> 281(4):798-801, 1985. English translation in <i>Soviet Math. Dokl.</i> 31:354-357, 1985. <span id="raz85b" style="color:maroon">[Raz85b]</span> A. A. Razborov. A lower bound on the monotone network complexity of the logical permanent, <i>Mat. Zametky</i> 37(6):887-900, 1985. English translation in <i>Russian Mathematical Notes</i> 37:485-493, 1985. <span id="raz87" style="color:maroon">[Raz87]</span> A. A. Razborov. Lower bounds for the size of circuits of bounded depth with basis {&amp;,}, <i>Mathematicheskie Zametki</i> 41(4):598-607, 1987. English translation in <i>Math. Notes. USSR</i> 41(4):333-338, 1987. <span id="raz94" style="color:maroon">[Raz94]</span> A. A. Razborov. On provably disjoint NP-pairs, ECCC [http://eccc.uni-trier.de/eccc-reports/1994/TR94-006/ TR94-006], 1994. <span id="reg02" style="color:maroon">[Reg02]</span> K. Regan. Understanding the Mulmuley-Sohoni approach to P vs. NP, <i>Bulletin of the EATCS</i> 78, October 2002. [http://people.cs.uchicago.edu/~fortnow/beatcs/column78.pdf http://people.cs.uchicago.edu/~fortnow/beatcs/column78.pdf]. <span id="rei04" style="color:maroon">[Rei04]</span> O. Reingold. Undirected st-connectivity in log-space, ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR04-094/ TR04-094], 2004. <span id="rr95" style="color:maroon">[RR95]</span> K. Regan, J. Royer. On Closure Properties of Bounded two-Sided Error Complexity Classes, Math. Systems Theory, 28 (1995) 229-243. ftp://ftp.cis.syr.edu/users/royer/coinflips.ps <span id="rr97" style="color:maroon">[RR97]</span> A. A. Razborov and S. Rudich. Natural proofs, <i>Journal of Computer and System Sciences</i> 55(1):24-35, 1997. ECCC [http://eccc.uni-trier.de/eccc-reports/1994/TR94-010/ TR94-010]. <span id="rs98" style="color:maroon">[RS98]</span> A. Russell and R. Sundaram. Symmetric alternation captures BPP, <i>Computational Complexity</i> 7(2):152-162, 1998. <span id="rtv05" style="color:maroon">[RTV05]</span> O. Reingold and L. Trevisan and S. Vadhan. Pseudorandom walks in biregular graphs and the RL vs. L problem, ECCC [http://eccc.uni-trier.de/eccc-reports/2005/TR05-022/ TR05-022], 2004. <span id="rub88" style="color:maroon">[Rub88]</span> R. Rubinstein. <i>Structural Complexity Classes of Sparse Sets: Intractability, Data Compression, and Printability</i>, PhD Thesis, Northeastern University (Boston, MA), 1988. <span id="rud97" style="color:maroon">[Rud97]</span> S. Rudich. Super-bits, demi-bits, and NP/qpoly-natural proofs, <i>RANDOM: International Workshop on Randomization and Approximation Techniques in Computer Science</i>, Lecture Notes in Computer Science, Springer-Verlag, 1997. <span id="rus85" style="color:maroon">[Rus85]</span> D. A. Russo. Structural Properties of Complexity Classes. PhD thesis, UC Santa Barbara, 1985. <span id="ruz81" style="color:maroon">[Ruz81]</span> W. L. Ruzzo. On uniform circuit complexity, <i>Journal of Computer and System Sciences</i> 22(3):365-383, 1971. <span id="rw01" style="color:maroon">[RW01]</span> S. Reith and K. Wagner. On Boolean lowness and Boolean highness, <i>Theoretical Computer Science</i> 261(2):305-321, 2001. ===== S ===== {{Reference |tag=San07 |title=Circuit lower bounds for Merlin-Arthur classes |journal=Electronic Colloquium on Computational Complexity |authors=R. Santhanam |srcdetail=Report TR07-005 }} <span id="sav70" style="color:maroon">[Sav70]</span> W. Savitch. Relationships between nondeterministic and deterministic tape complexities, <i>Journal of Computer and System Sciences</i> 4(2):177-192, 1970. <span id="sch02a" style="color:maroon">[Sch02a]</span> M. Schaefer and C. Umans. Completeness in the Polynomial-Time Hierarchy: A Compendium, <i>Sigact News</i> September, 2002. <span id="sch02b" style="color:maroon">[Sch02b]</span> M. Schaefer and C. Umans. Completeness in the Polynomial-Time Hierarchy: Part II, <i>Sigact News</i> December, 2002. <span id="sch03" style="color:maroon">[Sch03]</span> P. Schnoebelen. Oracle circuits for branching-time model checking, <i>Proceedings of ICALP 2003</i>, pp. 790-801, 2003. <span id="sch78" style="color:maroon">[Sch78]</span> C. P. Schnorr. Satisfiability Is Quasilinear Complete in NQL, <i>Journal of the ACM</i> 25(1):136-145, 1978. <span id="sch83" style="color:maroon">[Sch83]</span> U. Sch&ouml;ning. A low and a high hierarchy within NP, <i>Journal of Computer and System Sciences</i> 27:14-28, 1983. <span id="sch86" style="color:maroon">[Sch86]</span> U. Sch&ouml;ning. Complete Sets and Closeness to Complexity Classes, <i>Mathematical Systems Theory</i> 19:29-41, 1986. DOI:[http://dx.doi.org/10.1007/BF01704904 10.1007/BF01704904] <span id="sel79" style="color:maroon">[Sel79]</span> A. Selman. P-selective sets, tally languages, and the behavior of polynomial time reducibilities in NP, <i>Mathematical Systems Theory</i> 13(1):55-65, 1979. <span id="sf98" style="color:maroon">[SF98]</span> H. T. Siegelmann and S. Fishman. Analog computation with dynamical systems, Physica 120D, p. 214, 1998. <span id="sfm78" style="color:maroon">[SFM78]</span> J. Seiferas, M. Fischer, and A. Meyer. Separating nondeterministic time complexity classes, <i>Journal of the ACM</i> 25:146-167, 1978. <span id="sha90" style="color:maroon">[Sha90]</span> A. Shamir. IP=PSPACE, <i>Proceedings of IEEE FOCS'90</i>, pp. 11-15, 1990. <span id="she59" style="color:maroon">[She59]</span> J. C. Shepherdson. The reduction of two-way automata to one-way automata, <i>IBM Journal of Research and Development</i>, 3:198-200, 1959. <span id="she08" style="color:maroon">[She08]</span> A. A. Sherstov. Separating AC<sup>0</sup> from depth-2 majority circuits, <i>Computational Complexity</i>, 17(2):149-178, 2008. [http://www.cs.utexas.edu/~sherstov/publications/pdf/cc08hsmat.pdf http://www.cs.utexas.edu/~sherstov/publications/pdf/cc08hsmat.pdf] <span id="shi03" style="color:maroon">[Shi03]</span> Y. Shi. Quantum and classical tradeoffs, arXiv:[http://arxiv.org/abs/quant-ph/0312213 quant-ph/0312213], ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR04-023/ TR04-023], 2003. <span id="sho97" style="color:maroon">[Sho97]</span> P. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer, <i>SIAM Journal on Computing</i> 26(5):1484-1509, 1997. arXiv:[http://arxiv.org/abs/quant-ph/9508027 quant-ph/9508027]. <span id="sho99" style="color:maroon">[Sho99]</span> R. A. Shore. The recursively enumerable degrees, <i>Handbook of Recursion Theory</i> (E. Griffor, ed.), pp. 169-197, North-Holland, Amsterdam, 1999. <span id="sip82" style="color:maroon">[Sip82]</span> M. Sipser. On relativization and the existence of complete sets, <i>Proceedings of ICALP'82</i>, Springer-Verlag Lecture Notes in Computer Science volume 140, pp. 523-531, 1982. <span id="sip92" style="color:maroon">[Sip92]</span> M. Sipser. The history and status of the P versus NP question, <i>Proceedings of ACM STOC'92</i>, pp. 603-618, 1992. <span id="sm02" style="color:maroon">[SM02]</span> L. J. Stockmeyer and A. R. Meyer. Cosmological lower bound on the circuit complexity of a small problem in logic, <i>Journal of the ACM</i> 49(6):753-784, 2002. [http://theory.lcs.mit.edu/~meyer/stock-circuit-jacm.pdf http://theory.lcs.mit.edu/~meyer/stock-circuit-jacm.pdf]. {{Reference |tag=SM03 |authors=R. Santhanam, D. Melkebeek |title=Holographic proofs and derandomization |journal=Proceedings of the 18th Annual IEEE Conference on Computational Complexity |srcdetail=269-283 }} <span id="smo87" style="color:maroon">[Smo87]</span> R. Smolensky. Algebraic methods in the theory of lower bounds for Boolean circuit complexity, <i>Proceedings of ACM STOC'87</i>, pp. 77-82, 1987. <span id="sp98" style="color:maroon">[SP98]</span> U. Sch&ouml;ning and R. Pruim. <i>Gems of Theoretical Computer Science</i>, Springer-Verlag, 1998. <span id="spa02" style="color:maroon">[Spa02]</span> R. &#352;palek. Quantum circuits with unbounded fan-out, arXiv:[http://arxiv.org/abs/quant-ph/0208043 quant-ph/0208043], 2002. <span id="ss04" style="color:maroon">[SS04]</span> A. Selman and S. Sengupta. Polylogarithmic-round interactive proofs for coNP collapse the exponential hierarchy, <i>Proceedings of IEEE Complexity 2004</i>, pp. 82-90, 2004. ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR04-007/ TR04-007]. <span id="ss77" style="color:maroon">[SS77]</span> R. Solovay and V. Strassen. A fast Monte-Carlo test for primality, <i>SIAM Journal on Computing</i>, 6:84-86, 1977. <span id="sto76" style="color:maroon">[Sto76]</span> L. J. Stockmeyer. The polynomial hierarchy, <i>Theoretical Computer Science</i> 3:1-22, 1976. <span id="sto85" style="color:maroon">[Sto85]</span> L. J. Stockmeyer. On approximation algorithms for #P, <i>SIAM Journal on Computing</i> 14:849-861, 1985. <span id="stt05" style="color:maroon">[STT05]</span> Holger Spakowski, Mayur Thakur, and Rahul Tripathi. Quantum and Classical Complexity Classes: Separations, Collapses, and Closure Properties, Inform. and Comput. 200 (2005), no. 1, 1--34. [http://web.umr.edu/~thakurk/publications/quantum-j.pdf http://web.umr.edu/~thakurk/publications/quantum-j.pdf] <span id="su05" style="color:maroon">[SU05]</span> R. Shaltiel and C. Umans. Pseudorandomness for approximate counting and sampling, <i>Proceedings of IEEE Complexity'2005</i>, pp. 212-226, 2005. [http://www.cs.haifa.ac.il/~ronen/online_papers/derand-ccc-final.ps http://www.cs.haifa.ac.il/~ronen/online_papers/derand-ccc-final.ps]. <span id="sub94" style="color:maroon">[Sub94]</span> A. Subramanian. A New Approach to Stable Matching Problems, <i>SIAM Journal on Computing</i> 23(4), 671-701, 1994. <span id="sud78" style="color:maroon">[Sud78]</span> I. Sudborough. On the tape complexity of deterministic context-free languages, <i>Journal of the ACM</i> 25(3):405-414, 1978. <span id="sv97" style="color:maroon">[SV97]</span> A. Sahai and S. Vadhan. A complete promise problem for statistical zero-knowledge, <i>Proceedings of IEEE FOCS'97</i>. [http://www.eecs.harvard.edu/~salil/papers/complete-abs.html http://www.eecs.harvard.edu/~salil/papers/complete-abs.html]. <span id="sz95" style="color:maroon">[SZ95]</span> M. Saks and S. Zhou. RSPACE(s) is contained in DSPACE(s<sup>3/2</sup>), <i>Proceedings of IEEE FOCS'95</i>, pp. 344-353, 1995. <span id="sze87" style="color:maroon">[Sze87]</span> R. Szelepcs&eacute;nyi. The method of forcing for nondeterministic automata, <i>Bulletin of the EATCS</i> 33:96-100, 1987. {{Reference |id="szep94" |tag=Szep94 |title=Turing Machines With Sublogarithmic Space |journal=Lecture Notes in Computer Science |authors=Andrzej Szepietowski |srcdetail=volume 843 }} ===== T ===== <span id="tar88" style="color:maroon">[Tar88]</span> E. Tardos. The gap between monotone and non-monotone circuit complexity is exponential, <i>Combinatorica</i>, 8:141-142, 1988. <span id="tar89" style="color:maroon">[Tar89]</span> G. Tardos. Query complexity, or why is it difficult to separate NP<sup>A</sup> intersect coNP<sup>A</sup> from P<sup>A</sup> by random oracles A, <i>Combinatorica</i>, 9:385-392, 1989. <span id="tha98" style="color:maroon">[Tha98]</span> J. S. Thathachar. On Separating the Read-k-Times Branching Program Hierarchy, <i>Proceedings of the 30th ACM Symposium on Theory of Computing</i>, pp. 653-662, 1998. ECCC [http://eccc.hpi-web.de/eccc-reports/1998/TR98-002/ TR98-02], DOI:[http://doi.acm.org/10.1145/276698.276881 10.1145/276698.276881]. <span id="tod89" style="color:maroon">[Tod89]</span> S. Toda. On the computational power of PP and P, <i>Proceedings of IEEE FOCS'89</i>, pp. 514-519, 1989. <span id="tor00" style="color:maroon">[Tor00]</span> J. Tor&aacute;n. On the hardness of graph isomorphism, <i>Proceedings of IEEE FOCS'2000</i>, pp. 180-186, 2000. <span id="tor88" style="color:maroon">[Tor88]</span> J. Tor\'an. Structural Properties of the Counting Hierarchies, Ph.D Theis, 1988. <span id="tor90" style="color:maroon">[Tor90]</span> J. Tor&aacute;n. Counting the number of solutions, <i>Proceedings of 15th Conference on Mathematical Foundations of Computer Science (MFCS)</i>, pp. 121-135, Springer-Verlag Lecture Notes in Computer Science 452, 1990. <span id="tor91" style="color:maroon">[Tor91]</span> J. Tor&aacute;n. Complexity classes defined by counting quantifiers, <i>Journal of the ACM</i> 38:753-774, 1991. <span id="tur36" style="color:maroon">[Tur36]</span> A. M. Turing. On computable numbers, with an application to the <i>Entscheidungsproblem</i>, <i>Proceedings of the London Mathematical Society</i> 2(42):230-265, 1936; 2(43):544-546, 1937. <span id="tv02" style="color:maroon">[TV02]</span> L. Trevisan and S. Vadhan. Pseudorandomness and average-case complexity via uniform reductions, <i>Proceedings of CCC'2002</i>, pp. 129-138, 2002. ===== U ===== <span id="uma98" style="color:maroon">[Uma98]</span> C. Umans. The minimum equivalent DNF problem and shortest implicants, <i>Proceedings of IEEE FOCS'98</i>, pp. 556-563, 1998. ===== V ===== <span id="vad06" style="color:maroon">[Vad06]</span> S. Vadhan. An Unconditional Study of Computational Zero Knowledge, ECCC [http://eccc.hpi-web.de/eccc-reports/2006/TR06-056/ TR06-056]. <span id="val03" style="color:maroon">[Val03]</span> L. G. Valiant. Three problems in computer science, <i>Journal of the ACM</i> 50(1):96-99, 2003. <span id="val76" style="color:maroon">[Val76]</span> L. G. Valiant. Relative complexity of checking and evaluating, <i>Information Processing Letters</i>, 5:20-23, 1976. <span id="val79" style="color:maroon">[Val79]</span> L. G. Valiant. The complexity of computing the permanent, <i>Theoretical Computer Science</i>, 8:189-201, 1979. <span id="val79b" style="color:maroon">[Val79b]</span> L. G. Valiant. Completeness classes in algebra, <i>Proceedings of ACM STOC'79</i>, pp. 249-261, 1979. <span id="var82" style="color:maroon">[Var82]</span> M. Vardi. Complexity of relational query languages, <i>Proceedings of ACM STOC'82</i>, pp. 137-146, 1982. <span id="ven91" style="color:maroon">[Ven91]</span> H. Venkateswaran. Properties that characterize LOGCFL, <i>Journal of Computer and System Sciences</i> 43(2):380-404, 1991. <span id="ver92" style="color:maroon">[Ver92]</span> N. K. Vereshchagin. On the power of PP, <i>Proceedings of IEEE Complexity'92</i>, pp. 138-143, 1992. <span id="ver95" style="color:maroon">[Ver95]</span> N. K. Vereshchagin. Oracle separation of complexity classes and lower bounds for perceptrons solving separation problems, <i>Izvestiya Mathematics</i> 59(6):1103-1122, 1995. <span id="vid03" style="color:maroon">[Vid03]</span> G. Vidal. Efficient classical simulation of slightly entangled quantum computations, <i>Physical Review Letters</i> 91:147902, 2003. arXiv:[http://arxiv.org/abs/quant-ph/0301063 quant-ph/0301063]. <span id="vin04" style="color:maroon">[Vin04]</span> N. V. Vinodchandran. Counting complexity of solvable group problems, <i>SIAM Journal on Computing</i> 33(4):852-869, 2004, [http://www.cse.unl.edu/~vinod/papers/SIAMFinal.ps http://www.cse.unl.edu/~vinod/papers/SIAMFinal.ps]. <span id="vin04b" style="color:maroon">[Vin04b]</span> N. V. Vinodchandran. A note on the circuit complexity of PP, ECCC [http://eccc.uni-trier.de/eccc-reports/2004/TR04-056/ TR04-056], 2004. <span id="vsb83" style="color:maroon">[VSB+83]</span> L. G. Valiant, S. Skyum, S. Berkowitz, and C. Rackoff. Fast parallel computation of polynomials using few processors, <i>SIAM Journal on Computing</i> 12(4):641-644, 1983. <span id="vv85" style="color:maroon">[VV85]</span> U. V. Vazirani and V. V. Vazirani. Random polynomial time equals semi-random polynomial time, <i>Proceedings of IEEE FOCS'85</i>, pp. 417-428, 1985. <span id="vv86" style="color:maroon">[VV86]</span> L. G. Valiant and V. V. Vazirani. NP is as easy as detecting unique solutions, <i>Theoretical Computer Science</i> 47(3):85-93, 1986. <span id="vya03" style="color:maroon">[Vya03]</span> M. Vyalyi. QMA=PP implies that PP contains PH, ECCC [http://eccc.uni-trier.de/eccc-reports/2003/TR03-021/ TR03-021], 2003. ===== W ===== <span id="wag86" style="color:maroon">[Wag86]</span> K. W. Wagner. The complexity of combinatorial problems with succinct input representation, <i>Acta Informatica</i> 23:325-356, 1986. <span id="wag88" style="color:maroon">[Wag88]</span> K. W. Wagner. Bounded query computation, <i>Proceedings of IEEE Complexity'88</i>, pp. 260-277, 1988. <span id="ww85" style="color:maroon">[WW85]</span> K. W. Wagner and G. Wechsung. On the Boolean closure of NP, <i>Proceedings of the International Conference on Fundamentals of Computation Theory</i>, LNCS volume 199, Springer-Verlag, pp. 485-493. <span id="wat00" style="color:maroon">[Wat00]</span> J. Watrous. Succinct quantum proofs for properties of finite groups, <i>Proceedings of IEEE FOCS'2000</i>, pp. 537-546, 2000. arXiv:[http://arxiv.org/abs/cs.CC/0009002 cs.CC/0009002]. <span id="wat02" style="color:maroon">[Wat02]</span> J. Watrous. Limits on the power of quantum statistical zero-knowledge, to appear in <i>Proceedings of IEEE FOCS'2002</i>. arXiv:[http://arxiv.org/abs/quant-ph/0202111 quant-ph/0202111]. <span id="wat09" style="color:maroon">[Wat09]</span> J. Watrous. Quantum Computational Complexity, <i>Encyclopedia of Complexity and Systems Science</i>, Springer, pp. 7174-7201, 2009. arXiv:[http://arxiv.org/abs/0804.3401 quant-ph/0804.3401]. <span id="wat87" style="color:maroon">[Wat87]</span> O. Watanabe. Comparison of polynomial time completeness notions, <i>Theoretical Computer Science</i> 53:249-265, 1987. <span id="wat99" style="color:maroon">[Wat99]</span> J. Watrous. PSPACE has constant-round quantum interactive proof systems, <i>Proceedings of IEEE FOCS'99</i>, pp. 112-119, 1999. arXiv:[http://arxiv.org/abs/cs.CC/9901015 cs.CC/9901015]. <span id="wat99b" style="color:maroon">[Wat99b]</span> J. Watrous. Space-bounded quantum complexity, <i>Journal of Computer and System Sciences</i> 59(2):281-326, 1999. [http://www.cpsc.ucalgary.ca/%7Ejwatrous/papers/jcss_space.ps http://www.cpsc.ucalgary.ca/%7Ejwatrous/papers/jcss_space.ps]. <span id="weg87" style="color:maroon">[Weg87]</span> I. Wegener. The Complexity of Boolean Functions, New York: Wiley 1987. <span id="weg88" style="color:maroon">[Weg88]</span> I. Wegener. On the Complexity of Branching Programs and Decision Trees for Clique Functions, <i>Journal of the ACM</i> 35(2):461-471, 1988. DOI:[http://doi.acm.org/10.1145/42282.46161 10.1145/42282.46161]. <span id="weh06" style="color:maroon">[Weh06]</span> S. Wehner. Entanglement in interactive proof systems with binary answers. In <i>Proceedings of the 23rd Annual Symposium on Theoretical Aspects of Computer Science</i>, volume 3884 of <i>Lecture Notes in Computer Science</i>, pages 162–171. Springer, 2006 <span id="wig06" style="color:maroon">[Wig06]</span> A. Wigderson P, NP, and mathematics--a computational complexity perspective, 2006 mimeo. [www.math.ias.edu/~avi/PUBLICATIONS/MYPAPERS/W06/W06.pdf]. <span id="wil85" style="color:maroon">[Wil85]</span> C. Wilson. Relativized circuit complexity, <i>Journal of Computer and System Sciences</i> 31:169-181, 1985. <span id="wil11" style="color:maroon">[Wil11]</span> R. Williams. Non-uniform ACC circuit lower bounds. <i>To appear in IEEE Conference on Computational Complexity</i> 2011. <span id="wol94" style="color: maroon;">[Wol94]</span> Marty J. Wolf. Nondeterministic circuits, space complexity and quasigroups. <i>Theoretical Computer Science</i> 125:295–313, 1994. ===== Y ===== {{Reference |tag=Yap83 |authors=C. Yap |title=Some consequences of non-uniform conditions on uniform classes |journal=Theoretical Computer Science |srcdetail=(1983), 26, 287-300 }} <span id="yam99" style="color:maroon">[Yam99]</span> T. Yamakami. Polynomial time samplable distributions, J. Complexity 15 (1999), no. 4, 557--574. ECCC [http://eccc.hpi-web.de/eccc-reports/1995/TR95-039/ TR95-039]. <span id="yan81" style="color:maroon">[Yan81]</span> M. Yannakakis. Algorithms for acyclic database schemas, <i>Proceedings of VLDB</i> (Very Large Databases), 1981. <span id="yao85" style="color:maroon">[Yao85]</span> A. C.-C. Yao. Separating the polynomial hierarchy by oracles, <i>Proceedings of IEEE FOCS'85</i>, pp. 1-10, 1985. <span id="yao89" style="color:maroon">[Yao89]</span> A. C.-C. Yao. Circuits and local computation, <i>Proceedings of ACM STOC'89</i>, pp. 186-196, 1989. <span id="yao90" style="color:maroon">[Yao90]</span> A. C.-C. Yao. On ACC and threshold circuits, <i>Proceedings of IEEE FOCS'90</i>, pp. 619-627, 1990. <span id="yao90b" style="color:maroon">[Yao90b]</span> A. C.-C. Yao. Coherent functions and program checkers, <i>Proceedings of ACM STOC'90</i>, 1990. <span id="yao93" style="color:maroon">[Yao93]</span> A. C.-C. Yao. Quantum circuit complexity, <i>Proceedings of IEEE FOCS'93</i>, pp. 352-361, 1993. <span id="yes83" style="color:maroon">[Yes83]</span> Y. Yesha. On certain polynomial-time truth-table reducibilities of complete sets to sparse sets, <i>SIAM Journal on Computing</i>, 12(3):411-425, 1983. DOI:[http://dx.doi.org/10.1137/0212027 10.1137/0212027] ===== Z ===== <span id="zac88" style="color:maroon">[Zac88]</span> S. Zachos. Probabilistic quantifiers and games, <i>Journal of Computer and System Sciences</i> 36(3):433-451, 1988. <span id="zh86" style="color:maroon">[ZH86]</span> S. Zachos and H. Heller. A decisive characterization of BPP. ''Information and Control'', 69(1&ndash;3):125&ndash;135, 1986. <span id="zuc91" style="color:maroon">[Zuc91]</span> D. Zuckerman. Simulating BPP using a general weak random source, <i>Algorithmica</i> 16 (1996), no. 4-5, 367--391 [http://www.cs.utexas.edu/users/diz/pubs/bpp.ps http://www.cs.utexas.edu/users/diz/pubs/bpp.ps]. [[Category:Computational Complexity]] Complexity Zoo2 3297 12672 2010-04-17T18:12:14Z Eric Ringger 2103 /* LOGNP: Logarithmically-Restricted NP */ __NOTOC__ ==Introduction== Welcome to the '''Complexity Zoo'''... There are now 462 classes and counting! [[Image:zoo.gif|thumb|right|200px|what's your problem?]] This information was originally moved from http://www.complexityzoo.com/ in August 2005, and is currently under the watchful eyes of its original creators: '''Zookeeper''': [[Scott Aaronson]]<br> '''Veterinarian''': [[Greg Kuperberg]]<br> Errors? Omissions? Misattributions? Your favorite class not here? Then please contribute to the zoo as you see fit by [[sign_up_instructions | signing up]] and clicking on the edit links. Please include references, or better yet links to papers if available. To create a new class, click on the edit link of the class before or after the one that you want to add and copy the format of that class. (The classes are alphabetized by their tag names.) Then add the class to the table of contents and increment the total number of classes. After this, you can use the side edit links to edit the individual sections. For more on using the wiki language, see our [[Simple_wiki_help | simple wiki help page]]. If you would like to contribute but feel unable to make the updates yourself, email the zookeeper at scott at scottaaronson dot com. ==See Also== *[[Zoo Intro|Introductory Essay]] *[[Zoo Glossary|Glossary]] *[[Zoo Pronunciation|Pronunciation Guide]] *[[Zoo References|References]] *[[Zoo Exhibit|Special Zoo Exhibit]] *[[Zoo Acknowledgments|Acknowledgments]] *<span style="color:red">**New**</span> [http://www.math.ucdavis.edu/~greg/zoology/intro.html Complexity Zoology], a computer-assisted survey, with [http://www.math.ucdavis.edu/~greg/zoology/diagram.xml active] and [http://www.math.ucdavis.edu/~greg/zoology/diagram.pdf static] inclusion diagrams. (Longtime Zoo watchers may recall Chris Bourke's LaTeX version of the Zoo and Chad Brewbaker's graphical inclusion diagram. These references are obsolete until further notice.) ==Table of Contents== '''<font color="red">&#8709;:</font>''' [[#01npc|0-1-NP<sub>C</sub>]] - [[#1nauxpdap|1NAuxPDA<sup>p</sup>]] - [[#sharpac0|#AC<sup>0</sup>]] - [[#sharpl|#L]] - [[#sharplpoly|#L/poly]] - [[#sharpga|#GA]] - [[#sharpp|#P]] - [[#sharpwt|#W[t]]] - [[#parityexp|&#8853;EXP]] - [[#parityl|&#8853;L]] - [[#paritylpoly|&#8853;L/poly]] - [[#parityp|&#8853;P]] - [[#paritysac0|&#8853;SAC<sup>0</sup>]] - [[#paritysac1|&#8853;SAC<sup>1</sup>]] '''<font color="red">A:</font>''' [[#a0pp|A<sub>0</sub>PP]] - [[#ac|AC]] - [[#ac0|AC<sup>0</sup>]] - [[#ac0m|AC<sup>0</sup>[m]]] - [[#ac1|AC<sup>1</sup>]] - [[#acc0|ACC<sup>0</sup>]] - [[#ah|AH]] - [[#al|AL]] - [[#all|ALL]] - [[#algppoly|AlgP/poly]] - [[#almostnp|Almost-NP]] - [[#almostp|Almost-P]] - [[#almostpspace|Almost-PSPACE]] - [[#am|AM]] - [[#amexp|AM<sub>EXP</sub>]] - [[#amicoam|AM &#8745; coAM]] - [[#ampolylog|AM[polylog]]] - [[#ampmp|AmpMP]] - [[#amppbqp|AmpP-BQP]] - [[#ap|AP]] - [[#app|APP]] - [[#apx|APX]] - [[#aucspace|AUC-SPACE(f(n))]] - [[#auxpda|AuxPDA]] - [[#avbpp|AVBPP]] - [[#avge|AvgE]] - [[#avgp|AvgP]] - [[#awp|AW[P]]] - [[#awpp|AWPP]] - [[#awsat|AW[SAT]]] - [[#awstar|AW[*]]] - [[#awt|AW[t]]] - [[#axp|AxP]] - [[#axpp|AxPP]] '''<font color="red">B:</font>''' [[#betap|&beta;P]] - [[#bh|BH]] - [[#bpdp|BP<sub>d</sub>(P)]] - [[#bpe|BPE]] - [[#bpee|BPEE]] - [[#bphspace|BP<sub>H</sub>SPACE(f(n))]] - [[#bpl|BPL]] - [[#bpnp|BP&#149;NP]] - [[#bpp|BPP]] - [[#bppcc|BPP<sup>cc</sup>]] - [[#bppkt|BPP<sup>KT</sup>]] - [[#bpplog|BPP/log]] - [[#bppmlog|BPP/mlog]] - [[#bppsslog|BPP//log]] - [[#bpprlog|BPP/rlog]] - [[#bppobdd|BPP-OBDD]] - [[#bpppath|BPP<sub>path</sub>]] - [[#bpqp|BPQP]] - [[#bpspace|BPSPACE(f(n))]] - [[#bptime|BPTIME(f(n))]] - [[#bqnc|BQNC]] - [[#bqnp|BQNP]] - [[#bqp|BQP]] - [[#bqplog|BQP/log]] - [[#bqppoly|BQP/poly]] - [[#bqpmlog|BQP/mlog]] - [[#bqpmpoly|BQP/mpoly]] - [[#bqpqlog|BQP/qlog]] - [[#bqpqpoly|BQP/qpoly]] - [[#bqpobdd|BQP-OBDD]] - [[#bqpspace|BQPSPACE]] - [[#bqpttpoly|BQP<sub>tt</sub>/poly]] - [[#bqtime|BQTIME(f(n))]] - [[#bwbp|k-BWBP]] '''<font color="red">C:</font>''' [[#cequalsac0|C<sub>=</sub>AC<sup>0</sup>]] - [[#cequalsl|C<sub>=</sub>L]] - [[#cequalsp|C<sub>=</sub>P]] - [[#cfl|CFL]] - [[#clog|CLOG]] - [[#ch|CH]] - [[#check|Check]] - [[#clsharpp|CL#P]] - [[#ckp|C<sub>k</sub>P]] - [[#cnp|CNP]] - [[#coam|coAM]] - [[#cocequalsp|coC<sub>=</sub>P]] - [[#cofrip|cofrIP]] - [[#coh|Coh]] - [[#coma|coMA]] - [[#comodkp|coMod<sub>k</sub>P]] - [[#compip|compIP]] - [[#compnp|compNP]] - [[#cone|coNE]] - [[#conexp|coNEXP]] - [[#conl|coNL]] - [[#conp|coNP]] - [[#conpcc|coNP<sup>cc</sup>]] - [[#conppoly|coNP/poly]] - [[#conqp|coNQP]] - [[#core|coRE]] - [[#cornc|coRNC]] - [[#corp|coRP]] - [[#cosl|coSL]] - [[#cosparse|coSPARSE]] - [[#coucc|coUCC]] - [[#coup|coUP]] - [[#cp|CP]] - [[#csize|CSIZE(f(n))]] - [[#csl|CSL]] - [[#czk|CZK]] '''<font color="red">D:</font>''' [[#dsharpp|D#P]] - [[#dcfl|DCFL]] - [[#delta2p|&#916;<sub>2</sub>P]] - [[#deltabpp|&#948;-BPP]] - [[#deltarp|&#948;-RP]] - [[#det|DET]] - [[#diffac0|DiffAC<sup>0</sup>]] - [[#disnp|DisNP]] - [[#distnp|DistNP]] - [[#dp|DP]] - [[#dqp|DQP]] - [[#dspace|DSPACE(f(n))]] - [[#dtime|DTIME(f(n))]] - [[#dtisp|DTISP(t(n),s(n))]] - [[#dynfo|Dyn-FO]] - [[#dynthc0|Dyn-ThC<sup>0</sup>]] '''<font color="red">E:</font>''' [[#e|E]] - [[#ee|EE]] - [[#eee|EEE]] - [[#eespace|EESPACE]] - [[#eexp|EEXP]] - [[#eh|EH]] - [[#elementary|ELEMENTARY]] - [[#elkp|EL<sub>k</sub>P]] - [[#ep|EP]] - [[#eptas|EPTAS]] - [[#eqbp|k-EQBP]] - [[#eqp|EQP]] - [[#eqpk|EQP<sub>K</sub>]] - [[#eqtime|EQTIME(f(n))]] - [[#espace|ESPACE]] - [[#existsbpp|&#8707;BPP]] - [[#existsniszk|&#8707;NISZK]] - [[#exp|EXP]] - [[#exppoly|EXP/poly]] - [[#expspace|EXPSPACE]] '''<font color="red">F:</font>''' [[#fbqp|FBQP]] - [[#few|Few]] - [[#fewp|FewP]] - [[#fh|FH]] - [[#fnl|FNL]] - [[#fnlpoly|FNL/poly]] - [[#fnp|FNP]] - [[#fo|FO(t(n))]] - [[#foll|FOLL]] - [[#fp|FP]] - [[#fpnplog|FP<sup>NP[log]</sup>]] - [[#fpr|FPR]] - [[#fpras|FPRAS]] - [[#fpt|FPT]] - [[#fptnu|FPT<sub>nu</sub>]] - [[#fptsu|FPT<sub>su</sub>]] - [[#fptas|FPTAS]] - [[#fqma|FQMA]] - [[#frip|frIP]] - [[#ftape|F-TAPE(f(n))]] - [[#ftime|F-TIME(f(n))]] '''<font color="red">G:</font>''' [[#ga|GA]] - [[#ganspace|GAN-SPACE(f(n))]] - [[#gapac0|GapAC<sup>0</sup>]] - [[#gapl|GapL]] - [[#gapp|GapP]] - [[#gc|GC(s(n),C)]] - [[#gcsl|GCSL]] - [[#gi|GI]] - [[#glo|GLO]] - [[#gpcd|GPCD(r(n),q(n))]] - [[#gt|G[t]]] '''<font color="red">H:</font>''' [[#halfp|HalfP]] - [[#heurbpp|HeurBPP]] - [[#heurbptime|HeurBPTIME(f(n))]] - [[#hkp|H<sub>k</sub>P]] - [[#hvszk|HVSZK]] '''<font color="red">I:</font>''' [[#iclogpoly|IC[log,poly]]] - [[#ip|IP]] - [[#ipp|IPP]] - [[#ippolylog|IP[polylog]]] '''<font color="red">L:</font>''' [[#l|L]] - [[#lin|LIN]] - [[#lkp|L<sub>k</sub>P]] - [[#logcfl|LOGCFL]] - [[#logfew|LogFew]] - [[#logfewnl|LogFewNL]] - [[#lognp|LOGNP]] - [[#logsnp|LOGSNP]] - [[#l/poly|L/poly]] - [[#lwpp|LWPP]] '''<font color="red">M:</font>''' [[#ma|MA]] - [[#maprime|MA']] - [[#mac0|MAC<sup>0</sup>]] - [[#mae|MA<sub>E</sub>]] - [[#maexp|MA<sub>EXP</sub>]] - [[#mal|mAL]] - [[#maxnp|MaxNP]] - [[#maxpb|MaxPB]] - [[#maxsnp|MaxSNP]] - [[#maxsnp0|MaxSNP<sub>0</sub>]] - [[#mconl|mcoNL]] - [[#minpb|MinPB]] - [[#mip|MIP]] - [[#mipstar21|MIP*[2,1]]] - [[#mipexp|MIP<sub>EXP</sub>]] - [[#mkp|(M<sub>k</sub>)P]] - [[#ml|mL]] - [[#mmsnp|MMSNP]] - [[#mnc1|mNC<sup>1</sup>]] - [[#mnl|mNL]] - [[#mnp|mNP]] - [[#modkl|Mod<sub>k</sub>L]] - [[#modkp|Mod<sub>k</sub>P]] - [[#modp|ModP]] - [[#modzkl|ModZ<sub>k</sub>L]] - [[#mp|mP]] - [[#mp2|MP]] - [[#mpc|MPC]] - [[#mppoly|mP/poly]] - [[#mtc0|mTC<sup>0</sup>]] '''<font color="red">N:</font>''' [[#nauxpdap|NAuxPDA<sup>p</sup>]] - [[#nc|NC]] - [[#nc0|NC<sup>0</sup>]] - [[#nc1|NC<sup>1</sup>]] - [[#nc2|NC<sup>2</sup>]] - [[#ne|NE]] - [[#nepoly|NE/poly]] - [[#nearlyp|Nearly-P]] - [[#nee|NEE]] - [[#neee|NEEE]] - [[#neexp|NEEXP]] - [[#nexp|NEXP]] - [[#nexppoly|NEXP/poly]] - [[#niqszk|NIQSZK]] - [[#niszk|NISZK]] - [[#niszkh|NISZK<sub>h</sub>]] - [[#nl|NL]] - [[#nlpoly|NL/poly]] - [[#nlin|NLIN]] - [[#nlog|NLOG]] - [[#none|NONE]] - [[#np|NP]] - [[#npc|NPC]] - [[#npc2|NP<sub>C</sub>]] - [[#npcc|NP<sup>cc</sup>]] - [[#npi|NPI]] - [[#npiconp|NP &#8745; coNP]] - [[#npiconppoly|(NP &#8745; coNP)/poly]] - [[#nplog|NP/log]] - [[#npmv|NPMV]] - [[#npmvsel|NPMV-sel]] - [[#npmvt|NPMV<sub>t</sub>]] - [[#npmvtsel|NPMV<sub>t</sub>-sel]] - [[#npo|NPO]] - [[#npopb|NPOPB]] - [[#nppoly|NP/poly]] - [[#nppsamp|(NP,P-samplable)]] - [[#npr|NP<sub>R</sub>]] - [[#npspace|NPSPACE]] - [[#npsv|NPSV]] - [[#npsvsel|NPSV-sel]] - [[#npsvt|NPSV<sub>t</sub>]] - [[#npsvtsel|NPSV<sub>t</sub>-sel]] - [[#nqp|NQP]] - [[#nspace|NSPACE(f(n))]] - [[#nt|NT]] - [[#ntstar|NT*]] - [[#ntime|NTIME(f(n))]] '''<font color="red">O:</font>''' [[#ocq|OCQ]] - [[#optp|OptP]] '''<font color="red">P:</font>''' [[#p|P]] - [[#plog|P/log]] - [[#ppoly|P/poly]] - [[#psharpp|P<sup>#P</sup>]] - [[#psharpp1|P<sup>#P</sup>]] - [[#pac0|PAC<sup>0</sup>]] - [[#pbp|PBP]] - [[#kpbp|k-PBP]] - [[#pc|P<sub>C</sub>]] - [[#pcc|P<sup>cc</sup>]] - [[#pcd|PCD(r(n),q(n))]] - [[#pclose|P-Close]] - [[#pcp|PCP(r(n),q(n))]] - [[#permup|PermUP]] - [[#pexp|PEXP]] - [[#pf|PF]] - [[#pfchk|PFCHK(t(n))]] - [[#ph|PH]] - [[#phcc|PH<sup>cc</sup>]] - [[#phi2p|&#934;<sub>2</sub>P]] - [[#php|PhP]] - [[#pi2p|&#928;<sub>2</sub>P]] - [[#pinc|PINC]] - [[#pio|PIO]] - [[#pk|P<sup>K</sup>]] - [[#pkc|PKC]] - [[#pl|PL]] - [[#pl1|PL<sub>1</sub>]] - [[#plinfinity|PL<sub>&#8734;</sub>]] - [[#plf|PLF]] - [[#pll|PLL]] - [[#pls|PLS]] - [[#pnp|P<sup>NP</sup>]] - [[#pparnp|P<sup>&#124;&#124;NP</sup>]] - [[#pnpk|P<sup>NP[k]</sup>]] - [[#pnplog|P<sup>NP[log]</sup>]] - [[#pnplog2|P<sup>NP[log^2]</sup>]] - [[#pobdd|P-OBDD]] - [[#podn|PODN]] - [[#polyl|polyL]] - [[#postbqp|PostBQP]] - [[#pp|PP]] - [[#pppoly|PP/poly]] - [[#ppa|PPA]] - [[#ppad|PPAD]] - [[#ppads|PPADS]] - [[#ppp2|P<sup>PP</sup>]] - [[#ppp|PPP]] - [[#ppspace|PPSPACE]] - [[#pquery|PQUERY]] - [[#pr|PR]] - [[#pr2|P<sub>R</sub>]] - [[#prhspace|Pr<sub>H</sub>SPACE(f(n))]] - [[#promisebpp|PromiseBPP]] - [[#promisebqp|PromiseBQP]] - [[#promisep|PromiseP]] - [[#promiserp|PromiseRP]] - [[#prspace|PrSPACE(f(n))]] - [[#psel|P-Sel]] - [[#psk|PSK]] - [[#pspace|PSPACE]] - [[#pspacepoly|PSPACE/poly]] - [[#pt1|PT<sub>1</sub>]] - [[#ptape|PTAPE]] - [[#ptas|PTAS]] - [[#ptwk|PT/WK(f(n),g(n))]] - [[#pzk|PZK]] '''<font color="red">Q:</font>''' [[#q|Q]] - [[#qac0|QAC<sup>0</sup>]] - [[#qac0m|QAC<sup>0</sup>[m]]] - [[#qacc0|QACC<sup>0</sup>]] - [[#qacwf0|QAC<sub>f</sub><sup>0</sup>]] - [[#qam|QAM]] - [[#qcfl|QCFL]] - [[#qcma|QCMA]] - [[#qh|QH]] - [[#qip|QIP]] - [[#qip2|QIP]] - [[#qma|QMA]] - [[#qma-plus|QMA-plus]] - [[#qma2|QMA(2)]] - [[#qmalog|QMA<sub>log</sub>]] - [[#qmam|QMAM]] - [[#qmaqpoly|QMA/qpoly]] - [[#qmip|QMIP]] - [[#qmiple|QMIP<sub>le</sub>]] - [[#qmipne|QMIP<sub>ne</sub>]] - [[#qnc|QNC]] - [[#qnc0|QNC<sup>0</sup>]] - [[#qncf0|QNC<sub>f</sub><sup>0</sup>]] - [[#qnc1|QNC<sup>1</sup>]] - [[#qp|QP]] - [[#qplin|QPLIN]] - [[#qpspace|QPSPACE]] - [[#qrg|QRG]] - [[#qs2p|QS<sub>2</sub>P]] - [[#qszk|QSZK]] '''<font color="red">R:</font>''' [[#r|R]] - [[#rbqp|RBQP]] - [[#re|RE]] - [[#reg|REG]] - [[#revspace|RevSPACE(f(n))]] - [[#rg|RG]] - [[#rg1|RG]] - [[#rhl|R<sub>H</sub>L]] - [[#rhspace|R<sub>H</sub>SPACE(f(n))]] - [[#rl|RL]] - [[#rnc|RNC]] - [[#rp|RP]] - [[#rpp|RPP]] - [[#rqp|RQP]] - [[#rspace|RSPACE(f(n))]] '''<font color="red">S:</font>''' [[#s2p|S<sub>2</sub>P]] - [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]] - [[#sac|SAC]] - [[#sac0|SAC<sup>0</sup>]] - [[#sac1|SAC<sup>1</sup>]] - [[#saptime|SAPTIME]] - [[#sbp|SBP]] - [[#sc|SC]] - [[#se|SE]] - [[#seh|SEH]] - [[#selfnp|SelfNP]] - [[#sfk|SF<sub>k</sub>]] - [[#sigma2p|&#931;<sub>2</sub>P]] - [[#skc|SKC]] - [[#sl|SL]] - [[#slicewisepspace|SLICEWISE PSPACE]] - [[#snp|SNP]] - [[#soe|SO-E]] - [[#sp|SP]] - [[#spanp|span-P]] - [[#sparse|SPARSE]] - [[#spl|SPL]] - [[#spp|SPP]] - [[#sqg|SQG]] - [[#subexp|SUBEXP]] - [[#symp|symP]] - [[#szk|SZK]] - [[#szkh|SZK<sub>h</sub>]] '''<font color="red">T:</font>''' [[#tally|TALLY]] - [[#tc0|TC<sup>0</sup>]] - [[#tfnp|TFNP]] - [[#theta2p|&Theta;<sub>2</sub>P]] - [[#treebqp|TreeBQP]] - [[#treeregular|TREE-REGULAR]] '''<font color="red">U:</font>''' [[#uap|UAP]] - [[#ucc|UCC]] - [[#ue|UE]] - [[#ul|UL]] - [[#ulpoly|UL/poly]] - [[#up|UP]] - [[#us|US]] '''<font color="red">V:</font>''' [[#vnc|VNC<sub>k</sub>]] - [[#vnp|VNP<sub>k</sub>]] - [[#vp|VP<sub>k</sub>]] - [[#vqp|VQP<sub>k</sub>]] '''<font color="red">W:</font>''' [[#w1|W]] - [[#wapp|WAPP]] - [[#wp|W[P]]] - [[#wpp|WPP]] - [[#wsat|W[SAT]]] - [[#wstar|W[*]]] - [[#wt|W[t]]] - [[#wstart|W<sup>*</sup>[t]]] '''<font color="red">X:</font>''' [[#xormipstar21|XOR-MIP*[2,1]]] - [[#xp|XP]] - [[#xpuniform|XP<sub>uniform</sub>]] '''<font color="red">Y:</font>''' [[#yacc|YACC]] - [[#yp|YP]] - [[#ypp|YPP]] - [[#yqp|YQP]] '''<font color="red">Z:</font>''' [[#zbqp|ZBQP]] - [[#zpe|ZPE]] - [[#zpp|ZPP]] - [[#zptime|ZPTIME(f(n))]] - [[#zqp|ZQP]] ==The Classes== '''<font color="red">Warning:</font>''' Please do not feed oracles to the complexity classes! These classes require a specially balanced diet to ensure proper relativization. ---- ===== <span id="01npc" style="color:red">0-1-NP<sub>C</sub></span>: Binary Restriction of [[#np|NP]] Over The Complex Numbers ===== The intersection of [[#npc2|NP<sub>C</sub>]] with {0,1}<sup>*</sup> (i.e. the set of binary strings). Contains [[#np|NP]]. Is contained in [[#pspace|PSPACE]], and in [[#am|AM]] assuming the Extended Riemann Hypothesis [[zooref#koi96|[Koi96]]]. ---- ===== <span id="1nauxpdap" style="color:red">1NAuxPDA<sup>p</sup></span>: One-Way [[#nauxpdap|NAuxPDA<sup>p</sup>]] ===== Defined in [[zooref#bra77|[Bra77]]], where it was also shown that 1NAuxPDA<sup>p</sup> strictly contains [[#cfl|CFL]] and is strictly contained in [[#logcfl|LOGCFL]]. The class corresponds to the closure of [[#cfl|CFL]] under one-way log-space reductions. ---- ===== <span id="sharpac0" style="color:red">#AC<sup>0</sup></span>: Sharp-[[#ac0|AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to nonnegative integers computed by polynomial-size constant-depth arithmetic circuits, using addition and multiplication gates and the constants 0 and 1. Contained in [[#gapac0|GapAC<sup>0</sup>]]. ---- ===== <span id="sharpga" style="color:red">#GA</span>: Graph Automorphism ===== The class of problems (Karp-)reducible to counting the number of automorphisms of a graph. Counterpart of [[#gi|GI]]. ---- ===== <span id="sharpl" style="color:red">#L</span>: Sharp-L ===== Has the same relation to [[#l|L]] as [[#sharpp|#P]] does to [[#p|P]]. &#35;L is contained in [[#det|DET]] [[zooref#aj93|[AJ93]]]. ---- ===== <span id="sharplpoly" style="color:red">#L/poly</span>: Nonuniform [[#sharpl|#L]] ===== Has the same relation to [[#sharpl|#L]] as [[#ppoly|P/poly]] does to [[#p|P]]. ---- ===== <span id="sharpp" style="color:red">#P</span>: Sharp-P ===== The class of function problems of the form "compute f(x)," where f is the number of accepting paths of an [[#np|NP]] machine. The canonical #P-complete problem is #SAT: given a Boolean formula, compute how many satisfying assignments it has. Defined in [[zooref#val79|[Val79]]], where it was also shown that the problem of counting the number of perfect matchings in a bipartite graph (or equivalently, computing the permanent of a 0-1 matrix) is #P-complete. What makes that interesting is that the associated decision problem (whether a bipartite graph <i>has</i> a perfect matching) is in [[#p|P]]. [[#ph|PH]] is in [[#psharpp|P<sup>#P</sup>]] [[zooref#tod89|[Tod89]]]. Any function in #P can be approximated to within a polynomial factor in [[#bpp|BPP]] with [[#np|NP]] oracle [[zooref#sto85|[Sto85]]]. ---- ===== <span id="sharpwt" style="color:red">#W[t]</span>: Sharp-[[#wt|W[t]]] ===== Roughly, the analogue of [[#sharpp|#P]] for parameterized complexity. I.e. the class of parameterized counting problems that are fixed-parameter parsimonious reducible to the following problem: <ul> '''#WSAT:''' Given a Boolean formula, count the number of satisfying assignments of Hamming weight k (where k is the parameter). </ul> Defined in [[zooref#fg02|[FG02]]], which should be consulted for the full definition. [[zooref#fg02|[FG02]]] also showed that there exist #W-complete problems whose corresponding decision problems are fixed-parameter tractable (i.e. in [[#fpt|FPT]]). ---- ===== <span id="parityexp" style="color:red">&#8853;EXP</span>: Parity [[#exp|EXP]] ===== The exponential-time analogue of [[#parityp|&#8853;P]]. There exists an oracle relative to which &#8853;EXP = [[#zpp|ZPP]] [[zooref#bbf98|[BBF98]]]. ---- ===== <span id="parityl" style="color:red">&#8853;L</span>: Parity [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#parityp|&#8853;P]] does to [[#p|P]]. Contains [[#sl|SL]] [[zooref#kw93|[KW93]]]. Solving a linear system over Z<sub>2</sub> is complete for &#8853;L [[zooref#dam90|[Dam90]]]. &#8853;L<sup>&#8853;L</sup> = &#8853;L [[zooref#hrv00|[HRV00]]]. ---- ===== <span id="paritylpoly" style="color:red">&#8853;L/poly</span>: Nonuniform [[#parityl|&#8853;L]] ===== Has the same relation to [[#parityl|&#8853;L]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contains [[#nl/poly|NL/poly]] [[zooref#gw96|[GW96]]]. ---- ===== <span id="parityp" style="color:red">&#8853;P</span>: Parity [[#p|P]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' then the number of accepting paths is odd.</li> <li>If the answer is 'no,' then the number of accepting paths is even.</li> </ol> Defined in [[zooref#pz83|[PZ83]]]. Contains graph isomorphism; indeed, graph isomorphism is low for &#8853;P [[zooref#ak02|[AK02]]]. Contains [[#fewp|FewP]] [[zooref#ch89|[CH89]]]. There exists an oracle relative to which [[#p|P]] = &#8853;P but [[#p|P]] is not equal to [[#np|NP]] (and indeed [[#np|NP]] = [[#exp|EXP]]) [[zooref#bbf98|[BBF98]]]. Equals [[#modkp|Mod<sub>2^m</sub>P]] for every positive integer m. ---- ===== <span id="paritysac0" style="color:red">&#8853;SAC<sup>0</sup></span>: [[#ac0|AC<sup>0</sup>]] With Unbounded Parity Gates ===== ---- ===== <span id="paritysac1" style="color:red">&#8853;SAC<sup>1</sup></span>: [[#ac1|AC<sup>1</sup>]] With Unbounded Parity Gates ===== The class of problems solvable by a nonuniform family of polynomial-size, polylog-depth circuits with unbounded-fanin XOR and bounded-fanin AND gates. Defined in [[zooref#gw96|[GW96]]], where it was also shown that &#8853;SAC<sup>1</sup> contains [[#sac1|SAC<sup>1</sup>]]. ---- ===== <span id="a0pp" style="color:red">A<sub>0</sub>PP</span>: One-Sided Analog of [[#awpp|AWPP]] ===== Same as [[#sbp|SBP]], except that f is a [[#gapp|GapP]] rather than [[#sharpp|#P]] function. Defined in [[zooref#vya03|[Vya03]]], where the following was also shown: <ul> <li>A<sub>0</sub>PP contains [[#qma|QMA]], [[#awpp|AWPP]], and [[#cocequalsp|coC<sub>=</sub>P]].</li> <li>A<sub>0</sub>PP is contained in [[#pp|PP]].</li> <li>If A<sub>0</sub>PP = [[#pp|PP]] then [[#ph|PH]] is contained in [[#pp|PP]].</li> </ul> ---- ===== <span id="ac" style="color:red">AC</span>: Unbounded Fanin Polylogarithmic-Depth Circuits ===== AC<sup>i</sup> is the class of decision problems solvable by a nonuniform family of Boolean circuits, with polynomial size, depth O(log<sup>i</sup>(n)), and unbounded fanin. The gates allowed are AND, OR, and NOT. Then AC is the union of AC<sup>i</sup> over all nonnegative i. AC<sup>i</sup> is contained in [[#nc|NC]]<sup>i+1</sup>; thus, AC = [[#nc|NC]]. Contains [[#nl|NL]]. For a random oracle A, (AC<sup>i</sup>)<sup>A</sup> is strictly contained in (AC<sup>i+1</sup>)<sup>A</sup>, and (uniform) AC<sup>A</sup> is strictly contained in P<sup>A</sup>, with probability 1 [[zooref#mil92|[Mil92]]]. ---- ===== <span id="ac0" style="color:red">AC<sup>0</sup></span>: Unbounded Fanin Constant-Depth Circuits ===== An especially important subclass of [[#ac|AC]], corresponding to constant-depth, unbounded-fanin, polynomial-size circuits with AND, OR, and NOT gates. Computing the parity or majority of n bits is not in AC<sup>0</sup> [[zooref#fss84|[FSS84]]]. There are functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in AC<sup>0</sup> [[zooref#nw94|[NW94]]]. But there are no functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in [[#qp|QP]] (quasipolynomial time) [[zooref#lmn93|[LMN93]]]. [[zooref#lmn93|[LMN93]]] showed furthermore that functions with AC<sup>0</sup> circuits of depth d are learnable in [[#qp|QP]], given their outputs on O(2<sup>log(n)^O(d)</sup>) randomly chosen inputs. On the other hand, this learning algorithm is essentially optimal, unless there is a 2<sup>n^o(1)</sup> algorithm for factoring [[zooref#kha93|[Kha93]]]. Although there are no good pseudorandom <i>functions</i> in AC<sup>0</sup>, [[zooref#in96|[IN96]]] showed that there are pseudorandom <i>generators</i> in AC<sup>0</sup> that stretch n bits to n+&#920;(log n), assuming the hardness of a problem based on subset sum. Work of [[zooref#aik04|[AIK04]]] shows pseudorandom generators in [[#nc0|NC<sup>0</sup>]] under more relaxed assumptions. AC<sup>0</sup> contains [[#nc0|NC<sup>0</sup>]], and is contained in [[#qac0|QAC<sup>0</sup>]] and [[#mac0|MAC<sup>0</sup>]]. In descriptive complexity, uniform AC<sup>0</sup> can be characterized as the class of problems expressible by first-order predicates with addition and multiplication operators - or indeed, with ordering and multiplication, or ordering and division (see [[zooref#lee02|[Lee02]]]). [[zooref#blm98|[BLM+98]]] showed the following problem is complete for depth-k AC<sup>0</sup> circuits (with a uniformity condition): <ul> Given a grid graph of polynomial length and width k, decide whether there is a path between vertices s and t (which can be given as part of the input). </ul> ---- ===== <span id="ac0m" style="color:red">AC<sup>0</sup>[m]</span>: [[#ac0|AC<sup>0</sup>]] With MOD m Gates ===== Same as [[#ac0|AC<sup>0</sup>]], but now "MOD m" gates (for a specific m) are allowed in addition to AND, OR, and NOT gates. (A MOD m gate outputs 0 if the sum of its inputs is congruent to 0 modulo m, and 1 otherwise.) If m is a power of a prime p, then for any prime q not equal to p, deciding whether the sum of n bits is congruent to 0 modulo q is not in AC<sup>0</sup>[m] [[zooref#raz87|[Raz87]]] [[zooref#smo87|[Smo87]]]. It follows that, for any such m, AC<sup>0</sup>[m] is strictly contained in [[#nc1|NC<sup>1</sup>]]. However, if m is a product of distinct primes (i.e. 6), then it is not even known whether AC<sup>0</sup>[m] = [[#np|NP]]! See also: [[#qac0m|QAC<sup>0</sup>[m]]]. ---- ===== <span id="ac1" style="color:red">AC<sup>1</sup></span>: Unbounded Fanin Log-Depth Circuits ===== See [[#ac|AC]]. ---- ===== <span id="acc0" style="color:red">ACC<sup>0</sup></span>: [[#ac0|AC<sup>0</sup>]] With Arbitrary MOD Gates ===== Same as [[#ac0m|AC<sup>0</sup>[m]]], but now the constant-depth circuit can contain MOD m gates for <i>any</i> m. Contained in [[#tc0|TC<sup>0</sup>]]. Indeed, can be simulated by depth-3 threshold circuits of quasipolynomial size [[zooref#yao90|[Yao90]]]. In 1996, [[zooref#all96|[All96]]] suggested the existence of cryptographically secure functions in ACC<sup>0</sup> as an important open question. In 2004, work of [[zooref#aik04|[AIK04]]] showed pseudorandom generators in [[#nc0|NC<sup>0</sup>]] based on widely-believed assumptions. Contains 4-[[#kpbp|PBP]] [[zooref#bt88|[BT88]]]. See also: [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="ah" style="color:red">AH</span>: Arithmetic Hierarchy ===== The analog of [[#ph|PH]] in computability theory. Let &#916;<sub>0</sub> = &#931;<sub>0</sub> = &#928;<sub>0</sub> = [[#r|R]]. Then for i&gt;0, let <ul> <li>&#916;<sub>i</sub> = [[#r|R]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#931;<sub>i</sub> = [[#re|RE]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#928;<sub>i</sub> = [[#core|coRE]] with &#931;<sub>i-1</sub> oracle.</li> </ul> Then AH is the union of these classes for all nonnegative constant i. Each level of AH strictly contains the levels below it. ---- ===== <span id="al" style="color:red">AL</span>: Alternating [[#l|L]] ===== Same as [[#ap|AP]], but for logarithmic-space instead of polynomial-time. AL = [[#p|P]] [[zooref#cks81|[CKS81]]]. ---- ===== <span id="all" style="color:red">ALL</span>: The Class of All Languages ===== Literally, the class of ALL languages. ALL is a gargantuan beast that's been wreaking havoc in the Zoo of late. First [[zooref#aar04b|[Aar04b]]] observed that [[#pp|PP]]/rpoly ([[#pp|PP]] with polynomial-size randomized advice) equals ALL, as does [[#postbqp|PostBQP]]/qpoly ([[#postbqp|PostBQP]] with polynomial-size quantum advice). Then [[zooref#raz05|[Raz05]]] showed that [[#qip|QIP]]/qpoly, and even [[#ip|IP]](2)/rpoly, equal ALL. Nor is it hard to show that [[#maexp|MA<sub>EXP</sub>]]/rpoly = ALL. On the other hand, even though [[#pspace|PSPACE]] contains [[#pp|PP]], and [[#expspace|EXPSPACE]] contains [[#maexp|MA<sub>EXP</sub>]], it's easy to see that [[#pspace|PSPACE]]/rpoly = [[#pspace|PSPACE]]/poly and [[#expspace|EXPSPACE]]/rpoly = [[#expspace|EXPSPACE]]/poly are not ALL. So does ALL have no respect for complexity class inclusions at ALL? (Sorry.) It is not as contradictory as it first seems. The deterministic base class in all of these examples is modified by computational non-determinism ''after'' it is modified by advice. For example, [[#maexp|MA<sub>EXP</sub>]]/rpoly means M(A<sub>EXP</sub>/rpoly), while ([[#maexp|MA<sub>EXP</sub>]])/rpoly equals [[#maexp|MA<sub>EXP</sub>]]/poly by a standard argument. In other words, it's only the verifier, not the prover or post-selector, who receives the randomized or quantum advice. The prover knows a description of the advice state, but not its measured values. Modification by /rpoly does preserve class inclusions when it is applied after other changes. ---- ===== <span id="algppoly" style="color:red">AlgP/poly</span>: Polynomial-Size Algebraic Circuits ===== The class of multivariate polynomials over the integers that can be evaluated using a polynomial (in the input size n) number of additions, subtractions, and multiplications, together with the constants -1 and 1. The class is nonuniform, in the sense that the polynomial for each input size n can be completely different. Named in [[zooref#imp02|[Imp02]]], though it has been considered since the 1970's. If [[#p|P]] = [[#bpp|BPP]] (or even [[#bpp|BPP]] is contained in [[#ne|NE]]), then either [[#nexp|NEXP]] is not in [[#ppoly|P/poly]], or else the permanent polynomial of a matrix is not in AlgP/poly [[zooref#ki02|[KI02]]]. ---- ===== <span id="almostnp" style="color:red">Almost-[[#np|NP]]</span>: Languages Almost Surely in [[#np|NP]]<sup>A</sup> ===== The class of problems that are in [[#np|NP]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[#am|AM]] [[zooref#nw94|[NW94]]]. ---- ===== <span id="almostp" style="color:red">Almost-[[#p|P]]</span>: Languages Almost Surely in [[#p|P]]<sup>A</sup> ===== The class of problems that are in [[#p|P]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[#bpp|BPP]] [[zooref#bg81|[BG81]]]. ---- ===== <span id="almostpspace" style="color:red">Almost-[[#pspace|PSPACE]]</span>: Languages Almost Surely in [[#pspace|PSPACE]]<sup>A</sup> ===== The class of problems that are in [[#pspace|PSPACE]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Almost-PSPACE is not known to equal [[#pspace|PSPACE]] -- rather surprisingly, given the fact that [[#pspace|PSPACE]] equals BPPSPACE and even [[#ppspace|PPSPACE]]. What's known is that Almost-PSPACE = BP<sup>exp</sup>&#149;[[#pspace|PSPACE]], where BP<sup>exp</sup>&#149; is like the BP&#149; operator but with exponentially-long strings [[zooref#bvw98|[BVW98]]]. It follows that Almost-PSPACE is contained in [[#nexp|NEXP]]<sup>[[#np|NP]]</sup> &#8745; [[#conexp|coNEXP]]<sup>[[#np|NP]]</sup>. Whereas both BP<sup>exp</sup>&#149;[[#pspace|PSPACE]] and BPPSPACE machines are allowed exponentially many random bits, the former has a reusable record of all of these bits on a witness tape, while the latter can only preserve a fraction of them on the work tape. ---- ===== <span id="am" style="color:red">AM</span>: Arthur-Merlin ===== The class of decision problems for which a "yes" answer can be verified by an <i>Arthur-Merlin protocol</i>, as follows. Arthur, a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier, generates a "challenge" based on the input, and sends it together with his random coins to Merlin. Merlin sends back a response, and then Arthur decides whether to accept. Given an algorithm for Arthur, we require that <ol> <li>If the answer is "yes," then Merlin can act in such a way that Arthur accepts with probability at least 2/3 (over the choice of Arthur's random bits).</li> <li>If the answer is "no," then however Merlin acts, Arthur will reject with probability at least 2/3.</li> </ol> Surprisingly, it turns out that such a system is just as powerful as a <i>private-coin</i> one, in which Arthur does not need to send his random coins to Merlin [[zooref#gs86|[GS86]]]. So, Arthur never needs to hide information from Merlin. Furthermore, define AM[k] similarly to AM, except that Arthur and Merlin have k rounds of interaction. Then for all constant k&gt;2, AM[k] = AM = AM [[zooref#bm88|[BM88]]]. Also, the result of [[zooref#gs86|[GS86]]] can then be stated as follows: [[#ip|IP]][k] is contained in AM[k+2] for every k (constant or non-constant). AM contains graph nonisomorphism. Contains [[#np|NP]], [[#bpp|BPP]], and [[#szk|SZK]], and is contained in [[#pi2p|&#928;<sub>2</sub>P]] and [[#nppoly|NP/poly]]. If AM contains [[#conp|coNP]] then [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]] [[zooref#bhz87|[BHZ87]]]. There exists an oracle relative to which AM is not contained in [[#pp|PP]] [[zooref#ver92|[Ver92]]]. AM = [[#np|NP]] under a strong derandomization assumption: namely that some language in [[#ne|NE]] &#8745; [[#cone|coNE]] requires nondeterministic circuits of size 2<sup>&#937;(n)</sup> ([[zooref#mv99|[MV99]]], improving [[zooref#km99|[KM99]]]). (A nondeterministic circuit C has two inputs, x and y, and accepts on x if there exists a y such that C(x,y)=1.) ---- ===== <span id="amexp" style="color:red">AM<sub>EXP</sub></span>: Exponential-Time [[#am|AM]] ===== Same as [[#am|AM]], except that Arthur is exponential-time and can exchange exponentially long messages with Merlin. Contains [[#maexp|MA<sub>EXP</sub>]], and is contained in [[#eh|EH]] and indeed [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. If [[#conp|coNP]] is contained in [[#ampolylog|AM[polylog]]] then [[#eh|EH]] collapses to AM<sub>EXP</sub> [[zooref#pv04|[PV04]]]. ---- ===== <span id="amicoam" style="color:red">AM &#8745; coAM</span> ===== The class of decision problems for which both "yes" and "no" answers can be verified by an [[#am|AM]] protocol. If [[#exp|EXP]] requires exponential time even for [[#am|AM]] protocols, then AM &#8745; coAM = [[#npiconp|NP &#8745; coNP]] [[zooref#gst03|[GST03]]]. There exists an oracle relative to which AM &#8745; coAM is not contained in [[#pp|PP]] [[zooref#ver95|[Ver95]]]. ---- ===== <span id="ampolylog" style="color:red">AM[polylog]</span>: [[#am|AM]] With Polylog Rounds ===== Same as [[#am|AM]], except that we allow polylog(n) rounds of interaction between Arthur and Merlin instead of a constant number. Not much is known about AM[polylog] -- for example, whether it sits in [[#ph|PH]]. However, [[zooref#ss04|[SS04]]] show that if AM[polylog] contains [[#conp|coNP]], then [[#eh|EH]] collapses to [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. ([[zooref#pv04|[PV04]]] improved the collapse to [[#amexp|AM<sub>EXP</sub>]].) ---- ===== <span id="ampmp" style="color:red">AmpMP</span>: Amplifiable [[#mp2|MP]] ===== The class of decision problems such that for some [[#sharpp|#P]] function f(x,0<sup>m</sup>), <ol> <li>The answer on input x is 'yes' if and only if the middle bit of f(x) is 1.</li> <li>The m bits of f(x) to the left and right of the middle bit are all 0.</li> </ol> Defined in [[zooref#gkr95|[GKR+95]]]. Contains [[#ph|PH]] and Contained in [[#mp2|MP]]. ---- ===== <span id="amppbqp" style="color:red">AmpP-BQP</span>: [[#bqp|BQP]] Restricted To [[Zoo_Exhibit#ampp|AmpP]] States ===== Similar to [[#treebqp|TreeBQP]] except that the quantum computer's state at each time step is restricted to being exponentially close to a state in [[Zoo_Exhibit#ampp|AmpP]] (that is, a state for which the amplitudes are computable by a classical polynomial-size circuit). Defined in [[zooref#aar03b|[Aar03b]]], where it was also observed that AmpP-BQP is contained in the third level of [[#ph|PH]], just as [[#treebqp|TreeBQP]] is. ---- ===== <span id="ap" style="color:red">AP</span>: Alternating [[#p|P]] ===== An <i>alternating Turing machine</i> is a nondeterministic machine with two kinds of states, AND states and OR states. It accepts if and only if the tree of all computation paths, considered as an AND-OR tree, evaluates to 1. (Here 'Accept' corresponds to 1 and 'Reject' to 0.) Then AP is the class of decision problems solvable in polynomial time by an alternating Turing machine. AP = [[#pspace|PSPACE]] [[zooref#cks81|[CKS81]]]. The abbreviation AP is also used for Approximable in Polynomial Time, see [[#axp|AxP]]. ---- ===== <span id="app" style="color:red">APP</span>: Amplified [[#pp|PP]] ===== Roughly, the class of decision problems for which the following holds. For all polynomials p(n), there exist [[#gapp|GapP]] functions f and g such that for all inputs x with n=|x|, <ol> <li>If the answer is "yes" then 1 &gt; f(x)/g(1<sup>n</sup>) &gt; 1-2<sup>-p(n)</sup>.</li> <li>If the answer is "no" then 0 &lt; f(x)/g(1<sup>n</sup>) &lt; 2<sup>-p(n)</sup>.</li> </ol> Defined in [[zooref#li93|[Li93]]], where the following was also shown: <ul> <li>APP is contained in [[#pp|PP]], and indeed is low for [[#pp|PP]].</li> <li>APP is closed under intersection, union, and complement.</li> </ul> APP contains [[#awpp|AWPP]] [[zooref#fen02|[Fen02]]]. The abbreviation APP is also used for Approximable in Probabilistic Polynomial Time, see [[#axpp|AxPP]]. ---- ===== <span id="apx" style="color:red">APX</span>: Approximable ===== The subclass of [[#npo|NPO]] problems that admit constant-factor approximation algorithms. (I.e., there is a polynomial-time algorithm that is guaranteed to find a solution within a constant factor of the optimum cost.) Contains [[#ptas|PTAS]]. Equals the closure of [[#maxsnp|MaxSNP]] and of [[#maxnp|MaxNP]] under [[#ptas|PTAS]] reduction [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. Defined in [[zooref#acg99|[ACG+99]]]. ---- ===== <span id="aucspace" style="color:red">AUC-SPACE(f(n))</span>: Randomized Alternating f(n)-Space ===== The class of problems decidable by an O(f(n))-space Turing machine with three kinds of quantifiers: existential, universal, and randomized. Contains [[#ganspace|GAN-SPACE(f(n))]]. AUC-SPACE(poly(n)) = [[#saptime|SAPTIME]] = [[#pspace|PSPACE]] [[zooref#pap83|[Pap83]]]. [[zooref#con92|[Con92]]] shows that AUC-SPACE(log n) has a natural complete problem, and is contained in [[#npiconp|NP &#8745; coNP]]. ---- ===== <span id="auxpda" style="color:red">AuxPDA</span>: Auxiliary Pushdown Automata ===== Equivalent to [[#nauxpdap|NAuxPDA<sup>p</sup>]] without the running-time restriction. Equals [[#p|P]] [[zooref#coo71b|[Coo71b]]]. ---- ===== <span id="avbpp" style="color:red">AVBPP</span>: Average-Case [[#bpp|BPP]] ===== Defined in [[zooref#ow93|[OW93]]] to be the class of decision problems that have a good average-case [[#bpp|BPP]] algorithm, whenever the input is chosen from an efficiently samplable distribution. Note that this is <i>not</i> the same as the [[#bpp|BPP]] version of [[#avgp|AvgP]]. ---- ===== <span id="avge" style="color:red">AvgE</span>: Average Exponential-Time With Linear Exponent ===== Has the same relation to [[#e|E]] as [[#avgp|AvgP]] does to [[#p|P]]. ---- ===== <span id="avgp" style="color:red">AvgP</span>: Average Polynomial-Time ===== A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. A function f, from strings to integers, is <i>polynomial on &#956;-average</i> if there exists a constant &#949;&gt;0 such that the expectation of f<sup>&#949;</sup>(x) is finite, when x is drawn from &#956;. Then (A,&#956;) is in AvgP if there is an algorithm for A whose running time is polynomial on &#956;-average. This convoluted definition is due to Levin [[zooref#lev86|[Lev86]]], who realized that simpler definitions lead to classes that fail to satisfy basic closure properties. Also see [[zooref#gol97|[Gol97]]] for more information. If AvgP = [[#distnp|DistNP]] then [[#exp|EXP]] = [[#nexp|NEXP]] [[zooref#bcg92|[BCG+92]]]. See also: [[#nppsamp|(NP,P-samplable)]]. ---- ===== <span id="awp" style="color:red">AW[P]</span>: Alternating [[#wp|W[P]]] ===== Same as [[#awsat|AW[SAT]]] but with 'circuit' instead of 'formula.' Has the same relation to [[#awsat|AW[SAT]]] as [[#wp|W[P]]] has to [[#wsat|W[SAT]]]. Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="awpp" style="color:red">AWPP</span>: Almost [[#wpp|WPP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that for some polynomial-time computable (i.e. [[#fp|FP]]) function f, <ol> <li>If the answer is "no," then the difference between the number of accepting and rejecting paths is non-negative and at most 2<sup>-poly(n)</sup>f(x).</li> <li>If the answer is "yes," then the difference is between (1-2<sup>-poly(n)</sup>)f(x) and f(x).</li> </ol> Defined in [[zooref#ffk94|[FFK94]]]. Contains [[#bqp|BQP]] [[zooref#fr98|[FR98]]], [[#wapp|WAPP]] [[zooref#bgm02|[BGM02]]], [[#lwpp|LWPP]], and [[#wpp|WPP]]. Contained in [[#app|APP]] [[zooref#fen02|[Fen02]]]. ---- ===== <span id="awsat" style="color:red">AW[SAT]</span>: Alternating [[#wsat|W[SAT]]] ===== Basically has the same relation to [[#wsat|W[SAT]]] as [[#pspace|PSPACE]] does to [[#np|NP]]. The class of decision problems of the form (x,r,k<sub>1</sub>,...,k<sub>r</sub>) (r,k<sub>1</sub>,...,k<sub>r</sub> parameters), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Parameterized QBFSAT:''' Given a Boolean formula F (with no restriction on depth), over disjoint variable sets S<sub>1</sub>,...,S<sub>r</sub>. Does there exist an assignment to S<sub>1</sub> of Hamming weight k<sub>1</sub>, such that for all assignments to S<sub>2</sub> of Hamming weight k<sub>2</sub>, etc. (alternating 'there exists' and 'for all'), F is satisfied? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#awstar|AW[*]]], and is contained in [[#awp|AW[P]]]. ---- ===== <span id="awstar" style="color:red">AW[*]</span>: Alternating [[#wstar|W[*]]] ===== The union of [[#awt|AW[t]]] over all t. ---- ===== <span id="awt" style="color:red">AW[t]</span>: Alternating [[#wt|W[t]]] ===== Has the same relation to [[#wt|W[t]]] as [[#pspace|PSPACE]] does to [[#np|NP]]. Same as [[#awsat|AW[SAT]]], except that the formula F can have depth at most t. Defined in [[zooref#df99|[DF99]]]. Contained in [[#awstar|AW[*]]]. ---- ===== <span id="axp" style="color:red">AxP</span>: Approximable in Polynomial Time ===== Usually called AP in the literature. I've renamed it AxP to distinguish it from the "other" [[#ap|AP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a deterministic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also showed that the set of AxP machines is in [[#re|RE]]. ---- ===== <span id="axpp" style="color:red">AxPP</span>: Approximable in Probabilistic Polynomial Time ===== Usually called APP. I've renamed it AxPP to distinguish it from the "other" [[#app|APP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a probabilistic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also show the following: <ul> <li>Approximating the acceptance probability of a Boolean circuit is AxPP-complete. The authors argue that this makes AxPP a more natural class than [[#bpp|BPP]], since the latter is not believed to have complete problems.</li> <li>If AxPP = [[#axp|AxP]], then [[#bpp|BPP]] = [[#p|P]].</li> <li>On the other hand, there exists an oracle relative to which [[#bpp|BPP]] = [[#p|P]] but AxPP does not equal [[#axp|AxP]].</li> </ul> Interestingly, it is unclear whether the set of AxPP machines is in [[#re|RE]]. ---- ===== <span id="betap" style="color:red">&#946;P</span>: Limited-Nondeterminism [[#np|NP]] ===== &#946;<sub>k</sub>P is the class of decision problems solvable by a polynomial-time Turing machine that makes O(log<sup>k</sup>n) nondeterministic transitions, with the same acceptance mechanism as [[#np|NP]]. Equivalently, the machine receives a purported proof of size O(log<sup>k</sup>n) that the answer is 'yes.' Then &#946;P is the union of &#946;<sub>k</sub>P over all constant k. Defined in [[zooref#kf84|[KF84]]]. See also the survey [[zooref#glm96|[GLM96]]]. There exist oracles relative to which basically any consistent inclusion structure among the &#946;<sub>k</sub>P's can be realized [[zooref#bg98|[BG98]]]. &#946;<sub>2</sub>P contains [[#lognp|LOGNP]] and [[#logsnp|LOGSNP]]. ---- ===== <span id="bh" style="color:red">BH</span>: Boolean Hierarchy Over [[#np|NP]] ===== The smallest class that contains [[#np|NP]] and is closed under union, intersection, and complement. The levels are defined as follows: <ul> <li>BH<sub>1</sub> = [[#np|NP]].</li> <li>BH<sub>2i</sub> is the class of languages that are the intersection of a BH<sub>2i-1</sub> language with a [[#conp|coNP]] language.</li> <li>BH<sub>2i+1</sub> is the class of languages that are the union of a BH<sub>2i</sub> language with an [[#np|NP]] language.</li> </ul> Then BH is the union over all i of BH<sub>i</sub>. Defined in [[zooref#ww85|[WW85]]]. For more detail see [[zooref#cgh88|[CGH+88]]]. Contained in [[#delta2p|&#916;<sub>2</sub>P]] and indeed in [[#pnplog|P<sup>NP[log]</sup>]]. If BH collapses at any level, then [[#ph|PH]] collapses to &#931;<sub>3</sub>P [[zooref#kad88|[Kad88]]]. See also: [[#qh|QH]]. ---- ===== <span id="bpdp" style="color:red">BP<sub>d</sub>(P)</span>: Polynomial Size d-Times-Only Branching Program ===== Defined in [[zooref#weg88|[Weg88]]]. The class of decision problems solvable by a family of polynomial size branching programs, with the additional condition that each bit of the input is tested at most d times. BP<sub>d</sub>(P) strictly contains BP<sub>d-1</sub>(P), for every d &gt; 1 [[zooref#tha98|[Tha98]]]. Contained in [[#pbp|PBP]]. See also: [[#pobdd|P-OBDD]], [[#kpbp|k-PBP]]. ---- ===== <span id="bpe" style="color:red">BPE</span>: Bounded-Error Probabilistic [[#e|E]] ===== Has the same relation to [[#e|E]] as [[#bpp|BPP]] does to [[#p|P]]. [[#ee|EE]] = BPE if and only if [[#exp|EXP]] = [[#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="bpee" style="color:red">BPEE</span>: Bounded-Error Probabilistic [[#ee|EE]] ===== Has the same relation to [[#ee|EE]] as [[#bpp|BPP]] does to [[#p|P]]. ---- ===== <span id="bphspace" style="color:red">BP<sub>H</sub>SPACE(f(n))</span>: Bounded-Error Halting Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts on every input <i>and</i> every random tape setting. Contains [[#rhspace|R<sub>H</sub>SPACE]](f(n)). Is contained in [[#dspace|DSPACE]](f(n)<sup>3/2</sup>) [[zooref#sz95|[SZ95]]]. ---- ===== <span id="bpl" style="color:red">BPL</span>: Bounded-Error Probabilistic [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#bpp|BPP]] does to [[#p|P]]. The Turing machine has to halt with probability 1 on every input. Contained in [[#sc|SC]] [[zooref#nis92|[Nis92]]] and in [[#pl|PL]]. ---- ===== <span id="bpnp" style="color:red">BP&#149;NP</span>: Probabilistic [[#np|NP]] ===== Equals [[#am|AM]]. ---- ===== <span id="bpp" style="color:red">BPP</span>: Bounded-Error Probabilistic Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes' then at least 2/3 of the computation paths accept.</li> <li>If the answer is 'no' then at most 1/3 of the computation paths accept.</li> </ol> (Here all computation paths have the same length.) Often identified as the class of feasible problems for a computer with access to a genuine random-number source. Defined in [[zooref#gil77|[Gil77]]]. Contained in [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]] [[zooref#lau83|[Lau83]]], and indeed in [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#gz97|[GZ97]]]. If BPP contains [[#np|NP]], then [[#rp|RP]] = [[#np|NP]] [[zooref#ko82|[Ko82]]] and [[#ph|PH]] is contained in BPP [[zooref#zac88|[Zac88]]]. If any problem in [[#e|E]] requires circuits of size 2<sup>&#937;(n)</sup>, then BPP = [[#p|P]] [[zooref#iw97|[IW97]]] (in other words, BPP can be derandomized). Indeed, <i>any</i> proof that BPP = [[#p|P]] requires showing either that [[#nexp|NEXP]] is not in [[#ppoly|P/poly]], or else that [[#sharpp|#P]] requires superpolynomial-size arithmetic circuits [[zooref#ki02|[KI02]]]. BPP is not known to contain complete problems. [[zooref#sip82|[Sip82]]], [[zooref#hh86|[HH86]]] give oracles relative to which BPP has no complete problems. There exist oracles relative to which [[#p|P]] = [[#rp|RP]] but still [[#p|P]] is not equal to BPP [[zooref#bf99|[BF99]]]. In contrast to the case of [[#p|P]], it is unknown whether BPP collapses to [[#bptime|BPTIME]](n<sup>c</sup>) for some fixed constant c. However, [[zooref#bar02|[Bar02]]] and [[zooref#fs04|[FS04]]] have shown hierarchy theorems for BPP with a small amount of advice. Equals [[#almostp|Almost-P]]. See also: [[#bpppath|BPP<sub>path</sub>]]. ---- ===== <span id="bppcc" style="color:red">BPP<sup>cc</sup></span>: Communication Complexity [[#bpp|BPP]] ===== The analogue of [[#pcc|P<sup>cc</sup>]] for bounded-error probabilistic communication complexity. Does not equal [[#pcc|P<sup>cc</sup>]], and is not contained in [[#npcc|NP<sup>cc</sup>]], because of the EQUALITY problem. Defined in [[zooref#bfs86|[BFS86]]]. ---- ===== <span id="bppkt" style="color:red">BPP<sup>KT</sup></span>: [[#bpp|BPP]] With Time-Bounded Kolmogorov Complexity Oracle ===== [[#bpp|BPP]] with an oracle that, given a string x, returns the minimum over all programs P that output x<sub>i</sub> on input i, of the length of P plus the maximum time taken by P on any input. A similar class was defined in [[zooref#abk02|[ABK+02]]], where it was also shown that in BPP<sup>KT</sup> one can factor, compute discrete logarithms, and more generally invert any one-way function on a non-negligible fraction of inputs. See also: [[#pk|P<sup>K</sup>]]. ---- ===== <span id="bpplog" style="color:red">BPP/log</span>: [[#bpp|BPP]] With Logarithmic Karp-Lipton Advice ===== The class of problems solvable by a semantic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, the machine must provide some answer with probability at least 2/3. See the discussion for [[#bqppoly|BQP/poly]]. Contained in [[#bppmlog|BPP/mlog]]. ---- ===== <span id="bppmlog" style="color:red">BPP/mlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, it need not be. Contained in [[#bpprlog|BPP/rlog]]. ---- ===== <span id="bppsslog" style="color:red">BPP//log</span>: [[#bpp|BPP]] With Logarithmic Randomness-Dependent Advice ===== The class of problems solvable by a [[#bpp|BPP]] machine that is given O(log n) advice bits, which can depend on both the machine's random coin flips and the input length n, but not on the input itself. Defined in [[zooref#tv02|[TV02]]], where it was also shown that if [[#exp|EXP]] is in BPP//log then [[#exp|EXP]] = [[#bpp|BPP]], and if [[#pspace|PSPACE]] is in BPP//log then [[#pspace|PSPACE]] = [[#bpp|BPP]]. ---- ===== <span id="bpprlog" style="color:red">BPP/rlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) random advice bits whose probability distribution depends only on the input length n. For each n, there exists good advice such that the output is correct with probability at least 2/3. Contains [[#bppmlog|BPP/mlog]]. The inclusion is strict, because BPP/rlog contains any finitely sparse language by fingerprinting; see the discussion for [[#all|ALL]]. Contained in [[#bppsslog|BPP//log]]. ---- ===== <span id="bppobdd" style="color:red">BPP-OBDD</span>: Polynomial-Size Bounded-Error Ordered Binary Decision Diagram ===== Same as [[#pobdd|P-OBDD]], except that probabilistic transitions are allowed and the OBDD need only accept with probability at least 2/3. Does not contain the integer multiplication problem [[zooref#ak96|[AK96]]]. Strictly contained in [[#bqpobdd|BQP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bpppath" style="color:red">BPP<sub>path</sub></span>: Threshold [[#bpp|BPP]] ===== Same as [[#bpp|BPP]], except that now the computation paths need not all have the same length. Defined in [[zooref#hht97|[HHT97]]], where the following was also shown: <ul> <li>BPP<sub>path</sub> contains [[#ma|MA]] and [[#pnplog|P<sup>NP[log]</sup>]], and is contained in [[#pp|PP]] and [[#bpp|BPP]]<sup>[[#np|NP]]</sup>.</li> <li>BPP<sub>path</sub> is closed under complementation, intersection, and union.</li> <li>If BPP<sub>path</sub> = BPP<sub>path</sub><sup>BPPpath</sup>, then [[#ph|PH]] collapses to BPP<sub>path</sub>.</li> <li>If BPP<sub>path</sub> contains [[#sigma2p|&#931;<sub>2</sub>P]], then [[#ph|PH]] collapses to [[#bpp|BPP]]<sup>[[#np|NP]]</sup>.</li> </ul> There exists an oracle relative to which BPP<sub>path</sub> is not contained in [[#sigma2p|&#931;<sub>2</sub>P]] [[zooref#bgm02|[BGM02]]]. ---- ===== <span id="bpqp" style="color:red">BPQP</span>: Bounded-Error Probabilistic [[#qp|QP]] ===== Equals [[#bptime|BPTIME]](2<sup>O((log n)^k)</sup>); that is, the class of problems solvable in quasipolynomial-time on a bounded-error machine. Defined in [[zooref#cns99|[CNS99]]], where the following was also shown: <ul> If either (1) [[#sharpp|#P]] does not have a subexponential-time bounded-error algorithm, or (2) [[#exp|EXP]] does not have subexponential-size circuits, then the BPQP hierarchy is strict -- that is, for all a &lt; b at least 1, [[#bptime|BPTIME]](2<sup>(log n)^a</sup>) is strictly contained in [[#bptime|BPTIME]](2<sup>(log n)^b</sup>). </ul> ---- ===== <span id="bpspace" style="color:red">BPSPACE(f(n))</span>: Bounded-Error Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts with probability 1 on every input. Contains [[#rspace|RSPACE(f(n))]] and [[#bphspace|BP<sub>H</sub>SPACE(f(n))]]. ---- ===== <span id="bptime" style="color:red">BPTIME(f(n))</span>: Bounded-Error Probabilistic f(n)-Time ===== Same as [[#bpp|BPP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#gil77|[Gil77]]]. BPTIME(n<sup>log n</sup>) does not equal BPTIME(2<sup>n^&epsilon;</sup>) for any &epsilon;>0 [[zooref#kv88|[KV88]]]. Proving a stronger time hierarchy theorem for BPTIME is a longstanding open problem; see [[zooref#bh97|[BH97]]] for details. [[zooref#bar02|[Bar02]]] has shown the following: <ul> <li>If we allow a small number of advice bits (say log n), then there is a strict hierarchy: for every d at least 1, BPTIME(n<sup>d</sup>)/(log n) does not equal BPTIME(n<sup>d+1</sup>)/(log n).</li> <li>In the uniform setting, if [[#bpp|BPP]] has complete problems then BPTIME(n<sup>d</sup>) does not equal BPTIME(n<sup>d+1</sup>).</li> <li>BPTIME(n) does not equal [[#np|NP]].</li> </ul> Subsequently, [[zooref#fs04|[FS04]]] managed to reduce the number of advice bits to only 1: BPTIME(n<sup>d</sup>)/1 does not equal BPTIME(n<sup>d+1</sup>)/1. They also proved a hierarchy theorem for [[#heurbptime|HeurBPTIME]]. For another bounded-error hierarchy result, see [[#bpqp|BPQP]]. ---- ===== <span id="bqnc" style="color:red">BQNC</span>: Alternate Name for [[#qnc|QNC]] ===== ---- ===== <span id="bqnp" style="color:red">BQNP</span>: Alternate Name for [[#qma|QMA]] ===== ---- ===== <span id="bqp" style="color:red">BQP</span>: Bounded-Error Quantum Polynomial-Time ===== The class of decision problems solvable in polynomial time by a quantum Turing machine, with at most 1/3 probability of error. One can equivalently define BQP as the class of decision problems solvable by a uniform family of polynomial-size quantum circuits, with at most 1/3 probability of error [[zooref#yao93|[Yao93]]]. Any universal gate set can be used as a basis; however, a technicality is that the transition amplitudes must be efficiently computable, since otherwise one could use them to encode the solutions to hard problems (see [[zooref#adh97|[ADH97]]]). BQP is often identified as the class of feasible problems for quantum computers. Contains the factoring and discrete logarithm problems [[zooref#sho97|[Sho97]]], the hidden Legendre symbol problem [[zooref#dhi02|[DHI02]]], the Pell's equation and principal ideal problems [[zooref#hal02|[Hal02]]], and some other problems not thought to be in [[#bpp|BPP]]. Defined in [[zooref#bv97|[BV97]]], where it is also shown that BQP contains [[#bpp|BPP]] and is contained in [[#p|P]] with a [[#sharpp|#P]] oracle. BQP<sup>BQP</sup> = BQP [[zooref#bv97|[BV97]]]. [[zooref#adh97|[ADH97]]] showed that BQP is contained in [[#pp|PP]], and [[zooref#fr98|[FR98]]] showed that BQP is contained in [[#awpp|AWPP]]. There exist oracles relative to which: <ul> <li>BQP does not equal [[#bpp|BPP]] [[zooref#bv97|[BV97]]] (and by similar arguments, is not in [[#ppoly|P/poly]]).</li> <li>BQP is not contained in [[#ma|MA]] [[zooref#wat00|[Wat00]]].</li> <li>BQP is not contained in [[#modkp|Mod<sub>p</sub>P]] for prime p [[zooref#gv02|[GV02]]].</li> <li>[[#np|NP]], and indeed [[#npiconp|NP &#8745; coNP]], are not contained in BQP (in fact, this holds with probability 1 relative to a random oracle and a random permutation oracle, respectively) [[zooref#bbb97|[BBB+97]]].</li> <li>[[#szk|SZK]] is not contained in BQP [[zooref#aar02|[Aar02]]].</li> <li>BQP is not contained in [[#szk|SZK]] (follows easily using the quantum walk problem in [[zooref#ccd03|[CCD+03]]]).</li> </ul> ---- ===== <span id="bqplog" style="color:red">BQP/log</span>: [[#bqp|BQP]] With Logarithmic-Size Karp-Lipton Advice ===== Same as [[#bqppoly|BQP/poly]] except that the advice is O(log n) bits instead of a polynomial number. Contained in [[#bqpmlog|BQP/mlog]]. ---- ===== <span id="bqppoly" style="color:red">BQP/poly</span>: [[#bqp|BQP]] With Polynomial-Size Karp-Lipton Advice ===== Is to [[#bqpmpoly|BQP/mpoly]] as [[#existsbpp|&#8707;BPP]] is to [[#ma|MA]]. Namely, the [[#bqp|BQP]] machine is required to give some answer with probability at least 2/3 even if the advice is bad. Even though [[#bqpmpoly|BQP/mpoly]] is a more natural class, BQP/poly follows the standard definition of advice as a class operator [[zooref#kl82|[KL82]]]. Contained in [[#bqpmpoly|BQP/mpoly]] and contains [[#bqplog|BQP/log]]. ---- ===== <span id="bqpmlog" style="color:red">BQP/mlog</span>: [[#bqp|BQP]] With Logarithmic-Size Deterministic Merlin-Like Advice ===== Same as [[#bqpmpoly|BQP/mpoly]] except that the advice is O(log n) bits instead of a polynomial number. Strictly contained in [[#bqpqlog|BQP/qlog]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpmpoly" style="color:red">BQP/mpoly</span>: [[#bqp|BQP]] With Polynomial-Size Deterministic Merlin-Like Advice ===== The class of languages recognized by a syntactic BQP machine with deterministic polynomial advice that depends only on the input length, such that the output is correct with probability 2/3 when the advice is good. Can also be defined as the class of problems solvable by a nonuniform family of polynomial-size quantum circuits, just as [[#ppoly|P/poly]] is the class solvable by a nonuniform family of polynomial-size classical circuits. Referred to with a variety of other ad hoc names, including [[#bqppoly|BQP/poly]] on occassion. Contains [[#bqpqlog|BQP/qlog]], and is contained in [[#bqpqpoly|BQP/qpoly]]. Does not contain [[#espace|ESPACE]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpqlog" style="color:red">BQP/qlog</span>: [[#bqp|BQP]] With Logarithmic-Size Quantum Advice ===== Same as [[#bqpmlog|BQP/mlog]] except that the advice is quantum instead of classical. Strictly contains [[#bqpmlog|BQP/mlog]] [[zooref#ny03|[NY03]]]. Contained in [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpqpoly" style="color:red">BQP/qpoly</span>: [[#bqp|BQP]] With Polynomial-Size Quantum Advice ===== The class of problems solvable by a [[#bqp|BQP]] machine that receives a quantum state &psi;<sub>n</sub> as advice, which depends only on the input length n. As with [[#bqpmpoly|BQP/mpoly]], the acceptance probability does not need to be bounded away from 1/2 if the machine is given bad advice. (Thus, we are discussing the class that [[zooref#ny03|[NY03]]] call BQP/*Qpoly.) Indeed, such a condition would make ''quantum'' advice unusable, by a continuity argument. Does not contain [[#eespace|EESPACE]] [[zooref#ny03|[NY03]]]. [[zooref#aar04b|[Aar04b]]] shows the following: <ul> <li>There exists an oracle relative to which BQP/qpoly does not contain [[#np|NP]].</li> <li>BQP/qpoly is contained in [[#pppoly|PP/poly]].</li> </ul> A ''classical'' oracle separation between BQP/qpoly and [[#bqpmpoly|BQP/mpoly]] is presently unknown, but there is a ''quantum'' oracle separation [[zooref#ak06|[AK06]]]. An unrelativized separation is too much to hope for, since it would imply that [[#pp|PP]] is not contained in [[#ppoly|P/poly]]. Contains [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpobdd" style="color:red">BQP-OBDD</span>: Polynomial-Size Bounded-Error Quantum Ordered Binary Decision Diagram ===== Same as [[#pobdd|P-OBDD]], except that unitary (quantum) transitions are allowed and the OBDD need only accept with probability at least 2/3. Strictly contains [[#bppobdd|BPP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bqpspace" style="color:red">BQPSPACE</span>: Bounded-Error Quantum [[#pspace|PSPACE]] ===== Equals [[#pspace|PSPACE]] and [[#ppspace|PPSPACE]]. ---- ===== <span id="bqtime" style="color:red">BQTIME(f(n))</span>: Bounded-Error Quantum f(n)-Time ===== Same as [[#bqp|BQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="bqpttmpoly" style="color:red">BQP<sub>tt</sub>/poly</span>: [[#bqpmpoly|BQP/mpoly]] With Truth-Table Queries ===== Same as [[#bqpmpoly|BQP/mpoly]], except that the machine only gets to make <i>nonadaptive</i> queries to whatever oracle it might have. Defined in [[zooref#ny03b|[NY03b]]], where it was also shown that [[#p|P]] is not contained in BQP<sub>tt</sub>/poly relative to an oracle. ---- ===== <span id="bwbp" style="color:red">k-BWBP</span>: Bounded-Width Branching Program ===== Alternate name for k-[[#kpbp|PBP]]. ---- ===== <span id="cequalsac0" style="color:red">C<sub>=</sub>AC<sup>0</sup></span>: Exact-Counting [[#ac0|AC<sup>0</sup>]] ===== The class of problems for which there exists a [[#diffac0|DiffAC<sup>0</sup>]] function f such that the answer is "yes" on input x if and only if f(x)=0. Equals [[#tc0|TC<sup>0</sup>]] and [[#pac0|PAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="cequalsl" style="color:red">C<sub>=</sub>L</span>: Exact-Counting [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#cequalsp|C<sub>=</sub>P]] does to [[#p|P]]. C<sub>=</sub>L<sup>C=L</sup> = L<sup>C=L</sup> [[zooref#abo99|[ABO99]]]. ---- ===== <span id="cequalsp" style="color:red">C<sub>=</sub>P</span>: Exact-Counting Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that the number of accepting paths exactly equals the number of rejecting paths, if and only if the answer is 'yes.' Equals [[#conqp|coNQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cfl" style="color:red">CFL</span>: Context-Free Languages ===== Does not equal [[#qcfl|QCFL]] [[zooref#mc00|[MC00]]]. Contained in [[#logcfl|LOGCFL]]. Strictly contains [[#dcfl|DCFL]] [[zooref#bra77|[Bra77]]]. ---- ===== <span id="ch" style="color:red">CH</span>: Counting Hierarchy ===== The union of the [[#ckp|C<sub>k</sub>P]]'s over all constant k. Contained in [[#pspace|PSPACE]]. It is an open problem whether there exists an oracle relative to which CH is infinite, or even unequal to [[#pspace|PSPACE]]. This is closely related to the problem of whether [[#tc0|TC<sup>0</sup>]] = [[#nc1|NC<sup>1</sup>]]. ---- ===== <span id="check" style="color:red">Check</span>: Checkable Languages ===== The class of problems such that a polynomial-time program P that allegedly solves them can be <i>checked</i> efficiently. That is, f is in Check if there exists a [[#bpp|BPP]] algorithm C such that for all programs P and inputs x, <ol> <li>If P(y)=f(y) for all inputs y, then C<sup>P</sup>(x) (C with oracle access to P) accepts with probability at least 2/3.</li> <li>If P(x) is not equal to f(x) then C<sup>P</sup>(x) accepts with probability at most 1/3.</li> </ol> Introduced in [[zooref#bk89|[BK89]]], where it was also shown that Check equals [[#frip|frIP]] &#8745; [[#cofrip|cofrIP]]. Check is contained in [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#frs88|[FRS88]]]. [[zooref#bg94|[BG94]]] show that if [[#nee|NEE]] is not contained in [[#bpee|BPEE]] then [[#np|NP]] is not contained in Check. ---- ===== <span id="clsharpp" style="color:red">CL#P</span>: Cluster Sharp-P ===== The class of [[#sharpp|#P]] function problems such that some underlying [[#np|NP]] machine $M$ witnessing membership in [[#sharpp|#P]] has "clustered" accepting paths. That is: <ul> <li>There exists a polynomial $p$ such that each computation path of $M$ on each input $x$ is exactly $p(|x|)$ bits long.</li> <li>There is a length-respecting total order $A$ having polynomial-time computable adjacency checks on the computation paths of $M$.</li> <li>The accepting paths of $M$ on any input $x$ are contiguous with respect to $A$.</li> </ul> Defined in [[zooref#hhk05|[HHK+05]]]. ---- ===== <span id="ckp" style="color:red">C<sub>k</sub>P</span>: k<sup>th</sup> Level of [[#ch|CH]] ===== Defined as follows: <ul> <li>C<sub>0</sub>P = [[#p|P]]</li> <li>C<sub>1</sub>P = [[#pp|PP]]</li> <li>C<sub>2</sub>P = [[#pp|PP]]<sup>[[#pp|PP]]</sup></li> <li>In general, C<sub>k+1</sub>P is [[#pp|PP]] with C<sub>k</sub>P oracle</li> </ul> The union of the C<sub>k</sub>P's is called the counting hierarchy, [[#ch|CH]]. Defined in [[zooref#wag86|[Wag86]]]. See [[zooref#tor91|[Tor91]]] or [[zooref#aw90|[AW90]]] for more information. ---- ===== <span id="clog" style="color:red">CLOG</span>: Continuous Logarithmic-Time ===== Roughly, the class of continuous problems solvable by an ordinary differential equation (ODE) with convergence time logarithmic in the size of the input. The vector field of the ODE is specified by an [[#nc1|NC<sup>1</sup>]] formula, with n parameters that represent the input. The point to which the ODE converges (assuming it does) is the output. Defined in [[zooref#bsf02|[BSF02]]], which should be consulted for more details. [[zooref#bsf02|[BSF02]]] show that finding the maximum of n integers is in CLOG. Thus, CLOG is best thought of as the continuous-time analog of [[#nc1|NC<sup>1</sup>]], not of [[#dtime|DTIME]](log n). Contained in [[#cp|CP]]. ---- ===== <span id="cnp" style="color:red">CNP</span>: Continuous [[#np|NP]] ===== A nondeterministic analog of [[#cp|CP]]. Defined in [[zooref#sf98|[SF98]]], which should be consulted for the definition (it has something to do with strange attractors, I think). The authors raise the question of whether [[#cp|CP]] equals CNP. ---- ===== <span id="coam" style="color:red">coAM</span>: Complement of [[#am|AM]] ===== ---- ===== <span id="cocequalsp" style="color:red">coC<sub>=</sub>P</span>: Complement of [[#cequalsp|C<sub>=</sub>P]] ===== Equals [[#nqp|NQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cofrip" style="color:red">cofrIP</span>: Complement of [[#frip|frIP]] ===== ---- ===== <span id="coh" style="color:red">Coh</span>: Coherent Languages ===== The class of problems L that are <i>efficiently autoreducible</i>, in the sense that given an input x and access to an oracle for L, a [[#bpp|BPP]] machine can compute L(x) by querying L only on points that differ from x. Defined in [[zooref#yao90b|[Yao90b]]]. [[zooref#bg94|[BG94]]] show that, assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], Coh &#8745; [[#np|NP]] is not contained in any of [[#compnp|compNP]], [[#check|Check]], or [[#frip|frIP]]. ---- ===== <span id="coma" style="color:red">coMA</span>: Complement of [[#ma|MA]] ===== ---- ===== <span id="comodkp" style="color:red">coMod<sub>k</sub>P</span>: Complement of [[#modkp|Mod<sub>k</sub>P]] ===== ---- ===== <span id="compip" style="color:red">compIP</span>: Competitive [[#ip|IP]] Proof System ===== Same as [[#compnp|compNP]] but for interactive ([[#ip|IP]]) proofs instead of [[#np|NP]] proofs. More formally, compIP is the class of decision problems L in [[#ip|IP]] = [[#pspace|PSPACE]] such that, if the answer is "yes," then that can be proven by an interactive protocol between a [[#bpp|BPP]] verifier and a prover, a [[#bpp|BPP]] machine with access only to an oracle for L. Assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], [[#np|NP]] (and indeed [[#np|NP]] &#8745; [[#coh|Coh]]) is not contained in [[#compip|compIP]] [[zooref#bg94|[BG94]]]. ---- ===== <span id="compnp" style="color:red">compNP</span>: Competitive [[#np|NP]] Proof System ===== The class of decision problems L in [[#np|NP]] such that, if the answer is "yes," then a proof can be constructed in polynomial time given access only to an oracle for L. Contains [[#npc|NPC]]. [[zooref#bg94|[BG94]]] show that compNP is contained in [[#frip|frIP]], and that assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], compNP does not equal [[#np|NP]]. ---- ===== <span id="cone" style="color:red">coNE</span>: Complement of [[#ne|NE]] ===== ---- ===== <span id="conexp" style="color:red">coNEXP</span>: Complement of [[#nexp|NEXP]] ===== Contained in [[#nexppoly|NEXP/poly]] (folklore result reported in [[http://weblog.fortnow.com/|Fortnow's weblog]]). ---- ===== <span id="conl" style="color:red">coNL</span>: Complement of [[#nl|NL]] ===== Equals [[#nl|NL]] [[zooref#imm88|[Imm88]]] [[zooref#sze87|[Sze87]]]. ---- ===== <span id="conp" style="color:red">coNP</span>: Complement of [[#np|NP]] ===== If [[#np|NP]] = coNP, then any inconsistent Boolean formula of size n has a proof of inconsistency of size polynomial in n. If [[#np|NP]] does not equal coNP, then [[#p|P]] does not equal [[#np|NP]]. But the other direction is not known. See also: [[#npiconp|NP &#8745; coNP]]. Every problem in coNP has an [[#ip|IP]] (interactive proof) system, where moreover the prover can be restricted to [[#bpp|BPP]]<sup>[[#sharpp|#P]]</sup>. ---- ===== <span id="conpcc" style="color:red">coNP<sup>cc</sup></span>: Complement of [[#npcc|NP<sup>cc</sup>]] ===== ---- ===== <span id="conppoly" style="color:red">coNP/poly</span>: Complement of [[#nppoly|NP/poly]] ===== If [[#np|NP]] is contained in coNP/poly then [[#ph|PH]] collapses to [[#s2p|S<sub>2</sub>P]]<sup>[[#np|NP]]</sup> [[zooref#cch01|[CCH+01]]]. <table border="2"><tr><td>[[#np|NP]]<sup>[[#np|NP]]^[[#np|NP]]^([[#conppoly|coNP/poly]] &#8745; [[#np|NP]])</sup> = [[#np|NP]]<sup>[[#np|NP]]^[[#np|NP]]</sup> [[zooref#hno96|[HNO+96]]]</td></tr></table> <i>Note:</i> At the suggestion of Luis Antu&ntilde;es, the above specimen of the Complexity Zoo has been locked in a cage. ---- ===== <span id="conqp" style="color:red">coNQP</span>: Complement of [[#nqp|NQP]] ===== Equals [[#cequalsp|C<sub>=</sub>P]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="core" style="color:red">coRE</span>: Complement of [[#re|RE]] ===== Does not equal [[#re|RE]]. The problem "given a computable predicate P, is P true of all positive integers?" is coRE-complete. ---- ===== <span id="cornc" style="color:red">coRNC</span>: Complement of [[#rnc|RNC]] ===== Contains the problem of whether a bipartite graph has a perfect matching [[zooref#kar86|[Kar86]]]. ---- ===== <span id="corp" style="color:red">coRP</span>: Complement of [[#rp|RP]] ===== Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ss77|[SS77]]]. ---- ===== <span id="cosl" style="color:red">coSL</span>: Complement of [[#sl|SL]] ===== ---- ===== <span id="cosparse" style="color:red">coSPARSE</span>: Complement of [[#sparse|SPARSE]] ===== ---- ===== <span id="coucc" style="color:red">coUCC</span>: Complement of [[#ucc|UCC]] ===== [[zooref#tor00|[Tor00]]] showed the following problem complete for coUCC under [[#l|L]] reductions: <ul> Given a colored graph G with at most two vertices having any given color, does G have any nontrivial automorphisms? </ul> ---- ===== <span id="coup" style="color:red">coUP</span>: Complement of [[#up|UP]] ===== ---- ===== <span id="cp" style="color:red">CP</span>: Continuous [[#p|P]] ===== Same as [[#clog|CLOG]], except that the convergence time can be polynomial rather than logarithmic in the input size. Defined in [[zooref#bsf02|[BSF02]]] and [[zooref#sf98|[SF98]]]. Finding a maximum flow, which is [[#p|P]]-complete, can be done in CP [[zooref#bsf02|[BSF02]]]. Based on this the authors argue that "[[#p|P]] is contained in CP," but this seems hard to formalize, since CP is not a complexity class in the usual sense. They also conjecture that "CP is contained in [[#p|P]]" (i.e. the class of ODE's they consider can be integrated efficiently on a standard Turing machine), but this is open. Contained in [[#cnp|CNP]]. ---- ===== <span id="csize" style="color:red">CSIZE(f(n))</span>: Circuit Size f(n) ===== The class of decision problems solvable by a (nonuniform) family of Boolean circuits of size O(f(n)). So for example, CSIZE(poly(n)) (the union of CSIZE(n<sup>k</sup>) over all k) equals [[#ppoly|P/poly]]. Defined in [[zooref#sm02|[SM02]]] among other places. ---- ===== <span id="csl" style="color:red">CSL</span>: Context Sensitive Languages ===== The class of languages generated by context-sensitive grammars. Equals [[#nspace|NSPACE]](n) [[zooref#kur64|[Kur64]]]. ---- ===== <span id="czk" style="color:red">CZK</span>: Computational Zero-Knowledge ===== Same as [[#szk|SZK]], except that now the two distributions are merely required to be <i>computationally indistinguishable</i> by any [[#bpp|BPP]] algorithm; they don't have to be statistically close. (The "two distributions" are (1) the distribution over Arthur's view of his interaction with Merlin, conditioned on Arthur's random coins, and (2) the distribution over views that Arthur can <i>simulate</i> without Merlin's help.) Unlike [[#szk|SZK]], it is not known if CZK is closed under complement. CZK is now known to share other properties with [[#szk|SZK]]: the verifier may as well be honest and may as well show his coins, and CZK is closed under unions [[zooref#vad06|[Vad06]]]. (Previously, these properties were only established in the presence of one-way functions.) Assuming the existence of one-way functions, CZK contains [[#np|NP]] [[zooref#gmw91|[GMW91]]], and indeed equals [[#ip|IP]]=[[#pspace|PSPACE]] [[zooref#bgg90|[BGG+90]]]. However, none of these implications of one-way functions relativize (Impagliazzo, unpublished). On the other hand, if one-way functions do not exist then CZK = [[#avbpp|AVBPP]] [[zooref#ow93|[OW93]]]. Contains [[#pzk|PZK]] and [[#szk|SZK]]. ---- ===== <span id="dsharpp" style="color:red">D#P</span>: Alternate Name for [[#psharpp|P<sup>#P</sup>]] ===== ---- ===== <span id="dcfl" style="color:red">DCFL</span>: Deterministic [[#cfl|CFL]] ===== The class of languages accepted by deterministic pushdown automata. Defined in [[zooref#gg66|[GG66]]], where it was also shown that DCFL is strictly contained in [[#cfl|CFL]] and strictly contains [[#reg|REG]]. ---- ===== <span id="delta2p" style="color:red">&#916;<sub>2</sub>P</span>: [[#p|P]] With [[#np|NP]] Oracle ===== A level of [[#ph|PH]], the polynomial hierarchy. Contains [[#bh|BH]]. There exists an oracle relative to which &#916;<sub>2</sub>P is not contained in [[#pp|PP]] [[zooref#bei94|[Bei94]]]. There exists another oracle relative to which &#916;<sub>2</sub>P is contained in [[#ppoly|P/poly]] [[zooref#bgs75|[BGS75]]], and indeed has linear-size circuits [[zooref#wil85|[Wil85]]]. If [[#p|P]] = [[#np|NP]], then any polynomial-size circuit C can be learned in &#916;<sub>2</sub>P with C oracle [[zooref#aar06|[Aar06]]]. ---- ===== <span id="deltabpp" style="color:red">&#948;-BPP</span>: &#948;-Semi-Random [[#bpp|BPP]] ===== Same as [[#bpp|BPP]], except that the random bit source is biased as follows. Each bit could depend on all the previous bits in arbitrarily complicated ways; the only promise is that the bit is 1 with probability in the range [&#948;,1-&#948;], conditioned on all previous bits. So clearly 0-BPP = [[#p|P]] and 1/2-BPP = [[#bpp|BPP]]. It turns out that, for any &#948;&gt;0, &#948;-BPP = [[#bpp|BPP]] [[zooref#vv85|[VV85]]], [[zooref#zuc91|[Zuc91]]]. ---- ===== <span id="deltarp" style="color:red">&#948;-RP</span>: &#948;-Semi-Random [[#rp|RP]] ===== Same as [[#deltabpp|&#948;-BPP]], but for [[#rp|RP]] instead of [[#bpp|BPP]]. For any &#948;&gt;0, &#948;-RP = [[#rp|RP]] [[zooref#vv85|[VV85]]]. ---- ===== <span id="det" style="color:red">DET</span>: Determinant ===== The class of decision problems reducible in [[#l|L]] to the problem of computing the determinant of an n-by-n matrix of n-bit integers. Defined in [[zooref#coo85|[Coo85]]]. Contained in [[#nc2|NC<sup>2</sup>]], and contains [[#nl|NL]] and [[#pl|PL]] [[zooref#bcp83|[BCP83]]]. Graph isomorphism is hard for DET under [[#l|L]]-reductions [[zooref#tor00|[Tor00]]]. ---- ===== <span id="diffac0" style="color:red">DiffAC<sup>0</sup></span>: Difference [[#sharpac0|#AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to integers expressible as the difference of two [[#sharpac0|#AC<sup>0</sup>]] functions. Equals [[#gapac0|GapAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="disnp" style="color:red">DisNP</span>: Disjoint [[#np|NP]] Pairs ===== The class of pairs (A,B), where A and B are [[#np|NP]] problems whose sets of "yes" instances are nonempty and disjoint. If there exists an optimal propositional proof system, then DisNP has a complete pair [[zooref#raz94|[Raz94]]]. On the other hand, there exists an oracle relative to which DisNP does not have a complete pair [[zooref#gss03|[GSS+03]]]. If [[#p|P]] does not equal [[#up|UP]], then DisNP contains pairs not separated by any set in [[#p|P]] [[zooref#gs88|[GS88]]]. On the other hand, there exists an oracle relative to which [[#p|P]] does not equal [[#np|NP]] but still DisNP does not contain any [[#p|P]]-inseparable pairs [[zooref#hs92|[HS92]]]. ---- ===== <span id="distnp" style="color:red">DistNP</span>: Distributional [[#np|NP]] ===== (also called (NP,P-computable) or RNP) A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. (A,&#956;) is in DistNP if A is in [[#np|NP]], and &#956; is [[#p|P]]-computable (meaning that its cumulative density function can be evaluated in polynomial time). DistNP has complete problems [[zooref#gur87|[Gur87]]], although unlike for [[#np|NP]] this is not immediate. Any DistNP-complete problem is also complete for [[#nppsamp|(NP,P-samplable)]] [[zooref#il90|[IL90]]]. ---- ===== <span id="dp" style="color:red">DP</span>: Difference Polynomial-Time ===== DP = [[#bh|BH]]<sub>2</sub>, the second level of the Boolean hierarchy. Defined in [[zooref#py84|[PY84]]]. ---- ===== <span id="dqp" style="color:red">DQP</span>: Dynamical Quantum Polynomial-Time ===== The class of decision problems solvable by a [[#bqp|BQP]] machine with oracle access to a <i>dynamical simulator</i>. When given a polynomial-size quantum circuit, the simulator returns a sample from the distribution over "classical histories" induced by the circuit. The simulator can adversarially choose any history distribution that satisfies the axioms of "symmetry" and "locality" -- so that the DQP algorithm has to work for any distribution satisfying these axioms. See [[zooref#aar05|[Aar05]]] for a full definition. There it is also shown that [[#szk|SZK]] is contained in DQP. Contains [[#bqp|BQP]], and is contained in [[#exp|EXP]] [[zooref#aar05|[Aar05]]]. There exists an oracle relative to which DQP does not contain [[#np|NP]] [[zooref#aar05|[Aar05]]]. ---- ===== <span id="dspace" style="color:red">DSPACE(f(n))</span>: Deterministic f(n)-Space ===== The class of decision problems solvable by a Turing machine in space O(f(n)). The Space Hierarchy Theorem: For constructible f(n) greater than log n, DSPACE(f(n)) is strictly contained in DSPACE(f(n) log(f(n))) [[zooref#hls65|[HLS65]]]. For space constructible f(n), strictly contains [[#dtime|DTIME]](f(n)) [[zooref#hpv77|[HPV77]]]. DSPACE(n) does not equal [[#np|NP]] (though we have no idea if one contains the other)! See also: [[#nspace|NSPACE]](f(n)). ---- ===== <span id="dtime" style="color:red">DTIME(f(n))</span>: Deterministic f(n)-Time ===== The class of decision problems solvable by a Turing machine in time O(f(n)). The Time Hierarchy Theorem: For constructible f(n) greater than n, DTIME(f(n)) is strictly contained in DTIME(f(n) log(f(n)) loglog(f(n))) [[zooref#hs65|[HS65]]]. For any space constructible f(n), DTIME(f(n)) is strictly contained in DSPACE(f(n)) [[zooref#hpv77|[HPV77]]]. Also, DTIME(n) is strictly contained in [[#ntime|NTIME(n)]] [[zooref#pps83|[PPS+83]]] (this result does not work for arbitrary f(n)). For any constructible superpolynomial f(n), DTIME(f(n)) with [[#pp|PP]] oracle is not in [[#ppoly|P/poly]] (see [[zooref#all96|[All96]]]). ---- ===== <span id="dtisp" style="color:red">DTISP(t(n),s(n))</span>: Simultaneous t(n)-Time and s(n)-Space ===== The class of decision problems solvable by a Turing machine that uses time O(t(n)) and space O(s(n)) simultaneously. Thus [[#sc|SC]] = DTISP(poly,polylog) for example. Defined in [[zooref#nis92|[Nis92]]], where it was also shown that for all space-constructible s(n)=&Omega;(log n), [[#bpspace|BPSPACE(s(n))]] is contained in DTISP(2<sup>O(s(n))</sup>,s<sup>2</sup>(n)). ---- ===== <span id="dynfo" style="color:red">Dyn-FO</span>: Dynamic [[#fo|FO]] ===== The class of <i>dynamic</i> problems solvable using first-order predicates. Basically what this means is that an algorithm maintains some polynomial-size data structure (say a graph), and receives a sequence of updates (add this edge, delete that one, etc.). For each update, it computes a new value for the data structure in [[#fo|FO]] -- that is, for each bit of the data structure, there is an [[#fo|FO]] function representing the new value of that bit, which takes as input both the update and the previous value of the data structure. At the end the algorithm needs to answer some question (i.e. is the graph connected?). See [[zooref#hi02|[HI02]]] for more information, and a complete problem for Dyn-FO. See also [[#dynthc0|Dyn-ThC<sup>0</sup>]]. ---- ===== <span id="dynthc0" style="color:red">Dyn-ThC<sup>0</sup></span>: Dynamic Threshold Circuits ===== Same as [[#dynfo|Dyn-FO]], except that now updates are computed via constant-depth predicates that have "COUNT" available, in addition to AND, OR, and NOT -- so it's a uniform version of [[#tc0|TC<sup>0</sup>]] rather than of [[#ac0|AC<sup>0</sup>]]. See [[zooref#hi02|[HI02]]] for more information. ---- ===== <span id="e" style="color:red">E</span>: Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>O(n)</sup>). Does not equal [[#np|NP]] [[zooref#boo72|[Boo72]]] or [[#pspace|PSPACE]] [[zooref#boo74|[Boo74]]] relative to any oracle. However, there is an oracle relative to which E is contained in [[#np|NP]] (see [[#zpp|ZPP]]), and an oracle relative to [[#pspace|PSPACE]] is contained in E (by equating the former with [[#p|P]]). There exists a problem that is complete for E under polynomial-time Turing reductions but not polynomial-time truth-table reductions [[zooref#wat87|[Wat87]]]. Problems hard for [[#bpp|BPP]] under Turing reductions have measure 1 in E [[zooref#as94|[AS94]]]. It follows that, if the problems complete for E under Turing reductions do not have measure 1 in E, then [[#bpp|BPP]] does not equal [[#exp|EXP]]. [[zooref#it89|[IT89]]] gave an oracle relative to which E = [[#ne|NE]] but still there is an exponential-time binary predicate whose corresponding <i>search</i> problem is not in E. Contrast with [[#exp|EXP]]. ---- ===== <span id="ee" style="color:red">EE</span>: Double-Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>2^O(n)</sup>) (though some authors alternatively define it as being equal to [[#dtime|DTIME]](2<sup>O(2^n)</sup>)). EE = [[#bpe|BPE]] if and only if [[#exp|EXP]] = [[#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. Contained in [[#eexp|EEXP]] and [[#nee|NEE]]. ---- ===== <span id="eee" style="color:red">EEE</span>: Triple-Exponential Time With Linear Exponent ===== Equals [[#dtime|DTIME]](2<sup>2^2^O(n)</sup>). In contrast to the case of [[#ee|EE]], it is not known whether EEE = [[#bpee|BPEE]] implies [[#ee|EE]] = [[#bpe|BPE]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="eespace" style="color:red">EESPACE</span>: Double-Exponential Space With Linear Exponent ===== Equals [[#dspace|DSPACE]](2<sup>2^O(n)</sup>). Is not contained in [[#bqpqpoly|BQP/qpoly]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="eexp" style="color:red">EEXP</span>: Double-Exponential Time ===== Equals [[#dtime|DTIME]](2<sup>2^p(n)</sup>) for p a polynomial. Contains [[#ee|EE]], and is contained in [[#neexp|NEEXP]]. ---- ===== <span id="eh" style="color:red">EH</span>: Exponential-Time Hierarchy With Linear Exponent ===== Has roughly the same relationship to [[#e|E]] as [[#ph|PH]] does to [[#p|P]]. More formally, EH is defined as the union of [[#e|E]], [[#ne|NE]], [[#ne|NE]]<sup>[[#np|NP]]</sup>, [[#ne|NE]] with [[#sigma2p|&#931;<sub>2</sub>P]] oracle, and so on. See [[zooref#har87|[Har87]]] for more information. If [[#conp|coNP]] is contained in [[#ampolylog|AM[polylog]]], then EH collapses to [[#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]] [[zooref#ss04|[SS04]]] and indeed [[#amexp|AM<sub>EXP</sub>]] [[zooref#pv04|[PV04]]]. On the other hand, [[#cone|coNE]] is contained in [[#nepoly|NE/poly]], so perhaps it wouldn't be so surprising if NE collapses. There exists an oracle relative to which EH does not contain [[#seh|SEH]] [[zooref#hem89|[Hem89]]]. EH and [[#seh|SEH]] are incomparable for all anyone knows. ---- ===== <span id="elementary" style="color:red">ELEMENTARY</span>: Iterated Exponential Time ===== Equals the union of [[#dtime|DTIME]](2<sup>n</sup>), [[#dtime|DTIME]](2<sup>2^n</sup>), [[#dtime|DTIME]](2<sup>2^2^n</sup>), and so on. Contained in [[#pr|PR]]. ---- ===== <span id="elkp" style="color:red">EL<sub>k</sub>P</span>: Extended Low Hierarchy ===== An extension of [[#lkp|L<sub>k</sub>P]]. The class of problems A such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> is contained in [[#ph|&#931;<sub>k-1</sub>P]]<sup>A,[[#np|NP]]</sup>. Defined in [[zooref#bbs86|[BBS86]]]. ---- ===== <span id="ep" style="color:red">EP</span>: NP with 2<sup>k</sup> Accepting Paths ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then the number of accepting paths is a power of two.</li> </ol> Contained in [[#cequalsp|C<sub>=</sub>P]], and in [[#modkp|Mod<sub>k</sub>P]] for any odd k. Contains [[#up|UP]]. Defined in [[zooref#bhr00|[BHR00]]]. ---- ===== <span id="eptas" style="color:red">EPTAS</span>: Efficient Polynomial-Time Approximation Scheme ===== The class of optimization problems such that, given an instance of length n, we can find a solution within a factor 1+&epsilon; of the optimum in time f(&epsilon;)p(n), where p is a polynomial and f is arbitrary. Contains [[#fptas|FPTAS]] and is contained in [[#ptas|PTAS]]. Defined in [[zooref#ct97|[CT97]]], where the following was also shown: <ul> <li>If [[#fpt|FPT]] = [[#xpuniform|XP<sub>uniform</sub>]] then EPTAS = [[#ptas|PTAS]].</li> <li>If EPTAS = [[#ptas|PTAS]] then [[#fpt|FPT]] = [[#wp|W[P]]].</li> <li>If [[#fpt|FPT]] is strictly contained in [[#w1|W]], then there is a natural problem that is in [[#ptas|PTAS]] but not in EPTAS. (See [[zooref#ct97|[CT97]]] for the statement of the problem, since it's not <i>that</i> natural.)</li> </ul> ---- ===== <span id="eqbp" style="color:red">k-EQBP</span>: Width-k Polynomial-Time Exact Quantum Branching Programs ===== See k-[[#kpbp|PBP]] for the definition of a classical branching program. A quantum branching program is the natural quantum generalization: we have a quantum state in a Hilbert space of dimension k. Each step t consists of applying a unitary matrix U<sup>(t)</sup>(x<sub>i</sub>): that is, U<sup>(t)</sup> depends on a single bit x<sub>i</sub> of the input. (So these are the quantum analogues of so-called <i>oblivious</i> branching programs.) In the end we measure to decide whether to accept; there must be zero probability of error. Defined in [[zooref#amp02|[AMP02]]], where it was also shown that [[#nc1|NC<sup>1</sup>]] is contained in 2-EQBP. k-BQBP can be defined similarly. ---- ===== <span id="eqp" style="color:red">EQP</span>: Exact Quantum Polynomial-Time ===== The same as [[#bqp|BQP]], except that the quantum algorithm must return the correct answer with probability 1, and run in polynomial time with probability 1. Unlike bounded-error quantum computing, there is no theory of universal QTMs for exact quantum computing models. In the original definition in [[zooref#bv97|[BV97]]], each language in EQP is computed by a single QTM, equivalently to a uniform family of quantum circuits with a finite gate set K whose amplitudes can be computed in polynomial time. See [[#eqpk|EQP<sub>K</sub>]]. However, some results require an infinite gate set. The official definition here is that the gate set should be finite. Without loss of generality, the amplitudes in the gate set K are algebraic numbers [[zooref#adh97|[ADH97]]]. There is an oracle that separates EQP from [[#np|NP]] [[zooref#bv97|[BV97]]], indeed from [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#gp01|[GP01]]]. There is also an oracle relative to which EQP is not in [[#modkp|Mod<sub>p</sub>P]] where p is prime [[zooref#gv02|[GV02]]]. On the other hand, EQP is in [[#lwpp|LWPP]] [[zooref#fr98|[FR98]]]. [[#p|P]]<sup>||[[#np|NP]][2k]</sup> is contained in EQP<sup>||[[#np|NP]][k]</sup>, where "||[[#np|NP]][k]" denotes k nonadaptive oracle queries to [[#np|NP]] (queries that cannot depend on the results of previous queries) [[zooref#bd99|[BD99]]]. See also [[#zbqp|ZBQP]]. ---- ===== <span id="eqpk" style="color:red">EQP<sub>K</sub></span>: Exact Quantum Polynomial-Time with Gate Set K ===== The set of problems that can be answered by a uniform family of polynomial-sized quantum circuits whose gates are drawn from a set K, and that return the correct answer with probability 1, and run in polynomial time with probability 1, and the allowed gates are drawn from a set K. K may be either finite or countable and enumerated. If S is a ring, the union of EQP<sub>K</sub> over all finite gate sets K whose amplitudes are in the ring R can be written EQP<sub>S</sub>. Defined in [[zooref#adh97|[ADH97]]] in the special case of a finite set of 1-qubit gates controlled by a second qubit. It was shown there that transcendental gates may be replaced by algebraic gates without decreasing the size of EQP<sub>K</sub>. [[zooref#fr98|[FR98]]] show that EQP<sub>Q</sub> is in [[#lwpp|LWPP]]. The proof can be generalized to any finite, algebraic gate set K. The hidden shift problem for a vector space over Z/2 is in EQP<sub>Q</sub> by Simon's algorithm. The discrete logarithm problem over Z/p is in EQP<sub>Q-bar</sub> using infinitely many gates [[zooref#mz03|[MZ03]]]. ---- ===== <span id="eqtime" style="color:red">EQTIME(f(n))</span>: Exact Quantum f(n)-Time ===== Same as [[#eqp|EQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="espace" style="color:red">ESPACE</span>: Exponential Space With Linear Exponent ===== Equals [[#dspace|DSPACE]](2<sup>O(n)</sup>). If [[#e|E]] = ESPACE then [[#p|P]] = [[#bpp|BPP]] [[zooref#hy84|[HY84]]]. Indeed if [[#e|E]] has nonzero measure in ESPACE then [[#p|P]] = [[#bpp|BPP]] [[zooref#lut91|[Lut91]]]. ESPACE is not contained in [[#ppoly|P/poly]] [[zooref#kan82|[Kan82]]]. Is not contained in [[#bqpmpoly|BQP/mpoly]] [[zooref#ny03|[NY03]]]. See also: [[#expspace|EXPSPACE]]. ---- ===== <span id="existsbpp" style="color:red">&#8707;BPP</span>: [[#bpp|BPP]] With Existential Operator ===== The class of problems for which there exists a [[#bpp|BPP]] machine M such that, for all inputs x, <ul> <li>If the answer is "yes" then there exists a y such that M(x,y) accepts.</li> <li>If the answer is "no" then for all y, M(x,y) rejects.</li> </ul> Contains [[#np|NP]] and [[#bpp|BPP]], and is contained in [[#ma|MA]] and [[#sbp|SBP]]. &#8707;BPP seems <i>obviously</i> equal to [[#ma|MA]], yet [[zooref#ffk93|[FFK+93]]] constructed an oracle relative to which they're unequal! Here is the difference: if the answer is "yes," [[#ma|MA]] requires only that there exist a y such that for at least 2/3 of random strings r, M(x,y,r) accepts (where M is a [[#p|P]] predicate). For all other y's, the proportion of r's such that M(x,y,r) accepts can be arbitrary (say, 1/2). For &#8707;BPP, by contrast, the probability that M(x,y) accepts must <i>always</i> be either at most 1/3 or at least 2/3, for all y's. ---- ===== <span id="existsniszk" style="color:red">&#8707;NISZK</span>: [[#niszk|NISZK]] With Existential Operator ===== Contains [[#np|NP]] and [[#niszk|NISZK]], and is contained in the third level of [[#ph|PH]]. ---- ===== <span id="exp" style="color:red">EXP</span>: Exponential Time ===== Equals the union of [[#dtime|DTIME]](2<sup>p(n)</sup>) over all polynomials p. Also equals [[#p|P]] with [[#e|E]] oracle. If [[#l|L]] = [[#p|P]] then [[#pspace|PSPACE]] = EXP. If EXP is in [[#ppoly|P/poly]] then EXP = [[#ma|MA]] [[zooref#bfl91|[BFL91]]]. Problems complete for EXP under many-one reductions have measure 0 in EXP [[zooref#may94|[May94]]], [[zooref#jl95|[JL95]]]. There exist oracles relative to which <ul> <li>EXP = [[#np|NP]] = [[#zpp|ZPP]] [[zooref#hel84|[Hel84]]],</li> <li>EXP = [[#nexp|NEXP]] but still [[#p|P]] does not equal [[#np|NP]] [[zooref#dek76|[Dek76]]],</li> <li>EXP does not equal [[#pspace|PSPACE]] [[zooref#dek76|[Dek76]]].</li> </ul> [[zooref#bt04|[BT04]]] show the following rather striking result: let A be many-one complete for EXP, and let S be any set in [[#p|P]] of subexponential density. Then A-S is Turing-complete for EXP. ---- ===== <span id="exppoly" style="color:red">EXP/poly</span>: Exponential Time With Polynomial-Size Advice ===== The class of decision problems solvable in [[#exp|EXP]] with the help of a polynomial-length advice string that depends only on the input length. Contains [[#bqpqpoly|BQP/qpoly]] [[zooref#aar04b|[Aar04b]]]. ---- ===== <span id="expspace" style="color:red">EXPSPACE</span>: Exponential Space ===== Equals the union of [[#dspace|DSPACE]](2<sup>p(n)</sup>) over all polynomials p. See also: [[#espace|ESPACE]]. Given a first-order statement about real numbers, involving only addition and comparison (no multiplication), we can decide in EXPSPACE whether it's true or not [[zooref#ber80|[Ber80]]]. ---- ===== <span id="fbqp" style="color:red">FBQP</span>: Function [[#bqp|BQP]] ===== Has the same relation to [[#bqp|BQP]] as [[#fnp|FNP]] does to [[#np|NP]]. There exists an oracle relative to which [[#pls|PLS]] is not contained in [[#fbqp|FBQP]] [[zooref#aar03|[Aar03]]]. ---- ===== <span id="few" style="color:red">Few</span>: [[#fewp|FewP]] With Flexible Acceptance Mechanism ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>The number of accepting paths a is bounded by a polynomial in the size of the input x.</li> <li>For some polynomial-time predicate Q, Q(x,a) is true if and only if the answer is 'yes.'</li> </ol> Also called FewPaths. Defined in [[zooref#ch89|[CH89]]]. Contains [[#fewp|FewP]], and is contained in [[#p|P]]<sup>[[#fewp|FewP]]</sup> [[zooref#kob89|[Kob89]]] and in [[#spp|SPP]] [[zooref#ffk94|[FFK94]]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fewp" style="color:red">FewP</span>: [[#np|NP]] With Few Witnesses ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then at least one path accepts; furthermore, the number of accepting paths is upper-bounded by a polynomial in n, the size of the input.</li> </ol> Defined in [[zooref#ar88|[AR88]]]. Is contained in [[#parityp|&#8853;P]] [[zooref#ch89|[CH89]]]. There exists an oracle relative to which [[#p|P]], [[#up|UP]], FewP, and [[#np|NP]] are all distinct [[zooref#rub88|[Rub88]]]. Also, there exists an oracle relative to which FewP does not have a Turing-complete set [[zooref#hjv93|[HJV93]]]. Contained in [[#few|Few]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fh" style="color:red">FH</span>: Fourier Hierarchy ===== FH<sub>k</sub> is the class of problems solvable by a uniform family of polynomial-size quantum circuits, with k levels of Hadamard gates and all other gates preserving the computational basis. (Conditional phase flip gates are fine, for example.) Thus <ul> <li>FH<sub>0</sub> = [[#p|P]]</li> <li>FH<sub>1</sub> = [[#bpp|BPP]]</li> <li>FH<sub>2</sub> contains factoring, because of Kitaev's phase estimation algorithm</li> </ul> It is an open problem to show that the Fourier hierarchy is infinite relative to an oracle (that is, FH<sub>k</sub> is strictly contained in FH<sub>k+1</sub>). Defined in [[zooref#shi03|[Shi03]]]. ---- ===== <span id="fnl" style="color:red">FNL</span>: Function [[#nl|NL]] ===== Has the same relation to [[#nl|NL]] as [[#fnp|FNP]] does to [[#np|NP]]. Defined by [[zooref#aj93|[AJ93]]], who also showed that if [[#nl|NL]] = [[#ul|UL]], then FNL is contained in [[#sharpl|#L]]. ---- ===== <span id="fnlpoly" style="color:red">FNL/poly</span>: Nonuniform [[#fnl|FNL]] ===== Has the same relation to [[#fnl|FNL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contained in [[#sharplpoly|#L/poly]] [[zooref#ra00|[RA00]]]. ---- ===== <span id="fnp" style="color:red">FNP</span>: Function [[#np|NP]] ===== The class of function problems of the following form: <ul> Given an input x and a polynomial-time predicate F(x,y), if there exists a y satisfying F(x,y) then output any such y, otherwise output 'no.' </ul> FNP generalizes [[#np|NP]], which is defined in terms of decision problems only. Actually the word "function" is misleading, since there could be many valid outputs y. That's unavoidable, since given a predicate F there's no "syntactic" criterion ensuring that y is unique. [[#fp|FP]] = FNP if and only if [[#p|P]] = [[#np|NP]]. Contains [[#tfnp|TFNP]]. A basic question about FNP problems is whether they're <i>self-reducible</i>; that is, whether they reduce to the corresponding [[#np|NP]] decision problems. Although this is true for all [[#npc|NPC]] problems, [[zooref#bg94|[BG94]]] shows that if [[#ee|EE]] does not equal [[#nee|NEE]], then there is a problem in [[#np|NP]] such that <i>no</i> corresponding FNP problem can be reduced to it. [[zooref#bg94|[BG94]]] cites Impagliazzo and Sudan as giving the same conclusion under the assumption that [[#ne|NE]] does not equal [[#cone|coNE]]. ---- ===== <span id="fo" style="color:red">FO(t(n))</span>: First-Order ===== The class of decision problems for which a "yes" answer can be expressed by a first-order logic predicate, with a block of restricted quantifiers repeated t(n) times. See [[zooref#imm98|[Imm98]]] for a full definition. FO(poly(n)) = [[#p|P]] (see [[zooref#var82|[Var82]]] for example). FO(poly(n)) is contained in [[#soe|SO-E]]. ---- ===== <span id="foll" style="color:red">FOLL</span>: First-Order loglog n ===== The class of decision problems solvable by a nonuniform family of polynomial-size, unbounded-fanin, depth O(loglog n) circuits with AND, OR, and NOT gates. Defined in [[zooref#bkl00|[BKL+00]]], where it was also shown that many problems on finite groups are in FOLL. Contains [[#ac0|AC<sup>0</sup>]], and is contained in [[#ac|AC]]<sup>1</sup>. Is not known to be comparable to [[#l/poly|L/poly]] or [[#nl/poly|NL/poly]]. ---- ===== <span id="fp" style="color:red">FP</span>: Function Polynomial-Time ===== Sometimes defined as the class of functions computable in polynomial time by a Turing machine. (Generalizes [[#p|P]], which is defined in terms of decision problems only.) However, if we want to compare FP to [[#fnp|FNP]], we should instead define it as the class of [[#fnp|FNP]] problems (that is, polynomial-time predicates P(x,y)) for which there exists a polynomial-time algorithm that, given x, outputs <i>any</i> y such that P(x,y). That is, there could be more than one valid output, even though any given algorithm only returns one of them. FP = [[#fnp|FNP]] if and only if [[#p|P]] = [[#np|NP]]. If FP<sup>[[#np|NP]]</sup> = FP<sup>[[#np|NP]][log]</sup> (that is, allowed only a logarithmic number of queries), then [[#p|P]] = [[#np|NP]] [[zooref#kre88|[Kre88]]]. The corresponding result for [[#pnp|P<sup>NP</sup>]] versus [[#pnplog|P<sup>NP[log]</sup>]] is not known, and indeed fails relative to some oracles (see [[zooref#har87b|[Har87b]]]). ---- ===== <span id="fpnplog" style="color:red">FP<sup>NP[log]</sup></span>: [[#fp|FP]] With Logarithmically Many Queries To [[#np|NP]] ===== Given a graph, the problem of outputting the size of its maximum clique is complete for FP<sup>NP[log]</sup>. ---- ===== <span id="fpr" style="color:red">FPR</span>: Fixed-Parameter Randomized ===== Has the same relation to [[#fpt|FPT]] as [[#r|R]] does to [[#p|P]]. Defined in [[zooref#ar01|[AR01]]], where it was shown that, if the Resolution proof system is <i>automatizable</i> (that is, if a refutation can always be found in time polynomial in the length of the shortest refutation), then [[#wp|W[P]]] is contained in FPR. ---- ===== <span id="fpras" style="color:red">FPRAS</span>: Fully Polynomial Randomized Approximation Scheme ===== The subclass of [[#sharpp|#P]] counting problems whose answer, y, is approximable in the following sense. There exists a randomized algorithm that, with probability at least 1-&delta;, approximates y to within an &epsilon; multiplicative factor in time polynomial in n (the input size), 1/&epsilon;, and log(1/&delta;). The permanent of a nonnegative matrix is in FPRAS [[zooref#jsv01|[JSV01]]]. ---- ===== <span id="fpt" style="color:red">FPT</span>: Fixed-Parameter Tractable ===== The class of decision problems of the form (x,k), k a parameter, that are solvable in time f(k)p(|x|), where f is arbitrary and p is a polynomial. The basic class of the theory of <i>fixed-parameter tractability</i>, as described by Downey and Fellows [[zooref#df99|[DF99]]]. Contained in [[#fptnu|FPT<sub>nu</sub>]], [[#w1|W]], and [[#fpr|FPR]]. Contains [[#fptas|FPTAS]] [[zooref#cc97|[CC97]]], as well as [[#fptsu|FPT<sub>su</sub>]]. Contains [[#eptas|EPTAS]] unless FPT = [[#w1|W]] [[zooref#baz95|[Baz95]]]. ---- ===== <span id="fptnu" style="color:red">FPT<sub>nu</sub></span>: Fixed-Parameter Tractable (nonuniform) ===== Same as [[#fpt|FPT]] except that the algorithm can vary with the parameter k (though its running time must always be O(p(|x|)), for a fixed polynomial p). An alternate view is that a single algorithm can take a polynomial-length advice string, depending on k. Defined in [[zooref#df99|[DF99]]] (though they did not use our notation). ---- ===== <span id="fptsu" style="color:red">FPT<sub>su</sub></span>: Fixed-Parameter Tractable (strongly uniform) ===== Same as [[#fpt|FPT]] except that f has to be recursive. Defined in [[zooref#df99|[DF99]]] (though they did not use our notation). ---- ===== <span id="fptas" style="color:red">FPTAS</span>: Fully Polynomial-Time Approximation Scheme ===== The subclass of [[#npo|NPO]] problems that admit an approximation scheme in the following sense. For any &#949;&gt;0, there is an algorithm that is guaranteed to find a solution whose cost is within a 1+&#949; factor of the optimum cost. Furthermore, the running time of the algorithm is polynomial in n (the size of the problem) and in 1/&#949;. Contained in [[#ptas|PTAS]]. Defined in [[zooref#acg99|[ACG+99]]]. Contained in [[#fpt|FPT]] [[zooref#cc97|[CC97]]]. ---- ===== <span id="fqma" style="color:red">FQMA</span>: Function [[#qma|QMA]] ===== The class of problems for which the task is to output a quantum certificate for a [[#qma|QMA]] problem, when such a certificate exists. Thus, the desired output is a quantum state. Defined in [[zooref#jwb03|[JWB03]]], where it is also shown that state preparation for 3-local Hamiltonians is FQMA-complete. The authors also observe that, in contrast to the case of [[#fnp|FNP]] versus [[#np|NP]], there is no obvious reduction of FQMA problems to [[#qma|QMA]] problems. ---- ===== <span id="frip" style="color:red">frIP</span>: Function-Restricted [[#ip|IP]] Proof Systems ===== The class of problems L that have a <i>decider</i> in the following sense. There exists a [[#bpp|BPP]] machine D such that for all inputs x, <ol> <li>If the answer is "yes" then D<sup>L</sup>(x) (D with oracle for L) accepts with probability at least 2/3.</li> <li>If the answer is "no" then D<sup>A</sup>(x) accepts with probability at most 1/3 for all oracles A.</li> </ol> Contains [[#compip|compIP]] [[zooref#bg94|[BG94]]] and [[#check|Check]] [[zooref#bk89|[BK89]]]. Contained in [[#mip|MIP]] = [[#nexp|NEXP]] [[zooref#frs88|[FRS88]]]. Assuming [[#nee|NEE]] is not contained in [[#bpee|BPEE]], [[#np|NP]] (and indeed [[#np|NP]] &#8745; [[#coh|Coh]]) is not contained in [[#frip|frIP]] [[zooref#bg94|[BG94]]]. ---- ===== <span id="ftape" style="color:red">F-TAPE(f(n))</span>: Provable [[#dspace|DSPACE(f(n))]] For Formal System F ===== The class of decision problems that can be <i>proven</i> to be solvable in O(f(n)) space on a deterministic Turing machine, from the axioms of formal system F. Defined in [[zooref#har78|[Har78]]]. See also [[#ftime|F-TIME(f(n))]]. The results about F-TAPE mirror those about [[#ftime|F-TIME]], but in some cases are sharper. ---- ===== <span id="ftime" style="color:red">F-TIME(f(n))</span>: Provable [[#dtime|DTIME(f(n))]] For Formal System F ===== The class of decision problems that can be <i>proven</i> to be solvable in O(f(n)) time on a deterministic Turing machine, from the axioms of formal system F. Defined in [[zooref#har78|[Har78]]], where the following was also shown: <ul> <li>If F-TIME(f(n)) = [[#dtime|DTIME(f(n))]], then [[#dtime|DTIME(f(n))]] is strictly contained in [[#dtime|DTIME(f(n)g(n))]] for any nondecreasing, unbounded, recursive g(n).</li> <li>There exist recursive, monotonically increasing f(n) such that F-TIME(f(n)) is strictly contained in [[#dtime|DTIME(f(n))]].</li> </ul> See also [[#ftape|F-TAPE(f(n))]]. ---- ===== <span id="ga" style="color:red">GA</span>: Graph Automorphism ===== Can be defined as the class of problems polynomial-time Turing reducible to the problem of deciding whether a given graph has any nontrivial automorphisms. Contains [[#p|P]] and is contained in [[#gi|GI]]. See [[zooref#kst93|[KST93]]] for much more information about GA. ---- ===== <span id="ganspace" style="color:red">GAN-SPACE(f(n))</span>: Games Against Nature f(n)-Space ===== The class of problems decidable by an O(f(n))-space Turing machine with two kinds of quantifiers: existential and randomized. Contains [[#nspace|NSPACE(f(n))]] and [[#bpspace|BPSPACE(f(n))]], and is contained in [[#aucspace|AUC-SPACE(f(n))]]. By linear programming, GAN-SPACE(log n) is contained in [[#p|P]]. ---- ===== <span id="gapac0" style="color:red">GapAC<sup>0</sup></span>: Gap [[#sharpac0|#AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to integers computable by constant-depth, polynomial-size arithmetic circuits with addition and multiplication gates and the constants 0, 1, and -1. (The only difference from [[#sharpac0|#AC<sup>0</sup>]] is the ability to subtract, using the constant -1.) Equals [[#diffac0|DiffAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="gapl" style="color:red">GapL</span>: Gap Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#gapp|GapP]] does to [[#p|P]]. ---- ===== <span id="gapp" style="color:red">GapP</span>: Gap Polynomial-Time ===== The class of functions f(x) such that for some [[#np|NP]] machine, f(x) is the number of accepting paths minus the number of rejecting paths. Equivalently, the closure of the [[#sharpp|#P]] functions under subtraction. Defined in [[zooref#ffk94|[FFK94]]] and independently [[zooref#gup95|[Gup95]]]. ---- ===== <span id="gc" style="color:red">GC(s(n),C)</span>: Guess and Check ===== The class of decision problems for which a "yes" answer can be verified by <ol> <li>guessing s(n) bits, then</li> <li>verifying the answer in complexity class C.</li> </ol> For example, GC(p(n),[[#p|P]]) = [[#np|NP]] where p is a polynomial. Defined in [[zooref#cc93|[CC93]]]. Umans [[zooref#uma98|[Uma98]]] has shown that given a DNF expression &#934;, the Shortest Implicant problem (is there a conjunction of at most k negated or non-negated literals that implies &#934;?) is GC(log<sup>2</sup>n, [[#conp|coNP]])-complete. ---- ===== <span id="gcsl" style="color:red">GCSL</span>: Growing [[#csl|CSL]] ===== The class of languages generated by context-sensitive grammars in which the right-hand side of each transformation is strictly longer than the left-hand side. Defined in [[zooref#dw86|[DW86]]]. ---- ===== <span id="gi" style="color:red">GI</span>: Graph Isomorphism ===== Can be defined as the class of problems polynomial-time Turing reducible to the problem of deciding whether two graphs are isomorphic. Contains [[#ga|GA]] and is contained in [[#delta2p|&#916;<sub>2</sub>P]]. The GI <i>problem</i> itself (as opposed to the set of problems Turing reducible to GI) is contained in [[#np|NP]] as well as [[#coam|coAM]] (and indeed [[#szk|SZK]]). So in particular, if graph isomorphism is [[#np|NP]]-complete, then [[#ph|PH]] collapses. See [[zooref#kst93|[KST93]]] for much more information about GI. ---- ===== <span id="glo" style="color:red">GLO</span>: Guaranteed Local Optima ===== The class of [[#npo|NPO]] problems which have the property that for all locally optimal solutions, the ratio between the values of the local and global optima is upper-bounded by a constant. Defined in [[zooref#ap95|[AP95]]], where it was also shown that GLO is strictly contained in [[#apx|APX]]. [[zooref#kms99|[KMS+99]]] showed that [[#maxsnp|MaxSNP]] is not contained in GLO. ---- ===== <span id="gpcd" style="color:red">GPCD(r(n),q(n))</span>: Generalized Probabilistically Checkable Debate ===== Same as [[#pcd|PCD]](r(n),q(n)), except that now the verifier is allowed nonadaptively to query O(q(n)) <i>rounds</i> of the debate, with no restriction on the number of bits it looks at within each round. Defined in [[zooref#cfl93|[CFL+93]]], who also showed that [[#pcd|PCD]](log n, q(n)) = GPCD(log n, q(n)) for every q(n). ---- ===== <span id="gt" style="color:red">G[t]</span>: Stratification of Fixed-Parameter Tractable Problems ===== (Basically) the class of decision problems of the form (x,k) (k a parameter), that are solvable by a parameterized family of circuits with unbounded fanin and depth t. A uniformity condition may also be imposed. Defined in [[zooref#df99|[DF99]]], which should be consulted for the full definition. Uniform G[P] (i.e. with no restriction on depth) is equal to [[#fpt|FPT]]. ---- ===== <span id="halfp" style="color:red">HalfP</span>: RP With Exactly Half Acceptance ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' exactly 1/2 of computation paths accept.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> Significantly, the number of candidate witnesses is restricted to be a power of 2. (This is implicit if they are binary strings.) Contained in [[#rp|RP]], [[#ep|EP]], and [[#modkp|Mod<sub>k</sub>P]] for every odd k. Contained in [[#eqp|EQP]] by the Deutsch-Jozsa algorithm. Defined in [[zooref#bb92|[BB92]]], where it was called C<sub>==</sub>P[half]. The name used here is from [[zooref#BS00|[BS00]]]. There it was shown that HalfP is contained in every similar class in which 1/2 is replaced by some other dyadic fraction. ---- ===== <span id="heurbpp" style="color:red">HeurBPP</span>: Heuristic [[#bpp|BPP]] ===== The class of problems for which a 1-1/poly(n) fraction of instances are solvable by a [[#bpp|BPP]] machine. [[zooref#fs04|[FS04]]] showed a strict hierarchy theorem for HeurBPP; thus, HeurBPP does not equal [[#heurbptime|HeurBPTIME]](n<sup>c</sup>) for any fixed c. ---- ===== <span id="heurbptime" style="color:red">HeurBPTIME(f(n))</span>: Heuristic [[#bptime|BPTIME]](f(n)) ===== The class of problems for which a 1-1/poly(n) fraction of instances are solvable by a [[#bptime|BPTIME]](f(n)) machine. Thus [[#heurbpp|HeurBPP]] is the union of HeurBPTIME(n<sup>c</sup>) over all c. ---- ===== <span id="hkp" style="color:red">H<sub>k</sub>P</span>: High Hierarchy In [[#np|NP]] ===== The class of problems A in [[#np|NP]] such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> = [[#ph|&#931;<sub>k+1</sub>P]]; that is, adding A as an oracle increases the power of the k<sup>th</sup> level of the polynomial hierarchy by a maximum amount. For all k, H<sub>k</sub> is contained in H<sub>k+1</sub>. Defined in [[zooref#sch83|[Sch83]]]. See also [[#lkp|L<sub>k</sub>P]]. ---- ===== <span id="hvszk" style="color:red">HVSZK</span>: Honest-Verifier [[#szk|SZK]] ===== The class of decision problems that have [[#szk|SZK]] protocols assuming an honest verifier (i.e. one who doesn't try to learn more about the problem by deviating from the protocol). Equals [[#szk|SZK]] [[zooref#oka96|[Oka96]]]. ---- ===== <span id="iclogpoly" style="color:red">IC[log,poly]</span>: Logarithmic Instance Complexity, Polynomial Time ===== The class of decision problems such that, for every n-bit string x, there exists a program A of size O(log n) that, given x as input, "correctly decides" the answer on x in time polynomial in n. This means: <ul> <li>There exists a polynomial p such that for any input y, A returns either "yes", "no", or "I don't know" in time p(|y|).</li> <li>Whenever A returns "yes" or "no", it is correct.</li> <li>A returns either "yes" or "no" on x.</li> </ul> Defined in [[zooref#oks94|[OKS+94]]]; see also [[zooref#lv97|[LV97]]]. If [[#np|NP]] is contained in IC[log,poly], then [[#p|P]] = [[#np|NP]] [[zooref#oks94|[OKS+94]]]. Indeed, any self-reducible problem in IC[log,poly] is also in [[#p|P]]. Strictly contains [[#plog|P/log]], and is strictly contained in [[#ppoly|P/poly]]. ---- ===== <span id="ip" style="color:red">IP</span>: Interactive Proof ===== The class of decision problems for which a "yes" answer can be verified by an <i>interactive proof</i>. Here a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier sends messages back and forth with an all-powerful prover. They can have polynomially many rounds of interaction. Given the verifier's algorithm, at the end: <ol> <li>If the answer is "yes," the prover must be able to behave in such a way that the verifier accepts with probability at least 2/3 (over the choice of the verifier's random bits).</li> <li>If the answer is "no," then however the prover behaves the verifier must reject with probability at least 2/3.</li> </ol> IP contains [[#ph|PH]] [[zooref#lfk90|[LFK+90]]], and indeed (this was discovered only a few days later) equals [[#pspace|PSPACE]] [[zooref#sha90|[Sha90]]]. On the other hand, [[#conp|coNP]] is not contained in IP relative to a random oracle [[zooref#ccg94|[CCG+94]]]. See also: [[#mip|MIP]], [[#qip|QIP]], [[#ma|MA]], [[#am|AM]]. ---- ===== <span id="ipp" style="color:red">IPP</span>: Unbounded [[#ip|IP]] ===== Same as [[#ip|IP]], except that if the answer is "yes," there need only be a prover strategy that causes the verifier to accept with probability greater than 1/2, while if the answer is "no," then for all prover strategies the verifier accepts with probability less than 1/2. Defined in [[zooref#ccg94|[CCG+94]]], where it was also shown that IPP = [[#pspace|PSPACE]] relative to <i>all</i> oracles. Since [[#ip|IP]] is strictly contained in [[#pspace|PSPACE]] relative to a random oracle, the authors interpreted this as evidence against the Random Oracle Hypothesis (a slight change in definition can cause the behavior of a class relative to a random oracle to change drastically). See also: [[#ppspace|PPSPACE]]. ---- ===== <span id="ippolylog" style="color:red">IP[polylog]</span>: Alternate Name for [[#ampolylog|AM[polylog]]] ===== ---- ===== <span id="l" style="color:red">L</span>: Logarithmic Space ===== The class of decision problems solvable by a Turing machine restricted to use an amount of memory logarithmic in the size of the input, n. (The input itself is not counted as part of the memory.) L contains [[#nc1|NC<sup>1</sup>]] [[zooref#bor77|[Bor77]]], and is contained in generalizations including [[#nl|NL]], [[#l/poly|L/poly]], [[#sl|SL]], [[#rl|RL]], [[#parityl|&#8853;L]], and [[#modkl|Mod<sub>k</sub>L]]. Reingold [[zooref#rei04|[Rei04]]] showed that, remarkably, L = [[#sl|SL]]. In other words, undirected graph connectivity is solvable in deterministic logarithmic space. ---- ===== <span id="lin" style="color:red">LIN</span>: Linear Time ===== The class of decision problems solvable by a deterministic Turing machine in linear time. Contained in [[#nlin|NLIN]]. ---- ===== <span id="lkp" style="color:red">L<sub>k</sub>P</span>: Low Hierarchy In [[#np|NP]] ===== The class of problems A such that [[#ph|&#931;<sub>k</sub>P]]<sup>A</sup> = [[#ph|&#931;<sub>k</sub>P]]; that is, adding A as an oracle does not increase the power of the k<sup>th</sup> level of the polynomial hierarchy. L<sub>1</sub>P = [[#npiconp|NP &#8745; coNP]]. For all k, L<sub>k</sub> is contained in L<sub>k+1</sub> and in [[#np|NP]]. Defined in [[zooref#sch83|[Sch83]]]. See also [[#hkp|H<sub>k</sub>P]]. ---- ===== <span id="logcfl" style="color:red">LOGCFL</span>: Logarithmically Reducible to CFL ===== The class of decision problems reducible in [[#l|L]] to the problem of deciding membership in a context-free language. Equivalently, LOGCFL is the class of decision problems solvable by a uniform family of [[#ac1|AC<sup>1</sup>]] circuits, in which no AND gate has fan-in exceeding 2 (see e.g. [[zooref#joh90|[Joh90]]], p. 137). LOGCFL is closed under complement [[zooref#bcd89|[BCD+89]]]. Contains [[#nl|NL]] [[zooref#sud78|[Sud78]]]. ---- ===== <span id="logfew" style="color:red">LogFew</span>: Logspace-Bounded [[#few|Few]] ===== The class of decision problems solvable by an [[#nl|NL]] machine such that <ol> <li>The number of accepting paths on input x is f(x), and</li> <li>The answer is 'yes' if and only if R(x,f(x))=1, where R is some predicate computable in [[#l|L]].</li> </ol> Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that LogFew is contained in [[#modkl|Mod<sub>k</sub>L]] for all k>1. ---- ===== <span id="logfewnl" style="color:red">LogFewNL</span>: Logspace-Bounded [[#fewp|FewP]] ===== Same as [[#fewp|FewP]] but for logspace-bounded (i.e. [[#nl|NL]]) machines. Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that LogFewNL is contained in [[#modzkl|ModZ<sub>k</sub>L]] for all k>1. ---- ===== <span id="lognp" style="color:red">LOGNP</span>: Logarithmically-Restricted [[#np|NP]] ===== The class of decision problems expressible in logical form as <ul> The set of I for which there exists a subset S={s<sub>1</sub>,...,s<sub>log n</sub>} of {1,...,n} of size log n, such that for all x there exists y such that for all j, the predicate &phi;(I,s<sub>j</sub>,x,y,j) holds. Here x and y are logarithmic-length strings, or equivalently polynomially bounded numbers, and &phi; is computable in [[#p|P]]. </ul> LOGNP<sub>0</sub> is the subclass in which &phi; is a first-order predicate without quantifiers and x and y are bounded lists of indices of input bits. LOGNP is also the closure of LOGNP<sub>0</sub> under many-one reduction. The motivation is that the analogue of LOGNP<sub>0</sub> without the logarithmic bound on |S| is [[#soe|SO-E]], which by Fagin's theorem equals [[#np|NP]] [[zooref#fag74|[Fag74]]]. Defined in [[zooref#py96|[PY96]]], where it was also shown that the following problem is complete for LOGNP under many-one reductions: <ul> <i>Vapnik-Chervonenkis (V-C) Dimension.</i> Given a family F of subsets of a set U, find a subset of S of U of maximum cardinality, such that every subset of S can be written as the intersection of S with some set in F. </ul> Contains [[#logsnp|LOGSNP]], and is contained in [[#betap|&#946;P]] (indeed &#946;<sub>2</sub>P). ---- ===== <span id="logsnp" style="color:red">LOGSNP</span>: Logarithmically-Restricted [[#snp|SNP]] ===== The class of decision problems expressible in logical form as <ul> The set of I for which there exists a subset S={s<sub>1</sub>,...,s<sub>log n</sub>} of {1,...,n} of size log n, such that for all x there exists j such that the predicate &phi;(I,s<sub>j</sub>,x,j) holds. Here x and y are logarithmic-length strings, or equivalently polynomially bounded numbers, and &phi; is computable in [[#p|P]]. </ul> LOGSNP<sub>0</sub> is the subclass in which &phi; is a first-order predicate without quantifiers and x is a bounded lists of indices of input bits. LOGSNP is also the closure of LOGSNP<sub>0</sub> under many-one reduction. See [[#lognp|LOGNP]] and [[#snp|SNP]] for the motivation. Defined in [[zooref#py96|[PY96]]]. Contained in [[#lognp|LOGNP]], and therefore [[#qplin|QPLIN]]. If [[#p|P]] = LOGSNP, then for every constructible f(n) &gt; n, [[#ntime|NTIME]](f(n)) is contained in [[#dtime|DTIME]](g(n)<sup>sqrt(g(n))</sup>), where g(n) = O(f(n) logf(n)) [[zooref#fk97|[FK97]]]. ---- ===== <span id="l/poly" style="color:red">L/poly</span>: Nonuniform Logarithmic Space ===== Has the same relation to [[#l|L]] as [[#ppoly|P/poly]] does to [[#p|P]]. Equals [[#pbp|PBP]] [[zooref#cob66|[Cob66]]]. Contains [[#sl|SL]] [[zooref#akl79|[AKL+79]]]. ---- ===== <span id="lwpp" style="color:red">LWPP</span>: Length-Dependent Wide [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then the difference of these numbers equals a function f(|x|) computable in polynomial time (i.e. [[#fp|FP]]). Here |x| is the length of the input x, and polynomial time'' means polynomial in |x|, the length of x, rather than the length of |x|.</li> </ol> Defined in [[zooref#ffk94|[FFK94]]], where it was also shown that LWPP is low for [[#pp|PP]] and [[#cequalsp|C<sub>=</sub>P]]. (I.e. adding LWPP as an oracle does not increase the power of these classes.) Contained in [[#wpp|WPP]] and [[#awpp|AWPP]]. Contains [[#spp|SPP]]. Also, contains the graph isomorphism problem [[zooref#kst92|[KST92]]]. Contains a whole litter of problems for solvable black-box groups: group intersection, group factorization, coset intersection, and double-coset membership [[zooref#vin04|[Vin04]]] ---- ===== <span id="ma" style="color:red">MA</span>: Merlin-Arthur ===== The class of decision problems solvable by a <i>Merlin-Arthur protocol</i>, which goes as follows. Merlin, who has unbounded computational resources, sends Arthur a polynomial-size purported proof that the answer to the problem is "yes." Arthur must verify the proof in [[#bpp|BPP]] (i.e. probabilistic polynomial-time), so that <ol> <li>If the answer is "yes," then there exists a proof such that Arthur accepts with probability at least 2/3.</li> <li>If the answer is "no," then for all proofs Arthur accepts with probability at most 1/3.</li> </ol> An alternative definition requires that if the answer is "yes," then there exists a proof such that Arthur accepts with certainty. However, the definitions with one-sided and two-sided error can be shown to be equivalent (exercise for the Zoo visitor). Contains [[#np|NP]] and [[#existsbpp|&#8707;BPP]], and is contained in [[#am|AM]] and in [[#qma|QMA]]. Also contained in [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]]. There exists an oracle relative to which [[#bqp|BQP]] is not in [[#ma|MA]] [[zooref#wat00|[Wat00]]]. Equals [[#np|NP]] under a derandomization assumption. See also: [[#mae|MA<sub>E</sub>]], [[#maexp|MA<sub>EXP</sub>]]. ---- ===== <span id="maprime" style="color:red">MA'</span>: Sparse [[#ma|MA]] ===== The subclass of [[#ma|MA]] such that for each input size n, there is a sparse set S<sub>n</sub> that Merlin's proof string always belongs to (no matter what the input is). Defined in [[zooref#kst93|[KST93]]], where it is also observed that if graph isomorphism is in [[#ppoly|P/poly]], then the complement of graph isomorphism is in MA'. ---- ===== <span id="mac0" style="color:red">MAC<sup>0</sup></span>: Majority of [[#ac0|AC<sup>0</sup>]] ===== Same as [[#ac0|AC<sup>0</sup>]], except now we're allowed a single unbounded-fanin majority gate at the root. Defined in [[zooref#jks02|[JKS02]]]. MAC<sup>0</sup> is strictly contained in [[#tc0|TC<sup>0</sup>]] [[zooref#abf94|[ABF+94]]]. ---- ===== <span id="mae" style="color:red">MA<sub>E</sub></span>: Exponential-Time [[#ma|MA]] With Linear Exponent ===== Same as [[#ma|MA]], except now Arthur is [[#e|E]] instead of polynomial-time. If MA<sub>E</sub> = [[#nee|NEE]] then [[#ma|MA]] = [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="maexp" style="color:red">MA<sub>EXP</sub></span>: Exponential-Time [[#ma|MA]] ===== Same as [[#ma|MA]], except now Arthur is [[#exp|EXP]] instead of polynomial-time, and the message from Merlin can be exponentially long. There is a problem in MA<sub>EXP</sub> that does not have polynomial-size circuits [[zooref#bft98|[BFT98]]]. On the other hand, there is an oracle relative to which every problem in MA<sub>EXP</sub> does have polynomial-size circuits. [[zooref#mvw99|[MVW99]]] considered the best circuit lower bound obtainable for a problem in MA<sub>EXP</sub>, using current techniques. They found that this bound is <i>half-exponential</i>: i.e. a function f such that f(f(n))=2<sup>n</sup>. Such functions exist, but are not expressible using standard asymptotic notation. ---- ===== <span id="mal" style="color:red">mAL</span>: Monotone [[#al|AL]] ===== Defined in [[zooref#gs90|[GS90]]]. Equals [[#mp|mP]] by definition. ---- ===== <span id="maxnp" style="color:red">MaxNP</span>: Maximization [[#np|NP]] ===== Has the same relation to [[#np|NP]] as [[#maxsnp|MaxSNP]] does to [[#snp|SNP]]. Contains [[#maxpb|MaxPB]]. The closure of MaxNP under [[#ptas|PTAS]] reduction is [[#apx|APX]] [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. ---- ===== <span id="maxpb" style="color:red">MaxPB</span>: [[#maxnp|MaxNP]] Polynomially Bounded ===== The subclass of [[#maxnp|MaxNP]] problems for which the cost function is guaranteed always to be bounded by a polynomial. [[#minpb|MinPB]] can be defined similarly. Defined in [[zooref#kt94|[KT94]]]. The closure of MaxPB under [[#ptas|PTAS]] reductions equals [[#npopb|NPOPB]] [[zooref#cks99|[CKS+99]]]. ---- ===== <span id="maxsnp" style="color:red">MaxSNP</span>: Maximization [[#snp|SNP]] ===== The class of optimization problems reducible by an "L-reduction" to a problem in [[#maxsnp0|MaxSNP<sub>0</sub>]]. (<i>Note:</i> 'L' stands for linear -- this is <i>not</i> the same as an [[#l|L]] reduction! For more details see [[zooref#py88|[PY88]]].) Defined in [[zooref#py88|[PY88]]], where the following was also shown: <ul> <li>Max3SAT is MaxSNP-complete. (Max3SAT is the problem of finding an assignment that maximizes the number of satisfied clauses in a CNF formula with at most 3 literals per clause.)</li> <li>Any problem in MaxSNP can be approximated to within a fixed ratio.</li> </ul> The closure of MaxSNP under [[#ptas|PTAS]] reduction is [[#apx|APX]] [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. ---- ===== <span id="maxsnp0" style="color:red">MaxSNP<sub>0</sub></span>: Generating Class of MaxSNP ===== The class of function problems expressible as "find a relation such that the set of k-tuples for which a given [[#snp|SNP]] predicate holds has maximum cardinality." For example (see [[zooref#pap94|[Pap94]]]), the Max-Cut problem can be expressed as follows: <ul> Given a graph G, find a subset S of vertices that maximizes the number of pairs (u,v) of vertices such that u is in S, and v is not in S, and G has an edge from u to v. </ul> Defined in [[zooref#py88|[PY88]]]. ---- ===== <span id="mconl" style="color:red">mcoNL</span>: Complement of [[#mnl|mNL]] ===== Defined in [[zooref#gs90|[GS90]]], where it was also shown that mcoNL does not equal [[#mnl|mNL]]. See also: [[#ml|mL]]. ---- ===== <span id="minpb" style="color:red">MinPB</span>: MinNP Polynomially Bounded ===== Same as [[#maxpb|MaxPB]] but for minimization instead of maximization problems. ---- ===== <span id="mip" style="color:red">MIP</span>: Multi-Prover Interactive Proof ===== Same as [[#ip|IP]], except that now the verifier can exchange messages with many provers, not just one. The provers cannot communicate with each other during the execution of the protocol, so the verifier can "cross-check" their assertions (as with suspects in separate interrogation rooms). Defined in [[zooref#bgk88|[BGK+88]]]. Let MIP[k] be the class of decision problems for which a "yes" answer can be verified with k provers. Then for all k&gt;2, MIP[k] = MIP = MIP [[zooref#bgk88|[BGK+88]]]. MIP equals [[#nexp|NEXP]] [[zooref#bfl91|[BFL91]]]; this is a famous non-relativizing result. ---- ===== <span id="mipstar21" style="color:red">MIP*[2,1]</span>: 2-Prover, 1-Round [[#mip|MIP]] With Quantum Provers ===== Same as [[#mip|MIP]], except that now only one round is allowed, and the two provers can share arbitrarily many entangled qubits. The verifier is classical, as are all messages between the provers and verifier. Defined in [[zooref#cht04|[CHT+04]]], where evidence was given suggesting that MIP* does not "obviously" equal [[#nexp|NEXP]]. By contrast, MIP[2,1], the corresponding class without entanglement, equals [[#nexp|NEXP]]. Indeed, the relationship between MIP* and [[#mip|MIP]] = [[#nexp|NEXP]] is completely unknown -- either could contain the other, or they could be incomparable. It is also unknown whether increasing the number of provers or rounds changes MIP*[2,1]. Contains [[#xormipstar21|XOR-MIP*[2,1]]]. ---- ===== <span id="mipexp" style="color:red">MIP<sub>EXP</sub></span>: Exponential-Time Multi-Prover Interactive Proof ===== The exponential-time analogue of [[#mip|MIP]]. In the unrelativized world, equals [[#neexp|NEEXP]]. There exists an oracle relative to which MIP<sub>EXP</sub> equals the intersection of [[#ppoly|P/poly]], [[#pnp|P<sup>NP</sup>]], and [[#parityp|&#8853;P]] [[zooref#bft98|[BFT98]]]. ---- ===== <span id="mkp" style="color:red">(M<sub>k</sub>)P</span>: Acceptance Mechanism by Monoid M<sub>k</sub> ===== A <i>monoid</i> is a set with an associative operation and an identity element (so it's like a group, except that it need not have inverses). Then (M<sub>k</sub>)P is the class of decision problems solvable by an [[#np|NP]] machine with the following acceptance mechanism. The i<sup>th</sup> computation path (under some lexicographic ordering) outputs an element m<sub>i</sub> of M<sub>k</sub>. Then the machine accepts if and only if m<sub>1</sub>m<sub>2</sub>...m<sub>s</sub> is the identity (where s is the number of paths). Defined by Hertrampf [[zooref#her97|[Her97]]], who also showed the following (in the special case M is a group): <ul> <li>If G is any nonsolvable group (for example S<sub>5</sub>, the symmetric group on 5 elements), then (G)P = [[#pspace|PSPACE]].</li> <li>(Z<sub>k</sub>)P = [[#comodkp|coMod<sub>k</sub>P]], where Z<sub>k</sub> is the cyclic group on k elements.</li> <li>If |G|=k, then (G)P contains [[#comodkp|coMod<sub>k</sub>P]].</li> </ul> ---- ===== <span id="ml" style="color:red">mL</span>: Monotone [[#l|L]] ===== The class of decision problems solvable by a family of monotone log-width polynomial-size leveled circuits. (A <i>leveled</i> circuit is one where gates on each level can depend only on the level immediately below it.) Defined in [[zooref#gs90|[GS90]]], who raise as an open problem to define a uniform version of mL. Strictly contains [[#mnc1|mNC<sup>1</sup>]] [[zooref#gs91|[GS91]]]. Contained in (nonuniform versions of) [[#mnl|mNL]] and [[#mconl|mcoNL]]. ---- ===== <span id="mmsnp" style="color:red">MMSNP</span>: Monadic Monotone [[#snp|SNP]] ===== Defined in [[zooref#fv93|[FV93]]] as a subclass of [[#snp|SNP]], where the second order existentially quantified variables are sets (monadic) and any relations in the first-order part occur negated (monotone). Further, no inequalities can occur in the first-order part. MMSNP seems to obey dichotomy, by excluding Ladner languages. This is still open but widely believed. Dropping any of the restrictions monotone/monadic/without inequalities allows Ladner languages unless P = NP, since any problem in NP is polynomial time equivalent to a problem in each of these broader classes. MMSNP therefore seems to be a maximal fragment of NP where Ladner languages are excluded. Every constraint satisfaction problem is expressible in MMSNP, and there is a polynomial time Turing reduction from every MMSNP query to finitely many constraint satisfaction problems. MMSNP therefore seems to capture the class of constraint satisfaction problems. ---- ===== <span id="mnc1" style="color:red">mNC<sup>1</sup></span>: Monotone [[#nc1|NC<sup>1</sup>]] ===== The class of decision problems solvable by a family of monotone [[#nc1|NC<sup>1</sup>]] circuits (i.e. AND and OR gates only). A uniformity condition could also be imposed. Defined in [[zooref#gs90|[GS90]]]. Strictly contained in [[#mnl|mNL]] [[zooref#kw88|[KW88]]], and indeed in [[#ml|mL]] [[zooref#gs91|[GS91]]]. Strictly contains [[#mtc0|mTC<sup>0</sup>]] [[zooref#yao89|[Yao89]]]. ---- ===== <span id="mnl" style="color:red">mNL</span>: Monotone [[#nl|NL]] ===== See [[#mp|mP]] for the definition of a monotone nondeterministic Turing machine, due to [[zooref#gs90|[GS90]]]. mNL is the class of decision problems solvable by a monotone nondeterministic log-space Turing machine. mNL does not equal [[#mconl|mcoNL]] [[zooref#gs90|[GS90]]], in contrast to the case for [[#nl|NL]] and [[#conl|coNL]]. Also, mNL strictly contains [[#mnc1|mNC<sup>1</sup>]] [[zooref#kw88|[KW88]]]. See also: [[#ml|mL]]. ---- ===== <span id="mnp" style="color:red">mNP</span>: Monotone [[#np|NP]] ===== The class of decision problems for which a 'yes' answer can be verified in [[#mp|mP]] (that is, monotone polynomial-time). The monotonicity requirement applies only to the input bits, not to the bits that are guessed nondeterministically. So, in the corresponding circuit, one can have NOT gates so long as they depend only on the nondeterministic guess bits. Defined in [[zooref#gs90|[GS90]]], where it was also shown that mNP is 'trivial': that is, it contains exactly the monotone problems in [[#np|NP]]. Strictly contains [[#mp|mP]] [[zooref#raz85|[Raz85]]]. ---- ===== <span id="modkl" style="color:red">Mod<sub>k</sub>L</span>: Mod-k [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#modkp|Mod<sub>k</sub>P]] does to [[#p|P]]. For any prime k, Mod<sub>k</sub>L contains [[#sl|SL]] [[zooref#kw93|[KW93]]]. For any prime k, Mod<sub>k</sub>L<sup>ModkL</sup> = Mod<sub>k</sub>L [[zooref#hrv00|[HRV00]]]. For any k>1, contains [[#logfew|LogFew]] [[zooref#bdh92|[BDH+92]]]. ---- ===== <span id="modkp" style="color:red">Mod<sub>k</sub>P</span>: Mod-k Polynomial-Time ===== For any k&gt;1: The class of decision problems solvable by an [[#np|NP]] machine such that the number of accepting paths is divisible by k, if and only if the answer is "no." Mod<sub>2</sub>P is more commonly known as [[#parityp|&#8853;P]] "parity-P." For every k, Mod<sub>k</sub>P contains graph isomorphism [[zooref#ak02|[AK02]]]. Defined in [[zooref#ch89|[CH89]]], [[zooref#her90|[Her90]]]. [[zooref#her90|[Her90]]] and [[zooref#bg92|[BG92]]] showed that Mod<sub>k</sub>P is the set of unions of languages in Mod<sub>p</sub>P for each prime p that divides k. In particular, if p is prime, then Mod<sub>p</sub>P = Mod<sub>p^m</sub>P for all positive integers m. A further fact is that Mod<sub>p</sub>P is closed under union, intersection, and complement for p prime. On the other hand, if k is not a prime power, then there exists an oracle relative to which Mod<sub>k</sub>P is not closed under intersection or complement [[zooref#bbr94|[BBR94]]]. For prime p, there exists an oracle relative to which Mod<sub>p</sub>P does not contain [[#eqp|EQP]] [[zooref#gv02|[GV02]]]. ---- ===== <span id="modp" style="color:red">ModP</span>: [[#modkp|Mod<sub>k</sub>P]] With Arbitrary k ===== The class of decision problems solvable by a [[#modkp|Mod<sub>k</sub>P]] machine where k can vary depending on the input. The only requirement is that 0<sup>k</sup> be computable in polynomial time. Defined in [[zooref#kt96|[KT96]]], where it was also shown that ModP is contained in [[#ampmp|AmpMP]]. ---- ===== <span id="modzkl" style="color:red">ModZ<sub>k</sub>L</span>: Restricted [[#modkl|Mod<sub>k</sub>L]] ===== The class of decision problems solvable by a nondeterministic logspace Turing machine, such that <ol> <li>If the answer is "yes," then the number of accepting paths is not congruent to 0 mod k.</li> <li>If the answer is "no," then there are no accepting paths.</li> </ol> Defined in [[zooref#bdh92|[BDH+92]]], where it was also shown that ModZ<sub>k</sub>L contains [[#logfewnl|LogFewNL]] for all k>1. Contained in [[#modkl|Mod<sub>k</sub>L]] and in [[#nl|NL]]. ---- ===== <span id="mp" style="color:red">mP</span>: Monotone [[#p|P]] ===== The definition of this class, due to [[zooref#gs90|[GS90]]], is not obvious. First, a <i>monotone nondeterministic Turing machine</i> is one such that, whenever it can make a transition with a 0 on its input tape, it can also make that same transition with a 1 on its input tape. (This restriction does not apply to the work tape.) A <i>monotone alternating Turing machine</i> is subject to the restriction that it can only reference an input bit x by, "there exists a z at most x," or "for all z at least x." Then applying the result of [[zooref#cks81|[CKS81]]] that [[#p|P]] = [[#al|AL]], mP is defined to be [[#mal|mAL]]: the class of decision problems solvable by a monotone alternating log-space Turing machine. Actually there's a caveat: A monotone Turing machine or circuit can first negate the <i>entire</i> input, then perform a monotone computation. That way it becomes meaningful to talk about whether a monotone complexity class is closed under complement. Strictly contained in [[#mnp|mNP]] [[zooref#raz85|[Raz85]]]. Deciding whether a bipartite graph has a perfect matching, despite being both a monotone problem and in [[#p|P]], requires monotone circuits of superpolynomial size [[zooref#raz85b|[Raz85b]]]. Letting MONO be the class of monotone problems, it follows that mP is strictly contained in MONO &#8745; [[#p|P]]. See also: [[#mnc1|mNC<sup>1</sup>]], [[#ml|mL]], [[#mnl|mNL]], [[#mconl|mcoNL]]. ---- ===== <span id="mp2" style="color:red">MP</span>: Middle-Bit [[#p|P]] ===== The class of decision problems such that for some [[#sharpp|#P]] function f, the answer on input x is 'yes' if and only if the middle bit of f(x) is 1. Defined in [[zooref#gkr95|[GKR+95]]]. Contains [[#ampmp|AmpMP]] and [[#ph|PH]]. MP with [[#modp|ModP]] oracle equals MP with [[#sharpp|#P]] oracle [[zooref#kt96|[KT96]]]. ---- ===== <span id="mpc" style="color:red">MPC</span>: Monotone Planar Circuits ===== The class of decision problems solvable by a family of <i>monotone stratified planar circuits</i> (a uniformity condition may also be imposed). Such a circuit can contain only AND and OR gates of bounded fanin. It must be embeddable in the plane with no wires crossing. Furthermore, the input bits can only be accessed at the bottom level, where they are listed in order (x<sub>1</sub>,...,x<sub>n</sub>). Defined in [[zooref#dc89|[DC89]]]. [[zooref#blm99|[BLM+99]]] showed that we can assume without loss of generality that the circuit has width n and depth n<sup>3</sup>. ---- ===== <span id="mppoly" style="color:red">mP/poly</span>: Monotone [[#ppoly|P/poly]] ===== The class of decision problems solvable by a nonuniform family of polynomial-size Boolean circuits with only AND and OR gates, no NOT gates. (Or rather, following the definitions of [[zooref#gs90|[GS90]]], the entire input can be negated as long as there are no other negations.) More straightforward to define than [[#mp|mP]]. ---- ===== <span id="mtc0" style="color:red">mTC<sup>0</sup></span>: Monotone [[#tc0|TC<sup>0</sup>]] ===== The class of decision problems solvable by a family of monotone [[#tc0|TC<sup>0</sup>]] circuits (i.e. constant-depth, polynomial-size, AND, OR, and threshold gates, but no NOT gates). A uniformity condition could also be imposed. Defined in [[zooref#gs90|[GS90]]]. Strictly contained in [[#mnc1|mNC<sup>1</sup>]] [[zooref#yao89|[Yao89]]]. ---- ===== <span id="nauxpdap" style="color:red">NAuxPDA<sup>p</sup></span>: Nondeterministic Auxiliary Pushdown Automata ===== The class of problems solvable by nondeterministic logarithmic-space and polynomial-time Turing machines with auxiliary pushdown. Equals [[#logcfl|LOGCFL]] [[zooref#sud78|[Sud78]]]. ---- ===== <span id="nc" style="color:red">NC</span>: Nick's Class ===== (Named in honor of Nick Pippenger.) NC<sup>i</sup> is the class of decision problems solvable by a nonuniform family of Boolean circuits, with polynomial size, depth O(log<sup>i</sup>(n)), and fan-in 2. Then NC is the union of NC<sup>i</sup> over all nonnegative i. Also, NC equals the union of [[#ptwk|PT/WK]](log<sup>k</sup>n, n<sup>k</sup>)/poly over all constants k. NC<sup>i</sup> is contained in [[#ac|AC]]<sup>i</sup>; thus, NC = [[#ac|AC]]. Contains [[#nl|NL]]. Generalizations include [[#rnc|RNC]] and [[#qnc|QNC]]. [[zooref#in96|[IN96]]] construct a candidate pseudorandom generator in NC based on the subset sum problem. For a random oracle A, (NC<sup>i</sup>)<sup>A</sup> is strictly contained in (NC<sup>i+1</sup>)<sup>A</sup>, and uniform NC<sup>A</sup> is strictly contained in P<sup>A</sup>, with probability 1 [[zooref#mil92|[Mil92]]]. ---- ===== <span id="nc0" style="color:red">NC<sup>0</sup></span>: Level 0 of [[#nc|NC]] ===== By definition, a decision problem in NC<sup>0</sup> can depend on only a constant number of bits of the input. Thus, NC<sup>0</sup> usually refers to <i>functions</i> computable by constant-depth, bounded-fanin circuits. There is a family of permutations computable by a uniform family of NC<sup>0</sup> circuits that is [[#p|P]]-hard to invert [[zooref#has88|[Has88]]]. Recently [[zooref#aik04|[AIK04]]] solved a longstanding open problem by showing that there exist pseudorandom generators and one-way functions in NC<sup>0</sup>, based on (for example) the hardness of factoring. Specifically, in these generators every bit of the output depends on only 4 input bits. Whether the dependence can be reduced to 3 bits under the same cryptographic assumptions is open, but [[zooref#aik04|[AIK04]]] have some partial results in this direction. It is known that the dependence cannot be reduced to 2 bits. ---- ===== <span id="nc1" style="color:red">NC<sup>1</sup></span>: Level 1 of [[#nc|NC]] ===== See [[#nc|NC]] for definition. [[zooref#kv94|[KV94]]] give a family of functions that is computable in NC<sup>1</sup>, but not efficiently learnable unless there exists an efficient algorithm for factoring Blum integers. Was shown to equal 5-[[#kpbp|PBP]] [[zooref#bar89|[Bar89]]]. On the other hand, width 5 is necessary unless NC<sup>1</sup> = [[#acc0|ACC<sup>0</sup>]] [[zooref#bt88|[BT88]]]. As an application of this result, NC<sup>1</sup> can be simulated on a quantum computer with three qubits, one initialized to a pure state and the remaining two in the maximally mixed state [[zooref#asv00|[ASV00]]]. Surprisingly, [[zooref#amp02|[AMP02]]] showed that only a <i>single</i> qubit is needed to simulate NC<sup>1</sup> - i.e. that NC<sup>1</sup> is contained in 2-[[#eqbp|EQBP]]. (Complex amplitudes are needed for this result.) Is contained in [[#l|L]] [[zooref#bor77|[Bor77]]]. Contains [[#tc0|TC<sup>0</sup>]]. NC<sup>1</sup> contains the integer division problem [[zooref#bch86|[BCH86]]], even if an [[#l|L]]-uniformity condition is imposed [[zooref#cdl01|[CDL01]]]. ---- ===== <span id="nc2" style="color:red">NC<sup>2</sup></span>: Level 2 of [[#nc|NC]] ===== See [[#nc|NC]] for definition. Contains [[#nl|NL]]. ---- ===== <span id="ne" style="color:red">NE</span>: Nondeterministic [[#e|E]] ===== Nondeterministic exponential time with linear exponent (i.e. [[#ntime|NTIME]](2<sup>O(n)</sup>)). [[#p|P]]<sup>NE</sup> = [[#np|NP]]<sup>NE</sup> [[zooref#hem89|[Hem89]]]. Contained in [[#nexp|NEXP]]. ---- ===== <span id="nearlyp" style="color:red">Nearly-[[#p|P]]</span>: Languages Superpolynomially Close to P ===== The set of languages L such that for every k, there is a language L_k in P that differs from L on at most 2^n/n^k inputs of length n. Discussed in [[zooref#ns05|[NS05]]] and implicitly defined in [[zooref#yam99|[Yam99]]]. ---- ===== <span id="nepoly" style="color:red">NE/poly</span>: Nonuniform [[#ne|NE]] ===== Contains [[#cone|coNE]], just as [[#nexppoly|NEXP/poly]] contains [[#conexp|coNEXP]]. ---- ===== <span id="nee" style="color:red">NEE</span>: Nondeterministic [[#ee|EE]] ===== Nondeterministic double-exponential time with linear exponent (i.e. [[#ntime|NTIME]](2<sup>2^O(n)</sup>)). If [[#mae|MA<sub>E</sub>]] = NEE then [[#ma|MA]] = [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]] [[zooref#ikw01|[IKW01]]]. Contained in [[#neexp|NEEXP]]. ---- ===== <span id="neee" style="color:red">NEEE</span>: Nondeterministic [[#eee|EEE]] ===== Nondeterministic triple-exponential time with linear exponent. ---- ===== <span id="neexp" style="color:red">NEEXP</span>: Nondeterministic [[#eexp|EEXP]] ===== Nondeterministic double-exponential time (i.e. [[#ntime|NTIME]](2<sup>2^p(n)</sup>) for p a polynomial). Equals [[#mipexp|MIP<sub>EXP</sub>]] (unrelativized). ---- ===== <span id="nexp" style="color:red">NEXP</span>: Nondeterministic [[#exp|EXP]] ===== Nondeterministic exponential time (i.e. [[#ntime|NTIME]](2<sup>p(n)</sup>) for p a polynomial). Equals [[#mip|MIP]] [[zooref#bfl91|[BFL91]]] (but not relative to all oracles). NEXP is in [[#ppoly|P/poly]] if and only if NEXP = [[#ma|MA]] [[zooref#ikw01|[IKW01]]]. [[zooref#ki02|[KI02]]] show the following: <ul> <li>If [[#p|P]] = [[#rp|RP]], then NEXP is not computable by polynomial-size arithmetic circuits.</li> <li>If [[#p|P]] = [[#bpp|BPP]] and if checking whether a Boolean circuit computes a function that is close to a low-degree polynomial over a finite field is in [[#p|P]], then NEXP is not in [[#ppoly|P/poly]].</li> <li>If NEXP is in [[#ppoly|P/poly]], then matrix permanent is NEXP-complete.</li> </ul> Does not equal [[#np|NP]] [[zooref#sfm78|[SFM78]]]. Does not equal [[#exp|EXP]] if and only if there is a sparse set in [[#np|NP]] that is not in [[#p|P]]. There exists an oracle relative to which [[#exp|EXP]] = NEXP but still [[#p|P]] does not equal [[#np|NP]] [[zooref#dek76|[Dek76]]]. The theory of reals with addition (see [[#expspace|EXPSPACE]]) is hard for NEXP [[zooref#fr74|[FR74]]]. ---- ===== <span id="nexppoly" style="color:red">NEXP/poly</span>: Nonuniform [[#nexp|NEXP]] ===== Contains [[#conexp|coNEXP]] (folklore result reported in [[http://weblog.fortnow.com/|Fortnow's weblog]]). ---- ===== <span id="niqszk" style="color:red">NIQSZK</span>: Non-Interactive [[#qszk|QSZK]] ===== Has the same relation to [[#qszk|QSZK]] as [[#niszk|NISZK]] does to [[#szk|SZK]]. Defined in [[zooref#kob02|[Kob02]]], where it was also shown that the following promise problem is complete for NIQSZK. Given a quantum circuit, we are promised that the state it prepares (when run on the all-0 state, and tracing out non-output qubits) has trace distance either at most 1/3 or at least 2/3 from the maximally mixed state. The problem is to output "no" in the former case and "yes" in the latter. NIQPZK can be defined similarly. ---- ===== <span id="niszk" style="color:red">NISZK</span>: Non-Interactive [[#szk|SZK]] ===== Defined in [[zooref#ddp98|[DDP+98]]]. Contained in [[#szk|SZK]]. [[zooref#gsv99|[GSV99]]] showed the following: <ul> <li>If [[#szk|SZK]] does not equal [[#bpp|BPP]] then NISZK does not equal [[#bpp|BPP]].</li> <li>NISZK equals [[#szk|SZK]] if and only if NISZK is closed under complement.</li> <li>NISZK has natural complete promise problems:</li> <ul> <li><i>Statistical Distance from Uniform (SDU)</i>: Given a circuit, consider the distribution over outputs when the circuit is given a uniformly random n-bit string. We're promised that the trace distance between this distribution and the uniform distribution is either at most 1/3 or at least 2/3. The problem is to output "yes" in the former case and "no" in the latter.</li> <li><i>Entropy Approximation (EA)</i>: Now we're promised that the entropy of the circuit's output distribution is either at least k+1 or at most k-1. The problem is to output "yes" in the former case and "no" in the latter.</li> </ul> </ul> NIPZK can be defined similarly. ---- ===== <span id="niszkh" style="color:red">NISZK<sub>h</sub></span>: [[#niszk|NISZK]] With Limited Help ===== The non-interactive analogue of [[#szkh|SZK<sub>h</sub>]]. Defined in [[zooref#bg03|[BG03]]], where the following was also shown: <ul> <li>NISZK<sub>h</sub> contains [[#niszk|NISZK]] and is contained in [[#szk|SZK]].</li> <li>Graph Isomorphism is in NISZK<sub>h</sub>.</li> <li>The following problem is complete for NISZK<sub>h</sub>: Given two functions from {0,1}<sup>n</sup> to {0,1}<sup>n</sup> (specified by circuits), decide whether their ranges are almost equal or almost disjoint, given that one of these is the case.</li> </ul> The quantum lower bound for the set comparison problem in [[zooref#aar02|[Aar02]]] implies an oracle relative to which NISZK<sub>h</sub> is not in [[#bqp|BQP]]. ---- ===== <span id="nl" style="color:red">NL</span>: Nondeterministic Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#np|NP]] does to [[#p|P]]. In a breakthrough result, was shown to equal [[#conl|coNL]] [[zooref#imm88|[Imm88]]] [[zooref#sze87|[Sze87]]]. (Though contrast to [[#mnl|mNL]].) Is contained in [[#logcfl|LOGCFL]] [[zooref#sud78|[Sud78]]], as well as [[#nc2|NC<sup>2</sup>]]. Is contained in [[#ulpoly|UL/poly]] [[zooref#ra00|[RA00]]]. Deciding whether a bipartite graph has a perfect matching is hard for NL [[zooref#kuw86|[KUW86]]]. ---- ===== <span id="nlpoly" style="color:red">NL/poly</span>: Nonuniform [[#nl|NL]] ===== Has the same relation to [[#nl|NL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Is contained in [[#paritylpoly|&#8853;L/poly]] [[zooref#gw96|[GW96]]], as well as [[#sac1|SAC<sup>1</sup>]]. Equals [[#ulpoly|UL/poly]] [[zooref#ra00|[RA00]]]. ---- ===== <span id="nlog" style="color:red">NLOG</span>: [[#nl|NL]] With Nondeterministic Oracle Tape ===== Same as [[#nl|NL]] -- but if there's an oracle, then NLOG can make queries nondeterministically on a polynomial-size, one-way oracle tape. ([[#nl|NL]], by contrast, can use nondeterministic transitions only on the worktape; oracle queries have to be deterministic.) See [[zooref#ll76|[LL76]]] or [[zooref#hck88|[HCK+88]]] for more information. Although NLOG is contained in [[#p|P]], there exists an oracle relative to which that is not the case. This illustrates that care is needed when defining oracle access mechanisms. ---- ===== <span id="nlin" style="color:red">NLIN</span>: Nondeterministic [[#lin|LIN]] ===== Has the same relation to [[#lin|LIN]] as [[#np|NP]] does to [[#p|P]]. ---- ===== <span id="none" style="color:red">NONE</span>: The Empty Class ===== The class that does not contain any languages. (It might not surprise you that I put this one in at the suggestion of a mathematician...) Is the opposite of [[#all|ALL]], but does not equal the complement [[#all|coALL]] = [[#all|ALL]]. Is closed under polynomial-time Turing reductions :-). Equals [[#sparse|SPARSE]] &#8745; [[#cosparse|coSPARSE]] and [[#tally|TALLY]] &#8745; [[#tally|coTALLY]]. ---- ===== <span id="np" style="color:red">NP</span>: Nondeterministic Polynomial-Time ===== The class of dashed hopes and idle dreams. More formally: an "NP machine" is a nondeterministic polynomial-time Turing machine. Then NP is the class of decision problems solvable by an NP machine such that <ol> <li>If the answer is "yes," at least one computation path accepts.</li> <li>If the answer is "no," all computation paths reject.</li> </ol> Equivalently, NP is the class of decision problems such that, if the answer is "yes," then there is a proof of this fact, of length polynomial in the size of the input, that can be verified in [[#p|P]] (i.e. by a deterministic polynomial-time algorithm). On the other hand, if the answer is "no," then the algorithm must declare invalid any purported proof that the answer is "yes." For example, the SAT problem is to decide whether a given Boolean formula has any satisfying truth assignments. SAT is in NP, since a "yes" answer can be proved by just exhibiting a satisfying assignment. A decision problem is NP-complete if (1) it is in NP, and (2) any problem in NP can be reduced to it (under some notion of reduction). The class of NP-complete problems is sometimes called [[#npc|NPC]]. That NP-complete problems exist is immediate from the definition. The seminal result of Cook [[zooref#coo71|[Coo71]]], Karp [[zooref#kar72|[Kar72]]], and Levin [[zooref#lev73|[Lev73]]] is that many <i>natural</i> problems (that have nothing to do with Turing machines) are NP-complete. The first such problem to be shown NP-complete was SAT [[zooref#coo71|[Coo71]]]. Other classic NP-complete problems include: <ul> <li>'''3-Colorability''': Given a graph, can each vertex be colored red, green, or blue so that no two neighboring vertices have the same color?</li> <li>'''Hamiltonian Cycle''': Given a graph, is there a cycle that visits each vertex exactly once?</li> <li>'''Traveling Salesperson''': Given a set of n cities, and the distance between each pair of cities, is there a route that visits each city exactly once before returning to the starting city, and has length at most T?</li> <li>'''Maximum Clique''': Given a graph, are there k vertices all of which are neighbors of each other?</li> <li>'''Subset Sum''': Given a collection of integers, is there a subset of the integers that sums to exactly x?</li> </ul> For many, many more NP-complete problems, see [[zooref#gj79|[GJ79]]]. NP contains [[#p|P]]. I've discovered a marvelous proof that NP and [[#p|P]] are unequal, but this web page is too small to contain it. Too bad, since otherwise I'd be eligible for$1,000,000 [[zooref#cmi00|[CMI00]]]. There exists an oracle relative to which [[#p|P]] and NP are unequal [[zooref#bgs75|[BGS75]]]. Indeed, [[#p|P]] and NP are unequal relative to a random oracle with probability 1 [[zooref#bg81|[BG81]]] (see [[zooref#afm01|[AFM01]]] for a novel take on this result). Though random oracle results are not always indicative about the unrelativized case [[zooref#ccg94|[CCG+94]]]. There even exists an oracle relative to which the [[#p|P]] versus NP problem is outside the usual axioms of set theory [[zooref#hh76|[HH76]]]. If we restrict to <i>monotone</i> classes, [[#mp|mP]] is strictly contained in [[#mnp|mNP]] [[zooref#raz85|[Raz85]]]. Perhaps the most important insight anyone has had into [[#p|P]] versus NP is to be found in [[zooref#rr97|[RR97]]]. There the authors show that no 'natural proof' can separate [[#p|P]] from NP (or more precisely, place NP outside of [[#ppoly|P/poly]]), unless secure pseudorandom generators do not exist. A proof is 'natural' if it satisfies two conditions called <i>constructivity</i> and <i>largeness</i>; essentially all lower bound techniques known to date satisfy these conditions. To obtain unnatural proof techniques, some people suspect we need to relate [[#p|P]] versus NP to heavy-duty 'traditional' mathematics, for instance algebraic geometry. See [[zooref#ms02|[MS02]]] (and the survey article [[zooref#reg02|[Reg02]]]) for a development of this point of view. For more on [[#p|P]] versus NP (circa 1992) see [[zooref#sip92|[Sip92]]]. For an opinion poll, see [[zooref#gas02|[Gas02]]]. If [[#p|P]] equals NP, then NP equals its complement [[#conp|coNP]]. Whether NP equals [[#conp|coNP]] is also open. NP and [[#conp|coNP]] can be extended to the polynomial hierarchy [[#ph|PH]]. The set of decision problems in NP, but not in [[#p|P]] or [[#npc|NPC]], is sometimes called [[#npi|NPI]]. If [[#p|P]] does not equal NP then [[#npi|NPI]] is nonempty [[zooref#lad75|[Lad75]]]. Probabilistic generalizations of NP include [[#ma|MA]] and [[#am|AM]]. If NP is in [[#coam|coAM]] (or [[#bpp|BPP]]) then [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]] [[zooref#bhz87|[BHZ87]]]. [[#ph|PH]] also collapses to [[#sigma2p|&#931;<sub>2</sub>P]] if NP is in [[#ppoly|P/poly]] [[zooref#kl82|[KL82]]]. There exist oracles relative to which NP is not in [[#bqp|BQP]] [[zooref#bbb97|[BBB+97]]]. An alternate characterization is NP = [[#pcp|PCP]](log n, O(1)) [[zooref#alm98|[ALM+98]]]. Also, [[zooref#fag74|[Fag74]]] gave a logical characterization of NP, which leads to the subclass [[#snp|SNP]]. ---- ===== <span id="npc" style="color:red">NPC</span>: [[#np|NP]]-Complete ===== The class of decision problems such that (1) they're in [[#np|NP]] and (2) every problem in [[#np|NP]] is reducible to them (under some notion of reduction). In other words, the hardest problems in [[#np|NP]]. Two notions of reduction from problem A to problem B are usually considered: <ol> <li><i>Karp</i> or <i>many-one</i> reductions. Here a polynomial-time algorithm is given as input an instance of problem A, and must produce as output an instance of problem B.</li> <li><i>Turing</i> reductions, in this context also called <i>Cook</i> reductions. Here the algorithm for problem B can make arbitrarily many calls to an oracle for problem A.</li> </ol> Some examples of NP-complete problems are discussed under the entry for [[#np|NP]]. The classic reference on NPC is [[zooref#gj79|[GJ79]]]. Unless [[#p|P]] = [[#np|NP]], NPC does not contain any sparse problems: that is, problems such that the number of 'yes' instances of size n is upper-bounded by a polynomial in n [[zooref#mah82|[Mah82]]]. A famous conjecture [[zooref#bh77|[BH77]]] asserts that all NP-complete problems are polynomial-time isomorphic -- i.e. between any two problems, there is a one-to-one and onto Karp reduction. If that's true, the NP-complete problems could be interpreted as mere "relabelings" of one another. NP-complete problems are <i>p-superterse</i> unless [[#p|P]] = [[#np|NP]] [[zooref#bks95|[BKS95]]]. This means that, given k Boolean formulas F<sub>1</sub>,...,F<sub>k</sub>, if you can rule out even <i>one</i> of the 2<sup>k</sup> possibilities in polynomial time (e.g., "if F<sub>1</sub>,...,F<sub>k-1</sub> are all unsatisfiable then F<sub>k</sub> is satisfiable"), then [[#p|P]] = [[#np|NP]]. ---- ===== <span id="npc2" style="color:red">NP<sub>C</sub></span>: [[#np|NP]] Over The Complex Numbers ===== An analog of [[#np|NP]] for Turing machines over a complex number field. Defined in [[zooref#bcs97|[BCS+97]]]. It is unknown whether [[#pc|P<sub>C</sub>]] = NP<sub>C</sub>, nor are implications known among this question, [[#pr2|P<sub>R</sub>]] versus [[#npr|NP<sub>R</sub>]], and [[#p|P]] versus [[#np|NP]]. However, [[zooref#ckk95|[CKK+95]]] show that if [[#ppoly|P/poly]] does not equal [[#nppoly|NP/poly]] then [[#pc|P<sub>C</sub>]] does not equal NP<sub>C</sub>. [[zooref#bcs97|[BCS+97]]] show the following striking result. For a positive integer n, let t(n) denote the minimum number of additions, subtractions, and multiplications needed to construct n, starting from 1. If for every sequence {n<sub>k</sub>} of positive integers, t(n<sub>k</sub> k!) grows faster than polylogarithmically in k, then [[#pc|P<sub>C</sub>]] does not equal NP<sub>C</sub>. See also [[#vnp|VNP<sub>k</sub>]]. ---- ===== <span id="npcc" style="color:red">NP<sup>cc</sup></span>: Communication Complexity [[#np|NP]] ===== The analogue of [[#pcc|P<sup>cc</sup>]] for nondeterministic communication complexity. Both communication bits and nondeterministic guess bits count toward the complexity. Does not equal [[#pcc|P<sup>cc</sup>]] or [[#conpcc|coNP<sup>cc</sup>]] because of the EQUALITY problem. Also, does not contain [[#bppcc|BPP<sup>cc</sup>]] because of that problem. Defined in [[zooref#bfs86|[BFS86]]]. Contained in [[#phcc|PH<sup>cc</sup>]]. ---- ===== <span id="npi" style="color:red">NPI</span>: [[#np|NP]]-Intermediate ===== Sometimes used to denote the set of decision problems in [[#np|NP]] that are neither NP-complete (that is, in [[#npc|NPC]]) nor in [[#p|P]]. Is thought to contain (for example) decision versions of factoring and graph isomorphism. Is nonempty if [[#p|P]] does not equal [[#np|NP]] [[zooref#lad75|[Lad75]]]. Indeed, under this assumption, it contains an infinite number of distinct polynomial-time equivalence classes. ---- ===== <span id="npiconp" style="color:red">NP &#8745; coNP</span> ===== The class of problems in both [[#np|NP]] and [[#conp|coNP]]. Contains factoring [[zooref#pra75|[Pra75]]]. Contains graph isomorphism under the assumption that some language in [[#ne|NE]] &#8745; [[#cone|coNE]] requires nondeterministic circuits of size 2<sup>&#937;(n)</sup> ([[zooref#mv99|[MV99]]], improving [[zooref#km99|[KM99]]]). (A nondeterministic circuit C has two inputs, x and y, and accepts on x if there exists a y such that C(x,y)=1.) Is not believed to contain complete problems. ---- ===== <span id="npiconppoly" style="color:red">(NP &#8745; coNP)/poly</span>: Nonuniform [[#npiconp|NP &#8745; coNP]] ===== Together with [[#nppoly|NP/poly &#8745; coNP/poly]], has the same relation to [[#npiconp|NP &#8745; coNP]] as [[#ppoly|P/poly]] has to [[#p|P]]. A language in (NP &#8745; coNP)/poly is defined by a single language in [[#npiconp|NP &#8745; coNP]] which is then modified by advice. A language in [[#nppoly|NP/poly &#8745; coNP/poly]] comes from two possibly different languages in [[#np|NP]] and [[#conp|coNP]] which become the same with good advice. There is an oracle relative to which [[#nppoly|NP/poly &#8745; coNP/poly]], indeed NP/1 &#8745; coNP/1, is not contained in (NP &#8745; coNP)/poly [[zooref#ffk93|[FFK+93]]]. Recently they improved this to NP/1 &#8745; coNP [[zooref#ff..|[FF..]]]. If [[#np|NP]] is contained in (NP &#8745; coNP)/poly, then [[#ph|PH]] collapses to [[#s2p|S<sub>2</sub>P]]<sup>[[#npiconp|NP &#8745; coNP]]</sup> [[zooref#cch01|[CCH+01]]]. ---- ===== <span id="nplog" style="color:red">NP/log</span>: [[#np|NP]] With Logarithmic Advice ===== Same as [[#nppoly|NP/poly]], except that now the advice string is logarithmic-size. ---- ===== <span id="npmv" style="color:red">NPMV</span>: [[#np|NP]] Multiple Value ===== The class of all (possibly partial, possibly multivalued) functions computed by an [[#np|NP]] machine as follows: ignore the rejecting paths, and consider any output of an accepting path to be "one of the outputs." Contains [[#npsv|NPSV]] and [[#npmvt|NPMV<sub>t</sub>]]. Defined in [[zooref#bls84|[BLS84]]]. Contrast with [[#fnp|FNP]]. ---- ===== <span id="npmvsel" style="color:red">NPMV-sel</span>: [[#npmv|NPMV]] Selective ===== Has the same relation to [[#npmv|NPMV]] as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npmvt" style="color:red">NPMV<sub>t</sub></span>: [[#npmv|NPMV]] Total ===== The class of all (possibly multivalued) [[#npmv|NPMV]] functions that are total (that is, defined for every input). ---- ===== <span id="npmvtsel" style="color:red">NPMV<sub>t</sub>-sel</span>: [[#npmvt|NPMV<sub>t</sub>]] Selective ===== Has the same relation to [[#npmvt|NPMV<sub>t</sub>]] as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npo" style="color:red">NPO</span>: [[#np|NP]] Optimization ===== The class of function problems of the form, "Find any n-bit string x that maximizes a cost function C(x), where C is computable in [[#fp|FP]] (i.e. polynomial-time)." Defined in [[zooref#acg99|[ACG+99]]]. Contains [[#apx|APX]] and [[#npopb|NPOPB]]. ---- ===== <span id="npopb" style="color:red">NPOPB</span>: [[#npo|NPO]] Polynomially Bounded ===== The subclass of [[#npo|NPO]] problems for which the cost function is guaranteed always to be bounded by a polynomial in n (the input size). See [[zooref#acg99|[ACG+99]]]. NPOPB equals the closure of [[#maxpb|MaxPB]] under [[#ptas|PTAS]] reductions [[zooref#cks99|[CKS+99]]]. ---- ===== <span id="nppoly" style="color:red">NP/poly</span>: Nonuniform [[#np|NP]] ===== Has the same relation to [[#np|NP]] as [[#ppoly|P/poly]] does to [[#p|P]]. Contains [[#am|AM]]. On the other hand, if NP/poly contains [[#conp|coNP]] then [[#ph|PH]] collapses to the third level. NP/poly-natural proofs cannot show that circuit families are outside [[#ppoly|P/poly]], under a pseudorandomness assumption [[zooref#rud97|[Rud97]]]. ---- ===== <span id="nppsamp" style="color:red">(NP,P-samplable)</span>: Average [[#np|NP]] With Samplable Distributions ===== See [[#avgp|AvgP]] for basic notions of average-case complexity. (NP,P-samplable) is the same as [[#distnp|DistNP]], except that the distribution &#956; only needs to be <i>samplable</i> in polynomial time. &#956;'s cumulative density function does not need to be computable in polynomial time. Any problem complete for [[#distnp|DistNP]] is also complete for (NP,P-samplable) [[zooref#il90|[IL90]]]. ---- ===== <span id="npr" style="color:red">NP<sub>R</sub></span>: [[#np|NP]] Over The Reals ===== An analog of [[#np|NP]] for Turing machines over a real number field. Defined in [[zooref#bcs97|[BCS+97]]]. It is unknown whether [[#pr2|P<sub>R</sub>]] = NP<sub>R</sub>, nor are implications known among this question, [[#pc|P<sub>C</sub>]] versus [[#npc2|NP<sub>C</sub>]], and [[#p|P]] versus [[#np|NP]]. Also, in contrast to the case of [[#npc2|NP<sub>C</sub>]], it is an open problem to show that [[#ppoly|P/poly]] distinct from [[#nppoly|NP/poly]] implies [[#pr2|P<sub>R</sub>]] distinct from NP<sub>R</sub>. The difference is that in the real case, a comparison (or greater-than) operator is available, and it is not known how much power this yields in comparison to the complex case. See also [[#vnp|VNP<sub>k</sub>]]. ---- ===== <span id="npspace" style="color:red">NPSPACE</span>: Nondeterministic [[#pspace|PSPACE]] ===== Equals [[#pspace|PSPACE]] [[zooref#sav70|[Sav70]]]. On the other hand, this result does not relativize if we allow strings of unbounded length to be written to the oracle tape. In particular, there exists an oracle relative to which NPSPACE is not contained in [[#exp|EXP]] [[zooref#gtw91|[GTW+91]]]. ---- ===== <span id="npsv" style="color:red">NPSV</span>: [[#np|NP]] Single Value ===== The class of [[#npmv|NPMV]] functions that are single-valued (i.e., such that every accepting path outputs the same value). Defined in [[zooref#bls84|[BLS84]]]. Contains [[#npsvt|NPSV<sub>t</sub>]]. [[#p|P]] = [[#np|NP]] if and only if [[#fp|FP]] = NPSV. ---- ===== <span id="npsvsel" style="color:red">NPSV-sel</span>: [[#npsv|NPSV]] Selective ===== Has the same relation to href="#npsv">NPSV as [[#psel|P-Sel]] does to [[#p|P]]. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="npsvt" style="color:red">NPSV<sub>t</sub></span>: [[#npsv|NPSV]] Total ===== The class of all [[#npsv|NPSV]] functions that are total (that is, defined on every input). Contained in [[#npmvt|NPMV<sub>t</sub>]]. ---- ===== <span id="npsvtsel" style="color:red">NPSV<sub>t</sub>-sel</span>: [[#npsvt|NPSV<sub>t</sub>]] Selective ===== Has the same relation to [[#npsvt|NPSV<sub>t</sub>]] as [[#psel|P-Sel]] does to [[#p|P]]. Also known as NP-sel. Defined in [[zooref#hhn95|[HHN+95]]]. ---- ===== <span id="nqp" style="color:red">NQP</span>: Nondeterministic Quantum Polynomial-Time ===== The class of decision problems solvable by a QTM in polynomial time such that a particular '|Accept&gt;' state has nonzero amplitude at the end of the computation, if and only if the answer is 'yes.' Since it has an exact amplitude condition, NQP has the same technical caveats as [[#eqp|EQP]]. Or it would, except that it turns out to equal [[#cocequalsp|coC<sub>=</sub>P]] [[zooref#fgh98|[FGH+98]]]. Defined in [[zooref#adh97|[ADH97]]]. Contrast with [[#qma|QMA]]. ---- ===== <span id="nspace" style="color:red">NSPACE(f(n))</span>: Nondeterministic f(n)-Space ===== Same as [[#npspace|NPSPACE]], but with f(n)-space (for some constructible function f) rather than polynomial-space machines. Contained in [[#dspace|DSPACE]](f(n)<sup>2</sup>) [[zooref#sav70|[Sav70]]], and indeed [[#revspace|RevSPACE]](f(n)<sup>2</sup>) [[zooref#cp95|[CP95]]]. NSPACE(n<sup>k</sup>) is strictly contained in NSPACE(n<sup>k+&#949;</sup>) for &#949;&gt;0 [[zooref#iba72|[Iba72]]] (actually the hierarchy theorem is stronger than this, but pretty technical to state). ---- ===== <span id="nt" style="color:red">NT</span>: Near-Testable ===== The class of decision problems such that whether the answer on input x agrees with the answer on input x-1 (that is, the lexicographic predecessor of x) is solvable in polynomial time. The Turing machine has to decide agreement or disagreement without access to the answer for x-1. Is contained in [[#e|E]], [[#ntstar|NT*]], and [[#parityp|&#8853;P]]. Defined in [[zooref#ghj91|[GHJ+91]]] to study [[#parityp|&#8853;P]]-complete problems. They show that [[#p|P]], NT, [[#ntstar|NT*]], and [[#parityp|&#8853;P]] are either all equal or strictly nested. In particular, they differ with probability 1 relative to a random oracle. ---- ===== <span id="ntstar" style="color:red">NT*</span>: Near-Testable With Forest Ordering ===== Defined like NT, but with a more general ordering on inputs. A problem L is in NT* if, first, there is a partially defined predecessor function pred(x) in [[#fp|FP]] that organizes the space of inputs into a forest. The size of the lineage of each x must also be bounded by 2<sup>poly(|x|)</sup>. Second, if L(x) is the Boolean answer to L on input x, then L(x)+L(pred(x)) is computable in polynomial time; or if pred(x) does not exist, L(x) is computable in polynomial time. Defined in [[zooref#ghj91|[GHJ+91]]]. Contains [[#nt|NT]] and is contained in [[#parityp|&#8853;P]]. The inclusions are either both strict or both equalities (whence [[#parityp|&#8853;P]] = [[#p|P]] as well). ---- ===== <span id="ntime" style="color:red">NTIME(f(n))</span>: Nondeterministic f(n)-Time ===== Same as [[#np|NP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. The Nondeterministic Time Hierarchy Theorem: If f and g are time-constructible and f(n+1)=o(g), then NTIME(f(n)) does not equal NTIME(g(n)) [[zooref#sfm78|[SFM78]]] (this is actually stronger than the hierarchy theorem for [[#dtime|DTIME]]). NTIME(n) strictly contains [[#dtime|DTIME(n)]] [[zooref#pps83|[PPS+83]]] (this result does not work for arbitrary f(n)). For any constructible superpolynomial f, NTIME(f(n)) with [[#np|NP]] oracle is not in [[#ppoly|P/poly]] [[zooref#kan82|[Kan82]]]. ---- ===== <span id="ocq" style="color:red">OCQ</span>: One Clean Qubit ===== The class of problems solvable by a [[#bqp|BQP]] machine in which a single qubit is initialized to the '0' state, and the remaining qubits are initialized to the maximally mixed state. (This definition is not known to be robust, so one also needs to specify a gate set.) We also need to stipulate that there are no "strong measurements" -- intermediate measurements on which later operations are conditioned -- since otherwise we can do all of [[#bqp|BQP]] by first initializing the computer to the all-0 state. Parker and Plenio [[zooref#pp00|[PP00]]] failed to appreciate this point. Defined by [[zooref#asv00|[ASV00]]] (though they didn't use the name OCQ), who also showed that if OCQ = [[#bqp|BQP]], something other than gate-by-gate simulation will be needed to show this. ---- ===== <span id="optp" style="color:red">OptP</span>: Optimum Polynomial-Time ===== The class of functions computable by taking the maximum of the output values over all accepting paths of an [[#np|NP]] machine. Defined in [[zooref#kre88|[Kre88]]]. Contrast with [[#fnp|FNP]]. ---- ===== <span id="p" style="color:red">P</span>: Polynomial-Time ===== The class that started it all. The class of decision problems solvable in polynomial time by a Turing machine. (See also [[#fp|FP]], for function problems.) Defined in [[zooref#edm65|[Edm65]]], [[zooref#cob64|[Cob64]]], [[zooref#rab60|[Rab60]]], and other seminal early papers. Contains some highly nontrivial problems, including linear programming [[zooref#kha79|[Kha79]]] and finding a maximum matching in a general graph [[zooref#edm65|[Edm65]]]. Contains the problem of testing whether an integer is prime [[zooref#aks02|[AKS02]]], an important result that improved on a proof requiring an assumption of the generalized Riemann hypothesis [[zooref#mil76|[Mil76]]]. A decision problem is P-complete if it is in P, and if every problem in P can be reduced to it in [[#l|L]] (logarithmic space). The canonical P-complete problem is <i>circuit evaluation</i>: given a Boolean circuit and an input, decide what the circuit outputs when given the input. Important subclasses of P include [[#l|L]], [[#nl|NL]], [[#nc|NC]], and [[#sc|SC]]. P is contained in [[#np|NP]], but whether they're equal seemed to be an open problem when I last checked. Efforts to generalize P resulted in [[#bpp|BPP]] and [[#bqp|BQP]]. The nonuniform version is [[#ppoly|P/poly]], the monotone version is [[#mp|mP]], and versions over the real and complex number fields are [[#pr2|P<sub>R</sub>]] and [[#pc|P<sub>C</sub>]] respectively. ---- ===== <span id="plog" style="color:red">P/log</span>: [[#p|P]] With Logarithmic Advice ===== Same as [[#ppoly|P/poly]], except that the advice string for input size n can have length at most logarithmic in n, rather than polynomial. Strictly contained in [[#iclogpoly|IC[log,poly]]]. If [[#np|NP]] is contained in P/log then [[#p|P]] = [[#np|NP]]. ---- ===== <span id="ppoly" style="color:red">P/poly</span>: Nonuniform Polynomial-Time ===== The class of decision problems solvable by a family of polynomial-size Boolean circuits. The family can be <i>nonuniform</i>; that is, there could be a completely different circuit for each input length. Equivalently, P/poly is the class of decision problems solvable by a polynomial-time Turing machine that receives an 'advice string,' that depends only on the size n of the input, and that itself has size upper-bounded by a polynomial in n. Contains [[#bpp|BPP]] by the progenitor of derandomization arguments [[zooref#adl78|[Adl78]]] [[zooref#kl82|[KL82]]]. By extension, BPP/poly, BPP/mpoly, and BPP/rpoly all equal P/poly. (By contrast, there is an oracle relative to which [[#bpplog|BPP/log]] does not equal [[#bppmlog|BPP/mlog]], while [[#bppmlog|BPP/mlog]] and [[#bpprlog|BPP/rlog]] are not equal relative to any oracle.) [[zooref#kl82|[KL82]]] showed that, if P/poly contains [[#np|NP]], then [[#ph|PH]] collapses to the second level, [[#sigma2p|&#931;<sub>2</sub>P]]. They also showed: <ul> <li>If [[#pspace|PSPACE]] is in P/poly then [[#pspace|PSPACE]] equals [[#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[#pi2p|&#928;<sub>2</sub>P]].</li> <li>If [[#exp|EXP]] is in P/poly then [[#exp|EXP]] = [[#sigma2p|&#931;<sub>2</sub>P]].</li> </ul> It was later shown that, if [[#np|NP]] is contained in P/poly, then [[#ph|PH]] collapses to [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#kw98|[KW98]]] and indeed [[#s2p|S<sub>2</sub>P]] [[zooref#cai01|[Cai01]]]. This seems close to optimal, since there exists an oracle relative to which the collapse cannot be improved to [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#wil85|[Wil85]]]. If [[#np|NP]] is not contained in P/poly, then [[#p|P]] does not equal [[#np|NP]]. Much of the effort toward separating [[#p|P]] from [[#np|NP]] is based on this observation. However, a 'natural proof' as defined by [[zooref#rr97|[RR97]]] cannot be used to show [[#np|NP]] is outside P/poly, if there is any pseudorandom generator in P/poly that has hardness 2<sup>&#937;(n^&#949;)</sup> for some &#949;&gt;0. If [[#np|NP]] is contained in P/poly, then [[#ma|MA]] = [[#am|AM]] [[zooref#aks95|[AKS+95]]] The monotone version of P/poly is [[#mppoly|mP/poly]]. P/poly has measure 0 in [[#e|E]] with [[#sigma2p|&#931;<sub>2</sub>P]] oracle [[zooref#may94b|[May94b]]]. Strictly contains [[#iclogpoly|IC[log,poly]]] and [[#plog|P/log]]. ---- ===== <span id="psharpp" style="color:red">P<sup>#P</sup></span>: [[#p|P]] With [[#sharpp|#P]] Oracle ===== I decided this class is so important that it deserves an entry of its own, apart from [[#sharpp|#P]]. Contains [[#ph|PH]] [[zooref#tod89|[Tod89]]], and is contained in [[#pspace|PSPACE]]. Equals [[#ppp2|P<sup>PP</sup>]] (exercise for the visitor). ---- ===== <span id="psharpp1" style="color:red">P<sup>#P</sup></span>: [[#p|P]] With Single Query To [[#sharpp|#P]] Oracle ===== Contains [[#ph|PH]] [[zooref#tod89|[Tod89]]]. ---- ===== <span id="pac0" style="color:red">PAC<sup>0</sup></span>: Probabilistic [[#ac0|AC<sup>0</sup>]] ===== The Political Action Committee for computational complexity research. The class of problems for which there exists a [[#diffac0|DiffAC<sup>0</sup>]] function f such that the answer is "yes" on input x if and only if f(x)>0. Equals [[#tc0|TC<sup>0</sup>]] and [[#cequalsac0|C<sub>=</sub>AC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="pbp" style="color:red">PBP</span>: Polynomial-Size Branching Program ===== Same as [[#kpbp|k-PBP]] but with no width restriction. Equals [[#l/poly|L/poly]] [[zooref#cob66|[Cob66]]]. Contains [[#pobdd|P-OBDD]], [[#bpdp|BP<sub>d</sub>(P)]]. ---- ===== <span id="kpbp" style="color:red">k-PBP</span>: Polynomial-Size Width-k Branching Program ===== A <i>branching program</i> is a directed acyclic graph with a designated start vertex. Each (non-sink) vertex is labeled by the name of an input bit, and has two outgoing edges, one of which is followed if that input bit is 0, the other if the bit is 1. A sink vertex can be either an 'accept' or a 'reject' vertex. The <i>size</i> of the branching program is the number of vertices. The branching program has <i>width k</i> if the vertices can be sorted into levels, each with at most k vertices, such that each edge goes from a level to the one immediately after it. Then k-PBP is the class of decision problems solvable by a family of polynomial-size, width-k branching programs. (A uniformity condition may also be imposed.) k-PBP equals (nonuniform) [[#nc1|NC<sup>1</sup>]] for constant k at least 5 [[zooref#bar89|[Bar89]]]. On the other hand, 4-PBP is in [[#acc0|ACC<sup>0</sup>]] [[zooref#bt88|[BT88]]]. Contained in k-[[#eqbp|EQBP]], as well as [[#pbp|PBP]]. See also [[#bpdp|BP<sub>d</sub>(P)]]. ---- ===== <span id="pc" style="color:red">P<sub>C</sub></span>: Polynomial-Time Over The Complex Numbers ===== An analog of [[#p|P]] for Turing machines over a complex number field. Defined in [[zooref#bcs97|[BCS+97]]]. See also [[#pr2|P<sub>R</sub>]], [[#npc2|NP<sub>C</sub>]], [[#npr|NP<sub>R</sub>]], [[#vp|VP<sub>k</sub>]]. ---- ===== <span id="pcc" style="color:red">P<sup>cc</sup></span>: Communication Complexity [[#p|P]] ===== In a two-party communication complexity problem, Alice and Bob have n-bit strings x and y respectively, and they wish to evaluate some Boolean function f(x,y) using as few bits of communication as possible. P<sup>cc</sup> is the class of (infinite families of) f's, such that the amount of communication needed is only O(polylog(n)), even if Alice and Bob are restricted to a deterministic protocol. Is strictly contained in [[#npcc|NP<sup>cc</sup>]] and in [[#bppcc|BPP<sup>cc</sup>]] because of the EQUALITY problem. Equals [[#npcc|NP<sup>cc</sup>]] &#8745; [[#npcc|coNP<sup>cc</sup>]]. Defined in [[zooref#bfs86|[BFS86]]]. ---- ===== <span id="pcd" style="color:red">PCD(r(n),q(n))</span>: Probabilistically Checkable Debate ===== The class of decision problems decidable by a <i>probabilistically checkable debate system</i>, as follows. Two debaters B and C alternate writing strings on a "debate tape," with B arguing that the answer is "yes" and C arguing the answer is "no." Then a polynomial-time verifier flips O(r(n)) random coins and makes O(q(n)) <i>nonadaptive</i> queries to the debate tape (meaning that they depend only on the input and the random coins, not the results of previous queries). The verifier then outputs an answer, which should be correct with high probability. Defined in [[zooref#cfl93|[CFL+93]]], who also showed that PCD(log n, 1) = [[#pspace|PSPACE]]. This result was used to show that certain problems are [[#pspace|PSPACE]]-hard even to approximate. Contained in [[#gpcd|GPCD]](r(n),q(n)). ---- ===== <span id="pclose" style="color:red">P-Close</span>: Problems Close to [[#p|P]] ===== The class of decision problems solvable by a polynomial-time algorithm that outputs the wrong answer on only a sparse (that is, polynomially-bounded) set of instances. Defined in [[zooref#yes83|[Yes83]]]. Contains [[#almostp|Almost-P]] and is contained in [[#ppoly|P/poly]] [[zooref#sch86|[Sch86]]]. ---- ===== <span id="pcp" style="color:red">PCP(r(n),q(n))</span>: Probabilistically Checkable Proof ===== The class of decision problems such that a "yes" answer can be verified by a <i>probabilistically checkable proof</i>, as follows. The verifier is a polynomial-time Turing machine with access to O(r(n)) uniformly random bits. It has random access to a <i>proof</i> (which might be exponentially long), but can query only O(q(n)) bits of the proof. Then we require the following: <ol> <li>If the answer is "yes," there exists a proof such that the verifier accepts with certainty.</li> <li>If the answer is "no," then for all proofs the verifier rejects with probability at least 1/2 (over the choice of the O(r(n)) random bits).</li> </ol> Defined in [[zooref#as98|[AS98]]]. By definition [[#np|NP]] = PCP(0,poly(n)). [[#mip|MIP]] = PCP(poly(n),poly(n)). PCP(r(n),q(n)) is contained in [[#ntime|NTIME]](2<sup>O(r(n))</sup>q(n) + poly(n)). [[#np|NP]] = PCP(log n, log n) [[zooref#as98|[AS98]]]. In fact, [[#np|NP]] = PCP(log n, 1) [[zooref#alm98|[ALM+98]]]! On the other hand, if [[#np|NP]] is contained in PCP(o(log n), o(log n)), then [[#p|P]] = [[#np|NP]] [[zooref#fgl91|[FGL+91]]]. Also, even though there exists an oracle relative to which [[#np|NP]] = [[#exp|EXP]] [[zooref#hel84|[Hel84]]], if we could show there exists an oracle relative to which PCP(log n, 1) = [[#exp|EXP]], then we'd have proved [[#p|P]] not equal to [[#np|NP]] [[zooref#for94|[For94]]]. Another weird oracle fact: since [[#np|NP]] does not equal [[#nexp|NEXP]] [[zooref#sfm78|[SFM78]]], PCP(0,log n) does not equal PCP(0,poly(n)). However, there exist oracles relative to which the latter inequality is false [[zooref#hcc92|[HCC+92]]]. ---- ===== <span id="permup" style="color:red">PermUP</span>: Self-Permuting [[#up|UP]] ===== The class of languages L in [[#up|UP]] such that the mapping from an input x to the unique witness for x is a permutation of L. Contains [[#p|P]]. Defined in [[zooref#ht03|[HT03]]], where it was also shown that the closure of PermUP under polynomial-time one-to-one reductions is [[#up|UP]]. On the other hand, they show that if PermUP = [[#up|UP]] then [[#e|E]] = [[#ue|UE]]. See also: [[#selfnp|SelfNP]]. ---- ===== <span id="pexp" style="color:red">PEXP</span>: Probabilistic Exponential-Time ===== Has the same relation to [[#exp|EXP]] as [[#pp|PP]] does to [[#p|P]]. Is not contained in [[#ppoly|P/poly]] [[zooref#bft98|[BFT98]]]. ---- ===== <span id="pf" style="color:red">PF</span>: Alternate Name for [[#fp|FP]] ===== ---- ===== <span id="pfchk" style="color:red">PFCHK(t(n))</span>: Proof-Checker ===== The class of decision problems solvable in time O(t(n)) by a nondeterministic Turing machine, as follows. The machine is given oracle access to a <i>proof string</i> of unbounded length. <ul> <li>If the answer is "yes," then there exists a value of the proof string such that all computation paths accept.</li> <li>If the answer is "no," then for all values of the proof string, there exists a computation path that rejects.</li> </ul> Credited in [[zooref#for94|[For94]]] to S. Arora, R. Impagliazzo, and U. Vazirani. An interesting question is whether [[#np|NP]] = PFCHK(log n) relative to all possible oracles. Fortnow [[zooref#for94|[For94]]] observes that the answer depends on what oracle access mechanism is used. ---- ===== <span id="ph" style="color:red">PH</span>: Polynomial-Time Hierarchy ===== Let &#916;<sub>0</sub>P = &#931;<sub>0</sub>P = &#928;<sub>0</sub>P = [[#p|P]]. Then for i&gt;0, let <ul> <li>&#916;<sub>i</sub>P = [[#p|P]] with &#931;<sub>i-1</sub>P oracle.</li> <li>&#931;<sub>i</sub>P = [[#np|NP]] with &#931;<sub>i-1</sub>P oracle.</li> <li>&#928;<sub>i</sub>P = [[#conp|coNP]] with &#931;<sub>i-1</sub>P oracle.</li> </ul> Then PH is the union of these classes for all nonnegative constant i. PH can also be defined using alternating quantifiers: it's the class of problems of the form, "given an input x, does there exist a y such that for all z, there exists a w ... such that &phi;(x,y,z,w,...)," where y,z,w,... are polynomial-size strings and &phi; is a polynomial-time computable predicate. It's not totally obvious that this is equivalent to the first definition, since the first one involves adaptive [[#np|NP]] oracle queries and the second one doesn't, but it is. Defined in [[zooref#sto76|[Sto76]]]. Contained in [[#p|P]] with a [[#pp|PP]] oracle [[zooref#tod89|[Tod89]]]. Contains [[#bpp|BPP]] [[zooref#lau83|[Lau83]]]. Relative to a random oracle, PH is strictly contained in [[#pspace|PSPACE]] with probability 1 [[zooref#cai86|[Cai86]]]. Furthermore, there exist oracles separating any &#931;<sub>i</sub>P from &#931;<sub>i+1</sub>P. On the other hand, it is unknown whether &#931;<sub>i</sub>P is strictly contained in &#931;<sub>i+1</sub>P relative to a <i>random</i> oracle with probability 1 (see [[zooref#has87|[Has87]]]). Book [[zooref#boo94|[Boo94]]] shows that if PH collapses relative to a random oracle with probability 1, then it collapses unrelativized. For a compendium of problems complete for different classes of the Polynomial Hierarchy see [[zooref#sch02a|[Sch02a]]] and [[zooref#sch02b|[Sch02b]]]. ---- ===== <span id="phcc" style="color:red">PH<sup>cc</sup></span>: Communication Complexity [[#ph|PH]] ===== The obvious generalization of [[#npcc|NP<sup>cc</sup>]] and [[#conpcc|coNP<sup>cc</sup>]] to a nondeterministic hierarchy. It is unknown whether &#931;<sub>2</sub><sup>cc</sup> equals &#928;<sub>2</sub><sup>cc</sup>. Defined in [[zooref#bfs86|[BFS86]]], where it was also shown (among other things) that [[#bppcc|BPP<sup>cc</sup>]] is contained in &#931;<sub>2</sub><sup>cc</sup> &#8745; &#928;<sub>2</sub><sup>cc</sup>. ---- ===== <span id="phi2p" style="color:red">&#934;<sub>2</sub>P</span>: Second Level of the Symmetric Hierarchy, Alternative Definition ===== The class of problems for which there exists a polynomial-time predicate P(x,y,z) such that for all x, if the answer on input x is "yes," then <ol> <li>For all y, there exists a z for which P(x,y,z).</li> <li>For all z, there exists a y for which P(x,y,z).</li> </ol> Contained in [[#sigma2p|&#931;<sub>2</sub>P]] and [[#pi2p|&#928;<sub>2</sub>P]]. Defined in [[zooref#can96|[Can96]]], where it was also observed that &#934;<sub>2</sub>P = [[#s2p|S<sub>2</sub>P]]. ---- ===== <span id="php" style="color:red">PhP</span>: Physical Polynomial-Time ===== Defined by Valiant [[zooref#val03|[Val03]]] to be "the class of physically constructible polynomial resource computers" (characterizing what "can be computed in the physical world in practice"). There he says that PhP contains [[#p|P]] and [[#bpp|BPP]], but that it is open whether PhP contains [[#bqp|BQP]], since no scalable quantum computing proposal has been demonstrated beyond reasonable doubt. For what it's worth, the present zookeeper has more qualms about admitting [[#dtime|DTIME]](n<sup>1000</sup>) into PhP than [[#bqtime|BQTIME]](n<sup>2</sup>). It is very possible that the total number of bits or bit tranisitions that can be witnessed by any one observer in the universe is finite. (Recent observations of the cosmological constant combined with plausible fundamental physics yields a bound of 10<sup>k</sup> with k in the low hundreds.) In practice, less than 10<sup>50</sup> bits and less than 10<sup>80</sup> bit transitions are available for human use. (This is combining the number of atoms in the Earth with the number of signals that they can exchange in a millenium.) The present veterinarian concurs that PhP is an unhealthy animal, although it is valid to ask whether [[#bqp|BQP]] is a realistic class. ---- ===== <span id="pi2p" style="color:red">&#928;<sub>2</sub>P</span>: [[#conp|coNP]] With [[#np|NP]] Oracle ===== Complement of [[#sigma2p|&#931;<sub>2</sub>P]]. Along with [[#sigma2p|&#931;<sub>2</sub>P]], comprises the second level of [[#ph|PH]], the polynomial hierarchy. For any fixed k, there is a problem in &#928;<sub>2</sub>P &#8745; [[#sigma2p|&#931;<sub>2</sub>P]] that cannot be solved by circuits of size n<sup>k</sup> [[zooref#kan82|[Kan82]]]. ---- ===== <span id="pinc" style="color:red">PINC</span>: Polynomial Ignorance of Names of Classes ===== (Actually, I've since been informed that PINC means "Incremental Polynomial-Time.") The class of function problems, f:{0,1}<sup>n</sup>-&gt;{0,1}<sup>m</sup>, such that the k<sup>th</sup> output bit is computable in time polynomial in n and k. Defined in [[zooref#jy88|[JY88]]]. Contained in [[#pio|PIO]]. This containment is strict, since if m=2<sup>n</sup> (say), then computing the first bit of f(x) might be [[#exp|EXP]]-complete. ---- ===== <span id="pio" style="color:red">PIO</span>: Polynomial Input Output ===== The class of function problems, f:{0,1}<sup>n</sup>-&gt;{0,1}<sup>m</sup>, such that f(x) is computable in time polynomial in n and m. Allows us to discuss whether a function is "efficiently computable" or not, even if the output is too long to write down in polynomial time. Defined in [[zooref#yan81|[Yan81]]]. Strictly contains [[#pinc|PINC]]. ---- ===== <span id="pk" style="color:red">P<sup>K</sup></span>: [[#p|P]] With Kolmogorov-Complexity Oracle ===== [[#p|P]] equipped with an oracle that, given a string x, returns the length of the shortest program that outputs x. A similar class was defined in [[zooref#abk02|[ABK+02]]], where it was also shown that P<sup>K</sup> contains [[#pspace|PSPACE]]. It is not known whether P<sup>K</sup> contains all of [[#r|R]], or even any recursive problem not in [[#pspace|PSPACE]]. See also: [[#bppkt|BPP<sup>KT</sup>]]. ---- ===== <span id="pkc" style="color:red">PKC</span>: Perfect Knowledge Complexity ===== Has the same relation to [[#pzk|PZK]] as [[#skc|SKC]] does to [[#szk|SZK]]. Defined in [[zooref#gp91|[GP91]]]. ---- ===== <span id="pl" style="color:red">PL</span>: Probabilistic [[#l|L]] ===== Has the same relation to [[#l|L]] that [[#pp|PP]] has to [[#p|P]]. Contains [[#bpl|BPL]]. PL<sup>PL</sup> = PL (see [[zooref#ho02|[HO02]]]). ---- ===== <span id="pl1" style="color:red">PL<sub>1</sub></span>: Polynomially-Bounded L<sub>1</sub> Spectral Norm ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that the sum of absolute values of Fourier coefficients of f is bounded by a polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PL<sub>1</sub> is contained in [[#pt1|PT<sub>1</sub>]] (and this inclusion is strict). ---- ===== <span id="plinfinity" style="color:red">PL<sub>&#8734;</sub></span>: Polynomially-Bounded L<sub>&#8734;</sub><sup>-1</sup> Spectral Norm ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that the maximum of |&alpha;|<sup>-1</sup>, over all Fourier coefficients &alpha; of f, is upper-bounded by a polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PL<sub>&#8734;</sub> contains [[#pt1|PT<sub>1</sub>]] (and this inclusion is strict). ---- ===== <span id="plf" style="color:red">PLF</span>: Polynomial Leaf ===== Defined in [[zooref#pap90|[Pap90]]]. I believe it's the same as [[#ppa|PPA]]. ---- ===== <span id="pll" style="color:red">PLL</span>: Polynomial Local Lemma ===== The class of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the Lov&aacute;sz Local Lemma. Defined in [[zooref#pap94b|[Pap94b]]]. ---- ===== <span id="pls" style="color:red">PLS</span>: Polynomial Local Search ===== The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "every finite directed acyclic graph has a sink." More precisely, for each input, there's a finite set of <i>solutions</i> (i.e. strings), and a polynomial-time algorithm that computes a <i>cost</i> for each solution, and a <i>neighboring solution</i> of lower cost provided that one exists. Then the problem is to return any solution that has cost less than or equal to all of its neighbors. (In other words, a local optimum.) (<i>Note:</i> In the Zookeeper's humble opinion, PLS <i>should</i> have been defined as follows: there exist polynomial-time algorithms that compute the cost of a solution, and the set of <i>all</i> neighbors of a given solution, not just a single solution of lower cost. Of course we'd require that every solution has only polynomially many neighbors. The two definitions are not obviously equivalent, and it's conceivable that knowing all the neighbors would be helpful -- for example, in simulated annealing one sometimes makes uphill moves.) Defined in [[zooref#jpy88|[JPY88]]], [[zooref#py88|[PY88]]]. There exists an oracle relative to which PLS is not contained in [[#fbqp|FBQP]] [[zooref#aar03|[Aar03]]]. Also, there exist oracles relative to which PLS is not contained in [[#ppa|PPA]] [[zooref#bm04|[BM04]]], and [[#ppa|PPA]] and [[#ppp|PPP]] are not contained in PLS [[zooref#mor01|[Mor01]]]. Whether PLS is not in [[#ppp|PPP]] relative to some oracle remains open. ---- ===== <span id="pnp" style="color:red">P<sup>NP</sup></span>: [[#p|P]] With Oracle Access To [[#np|NP]] ===== See [[#delta2p|&#916;<sub>2</sub>P]]. ---- ===== <span id="pparnp" style="color:red">P<sup>||NP</sup></span>: [[#p|P]] With Parallel Queries To [[#np|NP]] ===== Equals [[#pnplog|P<sup>NP[log]</sup>]] ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). ---- ===== <span id="pnpk" style="color:red">P<sup>NP[k]</sup></span>: [[#p|P]] With k [[#np|NP]] Queries(for constant k) ===== Equals [[#p|P]] with 2<sup>k</sup>-1 parallel queries to [[#np|NP]] (i.e. queries that do not depend on the outcomes of previous queries) ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). If P<sup>NP</sup> = P<sup>NP</sup>, then P<sup>NP</sup> = [[#pnplog|P<sup>NP[log]</sup>]] and indeed [[#ph|PH]] collapses to &Delta;<sub>3</sub>P (attributed in [[zooref#har87b|[Har87b]]] to J. Kadin). ---- ===== <span id="pnplog" style="color:red">P<sup>NP[log]</sup></span>: [[#p|P]] With Log [[#np|NP]] Queries ===== The class of decision problems solvable by a [[#p|P]] machine, that can make O(log n) queries to an [[#np|NP]] oracle (where n is the length of the input). Equals [[#pparnp|P<sup>&#124;&#124;NP</sup>]], the class of decision problems solvable by a [[#p|P]] machine that can make polynomially many <i>nonadaptive</i> queries to an [[#np|NP]] oracle (i.e. queries that do not depend on the outcomes of previous queries) ([[zooref#bh91|[BH91]]] and [[zooref#hem89|[Hem89]]] independently). P<sup>NP[log]</sup> is contained in [[#pp|PP]] [[zooref#bhw89|[BHW89]]]. Determining the winner in an election system proposed in 1876 by Charles Dodgson (a.k.a. Lewis Carroll) has been shown to be complete for P<sup>NP[log]</sup> [[zooref#hhr97|[HHR97]]]. Contains [[#pnpk|P<sup>NP[k]</sup>]] for all constants k. ---- ===== <span id="pnplog2" style="color:red">P<sup>NP[log^2]</sup></span>: [[#p|P]] With Log<sup>2</sup> [[#np|NP]] Queries ===== Same as [[#pnplog|P<sup>NP[log]</sup>]], except that now log<sup>2</sup> queries can be made. The model-checking problem for a certain temporal logic is P<sup>NP[log^2]</sup>-complete [[zooref#sch03|[Sch03]]]. For all k, [[#p|P]] with log<sup>k</sup> adaptive queries to [[#np|NP]] coincides with [[#p|P]] with log<sup>k+1</sup> nonadaptive queries [[zooref#cs92|[CS92]]]. ---- ===== <span id="pobdd" style="color:red">P-OBDD</span>: Polynomial-Size Ordered Binary Decision Diagram ===== An <i>ordered binary decision diagram (OBDD)</i> is a branching program (see [[#kpbp|k-PBP]]), with the additional constraint that if x<sub>i</sub> is queried before x<sub>j</sub> on any path, then i&lt;j. Then P-OBDD is the class of decision problems solvable by polynomial-size OBDD's. Contained in [[#pbp|PBP]], as well as [[#bppobdd|BPP-OBDD]]. ---- ===== <span id="podn" style="color:red">PODN</span>: Polynomial Odd Degree Node ===== The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "every finite graph has an even number of odd-degree nodes." Equals [[#ppa|PPA]] [[zooref#pap90|[Pap90]]]. ---- ===== <span id="polyl" style="color:red">polyL</span>: Polylogarithmic Space ===== Equals [[#dspace|DSPACE]]((log n)<sup>c</sup>). In contrast to [[#l|L]], which is contained in [[#p|P]], it is not known if polyL is contained in [[#p|P]] or vice versa. On the other hand, we do know that polyL does not equal [[#p|P]], since (for example) polyL does not have complete problems under many-to-one logspace reductions. ---- ===== <span id="postbqp" style="color:red">PostBQP</span>: [[#bqp|BQP]] With Postselection ===== A class inspired by the proverb, "if at first you don't succeed, try, try again." Formally, the class of decision problems solvable by a [[#bqp|BQP]] machine such that <ul> <li>If the answer is 'yes' then the second qubit has at least 2/3 probability of being measured 1, <i>conditioned</i> on the first qubit having been measured 1.</li> <li>If the answer is 'no' then the second qubit has at most 1/3 probability of being measured 1, conditioned on the first qubit having been measured 1.</li> <li>On any input, the first qubit has a nonzero probability of being measured 1.</li> </ul> Defined in [[zooref#aar05b|[Aar05b]]], where it is also shown that PostBQP equals [[#pp|PP]]. [[zooref#aar05b|[Aar05b]]] also gives the following alternate characterizations of PostBQP (and therefore of [[#pp|PP]]): <ul> <li>The quantum analogue of [[#bpppath|BPP<sub>path</sub>]].</li> <li>The class of problems solvable in quantum polynomial time if we allow arbitrary linear operations (not just unitary ones). Before measuring, we divide all amplitudes by a normalizing factor to make the probabilities sum to 1.</li> <li>The class of problems solvable in quantum polynomial time if we take the probability of measuring a basis state with amplitude &alpha; to be not |&alpha;|<sup>2</sup> but |&alpha;|<sup>p</sup>, where p is an even integer greater than 2. (Again we need to divide all amplitudes by a normalizing factor to make the probabilities sum to 1.)</li> </ul> ---- ===== <span id="pp" style="color:red">PP</span>: Probabilistic Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes' then at least 1/2 of computation paths accept.</li> <li>If the answer is 'no' then less than 1/2 of computation paths accept.</li> </ol> Defined in [[zooref#gil77|[Gil77]]]. PP is closed under union and intersection [[zooref#brs91|[BRS91]]] (this was an open problem for 14 years). Contains [[#pnplog|P<sup>NP[log]</sup>]] [[zooref#bhw89|[BHW89]]]. Equals PP<sup>[[#bpp|BPP]]</sup> [[zooref#kst89b|[KST+89b]]] as well as [[#postbqp|PostBQP]] [[zooref#aar05b|[Aar05b]]]. However, there exists an oracle relative to which PP does not contain [[#delta2p|&#916;<sub>2</sub>P]] [[zooref#bei94|[Bei94]]]. [[#ph|PH]] is in [[#ppp2|P<sup>PP</sup>]] [[zooref#tod89|[Tod89]]]. [[#bqp|BQP]] is low for PP; i.e. PP<sup>BQP</sup> = PP [[zooref#fr98|[FR98]]]. For a random oracle A, PP<sup>A</sup> is strictly contained in [[#pspace|PSPACE]]<sup>A</sup> with probability 1 [[zooref#abf94|[ABF+94]]]. For any fixed k, there exists a language in PP that does not have circuits of size n<sup>k</sup> [[zooref#vin04b|[Vin04b]]]. Indeed, there exists a language in PP that does not even have quantum circuits of size n<sup>k</sup> with quantum advice [[zooref#aar06|[Aar06]]]. By contrast, there exists an oracle relative to which PP has linear-size circuits [[zooref#aar06|[Aar06]]]. PP can be generalized to the counting hierarchy [[#ch|CH]]. ---- ===== <span id="pppoly" style="color:red">PP/poly</span>: Nonuniform [[#pp|PP]] ===== Contains [[#bqpqpoly|BQP/qpoly]] [[zooref#aar04b|[Aar04b]]]. If PP/poly = [[#ppoly|P/poly]] then [[#pp|PP]] is contained in [[#ppoly|P/poly]]. Indeed this is true with any syntactically defined class in place of [[#pp|PP]]. An implication is that any unrelativized separation of [[#bqpqpoly|BQP/qpoly]] from [[#bqpmpoly|BQP/mpoly]] would imply that [[#pp|PP]] does not have polynomial-size circuits. ---- ===== <span id="ppa" style="color:red">PPA</span>: Polynomial Parity Argument ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the lemma that "all graphs of maximum degree 2 have an even number of leaves." More precisely, there's a polynomial-time algorithm that, given any string, computes its 'neighbor' strings (of which there are at most two). Then given a leaf string (i.e. one with only one neighbor), the problem is to output another leaf string. As an example, suppose you're given a cubic graph (one where every vertex has degree 3), and a Hamiltonian cycle H on that graph. Then by making a sequence of modifications to H (albeit possibly exponentially many), it is always possible to find a second Hamilton cycle (see [[zooref#pap94|[Pap94]]]). So this problem is in PPA. Another problem in PPA is finding an Arrow-Debreu equilibrium, given the goods and utility functions of traders in a marketplace. Contained in [[#tfnp|TFNP]]. Contains [[#ppad|PPAD]]. There exist oracles relative to which PPA does not contain [[#pls|PLS]] [[zooref#bm04|[BM04]]] and [[#ppp|PPP]] [[zooref#bce95|[BCE+95]]]. There also exists an oracle relative to which PPA is not contained in [[#ppp|PPP]] [[zooref#bce95|[BCE+95]]]. ---- ===== <span id="ppad" style="color:red">PPAD</span>: Polynomial Parity Argument (Directed) ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. Same as [[#ppa|PPA]], except now the graph is directed, and we're asked to find either a source or a sink. Contained in [[#ppa|PPA]] and [[#ppads|PPADS]]. NASH, the problem of finding a Nash equilibrium in a normal form game of two or more players with specified utilities, is in PPAD [[zooref#pap94b|[Pap94b]]], and proved to be complete for PPAD with four players in [[zooref#dgp05|[DGP05]]], and shortly after extended to the case of three players [[zooref#dp05|[DP05]]] and independently [[zooref#cd05|[CD05]]]. There exists an oracle relative to which [[#ppp|PPP]] is not contained in PPAD [[zooref#bce95|[BCE+95]]]. ---- ===== <span id="ppads" style="color:red">PPADS</span>: Polynomial Parity Argument (Directed, Sink) ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. Same as [[#ppa|PPA]], except now the graph is directed, and we're asked to find a sink. Contained in [[#ppp|PPP]]. Contains [[#ppad|PPAD]]. ---- ===== <span id="ppp" style="color:red">PPP</span>: Polynomial Pigeonhole Principle ===== Defined in [[zooref#pap94b|[Pap94b]]]; see also [[zooref#bce95|[BCE+95]]]. The subclass of [[#tfnp|TFNP]] function problems that are guaranteed to have a solution because of the Pigeonhole Principle. More precisely, we're given a Boolean circuit, that maps n-bit strings to n-bit strings. The problem is to return <i>either</i> an input that maps to 0<sup>n</sup>, <i>or</i> two inputs that map to the same output. Contained in [[#tfnp|TFNP]]. Contains [[#ppads|PPADS]]. [[zooref#bce95|[BCE+95]]] give oracles relative to which PPP is not contained in [[#ppa|PPA]] and [[#ppad|PPAD]], and [[#ppa|PPA]] is not contained in PPP. [[zooref#mor01|[Mor01]]] gives an oracle relative to which PPP is not contained in [[#pls|PLS]]. Whether [[#pls|PLS]] is not contained in PPP relative to some oracle remains open. ---- ===== <span id="ppp2" style="color:red">P<sup>PP</sup></span>: [[#p|P]] With [[#pp|PP]] Oracle ===== A level of the counting hierarchy [[#ch|CH]]. It is not known whether there exists an oracle relative to which P<sup>PP</sup> does not equal [[#pspace|PSPACE]]. Contains [[#pp|PP]]<sup>[[#ph|PH]]</sup> [[zooref#tod89|[Tod89]]]. Equals [[#psharpp|P<sup>#P</sup>]] (exercise for the visitor). Since the permanent of a matrix is [[#sharpp|#P]]-complete [[zooref#val79|[Val79]]], Toda's theorem implies that any problem in the polynomial hierarchy can be solved by computing a sequence of permanents. ---- ===== <span id="pquery" style="color:red">PQUERY</span>: PSPACE With Polynomial Queries ===== The class of decision problems solvable in polynomial space using at most a polynomial number of queries to the oracle. Thus, PQUERY = [[#pspace|PSPACE]], but PQUERY<sup>A</sup> does not equal [[#pspace|PSPACE]]<sup>A</sup> for some oracles A. Defined in [[zooref#kur83|[Kur83]]], where it was actually put forward as a serious argument (!!) against believing relativization results. ---- ===== <span id="ppspace" style="color:red">PPSPACE</span>: Probabilistic [[#pspace|PSPACE]] ===== Same as [[#ipp|IPP]], except that [[#ipp|IPP]] uses private coins while PPSPACE uses public coins. Can also be defined as a probabilistic version of [[#pspace|PSPACE]]. Equals [[#pspace|PSPACE]]. Defined in [[zooref#pap83|[Pap83]]]. ---- ===== <span id="pr" style="color:red">PR</span>: Primitive Recursive Functions ===== Basically, the class of functions definable by recursively building up arithmetic functions: addition, multiplication, exponentiation, tetration, etc. What's <i>not</i> allowed is to "diagonalize" a whole series of such functions to produce an even faster-growing one. Thus, the Ackermann function was proposed in 1928 as an example of a recursive function that's not primitive recursive, showing that PR is strictly contained in [[#r|R]]. An interesting difference is that PR functions can be explicitly enumerated, whereas functions in [[#r|R]] cannot be (since otherwise the halting problem would be decidable). That is, PR is a "syntactic" class whereas [[#r|R]] is "semantic." On the other hand, we can "enumerate" any [[#re|RE]] set by a PR function in the following sense: given an input (M,k), where M is a Turing machine and k is an integer, if M halts within k steps then output M; otherwise output nothing. Then the union of the outputs, over all possible inputs (M,k), is exactly the set of M that halt. PR strictly contains [[#elementary|ELEMENTARY]]. ---- ===== <span id="pr2" style="color:red">P<sub>R</sub></span>: Polynomial-Time Over The Reals ===== An analog of [[#p|P]] for Turing machines over a real number field. Defined in [[zooref#bcs97|[BCS+97]]]. See also [[#pc|P<sub>C</sub>]], [[#npc2|NP<sub>C</sub>]], [[#npr|NP<sub>R</sub>]], [[#vp|VP<sub>k</sub>]]. ---- ===== <span id="prhspace" style="color:red">Pr<sub>H</sub>SPACE(f(n))</span>: Unbounded-Error Halting Probabilistic f(n)-Space ===== Has the same relation to [[#dspace|DSPACE]](f(n)) as [[#pp|PP]] does to [[#p|P]]. The Turing machine has to halt on every input <i>and</i> every setting of the random tape. Equals [[#prspace|PrSPACE]](f(n)) [[zooref#jun85|[Jun85]]]. ---- ===== <span id="promisebpp" style="color:red">PromiseBPP</span>: Promise-Problem [[#bpp|BPP]] ===== Same as [[#promiserp|PromiseRP]], but for [[#bpp|BPP]] instead of [[#rp|RP]]. Defined in [[zooref#bf99|[BF99]]]. ---- ===== <span id="promisebqp" style="color:red">PromiseBQP</span>: Promise-Problem [[#bqp|BQP]] ===== Same as [[#promisebqp|PromiseBQP]], but for [[#bqp|BQP]] instead of [[#bpp|BPP]]. If PromiseBQP = [[#promisep|PromiseP]] then [[#bqpmpoly|BQP/mpoly]] = [[#ppoly|P/poly]]. ---- ===== <span id="promisep" style="color:red">PromiseP</span>: Promise-Problem [[#p|P]] ===== The class of promise problems solvable by a [[#p|P]] machine. ---- ===== <span id="promiserp" style="color:red">PromiseRP</span>: Promise-Problem [[#rp|RP]] ===== The class of promise problems solvable by an [[#rp|RP]] machine. I.e., the machine must accept with probability at least 1/2 for "yes" inputs, and with probability 0 for "no" inputs, but could have acceptance probability between 0 and 1/2 for inputs that do not satisfy the promise. Defined in [[zooref#bf99|[BF99]]], where it was also shown that [[#bpp|BPP]] is in [[#rp|RP]]<sup>PromiseRP</sup> (i.e. with a single oracle query to PromiseRP). Contained in [[#promisebpp|PromiseBPP]]. ---- ===== <span id="prspace" style="color:red">PrSPACE(f(n))</span>: Unbounded-Error Probabilistic f(n)-Space ===== Has the same relation to [[#dspace|DSPACE]](f(n)) as [[#pp|PP]] does to [[#p|P]]. The Turing machine has to halt with probability 1 on every input. Contained in [[#dspace|DSPACE]](f(n)<sup>2</sup>) [[zooref#bcp83|[BCP83]]]. Equals [[#prhspace|Pr<sub>H</sub>SPACE]](f(n)) [[zooref#jun85|[Jun85]]]. ---- ===== <span id="psel" style="color:red">P-Sel</span>: P-Selective Sets ===== The class of decision problems for which there's a polynomial-time algorithm with the following property. Whenever it's given two instances, a "yes" and a "no" instance, the algorithm can always decide which is the "yes" instance. Defined in [[zooref#sel79|[Sel79]]], where it was also shown that if [[#np|NP]] is contained in P-Sel then [[#p|P]] = [[#np|NP]]. There exist P-selective sets that are not recursive (i.e. not in [[#r|R]]). ---- ===== <span id="psk" style="color:red">PSK</span>: Polynomial Sink ===== Yeah, I'm told that's what the S and K stand for. Go figure. The class of total function problems definable as follows: given a directed graph of indegree and outdegree at most 1, and given a source, find a sink. Defined in [[zooref#pap90|[Pap90]]]. Equals [[#ppads|PPADS]]. ---- ===== <span id="pspace" style="color:red">PSPACE</span>: Polynomial-Space ===== The class of decision problems solvable by a Turing machine in polynomial space. Equals [[#npspace|NPSPACE]] [[zooref#sav70|[Sav70]]], [[#ap|AP]] [[zooref#cks81|[CKS81]]], [[#ip|IP]] [[zooref#sha90|[Sha90]]], and, assuming the existence of one-way functions, [[#czk|CZK]] [[zooref#bgg90|[BGG+90]]]. Contains [[#p|P]] with [[#sharpp|#P]] oracle. A canonical PSPACE-complete problem is <i>Quantified Boolean Formula (QBF)</i>: Given a Boolean formula with universal and existential quantifiers, decide whether it's true or false. Relative to a random oracle, PSPACE strictly contains [[#ph|PH]] with probability 1 [[zooref#cai86|[Cai86]]]. PSPACE has a complete problem that is both downward self-reducible and random self-reducible [[zooref#tv02|[TV02]]]. It is the largest class with such a complete problem. Contained in [[#exp|EXP]]. There exists an oracle relative to which this containment is proper [[zooref#dek76|[Dek76]]]. ---- ===== <span id="pspacepoly" style="color:red">PSPACE/poly</span>: [[#pspace|PSPACE]] With Polynomial-Size Advice ===== Contains [[#qmaqpoly|QMA/qpoly]] [[zooref#aar06b|[Aar06b]]]. ---- ===== <span id="pt1" style="color:red">PT<sub>1</sub></span>: Polynomial Threshold Functions ===== The class of Boolean functions f:{-1,1}<sup>n</sup>->{-1,1} such that f(x)=sgn(p(x)), where p is a polynomial having a number of terms polynomial in n. Defined in [[zooref#bs90|[BS90]]], where it was also shown that PT<sub>1</sub> contains [[#pl1|PL<sub>1</sub>]] (and this inclusion is strict), and that PT<sub>1</sub> is contained in [[#plinfinity|PL<sub>&#8734;</sub>]] (and this inclusion is strict). ---- ===== <span id="ptape" style="color:red">PTAPE</span>: Archaic for [[#pspace|PSPACE]] ===== ---- ===== <span id="ptas" style="color:red">PTAS</span>: Polynomial-Time Approximation Scheme ===== The subclass of [[#npo|NPO]] problems that admit an <i>approximation scheme</i> in the following sense. For any &#949;&gt;0, there is a polynomial-time algorithm that is guaranteed to find a solution whose cost is within a 1+&#949; factor of the optimum cost. (However, the exponent of the polynomial might depend strongly on &#949;.) Contains [[#fptas|FPTAS]], and is contained in [[#apx|APX]]. As an example, the Traveling Salesman Problem in the Euclidean plane is in PTAS [[zooref#aro96|[Aro96]]]. Defined in [[zooref#acg99|[ACG+99]]]. ---- ===== <span id="ptwk" style="color:red">PT/WK(f(n),g(n))</span>: Parallel Time f(n) / Work g(n) ===== The class of decision problems solvable by a uniform family of Boolean circuits with depth upper-bounded by f(n) and size (number of gates) upper-bounded by g(n). The union of PT/WK(log<sup>k</sup>n, n<sup>k</sup>) over all constants k equals [[#nc|NC]]. ---- ===== <span id="pzk" style="color:red">PZK</span>: Perfect Zero Knowledge ===== Same as [[#szk|SZK]], but now the two distributions must be <i>identical</i>, not merely statistically close. (The "two distributions" are (1) the distribution over Arthur's view of his interaction with Merlin, conditioned on Arthur's random coins, and (2) the distribution over views that Arthur can <i>simulate</i> without Merlin's help.) Contained in [[#szk|SZK]]. See also: [[#czk|CZK]]. ---- ===== <span id="q" style="color:red">Q</span>: Quasi-Realtime Languages ===== The class of problems solvable by a nondeterministic multitape Turing machine in linear time. Defined in [[zooref#bg69|[BG69]]], where it was shown that Q equals the class of problems solvable by a nondeterministic multitape Turing machine in exactly n steps (as opposed to O(n) steps). Contains [[#gcsl|GCSL]]. ---- ===== <span id="qac0" style="color:red">QAC<sup>0</sup></span>: Quantum [[#ac0|AC<sup>0</sup>]] ===== The class of decision problems solvable by a family of constant-depth, polynomial-size quantum circuits. Here each layer of the circuit is a tensor product of one-qubit gates and Toffoli gates, or is a tensor product of controlled-NOT gates. A uniformity condition may also be imposed. Defined in [[zooref#moo99|[Moo99]]]. Contains [[#ac0|AC<sup>0</sup>]], and is contained in [[#qacwf0|QAC<sub>f</sub><sup>0</sup>]]. ---- ===== <span id="qac0m" style="color:red">QAC<sup>0</sup>[m]</span>: Quantum [[#ac0m|AC<sup>0</sup>[m]]] ===== Same as [[#qac0|QAC<sup>0</sup>]], except that now Mod-m gates are also allowed. A Mod-m gate computes whether the sum of a given set of bits is congruent to 0 modulo m, and exclusive-OR's the answer into another bit. Defined in [[zooref#moo99|[Moo99]]]. ---- ===== <span id="qacc0" style="color:red">QACC<sup>0</sup></span>: Quantum [[#acc0|ACC<sup>0</sup>]] ===== Same as [[#qac0m|QAC<sup>0</sup>[m]]], except that Mod-m gates are allowed for any m. Defined in [[zooref#moo99|[Moo99]]]. [[zooref#ghp00|[GHP00]]] showed that QACC<sup>0</sup> equals [[#qac0m|QAC<sup>0</sup>[p]]] for any prime p. ---- ===== <span id="qacwf0" style="color:red">QAC<sub>f</sub><sup>0</sup></span>: [[#qac0|QAC<sup>0</sup>]] With Fanout ===== Same as [[#qac0|QAC<sup>0</sup>]], except that an additional "quantum fanout" gate is available, which CNOT's a qubit into arbitrarily many target qubits in a single step. Defined in [[zooref#moo99|[Moo99]]], where it was also shown that QAC<sub>f</sub><sup>0</sup> = [[#qac0m|QAC<sup>0</sup>]] = [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="qam" style="color:red">QAM</span>: Quantum [[#am|AM]] ===== The class of decision problems for which a "yes" answer can be verified by a public-coin quantum [[#am|AM]] protocol, as follows. Arthur generates a uniformly random (classical) string and sends it to Merlin. Merlin responds with a polynomial-size quantum certificate, on which Arthur can perform any [[#bqp|BQP]] operation. The completeness and soundness requirements are the same as for [[#am|AM]]. Defined by Marriott and Watrous [[zooref#mw05|[MW05]]]. Contains [[#qma|QMA]] and is contained in [[#qip2|QIP]] and BP&#149;[[#pp|PP]] (and therefore [[#pspace|PSPACE]]). ---- ===== <span id="qcfl" style="color:red">QCFL</span>: Quantum [[#cfl|CFL]] ===== The class of decision problems recognized by quantum context-free languages, which are defined in [[zooref#mc00|[MC00]]]. The authors also showed that QCFL does not equal [[#cfl|CFL]]. ---- ===== <span id="qcma" style="color:red">QCMA</span>: Quantum Classical [[#ma|MA]] ===== The class of decision problems for which a "yes" answer can be verified by a <i>quantum</i> computer with access to a <i>classical</i> proof. Contains [[#ma|MA]], and is contained in [[#qma|QMA]]. Given a black-box group G and a subgroup H, the problem of testing non-membership in H has polynomial QCMA query complexity [[zooref#ak06|[AK06]]]. See [[zooref#ak06|[AK06]]] for a "quantum oracle separation" between QCMA and [[#qma|QMA]]. No classical oracle separation between QCMA and [[#qma|QMA]] is currently known. ---- ===== <span id="qh" style="color:red">QH</span>: Query Hierarchy Over [[#np|NP]] ===== QH<sub>i</sub> is defined to be P<sup>NP[k]</sup>; that is, [[#p|P]] with k queries to an [[#np|NP]] oracle (where k is a constant). Then QH is the union of QH<sub>i</sub> over all nonnegative i. QH = [[#bh|BH]] [[zooref#wag88|[Wag88]]]; thus, either both hierarchies are infinite or both collapse to some finite level. ---- ===== <span id="qip" style="color:red">QIP</span>: Quantum [[#ip|IP]] ===== The class of decision problems such that a "yes" answer can be verified by a <i>quantum interactive proof</i>. Here the verifier is a [[#bqp|BQP]] (i.e. quantum polynomial-time) algorithm, while the prover has unbounded computational resources (though cannot violate the linearity of quantum mechanics). The prover and verifier exchange a polynomial number of messages, which can be quantum states. Thus, the verifier's and prover's states may become entangled during the course of the protocol. Given the verifier's algorithm, we require that <ol> <li>If the answer is "yes," then the prover can behave in such a way that the verifier accepts with probability at least 2/3.</li> <li>If the answer is "no," then however the prover behaves, the verifier rejects with probability at least 2/3.</li> </ol> Let QIP[k] be QIP where the prover and verifier are restricted to exchanging k messages (with the prover going last). Defined in [[zooref#wat99|[Wat99]]], where it was also shown that [[#pspace|PSPACE]] is in QIP. Subsequently [[zooref#kw00|[KW00]]] showed that for all k&gt;3, QIP[k] = QIP = QIP. QIP is contained in [[#exp|EXP]] [[zooref#kw00|[KW00]]]. QIP(1) is more commonly known as [[#qma|QMA]]. See also: [[#qip2|QIP]], [[#qszk|QSZK]]. ---- ===== <span id="qip2" style="color:red">QIP</span>: 2-Message Quantum [[#ip|IP]] ===== See [[#qip|QIP]] for definition. Contains [[#qszk|QSZK]] [[zooref#wat02|[Wat02]]]. ---- ===== <span id="qma" style="color:red">QMA</span>: Quantum [[#ma|MA]] ===== The class of decision problems such that a "yes" answer can be verified by a 1-message quantum interactive proof. That is, a [[#bqp|BQP]] (i.e. quantum polynomial-time) verifier is given a quantum state (the "proof"). We require that <ol> <li>If the answer is "yes," then there exists a state such that verifier accepts with probability at least 2/3.</li> <li>If the answer is "no," then for all states the verifier rejects with probability at least 2/3.</li> </ol> QMA = [[#qip|QIP]](1). Defined in [[zooref#wat00|[Wat00]]], where it is also shown that <i>group non-membership</i> is in QMA. That is: let G be a group, whose elements are represented by polynomial-size strings. We're given a "black box" that correctly multiplies and inverts elements of G. Then given elements g and h<sub>1</sub>,...,h<sub>k</sub>, we can verify in QMA that g is not in the subgroup generated by h<sub>1</sub>,...,h<sub>k</sub>. Based on this, [[zooref#wat00|[Wat00]]] gives an oracle relative to which [[#ma|MA]] is strictly contained in QMA. Kitaev and Watrous (unpublished) showed QMA is contained in [[#pp|PP]]. Combining that result with [[zooref#ver92|[Ver92]]], one can obtain an oracle relative to which [[#am|AM]] is not in QMA. Kitaev ([[zooref#ksv02|[KSV02]]], see also [[zooref#an02|[AN02]]]) showed that the following problem is complete for QMA: <ul> '''5-Local Hamiltonians.''' Given an n-qubit Hilbert space, as well as a collection H<sub>1</sub>,...,H<sub>k</sub> of Hamiltonians (i.e. Hermitian positive semidefinite matrices), each of which acts on at most 5 qubits of the space. Also given reals a,b such that b-a = &Theta;(1/poly(n)). Decide whether the smallest eigenvalue of H=H<sub>1</sub>+...+H<sub>k</sub> is less than a or greater than b, promised that one of these is the case. Subsequently Kempe and Regev [[zooref#kr03|[KR03]]] showed that even 3-Local Hamiltonians is QMA-complete. A subsequent paper by Kempe, Kitaev, and Regev [[zooref#kkr04|[KKR04]]], has hit rock bottom (assuming [[#p|P]] does not equal QMA), by showing '''<font color="red">2</font>'''-local Hamiltonians QMA-complete. </ul> Compare to [[#nqp|NQP]]. If QMA = [[#pp|PP]] then [[#pp|PP]] contains [[#ph|PH]] [[zooref#vya03|[Vya03]]]. This result uses the fact that QMA is contained in [[#a0pp|A<sub>0</sub>PP]]. See also: [[#qcma|QCMA]], [[#qmaqpoly|QMA/qpoly]], [[#qszk|QSZK]], [[#qma2|QMA(2)]], [[#qma-plus|QMA-plus]]. ---- ===== <span id="qma-plus" style="color:red">QMA-plus</span>: [[#qma|QMA]] With Super-Verifier ===== Same as [[#qma|QMA]], except now the verifier can directly obtain the <i>probability</i> that a given observable of the certificate state, if measured, would equal 1. (In the usual model, by contrast, one can only sample an observable.) Defined in [[zooref#ar03|[AR03]]], where it was also shown that QMA-plus = [[#qma|QMA]]. ---- ===== <span id="qma2" style="color:red">QMA(2)</span>: Quantum [[#ma|MA]] With Multiple Certificates ===== Same as [[#qma|QMA]], except that now the verifier is given <i>two</i> polynomial-size quantum certificates, which are guaranteed to be unentangled. Defined in [[zooref#kmy01|[KMY01]]]. It is unknown whether QMA(k) = QMA(2) for all k>2, and also whether QMA(2) = [[#qma|QMA]]. ---- ===== <span id="qmalog" style="color:red">QMA<sub>log</sub></span>: [[#qma|QMA]] With Logarithmic-Size Proofs ===== Same as [[#qma|QMA]] except that the quantum proof has O(log n) qubits instead of a polynomial number. Equals [[#bqp|BQP]] [[zooref#mw05|[MW05]]]. ---- ===== <span id="qmam" style="color:red">QMAM</span>: Quantum Merlin-Arthur-Merlin Public-Coin Interactive Proofs ===== The class of decision problems for which a "yes" answer can be verified by a public-coin quantum MAM protocol, as follows. Merlin sends a polynomial-size quantum state to Arthur. Arthur then flips some classical coins (in fact, he only has to flip <i>one</i> without loss of generality) and sends the outcome to Merlin. At this stage Arthur is not yet allowed to perform any quantum operations. Merlin then sends Arthur another quantum state. Finally, Arthur performs a [[#bqp|BQP]] operation on both of the states simultaneously, and either accepts or rejects. The completeness and soundness requirements are the same as for [[#am|AM]]. Also, Merlin's messages might be entangled. Defined by Marriott and Watrous [[zooref#mw05|[MW05]]], who also showed that QMAM = [[#qip|QIP]](3) = [[#qip|QIP]]. Hence QMAM contains [[#pspace|PSPACE]]. ---- ===== <span id="qmaqpoly" style="color:red">QMA/qpoly</span>: [[#qma|QMA]] With Polynomial-Size Quantum Advice ===== Is contained in [[#pspacepoly|PSPACE/poly]] [[zooref#aar06b|[Aar06b]]]. ---- ===== <span id="qmip" style="color:red">QMIP</span>: Quantum Multi-Prover Interactive Proofs ===== The quantum generalization of [[#mip|MIP]], and the multi-prover generalization of [[#qip|QIP]]. A quantum multi-prover interactive proof system is the same as a classical one, except that all messages and verifier computations are quantum. As in [[#mip|MIP]], there is no communication among the provers; however, the provers share unlimited prior entanglement. The number of provers and number of rounds can both be polynomial in n. Defined in [[zooref#km02|[KM02]]]. Fascinatingly, no relationship between QMIP and [[#nexp|NEXP]] is known. We don't know whether allowing the provers unlimited prior entanglement makes the class more powerful, less powerful, or both! ---- ===== <span id="qmiple" style="color:red">QMIP<sub>le</sub></span>: Quantum Multi-Prover Interactive Proofs With Limited Prior Entanglement ===== Same as [[#qmip|QMIP]], except that now the provers share only a polynomial number of EPR pairs, instead of an unlimited number. Defined in [[zooref#km02|[KM02]]], where it was also shown that QMIP<sub>le</sub> is contained in [[#nexp|NEXP]] = [[#qmipne|QMIP<sub>ne</sub>]]. ---- ===== <span id="qmipne" style="color:red">QMIP<sub>ne</sub></span>: Quantum Multi-Prover Interactive Proofs With No Prior Entanglement ===== Same as [[#qmip|QMIP]], except that now the provers have no prior entanglement. Defined in [[zooref#km02|[KM02]]], where it was also shown that QMIP<sub>ne</sub> = [[#nexp|NEXP]]. Thus, QMIP<sub>ne</sub> contains [[#qmiple|QMIP<sub>le</sub>]]. ---- ===== <span id="qnc" style="color:red">QNC</span>: Quantum [[#nc|NC]] ===== The class of decision problems solvable by polylogarithmic-depth quantum circuits with bounded probability of error. (A uniformity condition may also be imposed.) Has the same relation to [[#nc|NC]] as [[#bqp|BQP]] does to [[#p|P]]. [[zooref#cw00|[CW00]]] showed that factoring is in [[#zpp|ZPP]] with a QNC oracle. Is incomparable with [[#bpp|BPP]] as far as anyone knows. See also: [[#rnc|RNC]]. ---- ===== <span id="qnc0" style="color:red">QNC<sup>0</sup></span>: Quantum [[#nc0|NC<sup>0</sup>]] ===== Constant-depth quantum circuits without fanout gates. Defined in [[zooref#spa02|[Spa02]]]. Contained in [[#qncf0|QNC<sub>f</sub><sup>0</sup>]]. ---- ===== <span id="qncf0" style="color:red">QNC<sub>f</sub><sup>0</sup></span>: Quantum [[#nc0|NC<sup>0</sup>]] With Unbounded Fanout ===== Constant-depth quantum circuits with unbounded-fanout gates. Defined in [[zooref#spa02|[Spa02]]]. Contains [[#qnc0|QNC<sup>0</sup>]], and is contained in [[#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="qnc1" style="color:red">QNC<sup>1</sup></span>: Quantum [[#nc1|NC<sup>1</sup>]] ===== Same as [[#qnc|QNC]]<sup>1</sup>, but for the exact rather than bounded-error case. In contrast to [[#nc1|NC<sup>1</sup>]], it is not clear how to simulate QNC<sup>1</sup> on a quantum computer in which one qubit is initialized to a pure state, and the remaining qubits are in the maximally mixed state [[zooref#asv00|[ASV00]]]. See also [[zooref#mn02|[MN02]]]. ---- ===== <span id="qp" style="color:red">QP</span>: Quasipolynomial-Time ===== Equals [[#dtime|DTIME]](2<sup>polylog(n)</sup>). ---- ===== <span id="qplin" style="color:red">QPLIN</span>: Linear Quasipolynomial-Time ===== Equals [[#dtime|DTIME]](n<sup>O(log n)</sup>). Has the same relationship to [[#qp|QP]] that [[#e|E]] does to [[#exp|EXP]]. ---- ===== <span id="qpspace" style="color:red">QPSPACE</span>: Quasipolynomial-Space ===== Equals [[#dspace|DSPACE]](2<sup>polylog(n)</sup>). According to [[zooref#bg94|[BG94]]], Beigel and Feigenbaum and (independently) Krawczyk showed that QPSPACE is not contained in [[#check|Check]]. ---- ===== <span id="qrg" style="color:red">QRG</span>: Quantum Refereed Games ===== Same as [[#rg|RG]], except that now the verifier is a [[#bqp|BQP]] machine, and can exchange polynomially many quantum messages with the competing provers. The two provers are computationally unbounded, but must obey the laws of quantum mechanics. Also, we can assume without loss of generality that the provers share no entanglement, because adversaries gain no advantage by sharing information. Defined in [[zooref#gut05|[Gut05]]], where it was also shown that QRG is contained in [[#nexp|NEXP]] &#8745; [[#conexp|coNEXP]]. QRG trivially contains [[#rg|RG]] (and hence [[#exp|EXP]]), as well as [[#sqg|SQG]]. ---- ===== <span id="qs2p" style="color:red">QS<sub>2</sub>P</span>: Quantum [[#s2p|S<sub>2</sub>P]] ===== The class of problems for which there exists a [[#bqp|BQP]] machine M such that: <ul> <li>If the answer is "yes," then there exists a quantum state &rho; such that for all quantum states &sigma;, M(&rho;,Ï) accepts with probability at least 2/3.</li> <li>If the answer is "no," then there exists a &sigma; such that for all &rho;, M(&rho;,&sigma;) rejects with probability at least 2/3.</li> </ul> In other words, it's the same as [[#sqg|SQG]], but without communication from the verifier back to the provers. Contains [[#qma|QMA]] (and indeed [[#p|P]]<sup>[[#qma|QMA]]</sup>), and is contained in [[#sqg|SQG]] and hence [[#exp|EXP]]. ---- ===== <span id="qszk" style="color:red">QSZK</span>: Quantum Statistical Zero-Knowledge ===== A quantum analog of [[#szk|SZK]] (or more precisely [[#hvszk|HVSZK]]). Arthur is a [[#bqp|BQP]] (i.e. quantum) verifier who can exchange quantum messages with Merlin. So Arthur and Merlin's states may become entangled during the course of the protocol. Arthur's "view" of his interaction with Merlin is taken to be the sequence of mixed states he has, over all steps of the protocol. The zero-knowledge requirement is that each of these states must have trace distance at most (say) 1/10 from a state that Arthur could prepare himself (in [[#bqp|BQP]]), without help from Merlin. Arthur is assumed to be an honest verifier. Defined in [[zooref#wat02|[Wat02]]], where the following was also shown: <ul> <li>QSZK is contained in [[#pspace|PSPACE]].</li> <li>QSZK is closed under complement.</li> <li>Any protocol can be parallelized to consist of two messages, so that QSZK is in [[#qip2|QIP]].</li> <li>One can assume without loss of generality that protocols are public-coin, as for [[#szk|SZK]].</li> <li>QSZK has a natural complete promise problem, called <i>Quantum State Distinguishability</i> (QSD). We are given quantum circuits Q<sub>0</sub> and Q<sub>1</sub>. Let &#961;<sub>0</sub> and &#961;<sub>1</sub> be the mixed states they produce respectively, when run on the all-0 state (and when non-output qubits are traced out). We are promised that the trace distance between &#961;<sub>0</sub> and &#961;<sub>1</sub> is either at most &#945; or at least &#946;, where &#945; and &#946; are constants in [0,1] satisfying &#945; &lt; &#946;<sup>2</sup>. The problem is to decide which of these is the case.</li> </ul> ---- ===== <span id="r" style="color:red">R</span>: Recursive Languages ===== The class of decision problems solvable by a Turing machine. Often identified with the class of 'effectively computable' functions (the <i>Church-Turing thesis</i>). Defined in [[zooref#tur36|[Tur36]]], [[zooref#chu41|[Chu41]]], and other seminal early papers. Equals [[#re|RE]] &#8745; [[#core|coRE]]. Strictly contains [[#pr|PR]], the primitive recursive functions (see [[zooref#kle71|[Kle71]]]). ---- ===== <span id="rbqp" style="color:red">RBQP</span>: Strict Quantum [[#rp|RP]] ===== The class of problems in [[#np|NP]] whose witnesses are in [[#fbqp|FBQP]]. For example, the set of square-free numbers is in coRBQP using only the fact that factoring is in [[#fbqp|FBQP]]. (Even without a proof that the factors are prime, the factorization proves that there is a square divisor.) Contains [[#rp|RP]] and [[#zbqp|ZBQP]], and is contained in [[#bqp|BQP]] and [[#rqp|RQP]]. Defined here to clarify [[#eqp|EQP]]; see also [[#zbqp|ZBQP]]. ---- ===== <span id="re" style="color:red">RE</span>: Recursively Enumerable Languages ===== The class of decision problems for which a 'yes' answer can be verified by a Turing machine in a finite amount of time. (If the answer is 'no,' on the other hand, the machine might never halt.) Equivalently, the class of decision problems for which a Turing machine can list all the 'yes' instances, one by one (this is what 'enumerable' means). A problem C is complete for RE if (1) C is in RE and (2) any problem in RE can be reduced to C by a Turing machine. Actually there are two types of reduction: M-reductions (for <i>many-one</i>), in which a single instance of the original problem is mapped to an instance of C, and T-reductions (for <i>Turing</i>), in which an algorithm for the original problem can make arbitrarily many calls to an oracle for C. RE-complete sets are also called <i>creative</i> sets for some reason. The canonical RE-complete problem is the <i>halting problem</i>: i.e., given a Turing machine, does it halt when started on a blank tape? The famous unsolvability of the halting problem [[zooref#tur36|[Tur36]]] implies that [[#r|R]] does not equal RE. Also, RE does not equal [[#core|coRE]]. RE and [[#core|coRE]] can be generalized to the <i>arithmetic hierarchy</i> [[#ah|AH]]. There are problems in RE that are neither RE-complete under T-reductions, nor in [[#r|R]] [[zooref#fri57|[Fri57]]] [[zooref#muc56|[Muc56]]]. This is the resolution of <i>Post's problem</i> [[zooref#pos44|[Pos44]]]. Indeed, RE contains infinitely many nonequivalent 'T-degrees.' (A T-degree is a class of problems, all of which can be T-reduced to one another.) The structure of the T-degrees has been studied in more detail than you can possibly imagine [[zooref#sho99|[Sho99]]]. ---- ===== <span id="reg" style="color:red">REG</span>: Regular Languages ===== The class of decision problems solvable by deterministic finite automata (DFA's). Equals the class solvable by nondeterministic finite automata (NDFA's). Equals [[#dspace|DSPACE]](O(1)) [[zooref#she59|[She59]]], which equals [[#dspace|DSPACE]](o(log log n)) [[zooref#hls65|[HLS65]]]. Includes, i.e., "Is the parity of the input odd?," but not "Are the majority of bits in the input 1's?" This is sometimes expressed as "finite automata can't count." Contained in [[#nc1|NC<sup>1</sup>]]. See e.g. [[zooref#koz97|[Koz97]]], [[zooref#gur89|[Gur89]]] for basic results on regular languages. ---- ===== <span id="revspace" style="color:red">RevSPACE(f(n))</span>: Reversible f(n)-Space ===== The class of decision problems solvable in space O(f(n)) by a reversible Turing machine (a deterministic Turing machine for which every configuration has at most one immediate predecessor). Was shown to equal [[#dspace|DSPACE]](f(n)) [[zooref#lmt97|[LMT97]]]. ---- ===== <span id="rg" style="color:red">RG</span>: Refereed Games ===== The class of problems solvable by a probabilistic polynomial-time verifier who can exchange a polynomial number of messages with two competing, computationally-unbounded provers -- one trying to convince the verifier that the answer is "yes," the other that the answer is "no." Note that the verifier can hide information from the provers. Public-coin RG amounts to [[#saptime|SAPTIME]], which equals [[#pspace|PSPACE]] [[zooref#pap83|[Pap83]]]. RG is in [[#exp|EXP]] relative to any oracle [[zooref#km92|[KM92]]]; they are equal, unrelativized [[zooref#fk97b|[FK97b]]]. Contains [[#rg1|RG]], and is contained in [[#qrg|QRG]]. See also [[#pcd|PCD]], [[#gpcd|GPCD]]. ---- ===== <span id="rg1" style="color:red">RG</span>: One-Round Refereed Games ===== Same as [[#rg|RG]], except that now the verifier can exchange only a single round of messages with the two provers. A <i>round</i> consists of private messages from the verifier to the provers, followed by private responses from the provers to the verifier. Since the queries are private, they may as well be parallel; likewise the responses. This makes RG a symmetric class, indeed a randomized analogue of [[#s2p|S<sub>2</sub>P]]. RG is contained in [[#pspace|PSPACE]], and they are equal, unrelativized [[zooref#fk97b|[FK97b]]]. Contains [[#s2p|S<sub>2</sub>P]] and is contained in [[#sqg|SQG]]. ---- ===== <span id="rhl" style="color:red">R<sub>H</sub>L</span>: Randomized Halting Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#rp|RP]] does to [[#p|P]]. The randomized machine must halt for every input <i>and</i> every setting of the random tape. Contains undirected reachability (is there a path from vertex u to vertex v in an undirected graph?) [[zooref#akl79|[AKL+79]]]. Contained in [[#rl|RL]]. ---- ===== <span id="rhspace" style="color:red">R<sub>H</sub>SPACE(f(n))</span>: One-Sided Error Halting Probabilistic f(n)-Space ===== Has the same relation to [[#bphspace|BP<sub>H</sub>SPACE(f(n))]] as [[#rp|RP]] does to [[#bpp|BPP]]. ---- ===== <span id="rl" style="color:red">RL</span>: Randomized Logarithmic-Space ===== Has the same relation to [[#l|L]] as [[#rp|RP]] does to [[#p|P]]. The randomized machine must halt with probability 1 on any input. It must also run in polynomial time (since otherwise we would just get [[#nl|NL]]). Contains [[#rhl|R<sub>H</sub>L]]. Contained in [[#sc|SC]] [[zooref#nis92|[Nis92]]]. [[zooref#rtv05|[RTV05]]] give strong evidence that RL = [[#l|L]]. ---- ===== <span id="rnc" style="color:red">RNC</span>: Randomized [[#nc|NC]] ===== Has the same relation to [[#nc|NC]] as [[#rp|RP]] does to [[#p|P]]. Contains the maximum matching problem for bipartite graphs [[zooref#mvv87|[MVV87]]]. Contained in [[#qnc|QNC]]. See also: [[#cornc|coRNC]]. ---- ===== <span id="rp" style="color:red">RP</span>: Randomized Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' at least 1/2 of computation paths accept.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ah87|[AH87]]]. For other problems in RP, see the standard text on randomized algorithms, [[zooref#mr95|[MR95]]]. See also: [[#corp|coRP]], [[#zpp|ZPP]], [[#bpp|BPP]]. ---- ===== <span id="rpp" style="color:red">RPP</span>: Restricted Pseudo Polynomial-Time ===== The class of decision problems (x,m) (where x is an input of length |x|=n and m is an integer parameter), that are solvable by a nondeterministic (i.e. [[#np|NP]]) machine in poly(n+m) time and O(m+log n) space simultaneously. Defined in [[zooref#mon80|[Mon80]]]. See also [[#fpt|FPT]]. ---- ===== <span id="rqp" style="color:red">RQP</span>: One-sided Error Extension of [[#eqp|EQP]] ===== The class of questions that can be answered by a QTM that accepts with probability 0 when the true answer is no, and accepts with probability at least 1/2 when the true answer is yes. Since one of the probabilities has to vanish, RQP has the same technical caveats as [[#eqp|EQP]]. Contains [[#zqp|ZQP]] and [[#rbqp|RBQP]], and is contained in [[#bqp|BQP]]. ---- ===== <span id="rspace" style="color:red">RSPACE(f(n))</span>: Randomized f(n)-Space ===== Same as [[#rl|RL]], but for O(f(n))-space instead of logarithmic-space. Contained in [[#nspace|NSPACE(f(n))]] and [[#bpspace|BPSPACE(f(n))]]. ---- ===== <span id="s2p" style="color:red">S<sub>2</sub>P</span>: Second Level of the Symmetric Hierarchy ===== The class of decision problems for which there is a polynomial-time predicate P such that, on input x, <ol> <li>If the answer is 'yes,' then there exists a y such that for all z, P(x,y,z) is true.</li> <li>If the answer is 'no,' then there exists a z such that for all y, P(x,y,z) is false.</li> </ol> Note that this differs from [[#sigma2p|&#931;<sub>2</sub>P]] in that the quantifiers in the second condition are reversed. Less formally, S<sub>2</sub>P is the class of one-round games in which a prover and a disprover submit simultaneous moves to a deterministic, polynomial-time referee. In [[#sigma2p|&#931;<sub>2</sub>P]], the disprover moves first. Defined in [[zooref#rs98|[RS98]]], where it was also shown that S<sub>2</sub>P contains [[#ma|MA]] and [[#delta2p|&#916;<sub>2</sub>P]]. Defined independently in [[zooref#can96|[Can96]]]. Contained in [[#zpp|ZPP]]<sup>[[#np|NP]]</sup> [[zooref#cai01|[Cai01]]]. ---- <table border="3"><tr><td> ===== <span id="s2exppnp" style="color:red">S<sub>2</sub>-EXP&#149;P<sup>NP</sup></span>: Don't Ask ===== One of the caged classes of the Complexity Zoo. Has been implicated in a collapse scandal involving [[#ampolylog|AM[polylog]]], [[#conp|coNP]], and [[#eh|EH]]. </td></tr></table> ---- ===== <span id="sac" style="color:red">SAC</span>: Semi-Unbounded-Fanin [[#ac|AC]] ===== SAC<sup>k</sup> is the class of decision problems solvable by a family of depth-O(log<sup>k</sup>n) circuits with unbounded-fanin OR & bounded-fanin AND gates. Negations are only allowed at the input level. A uniformity condition may also be imposed. Defined by [[zooref#bcd89|[BCD+89]]], who also showed that SAC<sub>k</sub> is closed under complement for every k&gt;0. ---- ===== <span id="sac0" style="color:red">SAC<sup>0</sup></span>: Semi-Unbounded-Fanin [[#ac0|AC<sup>0</sup>]] ===== See [[#sac|SAC]] for definition. Not closed under complement [[zooref#bcd89|[BCD+89]]]. ---- ===== <span id="sac1" style="color:red">SAC<sup>1</sup></span>: Semi-Unbounded-Fanin [[#ac1|AC<sup>1</sup>]] ===== See [[#sac|SAC]] for definition. Equals [[#logcfl|LOGCFL]]/poly [[zooref#ven91|[Ven91]]]. Contained in [[#paritysac1|&#8853;SAC<sup>1</sup>]] [[zooref#gw96|[GW96]]]. ---- ===== <span id="saptime" style="color:red">SAPTIME</span>: Stochastic Alternating Polynomial-Time ===== The class of problems solvable by a polynomial-time Turing machine with three kinds of quantifiers: existential, universal, and randomized. Defined in [[zooref#pap83|[Pap83]]], where it was also observed that SAPTIME = [[#pspace|PSPACE]]. ---- ===== <span id="sbp" style="color:red">SBP</span>: Small Bounded-Error Probability ===== The class of decision problems for which the following holds. There exists a [[#sharpp|#P]] function f and an [[#fp|FP]] function g such that, for all inputs x, <ol> <li>If the answer is "yes" then f(x) &gt; g(x).</li> <li>If the answer is "no" then f(x) &lt; g(x)/2.</li> </ol> Defined in [[zooref#bgm02|[BGM02]]], where the following was also shown: <ul> <li>SBP contains [[#ma|MA]], [[#wapp|WAPP]], and [[#existsbpp|&#8707;BPP]].</li> <li>SBP is contained in [[#am|AM]] and [[#bpppath|BPP<sub>path</sub>]].</li> <li>There exists an oracle relative to which SBP is not contained in [[#sigma2p|&#931;<sub>2</sub>P]].</li> <li>SBP is closed under union.</li> </ul> ---- ===== <span id="sc" style="color:red">SC</span>: Steve's Class ===== (Named in honor of Stephen Cook.) The class of decision problems solvable by a Turing machine that simultaneously uses polynomial time and polylogarithmic space. Note that SC might be smaller than [[#p|P]] &#8745; [[#polyL|polyL]], since for the latter, it suffices to have two separate algorithms: one polynomial-time and the other polylogarithmic-space. Deterministic context-free languages (DCFL's) can be recognized in SC [[zooref#coo79|[Coo79]]]. SC contains [[#rl|RL]] and [[#bpl|BPL]] [[zooref#nis92|[Nis92]]]. SC equals [[#dtisp|DTISP]](poly,polylog) by definition. ---- ===== <span id="se" style="color:red">SE</span>: Subexponentially-Solvable Search Problems ===== The class of [[#fnp|FNP]] search problems solvable in O(2<sup>&epsilon;n</sup>) time for every &epsilon;&gt;0. Defined in [[zooref#ipz01|[IPZ01]]], who also gave reductions showing that if any of k-SAT, k-colorability, k-set cover, clique, or vertex cover is in SE, then all of them are. ---- ===== <span id="seh" style="color:red">SEH</span>: Strong Exponential Hierarchy ===== The union of [[#ne|NE]], [[#np|NP]]<sup>[[#ne|NE]]</sup>, [[#np|NP]]<sup>[[#np|NP]]^[[#ne|NE]]</sup>, and so on. Is called "strong" to contrast it with the ordinary Exponential Hierarchy [[#eh|EH]]. Note that we would get the same class if we replaced [[#ne|NE]] by [[#nexp|NEXP]]. SEH collapses to [[#p|P]]<sup>[[#ne|NE]]</sup> [[zooref#hem89|[Hem89]]] There exists an oracle relative to which SEH is not contained in [[#eh|EH]] [[zooref#hem89|[Hem89]]]. [[#eh|EH]] and SEH are incomparable for all anyone knows. ---- ===== <span id="selfnp" style="color:red">SelfNP</span>: Self-Witnessing [[#np|NP]] ===== The class of languages L in [[#np|NP]] such that the union, over all x in L, of the set of valid witnesses for x equals L itself. Defined in [[zooref#ht03|[HT03]]], where it was shown that the closure of SelfNP under polynomial-time many-one reductions is [[#np|NP]]. They also show that if SelfNP = [[#np|NP]], then [[#e|E]] = [[#ne|NE]]; and that SAT is contained in SelfNP. See also: [[#permup|PermUP]]. ---- ===== <span id="sfk" style="color:red">SF<sub>k</sub></span>: Width-k Bottleneck Turing Machines ===== The class of decision problems solvable by a k-bottleneck Turing machine. This is a machine that, after a polynomial amount of time, erases everything on the tape except for a single k-valued "safe-storage". There's also a counter recording the number of erasings, which is in effect a non-deterministic witness. For example, SF<sub>2</sub> contains both [[#parityp|&#8853;P]] and [[#np|NP]] by using the counter as a witness. Defined in [[zooref#cf91|[CF91]]], where it was also shown that SF<sub>5</sub> = [[#pspace|PSPACE]]. The complexity of SF<sub>2</sub>, SF<sub>3</sub>, and SF<sub>4</sub> was studied in [[zooref#ogi94|[Ogi94]]] and [[zooref#her97|[Her97]]]. The following result of those authors is among the caged beasts of the Complexity Zoo: <table border="3"> <tr><td> SF<sub>4</sub> is contained in BP [[#parityp|&#8853;P]]<sup>[[#modkp|Mod_3P]] ^ [[#parityp|&#8853;P]] ^ [[#modkp|Mod_3P]] ^ [[#parityp|&#8853;P]]</sup> </td></tr> </table> (Here the BP operator means that one makes the class into a bounded-error probabilistic class, the same way one makes [[#p|P]] into [[#bpp|BPP]] and [[#np|NP]] into [[#am|AM]].) ---- ===== <span id="sigma2p" style="color:red">&#931;<sub>2</sub>P</span>: [[#np|NP]] With [[#np|NP]] Oracle ===== Complement of [[#pi2p|&#928;<sub>2</sub>P]]. Along with [[#pi2p|&#928;<sub>2</sub>P]], comprises the second level of [[#ph|PH]], the polynomial hierarchy. [[zooref#uma98|[Uma98]]] has shown that the following problems are complete for &#931;<sub>2</sub>P: <ul> <li><i>Minimum equivalent DNF.</i> Given a DNF formula F and integer k, is there a DNF formula equivalent to F with k or fewer occurences of literals?</li> <li><i>Shortest implicant.</i> Given a formula F and integer k, is there a conjunction of k or fewer literals that implies F? (Note that this problem cannot be &#931;<sub>2</sub>P-complete for <i>DNF</i> formulas unless &#931;<sub>2</sub>P equals [[#betap|&beta;P]]<sup>[[#np|NP]]</sup>.)</li> </ul> For any fixed k, there is a problem in &#931;<sub>2</sub>P &#8745; [[#pi2p|&#928;<sub>2</sub>P]] that cannot be solved by circuits of size n<sup>k</sup> [[zooref#kan82|[Kan82]]]. ---- ===== <span id="skc" style="color:red">SKC</span>: Statistical Knowledge Complexity ===== A hierarchy of generalizations of [[#szk|SZK]], in which Arthur is allowed to gain <i>some</i> information from his interaction with Merlin. Defined in [[zooref#gp91|[GP91]]]. There are several variants (which we only describe roughly), including: <ul> <li>'''SKC<sub>hint</sub>(k(n)): Hint sense.''' The simulator can reproduce Arthur's view of the protocol if given a hint string of size k(n).</li> <li>'''SKC<sub>hint</sub>(k(n)): Strict oracle sense.''' The simulator can reproduce Arthur's view if allowed k(n) queries to an oracle O.</li> <li>'''SKC<sub>avg</sub>(k(n)): Average oracle sense.''' For each input, the <i>expected</i> number of queries the simulator makes to oracle O is at most k(n).</li> <li>'''SKC<sub>ent</sub>(k(n)): Entropy sense.''' Defined in [[zooref#abv95|[ABV95]]]. For each input, the expectation (over Arthur's random coins) of -log(P) is at most k(n), where P is the probability that the view output by the simulator equals the view resulting from the actual protocol.</li> </ul> See also: [[#pkc|PKC]]. ---- ===== <span id="sl" style="color:red">SL</span>: Symmetric Logarithmic-Space ===== The class of problems solvable by a nondeterministic Turing machine in logarithmic space, such that <ol> <li>If the answer is 'yes,' one or more computation paths accept.</li> <li>If the answer is 'no,' all paths reject.</li> <li>If the machine can make a nondeterministic transition from configuration A to configuration B, then it can also transition from B to A. (This is what 'symmetric' means.)</li> </ol> Defined in [[zooref#lp82|[LP82]]]. The reachability problem (is there a path from vertex s to vertex t?) for undirected graphs is complete for SL, under [[#l|L]]-reduction. SL contains [[#l|L]], and is contained in [[#nl|NL]]. It follows from [[zooref#akl79|[AKL+79]]] that SL is contained in [[#l/poly|L/poly]]. [[zooref#kw93|[KW93]]] showed that SL is contained in [[#parityl|&#8853;L]], as well as [[#modkl|Mod<sub>k</sub>L]] for every prime k. SL is also contained in [[#dspace|DSPACE]](log<sup>3/2</sup>n) [[zooref#nsw92|[NSW92]]], and indeed in [[#dspace|DSPACE]](log<sup>4/3</sup>n) [[zooref#atw00|[ATW+00]]]. [[zooref#nt95|[NT95]]] showed that SL equals [[#cosl|coSL]], and furthermore that SL<sup>SL</sup> = SL (that is, the symmetric logspace hierarchy collapses). The story ends with the remarkable result that SL = [[#l|L]] (even relative to an oracle) [[zooref#rei04|[Rei04]]]. ---- ===== <span id="slicewisepspace" style="color:red">SLICEWISE PSPACE</span>: Parametrized [[#pspace|PSPACE]] ===== The parameterized version of [[#pspace|PSPACE]]. Same as [[#fpt|FPT]], except that now on input (x,k) (k a parameter), the <i>space</i> used must be f(k)p(|x|), where p is a polynomial. If [[#p|P]] = [[#pspace|PSPACE]], then [[#fpt|FPT]] = SLICEWISE PSPACE. Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="snp" style="color:red">SNP</span>: Strict [[#np|NP]] ===== [[zooref#fag74|[Fag74]]] showed that [[#np|NP]] is precisely the class of decision problems reducible to a graph-theoretic property expressible in second-order existential logic. For example (see [[zooref#pap94|[Pap94]]]), the property "graph G has a Hamiltonian path" is expressible as <ul> There exists a relation P(u,v) on vertices of G, such that P(u,u) is false, and for all distinct u,v either P(u,v) or P(v,u), and P(u,v) and P(v,w) implies P(u,w), and if P(u,w) and there does not exist a v for which P(u,v) and P(v,w), then there is an edge from u to w. </ul> (Here the relation P(u,v) defines a <i>total order</i> on vertices, such that any two consecutive vertices must be adjacent.) Then SNP is the class of decision problems reducible to a graph-theoretic predicate with <i>only</i> universal quantifiers over vertices, no existential quantifiers. As an example, k-SAT (CNF satisfiability with at most k literals per clause, for k a constant) is in SNP. But general SAT is not in SNP, basically because we're not allowed to say, "There exists a literal in this clause that satisfies the clause." Contains [[#mmsnp|MMSNP]]. See also: [[#maxsnp|MaxSNP]]. ---- ===== <span id="soe" style="color:red">SO-E</span>: Second Order Existential ===== The class of decision problems for which a "yes" answer is expressible by a proposition with second-order existential quantifiers followed by a first-order formula. See [[zooref#imm98|[Imm98]]] for a full definition. SO-E = [[#np|NP]] [[zooref#fag74|[Fag74]]]. Contains [[#fo|FO]](poly(n)). ---- ===== <span id="sp" style="color:red">SP</span>: Semi-Efficient Parallel ===== The class of problems in [[#p|P]] for which the best parallel algorithm (using a polynomial number of processors) is faster than the best serial algorithm by a factor of &Omega;(n<sup>&epsilon;</sup>) for some &epsilon;&gt;0. Defined in [[zooref#krs90|[KRS90]]]. SP is also an alternate name for [[#xpuniform|XP<sub>uniform</sub>]] ---- ===== <span id="spanp" style="color:red">span-P</span>: Span Polynomial-Time ===== The class of functions computable as |S|, where S is the set of output values returned by the accepting paths of an [[#np|NP]] machine. Defined in [[zooref#kst89|[KST+89]]], where it is also shown that span-P contains [[#sharpp|#P]] and [[#optp|OptP]]; and that span-P = [[#sharpp|#P]] if and only if [[#up|UP]] = [[#np|NP]]. ---- ===== <span id="sparse" style="color:red">SPARSE</span>: Sparse Languages ===== The class of decision problems for which the number of 'yes' instances of size n is upper-bounded by a polynomial in n. If SPARSE intersects [[#npc|NPC]] then [[#p|P]] = [[#np|NP]] [[zooref#mah82|[Mah82]]]. Contains [[#tally|TALLY]]. ---- ===== <span id="spl" style="color:red">SPL</span>: Stoic [[#pl|PL]] ===== Has the same relation to [[#pl|PL]] as [[#spp|SPP]] does to [[#pp|PP]]. Contains the maximum matching and perfect matching problems under a pseudorandom assumption [[zooref#arz99|[ARZ99]]]. Contains [[#ul|UL]]. Contained in [[#cequalsl|C<sub>=</sub>L]] and [[#modkl|Mod<sub>k</sub>L]]. Equals the set of problems low for [[#gapl|GapL]]. ---- ===== <span id="spp" style="color:red">SPP</span>: Stoic [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then these numbers differ by 2.</li> </ol> (A technicality: If the total number of paths is even then the numbers can't differ by 1.) Defined in [[zooref#ffk94|[FFK94]]], where it was also shown that SPP is low for [[#pp|PP]], [[#cequalsp|C<sub>=</sub>P]], [[#modkp|Mod<sub>k</sub>P]], and SPP itself. (I.e. adding SPP as an oracle does not increase the power of these classes.) Independently defined in [[zooref#oh93|[OH93]]], who called the class XP. Contained in [[#lwpp|LWPP]], [[#cequalsp|C<sub>=</sub>P]], and [[#wpp|WPP]] among other classes. Contains [[#fewp|FewP]]; indeed, [[#fewp|FewP]] is low for SPP, so that SPP<sup>[[#fewp|FewP]]</sup> = SPP [[zooref#ffk94|[FFK94]]]. Contains the problem of deciding whether a graph has any nontrivial automorphisms [[zooref#kst92|[KST92]]]. Indeed, contains graph isomorphism [[zooref#ak02|[AK02]]]. Contains a whole gaggle of problems for solvable black-box groups: solvability testing, membership testing, subgroup testing, normality testing, order verification, nilpotetence testing, group isomorphism, and group intersection [[zooref#vin04|[Vin04]]] [[zooref#ak02|[AK02]]] also showed that the Hidden Subgroup Problem for permutation groups, of interest in quantum computing, is in [[#fp|FP]]<sup>SPP</sup>. ---- ===== <span id="sqg" style="color:red">SQG</span>: Short Quantum Games ===== Same as [[#qrg|QRG]], except that now the verifier can exchange only a single round of quantum messages with the two provers. The verifier may process the yes-prover's response before sending a message to the no-prover (compare with [[#rg1|RG]], wherein the verifier's messages must be sent to the provers in parallel). Defined in [[zooref#gw05|[GW05]]], where it was also shown that SQG contains [[#qip|QIP]]. SQG is contained in [[#exp|EXP]] [[zooref#gut05|[Gut05]]], as well as in [[#qrg|QRG]]. SQG trivially contains [[#qs2p|QS<sub>2</sub>P]]. ---- ===== <span id="subexp" style="color:red">SUBEXP</span>: Deterministic Subexponential-Time ===== The intersection of [[#dtime|DTIME]](2<sup>n^&epsilon;</sup>) over all &epsilon;>0. (Note that the algorithm used may vary with &epsilon;.) ---- ===== <span id="symp" style="color:red">symP</span>: Alternate Name for [[#s2p|S<sub>2</sub>P]] ===== ---- ===== <span id="szk" style="color:red">SZK</span>: Statistical Zero Knowledge ===== The class of decision problems for which a "yes" answer can be verified by a <i>statistical zero-knowledge proof protocol</i>. In such a protocol, we have a [[#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier, Arthur, and a prover, Merlin, who has unbounded computational resources. By sending messages back and forth with Merlin, Arthur must become convinced (with high probability) that the answer is "yes," <i>without learning anything else about the problem</i> (statistically). What does that mean? For each choice of random coins, Arthur has a "view" of his entire interaction with Merlin, consisting of his random coins as well as all messages sent back and forth. Then the distribution over views resulting from interaction with Merlin has to be statistically close to a distribution that Arthur could generate himself (in polynomial-time), without interacting with Merlin. (Here "statistically close" means that, say, the trace distance is at most 1/10.) The most famous example of such a protocol is for <i>graph nonisomorphism</i>. Given two graphs G and H, Arthur can pick one of the graphs (each with probability 1/2), permute its vertices randomly, send the resulting graph to Merlin, and ask, "Which graph did I start with, G or H?" If G and H are non-isomorphic, Merlin can always answer correctly (since he can use exponential time), but if they're isomorphic, he can answer correctly with probability at most 1/2. Thus, if Merlin always gives the correct answer, Arthur becomes convinced the graphs are not isomorphic. On the other hand, Arthur already <i>knew</i> which graph (G or H) he started with, so he could simulate his entire view of the interaction himself, without Merlin's help. If that sounds like a complicated definition, well, it is. But it turns out that SZK has extremely nice properties. [[zooref#oka96|[Oka96]]] showed that: <ul> <li>SZK is closed under complement. I.e. Arthur can verify in zero-knowledge that two graphs <i>are</i> isomorphic, not only that they aren't.</li> <li>We can assume without loss of generality that the whole interaction consists of a constant number of messages.</li> <li>Amazingly, we can also assume without loss of generality that the protocol is <i>public-coin</i>. I.e. Arthur doesn't need to hide any of his random bits, as he did in the graph nonisomorphism protocol above, but can just send them all to Merlin!</li> <li>Finally, we can assume without loss of generality that the verifier (Arthur) is <i>honest</i>. A dishonest verifier would be one that tries to learn something about the problem (violating the zero-knowledge requirement) by deviating from the protocol.</li> </ul> Subsequently, [[zooref#sv97|[SV97]]] showed that SZK has a natural complete promise problem, called <i>Statistical Difference (SD)</i>. Given two polynomial-size circuits, C<sub>0</sub> and C<sub>1</sub>, let D<sub>0</sub> and D<sub>1</sub> be the distributions over their respective outputs when they're given as input a uniformly random n-bit string. We're promised that D<sub>0</sub> and D<sub>1</sub> have trace distance either at most 1/3 or at least 2/3; the problem is to decide which is the case. <i>Note:</i> The constants 1/3 and 2/3 can be amplified to 2<sup>-poly(n)</sup> and 1-2<sup>-poly(n)</sup> respectively. But it is crucial that (2/3)<sup>2</sup> &gt; 1/3. Another complete promise problem for SZK is <i>Entropy Difference (ED)</i> [[zooref#gv99|[GV99]]]. Here we're promised that either H(D<sub>0</sub>)&gt;H(D<sub>1</sub>)+1 or H(D<sub>1</sub>)&gt;H(D<sub>0</sub>)+1, where the distributions D<sub>0</sub> and D<sub>1</sub> are as above, and H denotes Shannon entropy. The problem is to determine which is the case. If any hard-on-average language is in SZK, then one-way functions exist [[zooref#ost91|[Ost91]]]. Zero-knowledge proofs were first studied in [[zooref#gmw91|[GMW91]]], [[zooref#gmr89|[GMR89]]]. Contains [[#pzk|PZK]] and [[#niszk|NISZK]], and is contained in [[#am|AM]] &#8745; [[#coam|coAM]], as well as [[#czk|CZK]] and [[#qszk|QSZK]]. There exists an oracle relative to which SZK is not in [[#bqp|BQP]] [[zooref#aar02|[Aar02]]]. Contained in [[#dqp|DQP]] [[zooref#aar02b|[Aar02b]]]. ---- ===== <span id="szkh" style="color:red">SZK<sub>h</sub></span>: [[#szk|SZK]] With Limited Help ===== The class of decision problems for which a "yes" answer can be verified by a statistical zero-knowledge proof protocol, and the prover and verifier both have access to a string computed by a trusted probabilistic polynomial-time third party with access to the input. Defined in [[zooref#bg03|[BG03]]], where it was also shown that SZK<sub>h</sub> = [[#szk|SZK]]. Contains [[#niszkh|NISZK<sub>h</sub>]]. ---- ===== <span id="tally" style="color:red">TALLY</span>: Tally Languages ===== The class of decision problems for which every 'yes' instance has the form 0<sup>n</sup> (i.e. inputs are encoded in unary). If TALLY intersects [[#npc|NPC]] then [[#p|P]] = [[#np|NP]] [[zooref#mah82|[Mah82]]]. Contained in [[#sparse|SPARSE]]. ---- ===== <span id="tc0" style="color:red">TC<sup>0</sup></span>: Constant-Depth Threshold Circuits ===== The class of decision problems solvable by polynomial-size, constant-depth circuits with unbounded fanin, which can use AND, OR, and NOT gates (as in [[#ac0|AC<sup>0</sup>]]) as well as <i>threshold</i> gates. A threshold gate returns 1 if at least half of its inputs are 1, and 0 otherwise. A uniformity requirement is sometimes also placed. TC<sup>0</sup> contains [[#acc0|ACC<sup>0</sup>]], and is contained in [[#nc1|NC<sup>1</sup>]]. TC<sup>0</sup> circuits of depth 3 are strictly more powerful than TC<sup>0</sup> circuits of depth 2 [[zooref#hmp93|[HMP+93]]]. TC<sup>0</sup> circuits of depth 3 and quasipolynomial size can simulate all of [[#acc0|ACC<sup>0</sup>]] [[zooref#yao90|[Yao90]]]. [[zooref#nr97|[NR97]]] give a candidate pseudorandom function family computable in TC<sup>0</sup>, that is secure assuming a subexponential lower bound on the hardness of factoring. (See also [[zooref#nrr01|[NRR01]]] for an improvement of this construction, as well as [[zooref#kha93|[Kha93]]].) One implication is that, assuming such a bound, there is no <i>natural proof</i> in the sense of [[zooref#rr97|[RR97]]] separating TC<sup>0</sup> from [[#ppoly|P/poly]]. (It is important for this that a <i>function family</i>, and not just a candidate pseudorandom <i>generator</i>, is computable in TC<sup>0</sup>.) Another implication is that functions in TC<sup>0</sup> are likely to be difficult to learn. The permanent of a 0-1 matrix cannot be computed in <i>uniform</i> TC<sup>0</sup> [[zooref#all99|[All99]]]. In a breakthrough result [[zooref#hes01|[Hes01]]] (building on [[zooref#bch86|[BCH86]]] and [[zooref#cdl01|[CDL01]]]), integer division was shown to be in [[#l|L]]-uniform TC<sup>0</sup>. Indeed division is <i>complete</i> for this class under [[#ac0|AC<sup>0</sup>]] reductions. ---- ===== <span id="tfnp" style="color:red">TFNP</span>: Total Function [[#np|NP]] ===== The class of function problems of the following form: <ul> Given an input x and a polynomial-time predicate F(x,y), output any y satisfying F(x,y). (Such a y is promised to exist.) </ul> Can be considered as the functional analogue of NP &#8745; coNP. Defined in [[zooref#mp91|[MP91]]]. Contained in [[#fnp|FNP]]. Subclasses include [[#ppa|PPA]], [[#ppp|PPP]], and [[#pls|PLS]]. ---- ===== <span id="theta2p" style="color:red">&#920;<sub>2</sub>P</span>: Alternate name for [[#pnplog|P<sup>NP[log]</sup>]] ===== ---- ===== <span id="treebqp" style="color:red">TreeBQP</span>: [[#bqp|BQP]] Restricted To Tree States ===== The class of languages accepted by a [[#bqp|BQP]] machine subject to the constraint that at every time step t, the machine's state is exponentially close to a <i>tree state</i> -- that is, a state expressible by a polynomial-size tree of additions and tensor products (together with complex constants and |0&gt; and |1&gt; leaf nodes). More formally, a uniform classical polynomial-time algorithm generates a sequence of gates g<sup>(1)</sup>, ... ,g<sup>(p(n))</sup>. Each g<sup>(t)</sup> can be either be selected from some finite universal basis of unitary gates (the choice turns out not to matter), or can be a 1-qubit measurement. When we perform a measurement, the state evolves to one of two possible pure states, with the usual probabilities, rather than to a mixed state. We require that the final gate g<sup>(p(n))</sup> is a measurement of the first qubit. If at least one intermediate state was more than distance 2<sup>-&Omega;(n)</sup> away from the nearest state of tree size at most p(n), then the outcome of the final measurement is chosen adversarially; otherwise it is given by the usual Born probabilities. The measurement must return 1 with probability at least 2/3 if the input is in the language, and with probability at most 1/3 otherwise. Contains [[#bpp|BPP]], and is contained in [[#bqp|BQP]]. Defined in [[zooref#aar03b|[Aar03b]]], where it was also shown that TreeBQP is contained in the third level of [[#ph|PH]], which might provide weak evidence that TreeBQP does not equal [[#bqp|BQP]]. ---- ===== <span id="treeregular" style="color:red">TREE-REGULAR</span>: Regular Tree-Valued Languages ===== Same as [[#reg|REG]], except that now the inputs are <i>trees</i> (say, binary trees) instead of strings. Each vertex is labeled with a symbol from a fixed alphabet. Evaluation begins at the leaves and proceeds to the root. The state of the finite automaton at each vertex v is a function of (1) the states at v's children (if any), and (2) the symbol at v. The tree is in the language if and only if the automaton is in an 'accept' state at the root. See [[zooref#koz92|[Koz92]]] for example. ---- ===== <span id="uap" style="color:red">UAP</span>: Unambiguous Alternating Polynomial-Time ===== Same as [[#ap|AP]], except we are promised that each existential quantifier has at most one 'yes' path, and each universal quantifier has at most one 'no' path. Contains [[#up|UP]]. Defined in [[zooref#nr98|[NR98]]], where it was also shown that, even though [[#ap|AP]] = [[#pspace|PSPACE]], it is unlikely that the same is true for UAP, since UAP is contained in [[#spp|SPP]]. [[zooref#cgr04|[CGR+04]]] have also shown that UAP<sup>UAP</sup> = UAP, and that UAP contains the Graph Isomorphism problem. ---- ===== <span id="ucc" style="color:red">UCC</span>: Unique Connected Component ===== The class of problems reducible in [[#l|L]] to the problem of whether an undirected graph has a unique connected component. See [[zooref#ag00|[AG00]]] for more information. Contained in [[#sl|SL]]. See also [[#coucc|coUCC]]. ---- ===== <span id="ul" style="color:red">UL</span>: Unambiguous [[#l|L]] ===== Has the same relation to [[#l|L]] as [[#up|UP]] does to [[#p|P]]. If UL = [[#nl|NL]], then [[#fnl|FNL]] is contained in [[#sharpl|#L]] [[zooref#aj93|[AJ93]]]. ---- ===== <span id="ulpoly" style="color:red">UL/poly</span>: Nonuniform [[#ul|UL]] ===== Has the same relation to [[#ul|UL]] as [[#ppoly|P/poly]] does to [[#p|P]]. Equals [[#nlpoly|NL/poly]] [[zooref#ra00|[RA00]]]. (A corollary is that UL/poly is closed under complement). Note that in UL/poly, the witness must be unique even for bad advice. UL/mpoly (as in [[#bqpmpoly|BQP/mpoly]]) is a more natural definition, but this is a moot distinction here because [[zooref#ra00|[RA00]]] show that they both equal [[#nlpoly|NL/poly]]. ---- ===== <span id="ue" style="color:red">UE</span>: Unambiguous Exponential-Time With Linear Exponent ===== Has the same relation to [[#e|E]] as [[#up|UP]] does to [[#p|P]]. ---- ===== <span id="up" style="color:red">UP</span>: Unambiguous Polynomial-Time ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is 'yes,' exactly one computation path accepts.</li> <li>If the answer is 'no,' all computation paths reject.</li> </ol> "Worst-case" one-way functions exist if and only if [[#p|P]] does not equal UP ([[zooref#gs88|[GS88]]] and independently [[zooref#ko85|[Ko85]]]). "Worst-case" one-way permutations exist if and only if [[#p|P]] does not equal UP &#8745; [[#coup|coUP]] [[zooref#ht03|[HT03]]]. Note that these are weaker than the one-way functions and permutations that are needed for cryptographic applications. There exists an oracle relative to which [[#p|P]] is strictly contained in UP is strictly contained in [[#np|NP]] [[zooref#rac82|[Rac82]]]; indeed, these classes are distinct with probability 1 relative to a random oracle [[zooref#bei89|[Bei89]]]. [[#np|NP]] is contained in [[#rp|RP]]<sup>Promise-UP</sup> [[zooref#vv86|[VV86]]]. On the other hand, [[zooref#bbf98|[BBF98]]] give an oracle relative to which [[#p|P]] = UP but still [[#p|P]] does not equal [[#np|NP]]. UP is not known or believed to contain complete problems. [[zooref#sip82|[Sip82]]], [[zooref#hh86|[HH86]]] give oracles relative to which UP has no complete problems. ---- ===== <span id="us" style="color:red">US</span>: Unique Polynomial-Time ===== The all-American counting class. The class of decision problems solvable by an [[#np|NP]] machine such that the answer is 'yes' if and only if exactly one computation path accepts. In contrast to [[#up|UP]], a machine can legally have more than one accepting path - that just means that the corresponding input is not in the language. Defined in [[zooref#bg82|[BG82]]]. Contains [[#conp|coNP]]. ---- ===== <span id="vnc" style="color:red">VNC<sub>k</sub></span>: Valiant [[#nc|NC]] Over Field k ===== Has the same relation to [[#vp|VP<sub>k</sub>]] as [[#nc|NC]] does to [[#p|P]]. More formally, the class of [[#vp|VP<sub>k</sub>]] problems computable by a straight-line program of depth polylogarithmic in n. Surprisingly, VNC<sub>k</sub> = [[#vp|VP<sub>k</sub>]] for any k [[zooref#vsb83|[VSB+83]]]. ---- ===== <span id="vnp" style="color:red">VNP<sub>k</sub></span>: Valiant [[#np|NP]] Over Field k ===== A superclass of [[#vp|VP<sub>k</sub>]] in Valiant's algebraic complexity theory, but not <i>quite</i> the analogue of [[#np|NP]]. A problem is in VNP<sub>k</sub> if there exists a polynomial p with the following properties: <ul> <li>p is computable in [[#vp|VP<sub>k</sub>]]; that is, by a polynomial-size straight-line program.</li> <li>The inputs to p are constants c<sub>1</sub>,...,c<sub>m</sub>,e<sub>1</sub>,...,e<sub>h</sub> and indeterminates X<sub>1</sub>,...,X<sub>n</sub> over the base field k.</li> <li>When p is summed over all 2<sup>h</sup> possible assignments of {0,1} to each of e<sub>1</sub>,...,e<sub>h</sub>, the result is some specified polynomial q.</li> </ul> Originated in [[zooref#val79b|[Val79b]]]. If the field k has characteristic greater than 2, then the permanent of an n-by-n matrix of indeterminates is VNP<sub>k</sub>-complete under a type of reduction called p-projections ([[zooref#val79b|[Val79b]]]; see also [[zooref#bur00|[Bur00]]]). A central conjecture is that for all k, [[#vp|VP<sub>k</sub>]] is not equal to VNP<sub>k</sub>. B&uuml;rgisser [[zooref#bur00|[Bur00]]] shows that if this were false then: <ul> <li>If k is finite, [[#nc2|NC<sup>2</sup>]]/poly = [[#ppoly|P/poly]] = [[#nppoly|NP/poly]] = [[#ph|PH]]/poly.</li> <li>If k has characteristic 0, then assuming the Generalized Riemann Hypothesis (GRH), [[#nc|NC]]<sup>3</sup>/poly = [[#ppoly|P/poly]] = [[#nppoly|NP/poly]] = [[#ph|PH]]/poly, and [[#sharpp|#P]]/poly = [[#fp|FP]]/poly.</li> </ul> In both cases, [[#ph|PH]] collapses to [[#sigma2p|&#931;<sub>2</sub>P]]. ---- ===== <span id="vp" style="color:red">VP<sub>k</sub></span>: Valiant [[#p|P]] Over Field k ===== The class of efficiently-solvable problems in Valiant's algebraic complexity theory. More formally, the input consists of constants c<sub>1</sub>,...,c<sub>m</sub> and indeterminates X<sup>1</sup>,...,X<sub>n</sub> over a base field k (for instance, the complex numbers or Z<sub>2</sub>). The desired output is a collection of polynomials over the X<sub>i</sub>'s. The complexity is the minimum number of pairwise additions, subtractions, and multiplications needed by a straight-line program to produce these polynomials. VP<sub>k</sub> is the class of problems whose complexity is polynomial in n. (Hence, VP<sub>k</sub> is a nonuniform class, in contrast to [[#pc|P<sub>C</sub>]] and [[#pr2|P<sub>R</sub>]].) Originated in [[zooref#val79b|[Val79b]]]; see [[zooref#bur00|[Bur00]]] for more information. Contained in [[#vnp|VNP<sub>k</sub>]] and [[#vqp|VQP<sub>k</sub>]], and contains [[#vnc|VNC<sub>k</sub>]]. ---- ===== <span id="vqp" style="color:red">VQP<sub>k</sub></span>: Valiant [[#qp|QP]] Over Field k ===== Has the same relation to [[#vp|VP<sub>k</sub>]] as [[#qp|QP]] does to [[#p|P]]. Originated in [[zooref#val79b|[Val79b]]]. The determinant of an n-by-n matrix of indeterminates is VQP<sub>k</sub>-complete under a type of reduction called qp-projections (see [[zooref#bur00|[Bur00]]] for example). It is an open problem whether the determinant is [[#vp|VP<sub>k</sub>]]-complete. ---- ===== <span id="w1" style="color:red">W</span>: Weighted Analog of [[#np|NP]] ===== The class of decision problems of the form (x,k) (k a parameter), that are <i>fixed-parameter reducible</i> to the following: <ul> '''Weighted 3SAT:''' Given a 3SAT formula, does it have a satisfying assignment of Hamming weight k? </ul> A fixed-parameter reduction is a Turing reduction that takes time at most f(k)p(|x|), where f is an arbitrary function and p is a polynomial. Also, if the input is (x,k), then all Weighted 3SAT instances the algorithm queries about must have the form <x',k'> where k' is at most k. Contains [[#fpt|FPT]]. Defined in [[zooref#df99|[DF99]]], where the following is also shown: <ul> <li>If [[#fpt|FPT]] = W then [[#np|NP]] is contained in [[#dtime|DTIME]](2<sup>o(n)</sup>).</li> </ul> W can be generalized to [[#wt|W[t]]]. ---- ===== <span id="wapp" style="color:red">WAPP</span>: Weak Almost-Wide [[#pp|PP]] ===== The class of decision problems for which there exists a [[#sharpp|#P]] function f, a polynomial p, and an &epsilon; &gt; 0, such that for all inputs x, <ol> <li>If the answer is "yes" then 2<sup>p(|x|)</sup> &ge; f(x) &gt; (1+&epsilon;) 2<sup>p(|x|)-1</sup>.</li> <li>If the answer is "no" then 0 &le; f(x) &lt; (1-&epsilon;) 2<sup>p(|x|)-1</sup>.</li> </ol> Defined in [[zooref#bgm02|[BGM02]]], where it is also shown that WAPP is contained in [[#awpp|AWPP]] and [[#sbp|SBP]]. ---- ===== <span id="wp" style="color:red">W[P]</span>: Weighted Circuit Satisfiability ===== The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted Circuit-SAT:''' Given a Boolean circuit C (with no restriction on depth), does C have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#wsat|W[SAT]]]. ---- ===== <span id="wpp" style="color:red">WPP</span>: Wide [[#pp|PP]] ===== The class of decision problems solvable by an [[#np|NP]] machine such that <ol> <li>If the answer is "no," then the number of accepting computation paths exactly equals the number of rejecting paths.</li> <li>If the answer is "yes," then their difference exactly equals a function f(x) computable in polynomial time (i.e. [[#fp|FP]]).</li> </ol> Defined in [[zooref#ffk94|[FFK94]]]. Contained in [[#cequalsp|C<sub>=</sub>P]] &#8745; [[#cocequalsp|coC<sub>=</sub>P]], as well as [[#awpp|AWPP]]. Contains [[#spp|SPP]] and [[#lwpp|LWPP]]. ---- ===== <span id="wsat" style="color:red">W[SAT]</span>: Weighted Satisfiability ===== The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted SAT:''' Given a Boolean formula F (with no restriction on depth), does F have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#wt|W[t]]] for every t, and is contained in [[#wp|W[P]]]. ---- ===== <span id="wstar" style="color:red">W[*]</span>: Union of W[t]'s ===== The union of [[#wt|W[t]]] over all t. ---- ===== <span id="wt" style="color:red">W[t]</span>: Nondeterministic Fixed-Parameter Hierarchy ===== A generalization of [[#w1|W]]. The class of decision problems of the form (x,k) (k a parameter), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Weighted Weft-t Depth-h Circuit-SAT:''' Given a Boolean circuit C, with a mixture of fanin-2 and unbounded-fanin gates. The number unbounded-fanin gates along any path to the root is at most t, and the total depth (fanin-2 and unbounded-fanin) is at most h. Does C have a satisfying assignment of Hamming weight k? </ul> See [[#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contained in [[#wsat|W[SAT]]] and in [[#wstart|W<sup>*</sup>[t]]]. ---- ===== <span id="wstart" style="color:red">W<sup>*</sup>[t]</span>: [[#wt|W[t]]] With Parameter-Dependent Depth ===== Same as [[#wt|W[t]]], except that now the circuit depth can depend on the parameter k rather than being constant. (The number of unbounded-fanin gates along any path to the root is still at most t.) W<sup>*</sup> = [[#wt|W]] [[zooref#dft96|[DFT96]]], and W<sup>*</sup> = [[#wt|W]] [[zooref#df97|[DF97]]], but the problem is open for larger t. ---- ===== <span id="xormipstar21" style="color:red">XOR-MIP*[2,1]</span>: [[#mipstar21|MIP*[2,1]]] With 1-Bit Proofs ===== Same as [[#mipstar21|MIP*[2,1]]], but with the further restriction that both provers send only a single bit to the verifier, and the verifier's output is a function of the exclusive-OR of those bits. There should exist 0&lt;a&lt;b&lt;1 such that if the answer is "yes", then for some responses of the provers the verifier accepts with probability at least b, while if the answer is "no", then for all responses of the provers the verifier accepts with probability at most a. Defined by [[zooref#cht04|[CHT+04]]], whose motivation was a connection to the Bell and CHSH inequalities of quantum physics. XOR-MIP*[2,1] is contained in [[#nexp|NEXP]] [[zooref#cht04|[CHT+04]]]. ---- ===== <span id="xp" style="color:red">XP</span>: Fixed-Parameter Tractable for Each Parameter ===== The class of decision problems of the form (x,k) (k a parameter) that are solvable in time O(|x|<sup>f(k)</sup>) for some function f. The algorithm used may depend on k. Defined in [[zooref#df99|[DF99]]]. Contains [[#xpuniform|XP<sub>uniform</sub>]]. Strictly contains [[#fpt|FPT]] (by diagonalization). ---- ===== <span id="xpuniform" style="color:red">XP<sub>uniform</sub></span>: Uniform [[#xp|XP]] ===== Same as [[#xp|XP]] except that the algorithm used must be the same for each k (though it can take k as input). Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="yacc" style="color:red">YACC</span>: Yet Another Complexity Class ===== A term of derision, used against a complexity class. ---- ===== <span id="yp" style="color:red">YP</span>: Your Polynomial-Time or Yaroslav-Percival ===== The class of decision problems for which there exists a polynomial-time machine M such that: <ul> <li>For all input sizes n, there exists a polynomial-size advice string s<sub>n</sub> such that M(x,s<sub>n</sub>) outputs the correct answer for all inputs x of size n.</li> <li>For all inputs x and advice strings s, M(x,s) outputs either the correct answer or "I don't know."</li> </ul> Defined in a [http://www.blogger.com/comment.g?blogID=17392898&postID=114560148725169634 recent post] of the blog [http://www.scottaaronson.com/blog/ Shtetl-Optimized]. See there for an explanation of the class's name. Contains [[#zpp|ZPP]] by the same argument that places [[#bpp|BPP]] in [[#ppoly|P/poly]]. Also contains [[#p|P]] with [[#tally|TALLY]] &#8745; [[#np|NP]] &#8745; [[#conp|coNP]] oracle. Is contained in [[#npiconp|NP &#8745; coNP]] and [[#ypp|YPP]]. ---- ===== <span id="ypp" style="color:red">YPP</span>: Yaroslav [[#bpp|BPP]] ===== The probabilistic analogue of [[#yp|YP]]; it is to YP what [[#ma|MA]] is to [[#np|NP]]. Formally, the class of decision problems for which there exists a syntactic [[#bpp|BPP]] machine M such that: <ul> <li>For all input sizes n, there exists a polynomial-size advice string a<sub>n</sub> such that for all inputs x of size n, M(x,a<sub>n</sub>) outputs the correct answer with probability at least 2/3.</li> <li>For all inputs x and advice strings a, the probability that M(x,a) outputs the incorrect answer is at most 1/3. In other words, the sum of the probabilities of the correct answer and "I don't know" is at least 2/3.</li> </ul> To amplify a YPP machine, one can run it multiple times, then accept if a majority of runs accept, reject if a majority reject, and otherwise output "I don't know." Contains [[#bpp|BPP]] and [[#yp|YP]], and is contained in [[#ma|MA]] and [[#ppoly|P/poly]]. ---- ===== <span id="yqp" style="color:red">YQP</span>: Yaroslav [[#bqp|BQP]] ===== Is to [[#ypp|YPP]] as [[#bqp|BQP]] is to [[#bpp|BPP]], and [[#qma|QMA]] is to [[#ma|MA]]. The machine is now a quantum computer and the advice is a quantum state |&psi;_n&gt;. Contains [[#bqp|BQP]] and [[#ypp|YPP]], and is contained in [[#qma|QMA]] and [[#bqpqpoly|BQP/qpoly]]. ---- ===== <span id="zbqp" style="color:red">ZBQP</span>: Strict Quantum [[#zpp|ZPP]] ===== Defined as [[#rbqp|RBQP &#8745; coRBQP]]. Equivalently, the class of problems in [[#npiconp|NP &#8745; coNP]] such that both positive and negative witnesses are in [[#fbqp|FBQP]]. For example, the language of square-free numbers is in ZBQP, because factoring is in [[#fbqp|FBQP]] and a factorization can be certified in [[#zpp|ZPP]] (indeed in [[#p|P]], by [[zooref#aks02|[AKS02]]]). Unlike [[#eqp|EQP]] or [[#zqp|ZQP]], ZBQP would generalize [[#zpp|ZPP]] in practice if quantum computers existed, in the sense that it provides proven answers. Contains [[#zpp|ZPP]] and is contained in [[#rqp|RBQP]] and [[#zqp|ZQP]]. Also, ZBQP<sup>ZBQP</sup> = ZBQP. Defined here to clarify [[#eqp|EQP]] and [[#zqp|ZQP]]. ---- ===== <span id="zpe" style="color:red">ZPE</span>: Zero-Error Probabilistic [[#e|E]] ===== Same as [[#zpp|ZPP]], but with 2<sup>O(n)</sup>-time instead of polynomial-time. ZPE = [[#ee|EE]] if and only if [[#zpp|ZPP]] = [[#exp|EXP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="zpp" style="color:red">ZPP</span>: Zero-Error Probabilistic Polynomial-Time ===== Defined as [[#rp|RP]] &#8745; [[#corp|coRP]]. The class of problems solvable by randomized algorithms that <i>always</i> return the correct answer, and whose <i>expected</i> running time (on any input) is polynomial. Defined in [[zooref#gil77|[Gil77]]]. Contains the problem of testing whether an integer is prime [[zooref#ss77|[SS77]]] [[zooref#ah87|[AH87]]]. In contrast to [[#bpp|BPP]] and [[#rp|RP]], it is not known whether showing ZPP = [[#p|P]] requires proving superpolynomial circuit lower bounds [[zooref#ki02|[KI02]]]. There exists an oracle relative to which ZPP = [[#exp|EXP]] [[zooref#hel84|[Hel84]]]. ---- ===== <span id="zptime" style="color:red">ZPTIME(f(n))</span>: Zero-Error Probabilistic f(n)-Time ===== Same as [[#zpp|ZPP]], but with O(f(n))-time instead of polynomial-time. For any constructible superpolynomial f, ZPTIME(f(n)) with [[#np|NP]] oracle is not contained in [[#ppoly|P/poly]] [[zooref#kw98|[KW98]]]. ---- ===== <span id="zqp" style="color:red">ZQP</span>: Zero-Error Extension Of [[#eqp|EQP]] ===== The class of questions that can be answered by a QTM that answers yes, no, or "maybe". If the correct answer is yes, then P[no] = 0, and vice-versa; and the probability of maybe is at most 1/2. Since some of the probabilities have to vanish, ZQP has the same technical caveats as [[#eqp|EQP]]. Defined independently in [[zooref#bw03|[BW03]]] and in [[zooref#nis02|[Nis02]]]. Contains [[#eqp|EQP]] and [[#zbqp|ZBQP]] and is contained in [[#bqp|BQP]]. Equals [[#rqp|RQP &#8745; coRQP]]. There is an oracle such that ZQP<sup>ZQP</sup> is larger than ZQP [[zooref#bw03|[BW03]]]; c.f. with [[#zbqp|ZBQP]]. ---- [[Category:Computational Complexity]] [[Category:Quantum Information]] Complexity Zoo:A 3555 30842 2012-04-28T01:17:11Z Scott Aaronson 102 /* AC0: Unbounded Fanin Constant-Depth Circuits */ __NOTOC__ {{CZ-Letter-Menu|A}} ===== <span id="a0pp" style="color:red">A<sub>0</sub>PP</span>: One-Sided Analog of [[#awpp|AWPP]] ===== Same as [[Complexity Zoo:S#sbp|SBP]], except that f is a nonnegative-valued [[Complexity Zoo:G#gapp|GapP]] function rather than a [[Complexity Zoo:Symbols#sharpp|#P]] function. Defined in [[zooref#vya03|[Vya03]]], where the following was also shown: <ul> <li>A<sub>0</sub>PP contains [[Complexity Zoo:Q#qma|QMA]], [[#awpp|AWPP]], and [[Complexity Zoo:C#cocequalsp|coC<sub>=</sub>P]].</li> <li>A<sub>0</sub>PP is contained in [[Complexity Zoo:P#pp|PP]].</li> <li>If A<sub>0</sub>PP = [[Complexity Zoo:P#pp|PP]] then [[Complexity Zoo:P#ph|PH]] is contained in [[Complexity Zoo:P#pp|PP]].</li> </ul> Kuperberg ([[zooref#kup09|[Kup09]]]) showed that A<sub>0</sub>PP = [[Complexity Zoo:S#sbqp|SBQP]]. ---- ===== <span id="ac" style="color:red">AC</span>: Unbounded Fanin Polylogarithmic-Depth Circuits ===== AC<sup>i</sup> is the class of decision problems solvable by a nonuniform family of Boolean circuits, with polynomial size, depth O(log<sup>i</sup>(n)), and unbounded fanin. The gates allowed are AND, OR, and NOT. Then AC is the union of AC<sup>i</sup> over all nonnegative i. AC<sup>i</sup> is contained in [[Complexity Zoo:N#nc|NC]]<sup>i+1</sup>; thus, AC = [[Complexity Zoo:N#nc|NC]]. Contains [[Complexity Zoo:N#nl|NL]]. For a random oracle A, (AC<sup>i</sup>)<sup>A</sup> is strictly contained in (AC<sup>i+1</sup>)<sup>A</sup>, and (uniform) AC<sup>A</sup> is strictly contained in P<sup>A</sup>, with probability 1 [[zooref#mil92|[Mil92]]]. fo-uniform AC with depth $t(n)$ is equal to [[#Complexity_Zoo:F#fot|FO[$t(n)$]]] ---- ===== <span id="ac0" style="color:red">AC<sup>0</sup></span>: Unbounded Fanin Constant-Depth Circuits ===== An especially important subclass of [[#ac|AC]], corresponding to constant-depth, unbounded-fanin, polynomial-size circuits with AND, OR, and NOT gates. Computing the [[Complexity_Garden#parity|Parity]] or [[Complexity_Garden#majority|Majority]] of n bits is not in AC<sup>0</sup> [[zooref#fss84|[FSS84]]]. There are functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in AC<sup>0</sup> [[zooref#nw94|[NW94]]]. But there are no functions in AC<sup>0</sup> that are pseudorandom for all statistical tests in [[Complexity Zoo:Q#qp|QP]] (quasipolynomial time) [[zooref#lmn93|[LMN93]]]. [[zooref#lmn93|[LMN93]]] showed furthermore that functions with AC<sup>0</sup> circuits of depth d are learnable in [[#qp|QP]], given their outputs on O(2<sup>log(n)^O(d)</sup>) randomly chosen inputs. On the other hand, this learning algorithm is essentially optimal, unless there is a 2<sup>n^o(1)</sup> algorithm for [[Complexity_Garden#integer_factorization|factoring]] [[zooref#kha93|[Kha93]]]. Although there are no good pseudorandom <i>functions</i> in AC<sup>0</sup>, [[zooref#in96|[IN96]]] showed that there are pseudorandom <i>generators</i> that stretch n bits to n+&#920;(log n), assuming the hardness of a problem based on subset sum. AC<sup>0</sup> contains [[Complexity Zoo:N#nc0|NC<sup>0</sup>]], and is contained in [[Complexity Zoo:Q#qacf0|QAC<sub>f</sub><sup>0</sup>]] and [[Complexity Zoo:M#mac0|MAC<sup>0</sup>]]. In descriptive complexity, uniform AC<sup>0</sup> can be characterized as the class of problems expressible by first-order predicates with addition and multiplication operators - or indeed, with ordering and multiplication, or ordering and division (see [[zooref#lee02|[Lee02]]]). So it's equivalent to the class [[Complexity_Zoo:F#fo|FO]] and to [[#Complexity_Zoo:A#AL|AL]] the alternating logtime hierarchy. [[zooref#blm98|[BLM+98]]] showed the following problem is complete for depth-k AC<sup>0</sup> circuits (with a uniformity condition): <ul> Given a grid graph of polynomial length and width k, decide whether there is a path between vertices s and t (which can be given as part of the input). </ul> ---- ===== <span id="ac0m" style="color:red">AC<sup>0</sup>[m]</span>: [[#ac0|AC<sup>0</sup>]] With MOD m Gates ===== Same as [[#ac0|AC<sup>0</sup>]], but now "MOD m" gates (for a specific m) are allowed in addition to AND, OR, and NOT gates. (A MOD m gate outputs 0 if the sum of its inputs is congruent to 0 modulo m, and 1 otherwise.) If m is a power of a prime p, then for any prime q not equal to p, deciding whether the sum of n bits is congruent to 0 modulo q is not in AC<sup>0</sup>[m] [[zooref#raz87|[Raz87]]] [[zooref#smo87|[Smo87]]]. It follows that, for any such m, AC<sup>0</sup>[m] is strictly contained in [[Complexity Zoo:N#nc1|NC<sup>1</sup>]]. However, if m is a product of distinct primes (e.g. 6), then it is not even known whether AC<sup>0</sup>[m] = [[Complexity Zoo:N#np|NP]]! See also: [[Complexity Zoo:Q#qac0m|QAC<sup>0</sup>[m]]]. ---- ===== <span id="ac1" style="color:red">AC<sup>1</sup></span>: Unbounded Fanin Log-Depth Circuits ===== See [[#ac|AC]]. ---- ===== <span id="acc0" style="color:red">ACC<sup>0</sup></span>: [[#ac0|AC<sup>0</sup>]] With Arbitrary MOD Gates ===== Same as [[#ac0m|AC<sup>0</sup>[m]]], but now the constant-depth circuit can contain MOD m gates for <i>any</i> m. Contained in [[Complexity Zoo:T#tc0|TC<sup>0</sup>]]. Indeed, can be simulated by depth-3 threshold circuits of quasipolynomial size [[zooref#yao90|[Yao90]]]. According to [[zooref#all96|[All96]]], there is no good evidence for the existence of cryptographically secure functions in ACC<sup>0</sup>. There is no non-uniform ACC<sup>0</sup> circuits of polynomial size for [[Complexity Zoo:R#N:ntime|NTIMES[2<sup>n</sup>]]] and no ACC<sup>0</sup> circuit of size 2<sup>n<sup>O(1)</sup></sup> for E<sup>NP</sup> (The class [[Complexity Zoo:E#e|E]] with an [[Complexity Zoo:N#np|NP]] oracle). These are the only two known nontrivial lower bounds against ACC<sup>0</sup> and were recently discovered by [[zooref#wil11|[Wil11]]]. Contains 4-[[Complexity Zoo:P#kpbp|PBP]] [[zooref#bt88|[BT88]]]. See also: [[Complexity Zoo:Q#qacc0|QACC<sup>0</sup>]]. ---- ===== <span id="ah" style="color:red">AH</span>: Arithmetic Hierarchy ===== The analog of [[Complexity Zoo:P#ph|PH]] in computability theory. Let &#916;<sub>0</sub> = &#931;<sub>0</sub> = &#928;<sub>0</sub> = [[Complexity Zoo:R#r|R]]. Then for i&gt;0, let <ul> <li>&#916;<sub>i</sub> = [[Complexity Zoo:R#r|R]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#931;<sub>i</sub> = [[Complexity Zoo:R#re|RE]] with &#931;<sub>i-1</sub> oracle.</li> <li>&#928;<sub>i</sub> = [[Complexity Zoo:C#core|coRE]] with &#931;<sub>i-1</sub> oracle.</li> </ul> Then AH is the union of these classes for all nonnegative constant i. Each level of AH strictly contains the levels below it. An equivalent definition is: $\Sigma_0=\Delta_0=\Pi_0$ is the set of numbers decided by formula with one free variable and bounded quantifier, where the primitives are + and $\times$. A bounded quantifier is of the form $\phi=\forall i<j \psi$ or $\phi=\exists i<j \psi$ where $j$ is considered to be free in $\phi$. Then $\Sigma_{i+1}$ is the sets of number validating a formula of the form $\exists X_1\dots\exists X_n,\psi$ with $\psi\in\Delta_i$. $\Delta_i$ is the set of formula who are negation of $\Sigma_i$ formula. $\Pi_i=\Sigma_i\cap\Delta_i$ ---- ===== <span id="al" style="color:red">AL</span>: Alternating [[Complexity_Zoo:L#l|L]] ===== Same as [[#ap|AP]], but for logarithmic-space instead of polynomial-time. AL = [[Complexity Zoo:P#p|P]] [[zooref#cks81|[CKS81]]]. ---- ===== <span id="all" style="color:red">ALL</span>: The Class of All Languages ===== Literally, the class of ALL languages. ALL is a gargantuan beast that's been wreaking havoc in the Zoo of late. First [[zooref#aar04b|[Aar04b]]] observed that [[Complexity Zoo:P#pp|PP]]/rpoly ([[Complexity Zoo:P#pp|PP]] with polynomial-size randomized advice) equals ALL, as does [[Complexity Zoo:P#postbqp|PostBQP]]/qpoly ([[Complexity Zoo:P#postbqp|PostBQP]] with polynomial-size quantum advice). Then [[zooref#raz05|[Raz05]]] showed that [[Complexity Zoo:Q#qip|QIP]]/qpoly, and even [[Complexity Zoo:I#ip|IP]](2)/rpoly, equal ALL. Nor is it hard to show that [[Complexity Zoo:M#maexp|MA<sub>EXP</sub>]]/rpoly = ALL. On the other hand, even though [[Complexity Zoo:P#pspace|PSPACE]] contains [[Complexity Zoo:P#pp|PP]], and [[Complexity Zoo:E#expspace|EXPSPACE]] contains [[#maexp|MA<sub>EXP</sub>]], it's easy to see that [[Complexity Zoo:P#pspace|PSPACE]]/rpoly = [[Complexity Zoo:P#pspace|PSPACE]]/poly and [[Complexity Zoo:E#expspace|EXPSPACE]]/rpoly = [[Complexity Zoo:E#expspace|EXPSPACE]]/poly are not ALL. So does ALL have no respect for complexity class inclusions at ALL? (Sorry.) It is not as contradictory as it first seems. The deterministic base class in all of these examples is modified by computational non-determinism ''after'' it is modified by advice. For example, [[Complexity Zoo:M#maexp|MA<sub>EXP</sub>]]/rpoly means M(A<sub>EXP</sub>/rpoly), while ([[Complexity Zoo:M#maexp|MA<sub>EXP</sub>]])/rpoly equals [[Complexity Zoo:M#maexp|MA<sub>EXP</sub>]]/poly by a standard argument. In other words, it's only the verifier, not the prover or post-selector, who receives the randomized or quantum advice. The prover knows a description of the advice state, but not its measured values. Modification by /rpoly does preserve class inclusions when it is applied after other changes. ---- ===== <span id="alogtime" style="color:red">ALOGTIME</span>: Logarithmic time alternating RAM ===== ALOGTIME is the class of languages decidable in logarithmic time by a random access alternating Turing machine. Known to be equal to U<sub>E<sup>*</sup></sub>-uniform [[Complexity Zoo:N#nc1|NC<sup>1</sup>]]. ---- ===== <span id="algppoly" style="color:red">AlgP/poly</span>: Polynomial-Size Algebraic Circuits ===== The class of multivariate polynomials over the integers that can be evaluated using a polynomial (in the input size n) number of additions, subtractions, and multiplications, together with the constants -1 and 1. The class is nonuniform, in the sense that the polynomial for each input size n can be completely different. Named in [[zooref#imp02|[Imp02]]], though it has been considered since the 1970's. If [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:B#bpp|BPP]] (or even [[Complexity Zoo:B#bpp|BPP]] is contained in [[Complexity Zoo:N#ne|NE]]), then either [[Complexity Zoo:N#nexp|NEXP]] is not in [[Complexity Zoo:P#ppoly|P/poly]], or else the permanent polynomial of a matrix is not in AlgP/poly [[zooref#ki02|[KI02]]]. ---- ===== <span id="almostnp" style="color:red">Almost-[[Complexity Zoo:N#np|NP]]</span>: Languages Almost Surely in [[Complexity Zoo:N#np|NP]]<sup>A</sup> ===== The class of problems that are in [[Complexity Zoo:N#np|NP]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[#am|AM]] [[zooref#nw94|[NW94]]]. ---- ===== <span id="almostp" style="color:red">Almost-[[Complexity Zoo:P#p|P]]</span>: Languages Almost Surely in [[Complexity Zoo:P#p|P]]<sup>A</sup> ===== The class of problems that are in [[Complexity Zoo:P#p|P]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Equals [[Complexity Zoo:B#bpp|BPP]] [[zooref#bg81|[BG81]]]. ---- ===== <span id="almostpspace" style="color:red">Almost-[[Complexity Zoo:P#pspace|PSPACE]]</span>: Languages Almost Surely in [[Complexity Zoo:P#pspace|PSPACE]]<sup>A</sup> ===== The class of problems that are in [[Complexity Zoo:P#pspace|PSPACE]]<sup>A</sup> with probability 1, where A is an oracle chosen uniformly at random. Almost-PSPACE is not known to equal [[Complexity Zoo:P#pspace|PSPACE]] -- rather surprisingly, given the fact that [[Complexity Zoo:P#pspace|PSPACE]] equals BPPSPACE and even [[Complexity Zoo:P#ppspace|PPSPACE]]. What's known is that Almost-PSPACE = BP<sup>exp</sup>&#149;[[Complexity Zoo:P#pspace|PSPACE]], where [[Zoo Operators#bpexp|BP<sup>exp</sup>&#149;]] is like the [[Zoo Operators#bp|BP&#149;]] operator but with exponentially-long strings [[zooref#bvw98|[BVW98]]]. It follows that Almost-PSPACE is contained in [[Complexity Zoo:N#nexp|NEXP]]<sup>[[Complexity Zoo:N#np|NP]]</sup> &#8745; [[Complexity Zoo:A#conexp|coNEXP]]<sup>[[Complexity Zoo:N#np|NP]]</sup>. Whereas both BP<sup>exp</sup>&#149;[[Complexity Zoo:P#pspace|PSPACE]] and BPPSPACE machines are allowed exponentially many random bits, the former has a reusable record of all of these bits on a witness tape, while the latter can only preserve a fraction of them on the work tape. ---- ===== <span id="am" style="color:red">AM</span>: Arthur-Merlin ===== The class of decision problems for which a "yes" answer can be verified by an <i>Arthur-Merlin protocol</i>, as follows. Arthur, a [[Complexity Zoo:B#bpp|BPP]] (i.e. probabilistic polynomial-time) verifier, generates a "challenge" based on the input, and sends it together with his random coins to Merlin. Merlin sends back a response, and then Arthur decides whether to accept. Given an algorithm for Arthur, we require that <ol> <li>If the answer is "yes," then Merlin can act in such a way that Arthur accepts with probability at least 2/3 (over the choice of Arthur's random bits).</li> <li>If the answer is "no," then however Merlin acts, Arthur will reject with probability at least 2/3.</li> </ol> Surprisingly, it turns out that such a system is just as powerful as a <i>private-coin</i> one, in which Arthur does not need to send his random coins to Merlin [[zooref#gs86|[GS86]]]. So, Arthur never needs to hide information from Merlin. Furthermore, define AM[k] similarly to AM, except that Arthur and Merlin have k rounds of interaction. Then for all constant k&gt;2, AM[k] = AM = AM [[zooref#bm88|[BM88]]]. Also, the result of [[zooref#gs86|[GS86]]] can then be stated as follows: [[Complexity Zoo:I#ip|IP]][k] is contained in AM[k+2] for every k (constant or non-constant). AM contains [[Complexity_Garden#graph_isomorphism|graph nonisomorphism]]. Contains [[Complexity Zoo:N#np|NP]], [[Complexity Zoo:B#bpp|BPP]], and [[Complexity Zoo:S#szk|SZK]], and is contained in [[Complexity Zoo:P#pi2p|&#928;<sub>2</sub>P]] and [[Complexity Zoo:N#nppoly|NP/poly]]. If AM contains [[Complexity Zoo:C#conp|coNP]] then [[Complexity Zoo:P#ph|PH]] collapses to [[Complexity Zoo:S#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[Complexity Zoo:P#pi2p|&#928;<sub>2</sub>P]] [[zooref#bhz87|[BHZ87]]]. There exists an oracle relative to which AM is not contained in [[Complexity Zoo:P#pp|PP]] [[zooref#ver92|[Ver92]]]. AM = [[Complexity Zoo:N#np|NP]] under a strong derandomization assumption: namely that some language in [[Complexity Zoo:N#ne|NE]] &#8745; [[Complexity Zoo:C#cone|coNE]] requires nondeterministic circuits of size 2<sup>&#937;(n)</sup> ([[zooref#mv99|[MV99]]], improving [[zooref#km99|[KM99]]]). (A nondeterministic circuit C has two inputs, x and y, and accepts on x if there exists a y such that C(x,y)=1.) ---- ===== <span id="amexp" style="color:red">AM<sub>EXP</sub></span>: Exponential-Time [[#am|AM]] ===== Same as [[#am|AM]], except that Arthur is exponential-time and can exchange exponentially long messages with Merlin. Contains [[Complexity Zoo:M#maexp|MA<sub>EXP</sub>]], and is contained in [[Complexity Zoo:E#eh|EH]] and indeed [[Complexity Zoo:S#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. If [[Complexity Zoo:C#conp|coNP]] is contained in [[#ampolylog|AM[polylog]]] then [[Complexity Zoo:E#eh|EH]] collapses to AM<sub>EXP</sub> [[zooref#pv04|[PV04]]]. ---- ===== <span id="amicoam" style="color:red">AM &#8745; coAM</span> ===== The class of decision problems for which both "yes" and "no" answers can be verified by an [[#am|AM]] protocol. If [[Complexity Zoo:E#exp|EXP]] requires exponential time even for [[#am|AM]] protocols, then AM &#8745; coAM = [[Complexity Zoo:N#npiconp|NP &#8745; coNP]] [[zooref#gst03|[GST03]]]. There exists an oracle relative to which AM &#8745; coAM is not contained in [[Complexity Zoo:P#pp|PP]] [[zooref#ver95|[Ver95]]]. ---- ===== <span id="ampolylog" style="color:red">AM[polylog]</span>: [[#am|AM]] With Polylog Rounds ===== Same as [[#am|AM]], except that we allow polylog(n) rounds of interaction between Arthur and Merlin instead of a constant number. Not much is known about AM[polylog] -- for example, whether it sits in [[Complexity Zoo:P#ph|PH]]. However, [[zooref#ss04|[SS04]]] show that if AM[polylog] contains [[Complexity Zoo:C#conp|coNP]], then [[Complexity Zoo:E#eh|EH]] collapses to [[Complexity Zoo:S#s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>]]. ([[zooref#pv04|[PV04]]] improved the collapse to [[#amexp|AM<sub>EXP</sub>]].) ---- ===== <span id="ampmp" style="color:red">AmpMP</span>: Amplifiable [[Complexity Zoo:M#mp2|MP]] ===== The class of decision problems such that for some [[Complexity Zoo:Symbols#sharpp|#P]] function f(x,0<sup>m</sup>), <ol> <li>The answer on input x is 'yes' if and only if the middle bit of f(x) is 1.</li> <li>The m bits of f(x) to the left and right of the middle bit are all 0.</li> </ol> Defined in [[zooref#gkr95|[GKR+95]]]. Contains [[Complexity Zoo:P#ph|PH]] and Contained in [[Complexity Zoo:M#mp2|MP]]. ---- ===== <span id="amppbqp" style="color:red">AmpP-BQP</span>: [[Complexity Zoo:B#bqp|BQP]] Restricted To [[Zoo_Exhibit#ampp|AmpP]] States ===== Similar to [[Complexity Zoo:T#treebqp|TreeBQP]] except that the quantum computer's state at each time step is restricted to being exponentially close to a state in [[Zoo_Exhibit#ampp|AmpP]] (that is, a state for which the amplitudes are computable by a classical polynomial-size circuit). Defined in [[zooref#aar03b|[Aar03b]]], where it was also observed that AmpP-BQP is contained in the third level of [[Complexity Zoo:P#ph|PH]], just as [[Complexity Zoo:T#treebqp|TreeBQP]] is. ---- ===== <span id="ap" style="color:red">AP</span>: Alternating [[Complexity Zoo:P#p|P]] ===== An <i>alternating Turing machine</i> is a nondeterministic machine with two kinds of states, AND states and OR states. It accepts if and only if the tree of all computation paths, considered as an AND-OR tree, evaluates to 1. (Here 'Accept' corresponds to 1 and 'Reject' to 0.) Then AP is the class of decision problems solvable in polynomial time by an alternating Turing machine. AP = [[Complexity Zoo:P#pspace|PSPACE]] [[zooref#cks81|[CKS81]]]. The abbreviation AP is also used for Approximable in Polynomial Time, see [[#axp|AxP]]. ---- ===== <span id="app" style="color:red">APP</span>: Amplified [[Complexity Zoo:P#pp|PP]] ===== Roughly, the class of decision problems for which the following holds. For all polynomials p(n), there exist [[Complexity Zoo:G#gapp|GapP]] functions f and g such that for all inputs x with n=|x|, <ol> <li>If the answer is "yes" then 1 &gt; f(x)/g(1<sup>n</sup>) &gt; 1-2<sup>-p(n)</sup>.</li> <li>If the answer is "no" then 0 &lt; f(x)/g(1<sup>n</sup>) &lt; 2<sup>-p(n)</sup>.</li> </ol> Defined in [[zooref#li93|[Li93]]], where the following was also shown: <ul> <li>APP is contained in [[Complexity Zoo:P#pp|PP]], and indeed is low for [[Complexity Zoo:P#pp|PP]].</li> <li>APP is closed under intersection, union, and complement.</li> </ul> APP contains [[#awpp|AWPP]] [[zooref#fen02|[Fen02]]]. The abbreviation APP is also used for Approximable in Probabilistic Polynomial Time, see [[#axpp|AxPP]]. ---- ===== <span id="apx" style="color:red">APX</span>: Approximable ===== The subclass of [[Complexity Zoo:N#npo|NPO]] problems that admit constant-factor approximation algorithms. (I.e., there is a polynomial-time algorithm that is guaranteed to find a solution within a constant factor of the optimum cost.) Contains [[Complexity Zoo:P#ptas|PTAS]]. Equals the closure of [[Complexity Zoo:M#maxsnp|MaxSNP]] and of [[Complexity Zoo:M#maxnp|MaxNP]] under [[Complexity Zoo:P#ptas|PTAS]] reduction [[zooref#kms99|[KMS+99]]], [[zooref#ct94|[CT94]]]. Defined in [[zooref#acg99|[ACG+99]]]. ---- ===== <span id="atime" style="color: red">ATIME</span>: Alternating [[Complexity Zoo:D#dtime|TIME]] ===== '''ATIME'''(f(n)) is the class of problems for which there are alternating Turing machines (see [[#ap|AP]]) which decide the problem in time bounded by f(n). In particular, [[#ap|AP]] = ATIME(poly(n)). ---- ===== <span id="aucspace" style="color:red">AUC-SPACE(f(n))</span>: Randomized Alternating f(n)-Space ===== The class of problems decidable by an O(f(n))-space Turing machine with three kinds of quantifiers: existential, universal, and randomized. Contains [[Complexity Zoo:G#ganspace|GAN-SPACE(f(n))]]. AUC-SPACE(poly(n)) = [[Complexity Zoo:S#saptime|SAPTIME]] = [[Complexity Zoo:P#pspace|PSPACE]] [[zooref#pap83|[Pap83]]]. [[zooref#con92|[Con92]]] shows that AUC-SPACE(log n) has a natural complete problem, and is contained in [[Complexity Zoo:N#npiconp|NP &#8745; coNP]]. ---- ===== <span id="auxpda" style="color:red">AuxPDA</span>: Auxiliary Pushdown Automata ===== Equivalent to [[Complexity Zoo:N#nauxpdap|NAuxPDA<sup>p</sup>]] without the running-time restriction. Equals [[Complexity Zoo:P#p|P]] [[zooref#coo71b|[Coo71b]]]. ---- ===== <span id="avbpp" style="color:red">AVBPP</span>: Average-Case [[Complexity Zoo:B#bpp|BPP]] ===== Defined in [[zooref#ow93|[OW93]]] to be the class of decision problems that have a good average-case [[Complexity Zoo:B#bpp|BPP]] algorithm, whenever the input is chosen from an efficiently samplable distribution. Note that this is <i>not</i> the same as the [[Complexity Zoo:B#bpp|BPP]] version of [[#avgp|AvgP]]. ---- ===== <span id="avge" style="color:red">AvgE</span>: Average Exponential-Time With Linear Exponent ===== Has the same relation to [[Complexity Zoo:E#e|E]] as [[#avgp|AvgP]] does to [[Complexity Zoo:P#p|P]]. ---- ===== <span id="avgp" style="color:red">AvgP</span>: Average Polynomial-Time ===== A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. A function f, from strings to integers, is <i>polynomial on &#956;-average</i> if there exists a constant &#949;&gt;0 such that the expectation of f<sup>&#949;</sup>(x) is finite, when x is drawn from &#956;. Then (A,&#956;) is in AvgP if there is an algorithm for A whose running time is polynomial on &#956;-average. This convoluted definition is due to Levin [[zooref#lev86|[Lev86]]], who realized that simpler definitions lead to classes that fail to satisfy basic closure properties. Also see [[zooref#gol97|[Gol97]]] for more information. If AvgP = [[Complexity Zoo:D#distnp|DistNP]] then [[Complexity Zoo:E#exp|EXP]] = [[Complexity Zoo:N#nexp|NEXP]] [[zooref#bcg92|[BCG+92]]]. Strictly contained in [[Complexity Zoo:H#heurp|HeurP]] [[zooref#ns05|[NS05]]]. See also: [[Complexity Zoo:N#nppsamp|(NP,P-samplable)]]. ---- ===== <span id="awp" style="color:red">AW[P]</span>: Alternating [[Complexity Zoo:W#wp|W[P]]] ===== Same as [[#awsat|AW[SAT]]] but with 'circuit' instead of 'formula.' Has the same relation to [[#awsat|AW[SAT]]] as [[Complexity Zoo:W#wp|W[P]]] has to [[Complexity Zoo:W#wsat|W[SAT]]]. Defined in [[zooref#df99|[DF99]]]. ---- ===== <span id="awpp" style="color:red">AWPP</span>: Almost [[Complexity Zoo:W#wpp|WPP]] ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that for some polynomial-time computable (i.e. [[Complexity Zoo:F#fp|FP]]) function f, <ol> <li>If the answer is "no," then the difference between the number of accepting and rejecting paths is non-negative and at most 2<sup>-poly(n)</sup>f(x).</li> <li>If the answer is "yes," then the difference is between (1-2<sup>-poly(n)</sup>)f(x) and f(x).</li> </ol> Defined in [[zooref#ffk94|[FFK94]]]. Contains [[Complexity Zoo:B#bqp|BQP]] [[zooref#fr98|[FR98]]], [[Complexity Zoo:W#wapp|WAPP]] [[zooref#bgm02|[BGM02]]], [[Complexity Zoo:L#lwpp|LWPP]], and [[Complexity Zoo:W#wpp|WPP]]. Contained in [[#app|APP]] [[zooref#fen02|[Fen02]]]. ---- ===== <span id="awsat" style="color:red">AW[SAT]</span>: Alternating [[Complexity Zoo:W#wsat|W[SAT]]] ===== Basically has the same relation to [[Complexity Zoo:W#wsat|W[SAT]]] as [[Complexity Zoo:P#pspace|PSPACE]] does to [[Complexity Zoo:N#np|NP]]. The class of decision problems of the form (x,r,k<sub>1</sub>,...,k<sub>r</sub>) (r,k<sub>1</sub>,...,k<sub>r</sub> parameters), that are fixed-parameter reducible to the following problem, for some constant h: <ul> '''Parameterized QBFSAT:''' Given a Boolean formula F (with no restriction on depth), over disjoint variable sets S<sub>1</sub>,...,S<sub>r</sub>. Does there exist an assignment to S<sub>1</sub> of Hamming weight k<sub>1</sub>, such that for all assignments to S<sub>2</sub> of Hamming weight k<sub>2</sub>, etc. (alternating 'there exists' and 'for all'), F is satisfied? </ul> See [[Complexity Zoo:W#w1|W]] for the definition of fixed-parameter reducibility. Defined in [[zooref#df99|[DF99]]]. Contains [[#awstar|AW[*]]], and is contained in [[#awp|AW[P]]]. ---- ===== <span id="awstar" style="color:red">AW[*]</span>: Alternating [[Complexity Zoo:W#wstar|W[*]]] ===== The union of [[#awt|AW[t]]] over all t. ---- ===== <span id="awt" style="color:red">AW[t]</span>: Alternating [[Complexity Zoo:W#wt|W[t]]] ===== Has the same relation to [[Complexity Zoo:W#wt|W[t]]] as [[Complexity Zoo:P#pspace|PSPACE]] does to [[Complexity Zoo:N#np|NP]]. Same as [[#awsat|AW[SAT]]], except that the formula F can have depth at most t. Defined in [[zooref#df99|[DF99]]]. Contained in [[#awstar|AW[*]]]. ---- ===== <span id="axp" style="color:red">AxP</span>: Approximable in Polynomial Time ===== Usually called AP in the literature. I've renamed it AxP to distinguish it from the "other" [[#ap|AP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a deterministic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also showed that the set of AxP machines is in [[Complexity Zoo:R#re|RE]]. ---- ===== <span id="axpp" style="color:red">AxPP</span>: Approximable in Probabilistic Polynomial Time ===== Usually called APP. I've renamed it AxPP to distinguish it from the "other" [[#app|APP]]. The class of real-valued functions from {0,1}<sup>n</sup> to [0,1] that can be approximated within any &epsilon;>0 by a probabilistic Turing machine in time polynomial in n and 1/&epsilon;. Defined by [[zooref#krc00|[KRC00]]], who also show the following: <ul> <li>Approximating the acceptance probability of a Boolean circuit is AxPP-complete. The authors argue that this makes AxPP a more natural class than [[Complexity Zoo:B#bpp|BPP]], since the latter is not believed to have complete problems.</li> <li>If AxPP = [[#axp|AxP]], then [[Complexity Zoo:B#bpp|BPP]] = [[Complexity Zoo:P#p|P]].</li> <li>On the other hand, there exists an oracle relative to which [[Complexity Zoo:B#bpp|BPP]] = [[Complexity Zoo:P#p|P]] but AxPP does not equal [[#axp|AxP]].</li> </ul> AxPP is recursively enumerable [[zooref#jer07|[Jeř07]]]. Complexity Zoo:B 3556 26636 2012-03-16T04:26:16Z Pcghostlmin 7264 /* BQP: Bounded-Error Quantum Polynomial-Time */ __NOTOC__ {{CZ-Letter-Menu|B}} ===== <span id="betap" style="color:red">&#946;P</span>: Limited-Nondeterminism [[Complexity Zoo:N#np|NP]] ===== &#946;<sub>k</sub>P is the class of decision problems solvable by a polynomial-time Turing machine that makes O(log<sup>k</sup>n) nondeterministic transitions, with the same acceptance mechanism as [[Complexity Zoo:N#np|NP]]. Equivalently, the machine receives a purported proof of size O(log<sup>k</sup>n) that the answer is 'yes.' Then &#946;P is the union of &#946;<sub>k</sub>P over all constant k. Defined in [[zooref#kf84|[KF84]]]. See also the survey [[zooref#glm96|[GLM96]]]. There exist oracles relative to which basically any consistent inclusion structure among the &#946;<sub>k</sub>P's can be realized [[zooref#bg98|[BG98]]]. &#946;<sub>2</sub>P contains [[Complexity Zoo:L#lognp|LOGNP]] and [[Complexity Zoo:L#logsnp|LOGSNP]]. ---- ===== <span id="bh" style="color:red">BH</span>: Boolean Hierarchy Over [[Complexity Zoo:N#np|NP]] ===== The smallest class that contains [[Complexity Zoo:N#np|NP]] and is closed under union, intersection, and complement. The levels are defined as follows: <ul> <li>BH<sub>1</sub> = [[Complexity Zoo:N#np|NP]].</li> <li>BH<sub>2i</sub> is the class of languages that are the intersection of a BH<sub>2i-1</sub> language with a [[Complexity Zoo:C#conp|coNP]] language.</li> <li>BH<sub>2i+1</sub> is the class of languages that are the union of a BH<sub>2i</sub> language with an [[Complexity Zoo:N#np|NP]] language.</li> </ul> Then BH is the union over all i of BH<sub>i</sub>. Defined in [[zooref#ww85|[WW85]]]. For more detail see [[zooref#cgh88|[CGH+88]]]. Contained in [[Complexity Zoo:D#delta2p|&#916;<sub>2</sub>P]] and indeed in [[Complexity Zoo:P#pnplog|P<sup>NP[log]</sup>]]. If BH collapses at any level, then [[Complexity Zoo:P#ph|PH]] collapses to &#931;<sub>3</sub>P [[zooref#kad88|[Kad88]]]. ''See also'': {{zcls|d|dp}}, [[Complexity Zoo:Q#qh|QH]]. ---- ===== <span id="bpdp" style="color:red">BP<sub>d</sub>(P)</span>: Polynomial Size d-Times-Only Branching Program ===== Defined in [[zooref#weg88|[Weg88]]]. The class of decision problems solvable by a family of polynomial size branching programs, with the additional condition that each bit of the input is tested at most d times. BP<sub>d</sub>(P) strictly contains BP<sub>d-1</sub>(P), for every d &gt; 1 [[zooref#tha98|[Tha98]]]. Contained in [[Complexity Zoo:P#pbp|PBP]]. See also: [[Complexity Zoo:P#pobdd|P-OBDD]], [[Complexity Zoo:P#kpbp|k-PBP]]. ---- ===== <span id="bpe" style="color:red">BPE</span>: Bounded-Error Probabilistic [[Complexity Zoo:E#e|E]] ===== Has the same relation to [[Complexity Zoo:E#e|E]] as [[#bpp|BPP]] does to [[Complexity Zoo:P#p|P]]. [[Complexity Zoo:E#ee|EE]] = BPE if and only if [[Complexity Zoo:E#exp|EXP]] = [[#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="bpee" style="color:red">BPEE</span>: Bounded-Error Probabilistic [[Complexity Zoo:E#ee|EE]] ===== Has the same relation to [[Complexity Zoo:E#ee|EE]] as [[#bpp|BPP]] does to [[Complexity Zoo:P#p|P]]. ---- ===== <span id="bphspace" style="color:red">BP<sub>H</sub>SPACE(f(n))</span>: Bounded-Error Halting Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts on every input <i>and</i> every random tape setting. Contains [[Complexity Zoo:R#rhspace|R<sub>H</sub>SPACE]](f(n)). Is contained in [[Complexity Zoo:D#dspace|DSPACE]](f(n)<sup>3/2</sup>) [[zooref#sz95|[SZ95]]]. ---- ===== <span id="bpl" style="color:red">BPL</span>: Bounded-Error Probabilistic [[Complexity Zoo:L#l|L]] ===== Has the same relation to [[Complexity Zoo:L#l|L]] as [[#bpp|BPP]] does to [[Complexity Zoo:P#p|P]]. The Turing machine has to halt with probability 1 on every input. Contained in [[Complexity Zoo:S#sc|SC]] [[zooref#nis92|[Nis92]]] and in [[Complexity Zoo:P#pl|PL]]. ---- ===== <span id="bpnp" style="color:red">BP&#149;NP</span>: Probabilistic [[Complexity Zoo:N#np|NP]] ===== Equals [[Complexity Zoo:A#am|AM]]. ---- ===== <span id="bpp" style="color:red">BPP</span>: Bounded-Error Probabilistic Polynomial-Time ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that <ol> <li>If the answer is 'yes' then at least 2/3 of the computation paths accept.</li> <li>If the answer is 'no' then at most 1/3 of the computation paths accept.</li> </ol> (Here all computation paths have the same length.) Often identified as the class of feasible problems for a computer with access to a genuine random-number source. Defined in [[zooref#gil77|[Gil77]]]. Contained in [[Complexity Zoo:S#sigma2p|&#931;<sub>2</sub>P]] &#8745; [[Complexity Zoo:P#pi2p|&#928;<sub>2</sub>P]] [[zooref#lau83|[Lau83]]], and indeed in [[Complexity Zoo:Z#zpp|ZPP]]<sup>[[Complexity Zoo:N#np|NP]]</sup> [[zooref#gz97|[GZ97]]]. If BPP contains [[Complexity Zoo:N#np|NP]], then [[Complexity Zoo:R#rp|RP]] = [[Complexity Zoo:N#np|NP]] [[zooref#ko82|[Ko82,]][[zooref#gil77|Gil77]]] and [[Complexity Zoo:P#ph|PH]] is contained in BPP [[zooref#zac88|[Zac88]]]. If any problem in [[Complexity Zoo:E#e|E]] requires circuits of size 2<sup>&#937;(n)</sup>, then BPP = [[Complexity Zoo:P#p|P]] [[zooref#iw97|[IW97]]] (in other words, BPP can be derandomized). Indeed, <i>any</i> proof that BPP = [[Complexity Zoo:P#p|P]] requires showing either that [[Complexity Zoo:N#nexp|NEXP]] is not in [[Complexity Zoo:P#ppoly|P/poly]], or else that [[Complexity Zoo:Symbols#sharpp|#P]] requires superpolynomial-size arithmetic circuits [[zooref#ki02|[KI02]]]. BPP is not known to contain complete problems. [[zooref#sip82|[Sip82]]], [[zooref#hh86|[HH86]]] give oracles relative to which BPP has no complete problems. There exist oracles relative to which [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:R#rp|RP]] but still [[Complexity Zoo:P#p|P]] is not equal to BPP [[zooref#bf99|[BF99]]]. In contrast to the case of [[Complexity Zoo:P#p|P]], it is unknown whether BPP collapses to [[#bptime|BPTIME]](n<sup>c</sup>) for some fixed constant c. However, [[zooref#bar02|[Bar02]]] and [[zooref#fs04|[FS04]]] have shown hierarchy theorems for BPP with a small amount of advice. A [[Zoo Glossary#zeroone-law|zero-one law]] exists stating that BPP has [[Zoo Glossary#p-measure|p-measure]] zero unless BPP = {{zcls|e|exp}} {{zcite|Mel00}}. Equals [[Complexity Zoo:A#almostp|Almost-P]]. See also: [[#bpppath|BPP<sub>path</sub>]]. ---- ===== <span id="bppcc" style="color:red">BPP<sup>cc</sup></span>: Communication Complexity [[#bpp|BPP]] ===== The analogue of [[Complexity Zoo:P#pcc|P<sup>cc</sup>]] for bounded-error probabilistic communication complexity. Does not equal [[Complexity Zoo:P#pcc|P<sup>cc</sup>]], and is not contained in [[Complexity Zoo:N#npcc|NP<sup>cc</sup>]], because of the EQUALITY problem. Defined in [[zooref#bfs86|[BFS86]]]. ---- ===== <span id="bppkcc" style="color:red">BPP<sub>$k$</sub><sup>cc</sup></span>: [[#bppcc|BPP<sup>cc</sup>]] in NOF model, $k$ players ===== Has the same relation to [[#bppcc|BPP<sup>cc</sup>]] and [[#bpp|BPP]] as {{zcls|p|pkcc|P<sub>$k$</sub><sup>cc</sup>}} does to {{zcls|p|pcc|P<sup>cc</sup>}} and {{zcls|p|p}}. {{zcls|n|npkcc|NP<sub>$k$</sub><sup>cc</sup>}} is not contained in {{zcls|b|bppkcc|BPP<sub>$k$</sub><sup>cc</sup>}} for $k\le(1-\delta)\cdot\log n$ players, for any constant $\delta>0$ {{zcite|DP08}}. ---- ===== <span id="bppkt" style="color:red">BPP<sup>KT</sup></span>: [[#bpp|BPP]] With Time-Bounded Kolmogorov Complexity Oracle ===== [[#bpp|BPP]] with an oracle that, given a string x, returns the minimum over all programs P that output x<sub>i</sub> on input i, of the length of P plus the maximum time taken by P on any input. A similar class was defined in [[zooref#abk02|[ABK+02]]], where it was also shown that in BPP<sup>KT</sup> one can [[Complexity_Garden#integer_factorization|factor]], compute [[Complexity_Garden#discrete_logarithm|discrete logarithms]], and more generally invert any one-way function on a non-negligible fraction of inputs. See also: [[Complexity Zoo:P#pk|P<sup>K</sup>]]. ---- ===== <span id="bpplog" style="color:red">BPP/log</span>: [[#bpp|BPP]] With Logarithmic Karp-Lipton Advice ===== The class of problems solvable by a semantic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, the machine must provide some answer with probability at least 2/3. See the discussion for [[#bqppoly|BQP/poly]]. Contained in [[#bppmlog|BPP/mlog]]. ---- ===== <span id="bppmlog" style="color:red">BPP/mlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) advice bits that depend only on the input length n. If the advice is good, the output must be correct with probability at least 2/3. If it is bad, it need not be. Contained in [[#bpprlog|BPP/rlog]]. ---- ===== <span id="bppsslog" style="color:red">BPP//log</span>: [[#bpp|BPP]] With Logarithmic Randomness-Dependent Advice ===== The class of problems solvable by a [[#bpp|BPP]] machine that is given O(log n) advice bits, which can depend on both the machine's random coin flips and the input length n, but not on the input itself. Defined in [[zooref#tv02|[TV02]]], where it was also shown that if [[Complexity Zoo:E#exp|EXP]] is in BPP//log then [[Complexity Zoo:E#exp|EXP]] = [[#bpp|BPP]], and if [[Complexity Zoo:P#pspace|PSPACE]] is in BPP//log then [[Complexity Zoo:P#pspace|PSPACE]] = [[#bpp|BPP]]. ---- ===== <span id="bpprlog" style="color:red">BPP/rlog</span>: [[#bpp|BPP]] With Logarithmic Deterministic Merlin-Like Advice ===== The class of problems solvable by a syntactic [[#bpp|BPP]] machine with O(log n) random advice bits whose probability distribution depends only on the input length n. For each n, there exists good advice such that the output is correct with probability at least 2/3. Contains [[#bppmlog|BPP/mlog]]. The inclusion is strict, because BPP/rlog contains any finitely sparse language by fingerprinting; see the discussion for [[Complexity Zoo:A#all|ALL]]. Contained in [[#bppsslog|BPP//log]]. ---- ===== <span id="bppobdd" style="color:red">BPP-OBDD</span>: Polynomial-Size Bounded-Error Ordered Binary Decision Diagram ===== Same as [[Complexity Zoo:P#pobdd|P-OBDD]], except that probabilistic transitions are allowed and the OBDD need only accept with probability at least 2/3. Does not contain the integer multiplication problem [[zooref#ak96|[AK96]]]. Strictly contained in [[#bqpobdd|BQP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bpppath" style="color:red">BPP<sub>path</sub></span>: Threshold [[#bpp|BPP]] ===== Same as [[#bpp|BPP]], except that now the computation paths need not all have the same length. Defined in [[zooref#hht97|[HHT97]]], where the following was also shown: <ul> <li>BPP<sub>path</sub> contains [[Complexity Zoo:M#ma|MA]] and [[Complexity Zoo:P#pnplog|P<sup>NP[log]</sup>]], and is contained in [[Complexity Zoo:P#pp|PP]] and [[#bpp|BPP]]<sup>[[Complexity Zoo:N#np|NP]]</sup>.</li> <li>BPP<sub>path</sub> is closed under complementation, intersection, and union.</li> <li>If BPP<sub>path</sub> = BPP<sub>path</sub><sup>BPP<sub>path</sub></sup>, then [[Complexity Zoo:P#ph|PH]] collapses to BPP<sub>path</sub>.</li> <li>If BPP<sub>path</sub> contains [[Complexity Zoo:S#sigma2p|&#931;<sub>2</sub>P]], then [[Complexity Zoo:P#ph|PH]] collapses to [[#bpp|BPP]]<sup>[[Complexity Zoo:N#np|NP]]</sup>.</li> </ul> There exists an oracle relative to which BPP<sub>path</sub> is not contained in [[Complexity Zoo:S#sigma2p|&#931;<sub>2</sub>P]] [[zooref#bgm02|[BGM02]]]. An alternate characterization of BPP<sub>path</sub> uses the idea of post-selection. That is, BPP<sub>path</sub> is the class of languages $L$ for which there exists a pair of polynomial-time Turing machines $A$ and $B$ such that the following conditions hold for all $x$: * If $x\in L$, $\Pr_{r\in\{0,1\}^{\mathrm{poly}(\left\vert x\right\vert)}}\left[A(x,r)\mid B(x,r)\right]\ge \frac23$. * If $x\notin L$, $\Pr_{r\in\{0,1\}^{\mathrm{poly}(\left\vert x\right\vert)}}\left[A(x,r)\mid B(x,r)\right]< \frac13$. * $\Pr_{r\in\{0,1\}^{\mathrm{poly}(n)}}\left[B(x,r)\right]>0$. We say that $B$ is the post-selector. Intuitively, this characterization allows a BPP machine to require that its random bits have some special but easily verifiable property. This characterization makes the inclusion NP &sube; BPP<sub>path</sub> nearly trivial. ''See Also'': {{zcls|p|postbqp|PostBQP}} (quantum analogue). ---- ===== <span id="bpqp" style="color:red">BPQP</span>: Bounded-Error Probabilistic [[Complexity Zoo:Q#qp|QP]] ===== Equals [[#bptime|BPTIME]](2<sup>O((log n)^k)</sup>); that is, the class of problems solvable in quasipolynomial-time on a bounded-error machine. Defined in [[zooref#cns99|[CNS99]]], where the following was also shown: <ul> If either (1) [[Complexity Zoo:Symbols#sharpp|#P]] does not have a subexponential-time bounded-error algorithm, or (2) [[Complexity Zoo:E#exp|EXP]] does not have subexponential-size circuits, then the BPQP hierarchy is strict -- that is, for all a &lt; b at least 1, [[#bptime|BPTIME]](2<sup>(log n)^a</sup>) is strictly contained in [[#bptime|BPTIME]](2<sup>(log n)^b</sup>). </ul> ---- ===== <span id="bpspace" style="color:red">BPSPACE(f(n))</span>: Bounded-Error Probabilistic f(n)-Space ===== The class of decision problems solvable in O(f(n))-space with error probability at most 1/3, by a Turing machine that halts with probability 1 on every input. Contains [[Complexity Zoo:R#rspace|RSPACE(f(n))]] and [[#bphspace|BP<sub>H</sub>SPACE(f(n))]]. ---- ===== <span id="bptime" style="color:red">BPTIME(f(n))</span>: Bounded-Error Probabilistic f(n)-Time ===== Same as [[#bpp|BPP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#gil77|[Gil77]]]. BPTIME(n<sup>log n</sup>) does not equal BPTIME(2<sup>n^&epsilon;</sup>) for any &epsilon;>0 [[zooref#kv88|[KV88]]]. Proving a stronger time hierarchy theorem for BPTIME is a longstanding open problem; see [[zooref#bh97|[BH97]]] for details. [[zooref#bar02|[Bar02]]] has shown the following: <ul> <li>If we allow a small number of advice bits (say log n), then there is a strict hierarchy: for every d at least 1, BPTIME(n<sup>d</sup>)/(log n) does not equal BPTIME(n<sup>d+1</sup>)/(log n).</li> <li>In the uniform setting, if [[#bpp|BPP]] has complete problems then BPTIME(n<sup>d</sup>) does not equal BPTIME(n<sup>d+1</sup>).</li> <li>BPTIME(n) does not equal [[Complexity Zoo:N#np|NP]].</li> </ul> Subsequently, [[zooref#fs04|[FS04]]] managed to reduce the number of advice bits to only 1: BPTIME(n<sup>d</sup>)/1 does not equal BPTIME(n<sup>d+1</sup>)/1. They also proved a hierarchy theorem for [[#heurbptime|HeurBPTIME]]. For another bounded-error hierarchy result, see [[#bpqp|BPQP]]. ---- ===== <span id="bqnc" style="color:red">BQNC</span>: Alternate Name for [[Complexity Zoo:Q#qnc|QNC]] ===== ---- ===== <span id="bqnp" style="color:red">BQNP</span>: Alternate Name for [[Complexity Zoo:Q#qma|QMA]] ===== ---- ===== <span id="bqp" style="color:red">BQP</span>: Bounded-Error Quantum Polynomial-Time ===== The class of decision problems solvable in polynomial time by a quantum Turing machine, with at most 1/3 probability of error. One can equivalently define BQP as the class of decision problems solvable by a uniform family of polynomial-size quantum circuits, with at most 1/3 probability of error [[zooref#yao93|[Yao93]]]. Any universal gate set can be used as a basis; however, a technicality is that the transition amplitudes must be efficiently computable, since otherwise one could use them to encode the solutions to hard problems (see [[zooref#adh97|[ADH97]]]). BQP is often identified as the class of feasible problems for quantum computers. Contains the [[Complexity_Garden#integer_factorization|factoring]] and [[Complexity_Garden#discrete_logarithm|discrete logarithm]] problems [[zooref#sho97|[Sho97]]], the hidden Legendre symbol problem [[zooref#dhi02|[DHI02]]], the Pell's equation and principal ideal problems [[zooref#hal02|[Hal02]]], and some other problems not thought to be in [[#bpp|BPP]]. Defined in [[zooref#bv97|[BV97]]], where it is also shown that BQP contains [[#bpp|BPP]] and is contained in [[Complexity Zoo:P#p|P]] with a [[Complexity Zoo:Symbols#sharpp|#P]] oracle. BQP<sup>BQP</sup> = BQP [[zooref#bv97|[BV97]]]. [[zooref#adh97|[ADH97]]] showed that BQP is contained in [[Complexity Zoo:P#pp|PP]], and [[zooref#fr98|[FR98]]] showed that BQP is contained in [[Complexity Zoo:A#awpp|AWPP]]. There exist oracles relative to which: <ul> <li>BQP does not equal to [[#bpp|BPP]] [[zooref#bv97|[BV97]]] (and by similar arguments, is not in [[Complexity Zoo:P#ppoly|P/poly]]).</li> <li>BQP is not contained in [[Complexity Zoo:M#ma|MA]] [[zooref#wat00|[Wat00]]].</li> <li>BQP is not contained in [[Complexity Zoo:M#modkp|Mod<sub>p</sub>P]] for prime p [[zooref#gv02|[GV02]]].</li> <li>[[Complexity Zoo:N#np|NP]], and indeed [[Complexity Zoo:N#npiconp|NP &#8745; coNP]], are not contained in BQP (in fact, this holds with probability 1 relative to a random oracle and a random permutation oracle, respectively) [[zooref#bbb97|[BBB+97]]].</li> <li>[[Complexity Zoo:S#szk|SZK]] is not contained in BQP [[zooref#aar02|[Aar02]]].</li> <li>BQP is not contained in [[Complexity Zoo:S#szk|SZK]] (follows easily using the quantum walk problem in [[zooref#ccd03|[CCD+03]]]).</li> <li>[[Complexity Zoo:P#ppad|PPAD]] is not contained in BQP [[zooref#li11|[Li11]]].</li> </ul> ---- ===== <span id="bqplog" style="color:red">BQP/log</span>: [[#bqp|BQP]] With Logarithmic-Size Karp-Lipton Advice ===== Same as [[#bqppoly|BQP/poly]] except that the advice is O(log n) bits instead of a polynomial number. Contained in [[#bqpmlog|BQP/mlog]]. ---- ===== <span id="bqppoly" style="color:red">BQP/poly</span>: [[#bqp|BQP]] With Polynomial-Size Karp-Lipton Advice ===== Is to [[#bqpmpoly|BQP/mpoly]] as [[#existsbpp|&#8707;BPP]] is to [[Complexity Zoo:M#ma|MA]]. Namely, the [[#bqp|BQP]] machine is required to give some answer with probability at least 2/3 even if the advice is bad. Even though [[#bqpmpoly|BQP/mpoly]] is a more natural class, BQP/poly follows the standard definition of advice as a class operator [[zooref#kl82|[KL82]]]. Contained in [[#bqpmpoly|BQP/mpoly]] and contains [[#bqplog|BQP/log]]. ---- ===== <span id="bqpmlog" style="color:red">BQP/mlog</span>: [[#bqp|BQP]] With Logarithmic-Size Deterministic Merlin-Like Advice ===== Same as [[#bqpmpoly|BQP/mpoly]] except that the advice is O(log n) bits instead of a polynomial number. Strictly contained in [[#bqpqlog|BQP/qlog]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpmpoly" style="color:red">BQP/mpoly</span>: [[#bqp|BQP]] With Polynomial-Size Deterministic Merlin-Like Advice ===== The class of languages recognized by a syntactic BQP machine with deterministic polynomial advice that depends only on the input length, such that the output is correct with probability 2/3 when the advice is good. Can also be defined as the class of problems solvable by a nonuniform family of polynomial-size quantum circuits, just as [[#ppoly|P/poly]] is the class solvable by a nonuniform family of polynomial-size classical circuits. Referred to with a variety of other ad hoc names, including [[#bqppoly|BQP/poly]] on occassion. Contains [[#bqpqlog|BQP/qlog]], and is contained in [[#bqpqpoly|BQP/qpoly]]. Does not contain [[Complexity Zoo:E#espace|ESPACE]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="bqpqlog" style="color:red">BQP/qlog</span>: [[#bqp|BQP]] With Logarithmic-Size Quantum Advice ===== Same as [[#bqpmlog|BQP/mlog]] except that the advice is quantum instead of classical. Strictly contains [[#bqpmlog|BQP/mlog]] [[zooref#ny03|[NY03]]]. Contained in [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpqpoly" style="color:red">BQP/qpoly</span>: [[#bqp|BQP]] With Polynomial-Size Quantum Advice ===== The class of problems solvable by a [[#bqp|BQP]] machine that receives a quantum state &psi;<sub>n</sub> as advice, which depends only on the input length n. As with [[#bqpmpoly|BQP/mpoly]], the acceptance probability does not need to be bounded away from 1/2 if the machine is given bad advice. (Thus, we are discussing the class that [[zooref#ny03|[NY03]]] call BQP/*Qpoly.) Indeed, such a condition would make ''quantum'' advice unusable, by a continuity argument. Does not contain [[Complexity Zoo:E#eespace|EESPACE]] [[zooref#ny03|[NY03]]]. [[zooref#aar04b|[Aar04b]]] shows the following: <ul> <li>There exists an oracle relative to which BQP/qpoly does not contain [[Complexity Zoo:N#np|NP]].</li> <li>BQP/qpoly is contained in [[Complexity Zoo:P#pppoly|PP/poly]].</li> </ul> A ''classical'' oracle separation between BQP/qpoly and [[#bqpmpoly|BQP/mpoly]] is presently unknown, but there is a ''quantum'' oracle separation [[zooref#ak06|[AK06]]]. An unrelativized separation is too much to hope for, since it would imply that [[Complexity Zoo:P#pp|PP]] is not contained in [[Complexity Zoo:P#ppoly|P/poly]]. Contains [[#bqpmpoly|BQP/mpoly]]. ---- ===== <span id="bqpobdd" style="color:red">BQP-OBDD</span>: Polynomial-Size Bounded-Error Quantum Ordered Binary Decision Diagram ===== Same as [[Complexity Zoo:P#pobdd|P-OBDD]], except that unitary (quantum) transitions are allowed and the OBDD need only accept with probability at least 2/3. Strictly contains [[#bppobdd|BPP-OBDD]] [[zooref#nhk00|[NHK00]]]. ---- ===== <span id="bqpspace" style="color:red">BQPSPACE</span>: Bounded-Error Quantum [[Complexity Zoo:P#pspace|PSPACE]] ===== Equals [[Complexity Zoo:P#pspace|PSPACE]] and [[Complexity Zoo:P#ppspace|PPSPACE]]. ---- ===== <span id="bqtime" style="color:red">BQTIME(f(n))</span>: Bounded-Error Quantum f(n)-Time ===== Same as [[#bqp|BQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="bqpctc" style="color: red">BQP<sub>CTC</sub></span>: [[#bqp|BQP]] With Closed Time Curves ===== Same as [[#bqp|BQP]] with access to two sets of qubits: causality-respecting qubits and CTC qubits. Defined in [[zooref#aar05c|[Aar05c]]], where it was shown that [[Complexity Zoo:P#pspace|PSPACE]] is contained in BQP<sub>CTC</sub>, which in turn is contained in [[Complexity Zoo:S#sqg|SQG]]. See also [[Complexity Zoo:P#pctc|P<sub>CTC</sub>]]. ---- ===== <span id="bqpttpoly" style="color:red">BQP<sub>tt</sub>/poly</span>: [[#bqpmpoly|BQP/mpoly]] With Truth-Table Queries ===== Same as [[#bqpmpoly|BQP/mpoly]], except that the machine only gets to make <i>nonadaptive</i> queries to whatever oracle it might have. Defined in [[zooref#ny03b|[NY03b]]], where it was also shown that [[Complexity Zoo:P#p|P]] is not contained in BQP<sub>tt</sub>/poly relative to an oracle. ---- ===== <span id="bwbp" style="color:red">k-BWBP</span>: Bounded-Width Branching Program ===== Alternate name for k-[[Complexity Zoo:P#kpbp|PBP]]. Complexity Zoo:C 3557 33165 2012-05-10T04:47:54Z Torzsmokus 10285 Undo revision 22314 by [[Special:Contributions/HalVarian|HalVarian]] ([[User talk:HalVarian|Talk]]) __NOTOC__ {{CZ-Letter-Menu|C}} ===== <span id="cequalsac0" style="color:red">C<sub>=</sub>AC<sup>0</sup></span>: Exact-Counting [[Complexity Zoo:A#ac0|AC<sup>0</sup>]] ===== The class of problems for which there exists a [[Complexity Zoo:D#diffac0|DiffAC<sup>0</sup>]] function f such that the answer is "yes" on input x if and only if f(x)=0. Equals [[Complexity Zoo:T#tc0|TC<sup>0</sup>]] and [[Complexity Zoo:P#pac0|PAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="cequalsl" style="color:red">C<sub>=</sub>L</span>: Exact-Counting [[Complexity Zoo:L#l|L]] ===== Has the same relation to [[Complexity Zoo:L#l|L]] as [[Complexity Zoo:C#cequalsp|C<sub>=</sub>P]] does to [[Complexity Zoo:P#p|P]]. C<sub>=</sub>L<sup>C=L</sup> = L<sup>C=L</sup> [[zooref#abo99|[ABO99]]]. ---- ===== <span id="cequalsp" style="color:red">C<sub>=</sub>P</span>: Exact-Counting Polynomial-Time ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that the number of accepting paths exactly equals the number of rejecting paths, if and only if the answer is 'yes.' Equals [[Complexity Zoo:C#conqp|coNQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cc" style="color:red">CC</span>: Comparator Circuits ===== A <i>comparator</i> gate consists of two inputs and outputs the minimum of its two inputs on its first output wire and outputs the maximum of its two inputs on its second output wire. One important restriction is that each output of a comparator gate has fanout at most one. The Comparator Circuit Value Problem (CCVP) is defined as following. Given a circuit composed of comparator gates, the inputs to the circuit, and one output of the circuit, calculate the value of this output. CC is defined as the class of problems log-space many-one reducible to CCVP [[zooref#ms89|[MS89]]]. At present it is only known that [[Complexity Zoo:N#nl|NL]]$\subseteq$CC$\subseteq$[[Complexity Zoo:P#p|P]] [[zooref#ms89|[MS89]]]. CC is an example of a complexity class neither known to be in [[Complexity Zoo:N#nc|NC]] nor [[Complexity Zoo:P#p|P]]-complete. Natural complete problems for the CC class include Stable Marriage Problem, Stable Roommate Problem, Lex-first Maximal Matching [[zooref#sub94|[Sub94]]]. ---- ===== <span id="cc0" style="color:red">CC<sup>0</sup></span>: Constant-Depth MOD<sub>''m''</sub> Circuits ===== The set of problems solvable by by constant-depth circuits having only MOD<sub>''m''</sub> gates for constant $m$. {{CZ-Class-Stub}} ---- ===== <span id="cfl" style="color:red">CFL</span>: Context-Free Languages ===== Does not equal [[Complexity Zoo:Q#qcfl|QCFL]] [[zooref#mc00|[MC00]]]. Contained in [[Complexity Zoo:L#logcfl|LOGCFL]]. Strictly contains [[Complexity Zoo:D#dcfl|DCFL]] [[zooref#bra77|[Bra77]]] and indeed [[Complexity Zoo:U#ucfl|UCFL]]. ---- ===== <span id="ch" style="color:red">CH</span>: Counting Hierarchy ===== The union of the [[#ckp|C<sub>k</sub>P]]'s over all constant k. Contained in [[Complexity Zoo:P#pspace|PSPACE]]. Strictly contains DLOGTIME-uniform NC<sup>1</sup> [[zooref#CMTV98|[CMTV98]]]. It is an open problem whether there exists an oracle relative to which CH is infinite, or even unequal to [[Complexity Zoo:P#pspace|PSPACE]]. This is closely related to the problem of whether [[Complexity Zoo:T#tc0|TC<sup>0</sup>]] = {{zcls|n|nc1|NC<sup>1</sup>}}, since a padding argument shows that [[Complexity Zoo:T#tc0|TC<sup>0</sup>]] = {{zcls|n|nc1|NC<sup>1</sup>}} implies CH = {{zcls|p|pspace}}. ---- ===== <span id="check" style="color:red">Check</span>: Checkable Languages ===== The class of problems such that a polynomial-time program P that allegedly solves them can be <i>checked</i> efficiently. That is, f is in Check if there exists a [[Complexity Zoo:B#bpp|BPP]] algorithm C such that for all programs P and inputs x, <ol> <li>If P(y)=f(y) for all inputs y, then C<sup>P</sup>(x) (C with oracle access to P) accepts with probability at least 2/3.</li> <li>If P(x) is not equal to f(x) then C<sup>P</sup>(x) accepts with probability at most 1/3.</li> </ol> Introduced in [[zooref#bk89|[BK89]]], where it was also shown that Check equals [[Complexity Zoo:F#frip|frIP]] &#8745; [[Complexity Zoo:C#cofrip|cofrIP]]. Check is contained in [[Complexity Zoo:N#nexp|NEXP]] &#8745; [[Complexity Zoo:C#conexp|coNEXP]] [[zooref#frs88|[FRS88]]]. [[zooref#bg94|[BG94]]] show that if [[Complexity Zoo:N#nee|NEE]] is not contained in [[Complexity Zoo:B#bpee|BPEE]] then [[Complexity Zoo:N#np|NP]] is not contained in Check. ---- ===== <span id="clsharpp" style="color:red">CL#P</span>: Cluster Sharp-P ===== The class of [[Complexity Zoo:Symbols#sharpp|#P]] function problems such that some underlying [[Complexity Zoo:N#np|NP]] machine $M$ witnessing membership in [[Complexity Zoo:Symbols#sharpp|#P]] has "clustered" accepting paths. That is: <ul> <li>There exists a polynomial $p$ such that each computation path of $M$ on each input $x$ is exactly $p(|x|)$ bits long.</li> <li>There is a length-respecting total order $A$ having polynomial-time computable adjacency checks on the computation paths of $M$.</li> <li>The accepting paths of $M$ on any input $x$ are contiguous with respect to $A$.</li> </ul> Defined in [[zooref#hhk05|[HHK+05]]]. ---- ===== <span id="ckp" style="color:red">C<sub>k</sub>P</span>: k<sup>th</sup> Level of [[Complexity Zoo:C#ch|CH]] ===== Defined as follows: <ul> <li>C<sub>0</sub>P = [[Complexity Zoo:P#p|P]]</li> <li>C<sub>1</sub>P = [[Complexity Zoo:P#pp|PP]]</li> <li>C<sub>2</sub>P = [[Complexity Zoo:P#pp|PP]]<sup>[[Complexity Zoo:P#pp|PP]]</sup></li> <li>In general, C<sub>k+1</sub>P is [[Complexity Zoo:P#pp|PP]] with C<sub>k</sub>P oracle</li> </ul> The union of the C<sub>k</sub>P's is called the counting hierarchy, [[Complexity Zoo:C#ch|CH]]. Defined in [[zooref#wag86|[Wag86]]]. See [[zooref#tor91|[Tor91]]] or [[zooref#aw90|[AW90]]] for more information. ---- ===== <span id="clog" style="color:red">CLOG</span>: Continuous Logarithmic-Time ===== Roughly, the class of continuous problems solvable by an ordinary differential equation (ODE) with convergence time logarithmic in the size of the input. The vector field of the ODE is specified by an [[Complexity Zoo:N#nc1|NC<sup>1</sup>]] formula, with n parameters that represent the input. The point to which the ODE converges (assuming it does) is the output. Defined in [[zooref#bsf02|[BSF02]]], which should be consulted for more details. [[zooref#bsf02|[BSF02]]] show that finding the maximum of n integers is in CLOG. Thus, CLOG is best thought of as the continuous-time analog of [[Complexity Zoo:N#nc1|NC<sup>1</sup>]], not of [[Complexity Zoo:D#dtime|DTIME]](log n). Contained in [[#cp|CP]]. ---- ===== <span id="cnp" style="color:red">CNP</span>: Continuous [[Complexity Zoo:N#np|NP]] ===== A nondeterministic analog of [[Complexity Zoo:C#cp|CP]]. Defined in [[zooref#sf98|[SF98]]], which should be consulted for the definition (it has something to do with strange attractors, I think). The authors raise the question of whether [[Complexity Zoo:C#cp|CP]] equals CNP. ---- ===== <span id="coam" style="color:red">coAM</span>: Complement of [[Complexity Zoo:A#am|AM]] ===== ---- ===== <span id="cocequalsp" style="color:red">coC<sub>=</sub>P</span>: Complement of [[Complexity Zoo:C#cequalsp|C<sub>=</sub>P]] ===== Equals [[Complexity Zoo:N#nqp|NQP]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="cofrip" style="color:red">cofrIP</span>: Complement of [[Complexity Zoo:F#frip|frIP]] ===== ---- ===== <span id="coh" style="color:red">Coh</span>: Coherent Languages ===== The class of problems L that are <i>efficiently autoreducible</i>, in the sense that given an input x and access to an oracle for L, a [[Complexity Zoo:B#bpp|BPP]] machine can compute L(x) by querying L only on points that differ from x. Defined in [[zooref#yao90b|[Yao90b]]]. [[zooref#bg94|[BG94]]] show that, assuming [[Complexity Zoo:N#nee|NEE]] is not contained in [[Complexity Zoo:B#bpee|BPEE]], Coh &#8745; [[Complexity Zoo:N#np|NP]] is not contained in any of [[#compnp|compNP]], [[#check|Check]], or [[Complexity Zoo:F#frip|frIP]]. ---- ===== <span id="coma" style="color:red">coMA</span>: Complement of [[Complexity Zoo:M#ma|MA]] ===== ---- ===== <span id="comodkp" style="color:red">coMod<sub>k</sub>P</span>: Complement of [[Complexity Zoo:M#modkp|Mod<sub>k</sub>P]] ===== ---- ===== <span id="compip" style="color:red">compIP</span>: Competitive [[Complexity Zoo:I#ip|IP]] Proof System ===== Same as [[#compnp|compNP]] but for interactive ([[Complexity Zoo:I#ip|IP]]) proofs instead of [[Complexity Zoo:N#np|NP]] proofs. More formally, compIP is the class of decision problems L in [[Complexity Zoo:I#ip|IP]] = [[Complexity Zoo:P#pspace|PSPACE]] such that, if the answer is "yes," then that can be proven by an interactive protocol between a [[Complexity Zoo:B#bpp|BPP]] verifier and a prover, a [[Complexity Zoo:B#bpp|BPP]] machine with access only to an oracle for L. Assuming [[Complexity Zoo:N#nee|NEE]] is not contained in [[Complexity Zoo:B#bpee|BPEE]], [[Complexity Zoo:N#np|NP]] (and indeed [[Complexity Zoo:N#np|NP]] &#8745; [[Complexity Zoo:C#coh|Coh]]) is not contained in [[Complexity Zoo:C#compip|compIP]] [[zooref#bg94|[BG94]]]. ---- ===== <span id="compnp" style="color:red">compNP</span>: Competitive [[Complexity Zoo:N#np|NP]] Proof System ===== The class of decision problems L in [[Complexity Zoo:N#np|NP]] such that, if the answer is "yes," then a proof can be constructed in polynomial time given access only to an oracle for L. Contains [[Complexity Zoo:N#npc|NPC]]. [[zooref#bg94|[BG94]]] show that compNP is contained in [[Complexity Zoo:F#frip|frIP]], and that assuming [[Complexity Zoo:N#nee|NEE]] is not contained in [[Complexity Zoo:B#bpee|BPEE]], compNP does not equal [[Complexity Zoo:N#np|NP]]. ---- ===== <span id="cone" style="color:red">coNE</span>: Complement of [[Complexity Zoo:N#ne|NE]] ===== ---- ===== <span id="conexp" style="color:red">coNEXP</span>: Complement of [[Complexity Zoo:N#nexp|NEXP]] ===== Contained in [[Complexity_Zoo:N#nexppoly|NEXP/poly]] (folklore result reported in [[http://weblog.fortnow.com/ Fortnow's weblog]]). ---- ===== <span id="conl" style="color:red">coNL</span>: Complement of [[Complexity Zoo:N#nl|NL]] ===== Equals [[Complexity Zoo:N#nl|NL]] [[zooref#imm88|[Imm88]]] [[zooref#sze87|[Sze87]]]. ---- ===== <span id="conp" style="color:red">coNP</span>: Complement of [[Complexity Zoo:N#np|NP]] ===== If [[Complexity Zoo:N#np|NP]] = coNP, then any inconsistent Boolean formula of size n has a proof of inconsistency of size polynomial in n. If [[Complexity Zoo:N#np|NP]] does not equal coNP, then [[Complexity Zoo:P#p|P]] does not equal [[Complexity Zoo:N#np|NP]]. But the other direction is not known. See also: [[Complexity Zoo:N#npiconp|NP &#8745; coNP]]. Every problem in coNP has an [[Complexity Zoo:I#ip|IP]] (interactive proof) system, where moreover the prover can be restricted to [[Complexity Zoo:B#bpp|BPP]]<sup>[[Complexity Zoo:Symbols#sharpp|#P]]</sup>. If every problem in coNP has an interactive protocol whose rounds are bounded by a polylogarithmic function, then {{zcls|e|eh}} collapses to the third level {{zcite|SS04}}. Co-NP is equal to [[#Complexity_Zoo:S#so|SO-A]], the second-order queries where the second-order quantifiers are only universals. ---- ===== <span id="conpcc" style="color:red">coNP<sup>cc</sup></span>: Complement of [[Complexity Zoo:N#npcc|NP<sup>cc</sup>]] ===== ---- ===== <span id="conppoly" style="color:red">coNP/poly</span>: Complement of [[Complexity Zoo:N#nppoly|NP/poly]] ===== If [[Complexity Zoo:N#np|NP]] is contained in coNP/poly then [[Complexity Zoo:P#ph|PH]] collapses to [[Complexity Zoo:S#s2p|S<sub>2</sub>P]]<sup>[[Complexity Zoo:N#np|NP]]</sup> [[zooref#cch01|[CCH+01]]]. <table border="2"><tr><td>[[Complexity Zoo:N#np|NP]]<sup>[[Complexity Zoo:N#np|NP]]^[[Complexity Zoo:N#np|NP]]^([[#conppoly|coNP/poly]] &#8745; [[Complexity Zoo:N#np|NP]])</sup> = [[Complexity Zoo:N#np|NP]]<sup>[[Complexity Zoo:N#np|NP]]^[[Complexity Zoo:N#np|NP]]</sup> [[zooref#hno96|[HNO+96]]]</td></tr></table> <i>Note:</i> At the suggestion of Luis Antu&ntilde;es, the above specimen of the Complexity Zoo has been locked in a cage. ---- ===== <span id="conqp" style="color:red">coNQP</span>: Complement of [[Complexity Zoo:N#nqp|NQP]] ===== Equals [[Complexity Zoo:C#cequalsp|C<sub>=</sub>P]] [[zooref#fgh98|[FGH+98]]]. ---- ===== <span id="core" style="color:red">coRE</span>: Complement of [[Complexity Zoo:R#re|RE]] ===== Does not equal [[Complexity Zoo:R#re|RE]]. The problem "given a computable predicate P, is P true of all positive integers?" is coRE-complete. ---- ===== <span id="cornc" style="color:red">coRNC</span>: Complement of [[Complexity Zoo:R#rnc|RNC]] ===== Contains the problem of whether a bipartite graph has a perfect matching [[zooref#kar86|[Kar86]]]. ---- ===== <span id="corp" style="color:red">coRP</span>: Complement of [[Complexity Zoo:R#rp|RP]] ===== Defined in [[zooref#gil77|[Gil77]]]. (This paper does not actually discuss coRP, other than implicitly mentioning that ZPP = RP ∩ co-RP. Is there a better reference?) Contains the problem of testing whether an integer is prime [[zooref#ss77|[SS77]]]. ---- ===== <span id="cosl" style="color:red">coSL</span>: Complement of [[Complexity Zoo:S#sl|SL]] ===== ---- ===== <span id="cosparse" style="color:red">coSPARSE</span>: Complement of [[Complexity Zoo:S#sparse|SPARSE]] ===== ---- ===== <span id="coucc" style="color:red">coUCC</span>: Complement of [[Complexity Zoo:U#ucc|UCC]] ===== [[zooref#tor00|[Tor00]]] showed the following problem complete for coUCC under [[Complexity Zoo:L#l|L]] reductions: <ul> Given a colored graph G with at most two vertices having any given color, does G have any nontrivial automorphisms? </ul> ---- ===== <span id="coup" style="color:red">coUP</span>: Complement of [[Complexity Zoo:U#up|UP]] ===== ---- ===== <span id="cp" style="color:red">CP</span>: Continuous [[Complexity Zoo:P#p|P]] ===== Same as [[#clog|CLOG]], except that the convergence time can be polynomial rather than logarithmic in the input size. Defined in [[zooref#bsf02|[BSF02]]] and [[zooref#sf98|[SF98]]]. Finding a maximum flow, which is [[Complexity Zoo:P#p|P]]-complete, can be done in CP [[zooref#bsf02|[BSF02]]]. Based on this the authors argue that "[[Complexity Zoo:P#p|P]] is contained in CP," but this seems hard to formalize, since CP is not a complexity class in the usual sense. They also conjecture that "CP is contained in [[Complexity Zoo:P#p|P]]" (i.e. the class of ODE's they consider can be integrated efficiently on a standard Turing machine), but this is open. Contained in [[Complexity Zoo:C#cnp|CNP]]. ---- ===== <span id="csize" style="color:red">CSIZE(f(n))</span>: Circuit Size f(n) ===== The class of decision problems solvable by a (nonuniform) family of Boolean circuits of size O(f(n)). So for example, CSIZE(poly(n)) (the union of CSIZE(n<sup>k</sup>) over all k) equals [[Complexity Zoo:P#ppoly|P/poly]]. Defined in [[zooref#sm02|[SM02]]] among other places. ---- ===== <span id="csl" style="color:red">CSL</span>: Context Sensitive Languages ===== The class of languages generated by context-sensitive grammars. Equals [[Complexity Zoo:N#nspace|NSPACE]](n) [[zooref#kur64|[Kur64]]]. ---- ===== <span id="csp" style="color:red">CSP</span>: Constraint Satisfaction Problems ===== Defined in [[zooref#fv93|[FV93]]] as the class of languages corresponding to fixed templates (where a template is a set of allowed constraints on values and variables) in the general [[Complexity Garden#constraint-sat|Constraint Satisfaction Problem]]. Under this construction, 3SAT may be expressed as the fixed template (over the alphabet $\{0,1\}$) containing $C_0, C_1, C_2, C_3$: $\begin{matrix} C_0 & = & \{0,1\}^3 \backslash (0,0,0) \\ C_1 & = & \{0,1\}^3 \backslash (1,0,0) \\ C_2 & = & \{0,1\}^3 \backslash (1,1,0) \\ C_3 & = & \{0,1\}^3 \backslash (1,1,1) \end{matrix}$ For example, a 3SAT clause $(x \vee y \vee \neg z)$ is represented in the CSP construction as $C_1(z, x, y) \in I$. By similar constructions, any k-SAT problem can be seen to be in CSP. The class also includes Graph k-Coloring (for $k\in\mathbb{N}$), Graph H-Coloring (for some graph $H$) and Linear Programming mod $q$. In [[zooref#fv93|[FV93]]], where the class is defined, the authors show that every problem in [[Complexity Zoo:M#mmsnp|MMSNP]] is reducible under randomized polynomial-time reductions to a problem in CSP. ---- ===== <span id="czk" style="color:red">CZK</span>: Computational Zero-Knowledge ===== Same as [[Complexity Zoo:S#szk|SZK]], except that now the two distributions are merely required to be <i>computationally indistinguishable</i> by any [[Complexity Zoo:B#bpp|BPP]] algorithm; they don't have to be statistically close. (The "two distributions" are (1) the distribution over the verifier's view of their interaction with the prover, conditioned on the verifier's random coins, and (2) the distribution over views that the verifier can <i>simulate</i> without the prover's help.) Unlike [[Complexity Zoo:S#szk|SZK]], it is not known if CZK is closed under complement. CZK is now known to share other properties with [[Complexity Zoo:S#szk|SZK]]: the verifier may as well be honest and may as well show their coins, and CZK is closed under unions [[zooref#vad06|[Vad06]]]. (Previously, these properties were only established in the presence of one-way functions [[zooref#gmw91|[GMW91]]].) Assuming the existence of one-way functions, CZK contains [[Complexity Zoo:N#np|NP]] [[zooref#gmw91|[GMW91]]], and actually equals [[Complexity Zoo:I#ip|IP]]=[[Complexity Zoo:P#pspace|PSPACE]] [[zooref#bgg90|[BGG+90]]]. However, none of these implications of one-way functions relativize (Impagliazzo, unpublished). On the other hand, if one-way functions do not exist then CZK = [[Complexity Zoo:A#avbpp|AVBPP]] [[zooref#ow93|[OW93]]]. Contains [[Complexity Zoo:P#pzk|PZK]] and [[Complexity Zoo:S#szk|SZK]]. Complexity Zoo:D 3558 18128 2011-11-17T03:10:40Z Cosenal 1840 added reference to the oracle separation between delta2p and BPP __NOTOC__ {{CZ-Letter-Menu|D}} ===== <span id="dsharpp" style="color:red">D#P</span>: Alternate Name for [[Complexity Zoo:P#psharpp|P<sup>#P</sup>]] ===== ---- ===== <span id="dcfl" style="color:red">DCFL</span>: Deterministic [[Complexity Zoo:C#cfl|CFL]] ===== The class of languages accepted by deterministic pushdown automata. Defined in [[zooref#gg66|[GG66]]], where it was also shown that DCFL is strictly contained in [[Complexity Zoo:C#cfl|CFL]], contained in [[Complexity Zoo:U#ucfl|UCFL]], and strictly contains [[Complexity Zoo:R#reg|REG]]. The inclusion in UCFL is also strict. ---- ===== <span id="delta2p" style="color:red">&#916;<sub>2</sub>P</span>: [[Complexity Zoo:P#p|P]] With [[Complexity Zoo:N#np|NP]] Oracle ===== A level of [[Complexity Zoo:P#ph|PH]], the polynomial hierarchy. Contains [[Complexity Zoo:B#bh|BH]]. There exists an oracle relative to which &#916;<sub>2</sub>P is not contained in [[Complexity Zoo:P#pp|PP]] [[zooref#bei94|[Bei94]]]. There exists another oracle relative to which &#916;<sub>2</sub>P is contained in [[Complexity Zoo:P#ppoly|P/poly]] [[zooref#bgs75|[BGS75]]], and indeed has linear-size circuits [[zooref#wil85|[Wil85]]]. There exists an oracle B for which [[Complexity Zoo:B#bpp|BPP]]<sup>B</sup> is exponentially more powerful than &#916;<sub>2</sub>P<sup>B</sup> [[zooref#kv96|[KV96]]]. If [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:N#np|NP]], then any polynomial-size circuit C can be learned in &#916;<sub>2</sub>P with C oracle [[zooref#aar06|[Aar06]]]. ---- ===== <span id="deltabpp" style="color:red">&#948;-BPP</span>: &#948;-Semi-Random [[Complexity Zoo:B#bpp|BPP]] ===== Same as [[Complexity Zoo:B#bpp|BPP]], except that the random bit source is biased as follows. Each bit could depend on all the previous bits in arbitrarily complicated ways; the only promise is that the bit is 1 with probability in the range [&#948;,1-&#948;], conditioned on all previous bits. So clearly 0-BPP = [[Complexity Zoo:P#p|P]] and 1/2-BPP = [[Complexity Zoo:B#bpp|BPP]]. It turns out that, for any &#948;&gt;0, &#948;-BPP = [[Complexity Zoo:B#bpp|BPP]] [[zooref#vv85|[VV85]]], [[zooref#zuc91|[Zuc91]]]. ---- ===== <span id="deltarp" style="color:red">&#948;-RP</span>: &#948;-Semi-Random [[Complexity Zoo:R#rp|RP]] ===== Same as [[#deltabpp|&#948;-BPP]], but for [[Complexity Zoo:R#rp|RP]] instead of [[Complexity Zoo:B#bpp|BPP]]. For any &#948;&gt;0, &#948;-RP = [[Complexity Zoo:R#rp|RP]] [[zooref#vv85|[VV85]]]. ---- ===== <span id="det" style="color:red">DET</span>: Determinant ===== The class of decision problems reducible in [[Complexity Zoo:L#l|L]] to the problem of computing the determinant of an n-by-n matrix of n-bit integers. Defined in [[zooref#coo85|[Coo85]]]. Contained in [[Complexity Zoo:N#nc2|NC<sup>2</sup>]], and contains [[Complexity Zoo:N#nl|NL]] and [[Complexity Zoo:P#pl|PL]] [[zooref#bcp83|[BCP83]]]. [[Complexity_Garden#graph_isomorphism|Graph isomorphism]] is hard for DET under [[Complexity Zoo:L#l|L]]-reductions [[zooref#tor00|[Tor00]]]. ---- ===== <span id="diffac0" style="color:red">DiffAC<sup>0</sup></span>: Difference [[Complexity Zoo:Symbols#sharpac0|#AC<sup>0</sup>]] ===== The class of functions from {0,1}<sup>n</sup> to integers expressible as the difference of two [[Complexity Zoo:Symbols#sharpac0|#AC<sup>0</sup>]] functions. Equals [[Complexity Zoo:G#gapac0|GapAC<sup>0</sup>]] under logspace uniformity [[zooref#abl98|[ABL98]]]. ---- ===== <span id="disnp" style="color:red">DisNP</span>: Disjoint [[Complexity Zoo:N#np|NP]] Pairs ===== The class of pairs (A,B), where A and B are [[Complexity Zoo:N#np|NP]] problems whose sets of "yes" instances are nonempty and disjoint. If there exists an optimal propositional proof system, then DisNP has a complete pair [[zooref#raz94|[Raz94]]]. On the other hand, there exists an oracle relative to which DisNP does not have a complete pair [[zooref#gss03|[GSS+03]]]. If [[Complexity Zoo:P#p|P]] does not equal [[Complexity Zoo:U#up|UP]], then DisNP contains pairs not separated by any set in [[Complexity Zoo:P#p|P]] [[zooref#gs88|[GS88]]]. On the other hand, there exists an oracle relative to which [[Complexity Zoo:P#p|P]] does not equal [[Complexity Zoo:N#np|NP]] but still DisNP does not contain any [[Complexity Zoo:P#p|P]]-inseparable pairs [[zooref#hs92|[HS92]]]. ---- ===== <span id="distnp" style="color:red">DistNP</span>: Distributional [[Complexity Zoo:N#np|NP]] ===== (also called (NP,P-computable) or RNP) A <i>distributional problem</i> consists of a decision problem A, and a probability distribution &#956; over problem instances. (A,&#956;) is in DistNP if A is in [[Complexity Zoo:N#np|NP]], and &#956; is [[Complexity Zoo:P#p|P]]-computable (meaning that its cumulative density function can be evaluated in polynomial time). DistNP has complete problems [[zooref#lev86|[Lev86]]] (see also [[zooref#gur87|[Gur87]]]), although unlike for [[Complexity Zoo:N#np|NP]] this is not immediate. Any DistNP-complete problem is also complete for [[Complexity Zoo:N#nppsamp|(NP,P-samplable)]] [[zooref#il90|[IL90]]]. ---- ===== <span id="dp" style="color:red">DP</span>: Difference Polynomial-Time ===== DP = [[Complexity Zoo:B#bh|BH]]<sub>2</sub>, the second level of the Boolean hierarchy. Defined in [[zooref#py84|[PY84]]]. ---- ===== <span id="dqp" style="color:red">DQP</span>: Dynamical Quantum Polynomial-Time ===== The class of decision problems solvable by a [[Complexity Zoo:B#bqp|BQP]] machine with oracle access to a <i>dynamical simulator</i>. When given a polynomial-size quantum circuit, the simulator returns a sample from the distribution over "classical histories" induced by the circuit. The simulator can adversarially choose any history distribution that satisfies the axioms of "symmetry" and "locality" -- so that the DQP algorithm has to work for any distribution satisfying these axioms. See [[zooref#aar05|[Aar05]]] for a full definition. There it is also shown that [[Complexity Zoo:S#szk|SZK]] is contained in DQP. Contains [[Complexity Zoo:B#bqp|BQP]], and is contained in [[Complexity Zoo:E#exp|EXP]] [[zooref#aar05|[Aar05]]]. There exists an oracle relative to which DQP does not contain [[Complexity Zoo:N#np|NP]] [[zooref#aar05|[Aar05]]]. ---- ===== <span id="dspace" style="color:red">DSPACE(f(n))</span>: Deterministic f(n)-Space ===== The class of decision problems solvable by a Turing machine in space O(f(n)). The Space Hierarchy Theorem: For constructible f(n) greater than log n, DSPACE(f(n)) is strictly contained in DSPACE(f(n) log(f(n))) [[zooref#hls65|[HLS65]]]. For space constructible f(n), strictly contains [[#dtime|DTIME]](f(n)) [[zooref#hpv77|[HPV77]]]. DSPACE(n) does not equal [[Complexity Zoo:N#np|NP]] (though we have no idea if one contains the other)! See also: [[Complexity Zoo:N#nspace|NSPACE]](f(n)). ---- ===== <span id="dtime" style="color:red">DTIME(f(n))</span>: Deterministic f(n)-Time ===== The class of decision problems solvable by a Turing machine in time $O(f(n))$. Note that some authors choose to call this class TIME. Of great relevance to DTIME is the Time Hierarchy Theorem: For any constructible function $f(n)$ greater than $n$, DTIME($f(n)$) is strictly contained in DTIME($f(n) \log(f(n)) \log\log(f(n))$) [[zooref#hs65|[HS65]]]. As a corollary, {{zcls|p|p}} &sub; {{zcls|e|exp}}. For any space constructible $f(n)$, DTIME($f(n)$) is strictly contained in DSPACE($f(n)$) [[zooref#hpv77|[HPV77]]]. Also, DTIME($n$) is strictly contained in [[Complexity Zoo:N#ntime|NTIME($n$)]] [[zooref#pps83|[PPS+83]]] (this result does not work for arbitrary $f(n)$). For any constructible superpolynomial $f(n)$, DTIME($f(n)$) with [[Complexity Zoo:P#pp|PP]] oracle is not in [[Complexity Zoo:P#ppoly|P/poly]] (see [[zooref#all96|[All96]]]). ---- ===== <span id="dtisp" style="color:red">DTISP(t(n),s(n))</span>: Simultaneous t(n)-Time and s(n)-Space ===== The class of decision problems solvable by a Turing machine that uses time O(t(n)) and space O(s(n)) simultaneously. Thus [[Complexity Zoo:S#sc|SC]] = DTISP(poly,polylog) for example. Defined in [[zooref#nis92|[Nis92]]], where it was also shown that for all space-constructible s(n)=&Omega;(log n), [[Complexity Zoo:B#bpspace|BPSPACE(s(n))]] is contained in DTISP(2<sup>O(s(n))</sup>,s<sup>2</sup>(n)). ---- ===== <span id="dynfo" style="color:red">Dyn-FO</span>: Dynamic [[Complexity Zoo:F#fo|FO]] ===== The class of <i>dynamic</i> problems solvable using first-order predicates. Basically what this means is that an algorithm maintains some polynomial-size data structure (say a graph), and receives a sequence of updates (add this edge, delete that one, etc.). For each update, it computes a new value for the data structure in [[Complexity Zoo:F#fo|FO]] -- that is, for each bit of the data structure, there is an [[Complexity Zoo:F#fo|FO]] function representing the new value of that bit, which takes as input both the update and the previous value of the data structure. At the end the algorithm needs to answer some question (i.e. is the graph connected?). See [[zooref#hi02|[HI02]]] for more information, and a complete problem for Dyn-FO. See also [[#dynthc0|Dyn-ThC<sup>0</sup>]]. ---- ===== <span id="dynthc0" style="color:red">Dyn-ThC<sup>0</sup></span>: Dynamic Threshold Circuits ===== Same as [[#dynfo|Dyn-FO]], except that now updates are computed via constant-depth predicates that have "COUNT" available, in addition to AND, OR, and NOT -- so it's a uniform version of [[Complexity Zoo:T#tc0|TC<sup>0</sup>]] rather than of [[Complexity Zoo:A#ac0|AC<sup>0</sup>]]. See [[zooref#hi02|[HI02]]] for more information. Complexity Zoo:E 3559 15274 2011-08-23T15:36:32Z Cosenal 1840 /* k-EQBP: Width-k Polynomial-Time Exact Quantum Branching Programs */ __NOTOC__ {{CZ-Letter-Menu|E}} ===== <span id="e" style="color:red">E</span>: Exponential Time With Linear Exponent ===== Equals [[Complexity Zoo:D#dtime|DTIME]](2<sup>O(n)</sup>). Does not equal [[Complexity Zoo:N#np|NP]] [[zooref#boo72|[Boo72]]] or [[Complexity Zoo:P#pspace|PSPACE]] [[zooref#boo74|[Boo74]]] relative to any oracle. However, there is an oracle relative to which E is contained in [[Complexity Zoo:N#np|NP]] (see [[Complexity Zoo:Z#zpp|ZPP]]), and an oracle relative to [[Complexity Zoo:P#pspace|PSPACE]] is contained in E (by equating the former with [[Complexity Zoo:P#p|P]]). There exists a problem that is complete for E under polynomial-time Turing reductions but not polynomial-time truth-table reductions [[zooref#wat87|[Wat87]]]. Problems hard for [[Complexity Zoo:B#bpp|BPP]] under Turing reductions have measure 1 in E [[zooref#as94|[AS94]]]. It follows that, if the problems complete for E under Turing reductions do not have measure 1 in E, then [[Complexity Zoo:B#bpp|BPP]] does not equal [[#exp|EXP]]. [[zooref#it89|[IT89]]] gave an oracle relative to which E = [[Complexity Zoo:N#ne|NE]] but still there is an exponential-time binary predicate whose corresponding <i>search</i> problem is not in E. {{zcite|BF03}} gave a proof that if E = {{zcls|n|ne}}, then no sparse set is ''collapsing'', where they defined a set $A$ to be collapsing if $A\notin\mathsf{P}$ and if for all $B$ such that $A$ and $B$ are Turing reducible to each other, $A$ and $B$ are many-to-one reducible to each other. Contrast with [[#exp|EXP]]. ---- ===== <span id="ee" style="color:red">EE</span>: Double-Exponential Time With Linear Exponent ===== Equals [[Complexity Zoo:D#dtime|DTIME]](2<sup>2<sup>O(n)</sup></sup>) (though some authors alternatively define it as being equal to [[Complexity Zoo:D#dtime|DTIME]](2<sup>O(2<sup>n</sup>)</sup>)). EE = [[Complexity Zoo:B#bpe|BPE]] if and only if [[#exp|EXP]] = [[Complexity Zoo:B#bpp|BPP]] [[zooref#ikw01|[IKW01]]]. Contained in [[#eexp|EEXP]] and [[Complexity Zoo:N#nee|NEE]]. ---- ===== <span id="eee" style="color:red">EEE</span>: Triple-Exponential Time With Linear Exponent ===== Equals [[Complexity Zoo:D#dtime|DTIME]](2<sup>2<sup>2<sup>O(n)</sup></sup></sup>). In contrast to the case of [[#ee|EE]], it is not known whether EEE = [[Complexity Zoo:B#bpee|BPEE]] implies [[#ee|EE]] = [[Complexity Zoo:B#bpe|BPE]] [[zooref#ikw01|[IKW01]]]. ---- ===== <span id="eespace" style="color:red">EESPACE</span>: Double-Exponential Space With Linear Exponent ===== Equals [[Complexity Zoo:D#dspace|DSPACE]](2<sup>2<sup>O(n)</sup></sup>). Is not contained in [[Complexity Zoo:B#bqpqpoly|BQP/qpoly]] [[zooref#ny03|[NY03]]]. ---- ===== <span id="eexp" style="color:red">EEXP</span>: Double-Exponential Time ===== Equals [[Complexity Zoo:D#dtime|DTIME]](2<sup>2<sup>p(n)</sup></sup>) for p a polynomial. Also known as [[Complexity Zoo:Symbols#2exp|2-EXP]]. Contains [[#ee|EE]], and is contained in [[Complexity Zoo:N#neexp|NEEXP]]. ---- ===== <span id="eh" style="color:red">EH</span>: Exponential-Time Hierarchy With Linear Exponent ===== Has roughly the same relationship to [[#e|E]] as [[Complexity Zoo:P#ph|PH]] does to [[Complexity Zoo:P#p|P]]. More formally, EH is defined as the union of [[#e|E]], [[Complexity Zoo:N#ne|NE]], [[Complexity Zoo:N#ne|NE]]<sup>[[Complexity Zoo:N#np|NP]]</sup>, [[Complexity Zoo:N#ne|NE]] with [[#sigma2p|&#931;<sub>2</sub>P]] oracle, and so on. See [[zooref#har87|[Har87]]] for more information. If [[Complexity Zoo:C#conp|coNP]] is contained in [[Complexity Zoo:A#ampolylog|AM[polylog]]], then EH collapses to {{zcls|s|s2exppnp|S<sub>2</sub>-EXP&#149;P<sup>NP</sup>}} [[zooref#ss04|[SS04]]] and indeed [[#amexp|AM<sub>EXP</sub>]] [[zooref#pv04|[PV04]]]. On the other hand, [[Complexity Zoo:C#cone|coNE]] is contained in [[Complexity Zoo:N#nepoly|NE/poly]], so perhaps it wouldn't be so surprising if NE collapses. There exists an oracle relative to which EH does not contain [[Complexity Zoo:S#seh|SEH]] [[zooref#hem89|[Hem89]]]. EH and [[Complexity Zoo:S#seh|SEH]] are incomparable for all anyone knows. ---- ===== <span id="elementary" style="color:red">ELEMENTARY</span>: Iterated Exponential Time ===== Equals the union of [[Complexity Zoo:D#dtime|DTIME]](2<sup>n</sup>), [[Complexity Zoo:D#dtime|DTIME]](2<sup>2<sup>n</sup></sup>), [[Complexity Zoo:D#dtime|DTIME]](2<sup>2<sup>2<sup>n</sup></sup></sup>), and so on. Contained in [[Complexity Zoo:P#pr|PR]]. ---- ===== <span id="elkp" style="color:red">EL<sub>k</sub>P</span>: Extended Low Hierarchy ===== An extension of [[Complexity Zoo:L#lkp|L<sub>k</sub>P]]. The class of problems A such that [[Complexity Zoo:P#ph|&#931;<sub>k</sub>P]]<sup>A</sup> is contained in [[Complexity Zoo:P#ph|&#931;<sub>k-1</sub>P]]<sup>A,[[Complexity Zoo:N#np|NP]]</sup>. Defined in [[zooref#bbs86|[BBS86]]]. ---- ===== <span id="ep" style="color:red">EP</span>: NP with 2<sup>k</sup> Accepting Paths ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then the number of accepting paths is a power of two.</li> </ol> Contained in [[Complexity Zoo:C#cequalsp|C<sub>=</sub>P]], and in [[Complexity Zoo:M#modkp|Mod<sub>k</sub>P]] for any odd k. Contains [[Complexity Zoo:U#up|UP]]. Defined in [[zooref#bhr00|[BHR00]]]. ---- ===== <span id="eptas" style="color:red">EPTAS</span>: Efficient Polynomial-Time Approximation Scheme ===== The class of optimization problems such that, given an instance of length n, we can find a solution within a factor 1+&epsilon; of the optimum in time f(&epsilon;)p(n), where p is a polynomial and f is arbitrary. Contains [[Complexity Zoo:F#fptas|FPTAS]] and is contained in [[Complexity Zoo:P#ptas|PTAS]]. Defined in [[zooref#ct97|[CT97]]], where the following was also shown: <ul> <li>If [[Complexity Zoo:F#fpt|FPT]] = [[Complexity Zoo:X#xpuniform|XP<sub>uniform</sub>]] then EPTAS = [[Complexity Zoo:P#ptas|PTAS]].</li> <li>If EPTAS = [[Complexity Zoo:P#ptas|PTAS]] then [[Complexity Zoo:F#fpt|FPT]] = [[Complexity Zoo:W#wp|W[P]]].</li> <li>If [[Complexity Zoo:F#fpt|FPT]] is strictly contained in [[Complexity Zoo:W#w1|W]], then there is a natural problem that is in [[Complexity Zoo:P#ptas|PTAS]] but not in EPTAS. (See [[zooref#ct97|[CT97]]] for the statement of the problem, since it's not <i>that</i> natural.)</li> </ul> ---- ===== <span id="eqbp" style="color:red">k-EQBP</span>: Width-k Polynomial-Time Exact Quantum Branching Programs ===== See k-[[Complexity Zoo:P#kpbp|PBP]] for the definition of a classical branching program. A quantum branching program is the natural quantum generalization: we have a quantum state in a Hilbert space of dimension k. Each step t consists of applying a unitary matrix U<sup>(t)</sup>(x<sub>i</sub>): that is, U<sup>(t)</sup> depends on a single bit x<sub>i</sub> of the input. (So these are the quantum analogues of so-called <i>oblivious</i> branching programs.) In the end we measure to decide whether to accept; there must be zero probability of error. Defined in [[zooref#amp02|[AMP02]]], where it was also shown that [[Complexity Zoo:N#nc1|NC<sup>1</sup>]] is contained in 2-EQBP. k-BQBP can be defined similarly. ---- ===== <span id="eqp" style="color:red">EQP</span>: Exact Quantum Polynomial-Time ===== The same as [[Complexity Zoo:B#bqp|BQP]], except that the quantum algorithm must return the correct answer with probability 1, and run in polynomial time with probability 1. Unlike bounded-error quantum computing, there is no theory of universal QTMs for exact quantum computing models. In the original definition in [[zooref#bv97|[BV97]]], each language in EQP is computed by a single QTM, equivalently to a uniform family of quantum circuits with a finite gate set K whose amplitudes can be computed in polynomial time. See [[#eqpk|EQP<sub>K</sub>]]. However, some results require an infinite gate set. The official definition here is that the gate set should be finite. Without loss of generality, the amplitudes in the gate set K are algebraic numbers [[zooref#adh97|[ADH97]]]. There is an oracle that separates EQP from [[Complexity Zoo:N#np|NP]] [[zooref#bv97|[BV97]]], indeed from [[Complexity Zoo:D#delta2p|&#916;<sub>2</sub>P]] [[zooref#gp01|[GP01]]]. There is also an oracle relative to which EQP is not in [[Complexity Zoo:M#modkp|Mod<sub>p</sub>P]] where p is prime [[zooref#gv02|[GV02]]]. On the other hand, EQP is in [[Complexity Zoo:L#lwpp|LWPP]] [[zooref#fr98|[FR98]]]. [[Complexity Zoo:P#p|P]]<sup>||[[Complexity Zoo:N#np|NP]][2k]</sup> is contained in EQP<sup>||[[Complexity Zoo:N#np|NP]][k]</sup>, where "||[[Complexity Zoo:N#np|NP]][k]" denotes k nonadaptive oracle queries to [[Complexity Zoo:N#np|NP]] (queries that cannot depend on the results of previous queries) [[zooref#bd99|[BD99]]]. See also [[Complexity Zoo:Z#zbqp|ZBQP]]. ---- ===== <span id="eqpk" style="color:red">EQP<sub>K</sub></span>: Exact Quantum Polynomial-Time with Gate Set K ===== The set of problems that can be answered by a uniform family of polynomial-sized quantum circuits whose gates are drawn from a set K, and that return the correct answer with probability 1, and run in polynomial time with probability 1, and the allowed gates are drawn from a set K. K may be either finite or countable and enumerated. If S is a ring, the union of EQP<sub>K</sub> over all finite gate sets K whose amplitudes are in the ring R can be written EQP<sub>S</sub>. Defined in [[zooref#adh97|[ADH97]]] in the special case of a finite set of 1-qubit gates controlled by a second qubit. It was shown there that transcendental gates may be replaced by algebraic gates without decreasing the size of EQP<sub>K</sub>. [[zooref#fr98|[FR98]]] show that EQP<sub>Q</sub> is in [[Complexity Zoo:L#lwpp|LWPP]]. The proof can be generalized to any finite, algebraic gate set K. The hidden shift problem for a vector space over Z/2 is in EQP<sub>Q</sub> by Simon's algorithm. The [[Complexity_Garden#discrete_logarithm|discrete logarithm]] problem over Z/p is in EQP<sub>Q-bar</sub> using infinitely many gates [[zooref#mz03|[MZ03]]]. ---- ===== <span id="eqtime" style="color:red">EQTIME(f(n))</span>: Exact Quantum f(n)-Time ===== Same as [[#eqp|EQP]], but with f(n)-time (for some constructible function f) rather than polynomial-time machines. Defined in [[zooref#bv97|[BV97]]]. ---- ===== <span id="espace" style="color:red">ESPACE</span>: Exponential Space With Linear Exponent ===== Equals [[Complexity Zoo:D#dspace|DSPACE]](2<sup>O(n)</sup>). If [[#e|E]] = ESPACE then [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:B#bpp|BPP]] [[zooref#hy84|[HY84]]]. Indeed if [[#e|E]] has nonzero measure in ESPACE then [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:B#bpp|BPP]] [[zooref#lut91|[Lut91]]]. ESPACE is not contained in [[Complexity Zoo:P#ppoly|P/poly]] [[zooref#kan82|[Kan82]]]. Is not contained in [[#bqpmpoly|BQP/mpoly]] [[zooref#ny03|[NY03]]]. See also: [[#expspace|EXPSPACE]]. ---- ===== <span id="existsbpp" style="color:red">&#8707;BPP</span>: [[Complexity Zoo:B#bpp|BPP]] With Existential Operator ===== The class of problems for which there exists a [[Complexity Zoo:B#bpp|BPP]] machine M such that, for all inputs x, <ul> <li>If the answer is "yes" then there exists a y such that M(x,y) accepts.</li> <li>If the answer is "no" then for all y, M(x,y) rejects.</li> </ul> Alternatively defined as NP<sup>BPP</sup>. Contains [[Complexity Zoo:N#np|NP]] and [[Complexity Zoo:B#bpp|BPP]], and is contained in [[Complexity Zoo:M#ma|MA]] and [[#sbp|SBP]]. &#8707;BPP seems <i>obviously</i> equal to [[Complexity Zoo:M#ma|MA]], yet [[zooref#ffk93|[FFK+93]]] constructed an oracle relative to which they're unequal! Here is the difference: if the answer is "yes," [[Complexity Zoo:M#ma|MA]] requires only that there exist a y such that for at least 2/3 of random strings r, M(x,y,r) accepts (where M is a [[Complexity Zoo:P#p|P]] predicate). For all other y's, the proportion of r's such that M(x,y,r) accepts can be arbitrary (say, 1/2). For &#8707;BPP, by contrast, the probability that M(x,y) accepts must <i>always</i> be either at most 1/3 or at least 2/3, for all y's. ---- ===== <span id="existsniszk" style="color:red">&#8707;NISZK</span>: [[Complexity Zoo:N#niszk|NISZK]] With Existential Operator ===== Contains [[Complexity Zoo:N#np|NP]] and [[Complexity Zoo:N#niszk|NISZK]], and is contained in the third level of [[Complexity Zoo:P#ph|PH]]. ---- ===== <span id="exp" style="color:red">EXP</span>: Exponential Time ===== Equals the union of [[Complexity Zoo:D#dtime|DTIME]](2<sup>p(n)</sup>) over all polynomials p. Also equals [[Complexity Zoo:P#p|P]] with [[#e|E]] oracle. If [[Complexity Zoo:L#l|L]] = [[Complexity Zoo:P#p|P]] then [[Complexity Zoo:P#pspace|PSPACE]] = EXP. If EXP is in [[Complexity Zoo:P#ppoly|P/poly]] then EXP = [[Complexity Zoo:M#ma|MA]] [[zooref#bfl91|[BFL91]]]. Problems complete for EXP under many-one reductions have measure 0 in EXP [[zooref#may94|[May94]]], [[zooref#jl95|[JL95]]]. There exist oracles relative to which <ul> <li>EXP = [[Complexity Zoo:N#np|NP]] = [[Complexity Zoo:Z#zpp|ZPP]] [[zooref#hel84|[Hel84a]]], [[zooref#hel84b|[Hel84b]]], [[zooref#kur85|[Kur85]]], [[zooref#hel86|[Hel86]]],</li> <li>EXP = [[Complexity Zoo:N#nexp|NEXP]] but still [[Complexity Zoo:P#p|P]] does not equal [[Complexity Zoo:N#np|NP]] [[zooref#dek76|[Dek76]]],</li> <li>EXP does not equal [[Complexity Zoo:P#pspace|PSPACE]] [[zooref#dek76|[Dek76]]].</li> </ul> [[zooref#bt04|[BT04]]] show the following rather striking result: let A be many-one complete for EXP, and let S be any set in [[Complexity Zoo:P#p|P]] of subexponential density. Then A-S is Turing-complete for EXP. {{zcite|SM03}} show that if EXP has circuits of polynomial size, then {{zcls|p|p}} can be simulated in {{zcls|m|mapolylog|MA<sub>POLYLOG</sub>}} such that no deterministic polynomial-time adversary can generate a list of inputs for a P problem that includes one which fails to be simulated. As a result, EXP &sube; {{zcls|m|ma}} if EXP has circuits of polynomial size. [[zooref#su05|[SU05]]] show that EXP $\not\subseteq$ [[Complexity Zoo:N#nppoly|NP/poly]] implies EXP $\not\subseteq$ [[Complexity Zoo:P#pparnp|P<sup>||NP</sup>]]/poly. In descriptive complexity EXPTIME can be defined as [[#Complexity_Zoo:S#sot|SO($2^{n^{O(1)}}$)]] which is also [[#Complexity_Zoo:F#solfp|SO(LFP)]] ---- ===== <span id="exppoly" style="color:red">EXP/poly</span>: Exponential Time With Polynomial-Size Advice ===== The class of decision problems solvable in [[#exp|EXP]] with the help of a polynomial-length advice string that depends only on the input length. Contains [[Complexity Zoo:B#bqpqpoly|BQP/qpoly]] [[zooref#aar04b|[Aar04b]]]. ---- ===== <span id="expspace" style="color:red">EXPSPACE</span>: Exponential Space ===== Equals the union of [[Complexity Zoo:D#dspace|DSPACE]](2<sup>p(n)</sup>) over all polynomials p. See also: [[#espace|ESPACE]]. Given a first-order statement about real numbers, involving only addition and comparison (no multiplication), we can decide in EXPSPACE whether it's true or not [[zooref#ber80|[Ber80]]]. Complexity Zoo:F 3560 14000 2011-07-13T05:06:06Z T. Brendan Leahy 2692 /* FO[t(n)]: Iterated First-Order logic */ __NOTOC__ {{CZ-Letter-Menu|F}} ===== <span id="fbqp" style="color:red">FBQP</span>: Function [[Complexity Zoo:B#bqp|BQP]] ===== Has the same relation to [[Complexity Zoo:B#bqp|BQP]] as [[#fnp|FNP]] does to [[Complexity Zoo:N#np|NP]]. There exists an oracle relative to which [[Complexity Zoo:P#pls|PLS]] is not contained in [[#fbqp|FBQP]] [[zooref#aar03|[Aar03]]]. ---- ===== <span id="few" style="color:red">Few</span>: [[#fewp|FewP]] With Flexible Acceptance Mechanism ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that <ol> <li>The number of accepting paths a is bounded by a polynomial in the size of the input x.</li> <li>For some polynomial-time predicate Q, Q(x,a) is true if and only if the answer is 'yes.'</li> </ol> Also called FewPaths. Defined in [[zooref#ch89|[CH89]]]. Contains [[#fewp|FewP]], and is contained in [[Complexity Zoo:P#p|P]]<sup>[[#fewp|FewP]]</sup> [[zooref#kob89|[Kob89]]] and in [[Complexity Zoo:S#spp|SPP]] [[zooref#ffk94|[FFK94]]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fewexp" style="color:red">FewEXP</span>: {{zcls|n|nexp}} With Few Witnesses ===== The class of decision problems solvable by an {{zcls|n|nexp}} machine such that, given a "yes" instance, no more than an exponential number of computation paths accept. Contained in {{zcls|m|mip}}<nowiki>[</nowiki>{{zcls|n|np}}<sup>FewEXP</sup><nowiki>]</nowiki> (MIP where provers are not unbounded in computational power, but are limited to NP<sup>FewEXP</sup>) {{zcite|AKS+94}}. Alternatively, FewEXP can refer to the sparsity of accepting paths in a given instance. In {{zcite|AKR+03}}, the authors show that the conjectures "FewEXP search instances are {{zcls|e|exp}}-solvable" and "FewEXP decision instances are EXP/poly-solvable" are equivalent. That is, for all NEXP machines $N$, the following conditions are equivalent: # There exists an EXP machine $M$ such that if given a string $x$, $N(x)$ accepts and has exponentially bounded accepting paths, then $M(x)$ produces one such path. # There exists an EXP/poly machine $M$ which accepts a string $x$ if and only $N(x)$ accepts. ---- ===== <span id="fewp" style="color:red">FewP</span>: [[Complexity Zoo:N#np|NP]] With Few Witnesses ===== The class of decision problems solvable by an [[Complexity Zoo:N#np|NP]] machine such that <ol> <li>If the answer is 'no,' then all computation paths reject.</li> <li>If the answer is 'yes,' then at least one path accepts; furthermore, the number of accepting paths is upper-bounded by a polynomial in n, the size of the input.</li> </ol> Defined in [[zooref#ar88|[AR88]]]. Is contained in [[Complexity Zoo:Symbols#parityp|&#8853;P]] [[zooref#ch89|[CH89]]]. There exists an oracle relative to which [[Complexity Zoo:P#p|P]], [[Complexity Zoo:U#up|UP]], FewP, and [[Complexity Zoo:N#np|NP]] are all distinct [[zooref#rub88|[Rub88]]]. Also, there exists an oracle relative to which FewP does not have a Turing-complete set [[zooref#hjv93|[HJV93]]]. Contained in [[#few|Few]]. See also the survey [[zooref#tor90|[Tor90]]]. ---- ===== <span id="fh" style="color:red">FH</span>: Fourier Hierarchy ===== FH<sub>k</sub> is the class of problems solvable by a uniform family of polynomial-size quantum circuits, with k levels of Hadamard gates and all other gates preserving the computational basis. (Conditional phase flip gates are fine, for example.) Thus <ul> <li>FH<sub>0</sub> = [[Complexity Zoo:P#p|P]]</li> <li>FH<sub>1</sub> = [[Complexity Zoo:B#bpp|BPP]]</li> <li>FH<sub>2</sub> contains [[Complexity_Garden#integer_factorization|factoring]] because of Kitaev's phase estimation algorithm</li> </ul> It is an open problem to show that the Fourier hierarchy is infinite relative to an oracle (that is, FH<sub>k</sub> is strictly contained in FH<sub>k+1</sub>). Defined in [[zooref#shi03|[Shi03]]]. ---- ===== <span id="fixp" style="color:red">FIXP</span>: Fixed Point ===== The class of fixed point problems. In the framework of fixed point problems, an instance I is associated with a (continuous) function F<sub>I</sub>, and a solution of I is a fixed point of F<sub>I</sub>. Properties of FIXP problems: <ol> <li> the function F<sub>I</sub> is represented by an algebraic circuit over {+, -, *, /, max, min} with rational constants <li> there is a polynomial time algorithm that computes the circuit from I. </ol> Every FIXP problem has Partial Computation, Decision, (Strong) Approximation, and Existence counterparts; these can all be solved in PSPACE. The Nash equilibrium problem for 3 or more players is FIXP-complete. Linear-FIXP = PPAD. Defined in [[zooref#ey07|[EY07]]]. ---- ===== <span id="fnl" style="color:red">FNL</span>: Function [[Complexity Zoo:N#nl|NL]] ===== Has the same relation to [[Complexity Zoo:N#nl|NL]] as [[#fnp|FNP]] does to [[Complexity Zoo:N#np|NP]]. Defined by [[zooref#aj93|[AJ93]]], who also showed that if [[Complexity Zoo:N#nl|NL]] = [[Complexity Zoo:U#ul|UL]], then FNL is contained in [[Complexity Zoo:Symbols#sharpl|#L]]. ---- ===== <span id="fnlpoly" style="color:red">FNL/poly</span>: Nonuniform [[#fnl|FNL]] ===== Has the same relation to [[#fnl|FNL]] as [[Complexity Zoo:P#ppoly|P/poly]] does to [[Complexity Zoo:P#p|P]]. Contained in [[Complexity Zoo:Symbols#sharplpoly|#L/poly]] [[zooref#ra00|[RA00]]]. ---- ===== <span id="fnp" style="color:red">FNP</span>: Function [[Complexity Zoo:N#np|NP]] ===== The class of function problems of the following form: <ul> Given an input x and a polynomial-time predicate F(x,y), if there exists a y satisfying F(x,y) then output any such y, otherwise output 'no.' </ul> FNP generalizes [[Complexity Zoo:N#np|NP]], which is defined in terms of decision problems only. Actually the word "function" is misleading, since there could be many valid outputs y. That's unavoidable, since given a predicate F there's no "syntactic" criterion ensuring that y is unique. [[#fp|FP]] = FNP if and only if [[Complexity Zoo:P#p|P]] = [[Complexity Zoo:N#np|NP]]. Contains [[Complexity Zoo:T#tfnp|TFNP]]. A basic question about FNP problems is whether they're <i>self-reducible</i>; that is, whether they reduce to the corresponding [[Complexity Zoo:N#np|NP]] decision problems. Although this is true for all [[Complexity Zoo:N#npc|NPC]] problems, [[zooref#bg94|[BG94]]] shows that if [[Complexity Zoo:E#ee|EE]] does not equal [[Complexity Zoo:N#nee|NEE]], then there is a problem in [[Complexity Zoo:N#np|NP]] such that <i>no</i> corresponding FNP problem can be reduced to it. [[zooref#bg94|[BG94]]] cites Impagliazzo and Sudan as giving the same conclusion under the assumption that [[Complexity Zoo:N#ne|NE]] does not equal [[Complexity Zoo:C#cone|coNE]]. ---- ===== <span id="fo" style="color:red">FO</span>: First-Order logic ===== First order logic is the smallest logical class of logic language. It is the base of [[zooref#imm98|Descriptive complexity]] and equal to the class [[Complexity_Zoo:A#AC|AC<sup>0</sup>]] and to [[Complexity_Zoo:A#AH|AH]], the alternating logtime hierarchy. When we use logic formalism, the input is a structure, usually it is either strings (of bits or over an alphabet) whose elements are position of the strings, or graphs whose elements are vertices. The mesure of the input will there be the size of the structure. Whatever the structure is, we can suppose that there are relation that you can test, by example $E(x,y)$ is true iff there is an edge from $x$ to $y$ if the structure is a graph, and $P(n)$ is true iff the nth letter of the string is 1. We also have constant, who are special elements of the structure, by example if we want to check reachability in a graph, we will have to choose two constant s and t. In descriptive complexity we almost always suppose that there is a total order over the elements and that we can check equality between elements. This let us consider elements as number, $x$ is the number $n$ iff there is $(n-1)$ elements $y$ such that $y<x$. Thanks to this we also want the primitive "bit", where $bit(x,y)$ is true if only the $y$th bith of $x$ is 1. (We can replace $bit$ by plus and time, ternary relation such that $plus(x,y,z)$ is true iff $x+y=z$ and $times(x,y,z)$ is true iff $x*y=z$). Since in a computer elements are only pointers or string of bit, thoses assumptions make sens, and those primitive function can be calculated in most of the small complexity classes. We can also imagine FO without those primitives, which gives us smaller complexity classes. The language FO is then defined as the closure by conjunction ( $\wedge$), negation ($\neg$) and universal quantification ($\forall$) over element of the structures. We also often use existantial quantification ($\exists$) and disjunction ($\vee$) but those can be defined thanks to the 3 first symbols. The semantics of the formulae in FO is straightforward, $\neg A$ is true iff $A$ is false, $A\wedge B$ is true iff $A$ is true and $B$ is true, and ($\forall x P$) is true iff whatever element we decide that $x$ is we can choose, $P$ is true. A querie in FO will then be to check if a FO formulae is true over a given structure, this structure is the input of the problem. One should not confuse this kind of problem with checking if a quantified boolean formula is true, which is the definition of QBF, which is [[Complexity_Zoo:P#PSPACE|Pspace]]-complete. The difference between those two problem is that in QBF the size of the problem is the size of the formula and elements are just boolean value, whereas in FO the size of the problem is the size of the structure and the formula is fixed. Every formulae is equivalent to a formulae in prenexe normal form where we put recursively every quantifier and then a quantifier-free formulae. ---- ===== <span id="fodtc" style="color:red">FO(DTC)</span>: First-order with deterministic transitive closure ===== FO(DTC) is defined as [[#Complexity_Zoo:F#fotc|FO(tc)]] where the transitive closure operator is deterministic, which means that when we apply DTC($\phi_{u,v}$), we know that for all $u$, there exist at most one $v$ such that phi(u,v). We can suppose that DTC($\phi_{u,v}$) is syntactic sugar for TC($\psi_{u,v}$) where $\psi(u,v)=\phi(u,v)\wedge \forall x, (x=v \vee \neg \psi(u,x))$. It was shown in [[zooref#imm99|[Imm99]]] page 144 that this class is equal to [[#Complexity_Zoo:L#L|L]]. ---- ===== <span id="folfp" style="color:red">FO(LFP)</span>: First-order with least fixed point ===== FO(LFP) is the set of boolean queries definable with [[#Complexity_Zoo:S#fopfp|first-order fixed-point]] formulae where the partial fixed point is limited to be monotone, which means that if the second order variable is $P$, then $P_i(x)$ always implies $P_{i+1}(x)$. We can obtain the monotony by restricting the formula $\phi$ to have only positive occurrences of $P$ (i.e. there is an even number of negations before every occurrence of $P$). We can also describe LFP($\phi_{P,x}$) as syntactic sugar of PFP($\psi_{P,x}$) where $\psi(P,x)=\phi(P,x)\vee P(x)$. Thanks to monotonicity we only add and never remove vectors to the truth table of $P$, and since there is only $n^k$ possible vectors we always find a fixed point before $n^k$ iterations. Hence it was shown in [[zooref#imm82|[Imm82]]] that FO(LFP)=P. This definition is equivalent to [[Complexity_Zoo:F#fot|FO($n^{O(1)}$)]]. ---- ===== <span id="fopfp" style="color:red">FO(PFP)</span>: First-order with partial fixed point ===== FO(pfp) is the set of boolean queries definable with [[#Complexity_Zoo:S#FO|first-order]] formulae with a partial fixed point operator. Let $k$ be an integer, $x, y$ vectors of $k$ variables, $P$ a second-order variable of arity $k$, and $\phi$ a FO(PFP) function using $x$ and $P$ as variables, then we can define iteratively $(P_i)_{i\in N}$ such that $P_0(x)=false$ and [itex]P_i(x)=\phi(P_{i-1},x)</mat