{
  "id": "complexity-class",
  "title": "Complexity Class",
  "lang": "en",
  "source_lang": "en",
  "summary": "A complexity class groups computational problems by the resources and computational models required to solve them.",
  "category": "computer-science",
  "subcategory": "algorithms-theory",
  "type": "concept",
  "aliases": [
    "Computational complexity class"
  ],
  "generated_at": "2026-11-04",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/complexity-class/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/complexity-class/",
      "json": "https://aiwiki.page/zh/complexity-class.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "A complexity class is a collection of computational problems defined by limits on the resources needed to solve them, together with the model of computation and the conditions for a correct answer. Resources commonly include running time, working memory, random bits, communication, and quantum operations. In computational complexity theory, classes provide a framework for comparing problems independently of particular programs or machines. Familiar examples include P, the class of decision problems solvable in deterministic polynomial time, and NP, the class whose positive answers have certificates verifiable in polynomial time.\n\nComplexity classes describe problems rather than individual algorithms. Showing that one algorithm is slow does not establish that its problem is intrinsically difficult: a different algorithm might be much faster. Membership in a class supplies an upper bound on the resources required, while lower bounds and separation theorems establish limits on what particular computational models can accomplish.\n\nThe relationships among classes organize much of theoretical computer science. Some are theorems, such as the equality of nondeterministic and deterministic polynomial space; others, especially the P versus NP problem, remain unresolved. The framework also extends beyond exact yes-or-no questions to counting, search, approximation, randomized computation, and quantum computation."
    },
    {
      "heading": "Formal foundations and historical development",
      "text": "Most standard complexity classes are defined using decision problems, whose answers are either yes or no. An instance is encoded as a finite string over an alphabet, usually \\(\\{0,1\\}\\). A decision problem is identified with the formal language consisting of its yes-instances. For example, the language of satisfiable Boolean formulas contains precisely those formula encodings for which some assignment makes the formula true. This representation allows problems about graphs, integers, logical formulas, and programs to be compared within a common mathematical framework.\n\nA computational model specifies the permitted operations and how their cost is measured. The Turing machine is the traditional reference model, although random-access machines and Boolean circuits are also central. For an input string \\(x\\), its length \\(n=|x|\\) measures the amount of encoded information. A time bound counts computational steps; a space bound counts working storage. In sublinear-space models, the input normally occupies a read-only tape that is not charged to the working-space budget. Otherwise, merely storing the input would prevent any nontrivial logarithmic-space computation.\n\nEncoding matters because complexity is measured against input length, not the numerical magnitude of an object. An integer \\(N\\) requires approximately \\(\\log_2 N\\) bits in binary but \\(N\\) symbols in unary. An algorithm taking time proportional to \\(N\\) may therefore be exponential in the binary input length. By contrast, reasonable encodings of explicitly represented graphs usually translate into one another with polynomial overhead. This helps make polynomial-time classifications robust, while leaving finer distinctions sensitive to the computational model and representation.\n\nThe modern framework emerged in the 1960s. In 1965, Juris Hartmanis and Richard Stearns published foundational work on the computational complexity of algorithms, including time hierarchies. Alan Cobham and Jack Edmonds independently helped establish polynomial time as a mathematical expression of efficient computation. Stephen Cook’s 1971 work and Leonid Levin’s independent work established the central completeness phenomenon for nondeterministic polynomial time. Richard Karp’s 1972 reductions connected this theory to a broad range of combinatorial problems.\n\nClasses are mathematical sets of problems, not performance ratings for software. A classification usually concerns arbitrarily large inputs and worst-case behavior. It abstracts away hardware speed, implementation quality, and many properties of naturally occurring instances. These abstractions make general theorems possible, but they also explain why a theoretical classification alone does not predict the running time of a particular application."
    },
    {
      "heading": "Deterministic time classes",
      "text": "For a function \\(t(n)\\), the class \\(\\mathrm{DTIME}(t(n))\\) contains languages decidable by a deterministic machine within \\(O(t(n))\\) steps, under a specified machine convention. The best-known deterministic time class is\n\n\\[\\mathrm{P}=\\bigcup_{k\\geq 1}\\mathrm{DTIME}(n^k).\\]\n\nThe union permits each problem to have its own fixed polynomial exponent. It does not permit the exponent to grow with the input. An algorithm taking \\(n^{100}\\) steps is polynomial-time in this formal sense, even though it would be impractical for most inputs.\n\nMany fundamental computational tasks have polynomial-time algorithms. The decision version of the shortest-path problem, asking whether a path of cost at most a given bound exists, is in P. Primality testing is another example: the deterministic polynomial-time algorithm of Manindra Agrawal, Neeraj Kayal, and Nitin Saxena, announced in 2002, established that deciding primality belongs to P without relying on unproved number-theoretic assumptions. These examples illustrate why a class concerns the existence of some suitable algorithm, not the historical difficulty of finding one.\n\nLarger deterministic time classes distinguish different scales of growth. Two important examples are\n\n\\[\\mathrm{EXP}=\\bigcup_{k\\geq 1}\\mathrm{DTIME}(2^{n^k}), \\qquad \\mathrm{E}=\\bigcup_{c\\geq 1}\\mathrm{DTIME}(2^{cn}).\\]\n\nThus E uses a linear exponent, while EXP permits any fixed polynomial in the exponent. These classes should not be confused with the informal category “exponential-time algorithm,” which is sometimes used less precisely. Similarly, quasipolynomial time, typically written \\(n^{(\\log n)^{O(1)}}\\), occupies an intermediate growth range between polynomial time and many familiar exponential bounds.\n\nThe time hierarchy theorem proves that sufficiently greater time resources permit the solution of additional problems. One standard formulation gives a strict separation between \\(\\mathrm{DTIME}(t_1(n))\\) and \\(\\mathrm{DTIME}(t_2(n))\\) when the bounds satisfy suitable constructibility conditions and\n\n\\[t_1(n)\\log t_1(n)=o(t_2(n)).\\]\n\nThe proof uses diagonalization: a machine simulates candidate machines with smaller time budgets and arranges to disagree with them on selected inputs. Consequently, P is strictly contained in EXP.\n\nThis theorem establishes a genuine hierarchy without identifying the exact complexity of every natural problem. It also does not settle comparisons involving different computational modes, such as deterministic versus nondeterministic polynomial time. The central distinction is between gaining more of the same resource and changing what a computational step is allowed to represent."
    },
    {
      "heading": "Nondeterminism, verification, and completeness",
      "text": "A nondeterministic computation may branch into multiple possible continuations. It accepts an input if at least one branch accepts. This is a mathematical acceptance rule, not a claim that ordinary hardware can explore exponentially many branches at no cost. The class NP consists of languages decidable by nondeterministic machines in polynomial time. Equivalently, a language \\(L\\) is in NP if there are a polynomial \\(p\\) and a polynomial-time verifier \\(V\\) such that\n\n\\[x\\in L \\quad\\Longleftrightarrow\\quad \\exists y,\\ |y|\\leq p(|x|),\\ V(x,y)=1.\\]\n\nThe string \\(y\\) is a certificate or witness. For the Boolean satisfiability problem, a satisfying assignment is such a certificate. For the Hamiltonian-cycle problem, a proposed ordering of the vertices can be checked efficiently to determine whether it describes a cycle visiting every vertex exactly once. The distinction is between finding a witness and checking a supplied witness. The definition does not imply that every no-instance has a comparably short certificate.\n\nA polynomial-time many-one reduction from a language \\(A\\) to a language \\(B\\) is a polynomial-time computable function \\(f\\) satisfying\n\n\\[x\\in A\\quad\\Longleftrightarrow\\quad f(x)\\in B.\\]\n\nSuch a reduction shows that an algorithm for \\(B\\) can solve \\(A\\) after efficient preprocessing. A problem is NP-hard if every problem in NP reduces to it, and NP-complete if it is both NP-hard and a member of NP. NP-completeness therefore combines a lower-bound comparison with an upper-bound membership statement. NP-hardness alone does not imply decidability or membership in NP.\n\nThe Cook–Levin theorem establishes that Boolean satisfiability is NP-complete. Karp’s subsequent reductions showed that problems including clique, vertex cover, and Hamiltonian cycle are NP-complete. These results explain how superficially different combinatorial tasks can share the same polynomial-time solvability status. If any NP-complete problem belongs to P, then P equals NP.\n\nThe class coNP consists of complements of NP languages. Unsatisfiability is coNP-complete: a formula is a yes-instance precisely when no satisfying assignment exists. Whether NP equals coNP remains open. More generally, the polynomial hierarchy organizes polynomial-time predicates with a fixed number of alternating existential and universal quantifier blocks. Its first existential level is NP and its first universal level is coNP. If P equals NP, the entire hierarchy collapses to P; other equalities between levels also have substantial structural consequences."
    },
    {
      "heading": "Space classes and alternating computation",
      "text": "Space measures how much working memory a computation uses, rather than how many steps it takes. The principal deterministic classes include L, consisting of problems solvable in logarithmic space, and PSPACE, consisting of problems solvable in polynomial space. Their nondeterministic counterparts include NL and NPSPACE. Time and space differ because working memory can be reused repeatedly: a polynomial-space computation may run for exponentially many steps while revisiting and updating a bounded collection of storage locations.\n\nThe standard chain of containments is\n\n\\[\\mathrm{L}\\subseteq\\mathrm{NL}\\subseteq\\mathrm{P} \\subseteq\\mathrm{NP}\\subseteq\\mathrm{PSPACE}\\subseteq\\mathrm{EXP}.\\]\n\nA deterministic polynomial-space decider has at most exponentially many distinct configurations. Since a halting deterministic computation cannot repeat a configuration, its running time is bounded by the number of configurations. This explains the final containment. None of the adjacent containments displayed here is known to be strict, although other theorems imply that not all of them can be equalities.\n\nSavitch’s theorem, proved by Walter Savitch in 1970, states that for suitable space bounds \\(s(n)\\geq\\log n\\),\n\n\\[\\mathrm{NSPACE}(s(n)) \\subseteq \\mathrm{DSPACE}(s(n)^2).\\]\n\nIts recursive reachability procedure asks whether one configuration can reach another within a bounded number of steps, guessing a midpoint by deterministic enumeration and recursively checking both halves. The recursion saves space by avoiding storage of an entire computation path, at the expense of potentially large running time. A major consequence is \\(\\mathrm{NPSPACE}=\\mathrm{PSPACE}\\).\n\nDirected graph reachability is NL-complete under logarithmic-space reductions. Undirected reachability belongs to L, as established by Omer Reingold in work first presented in 2005. Another important result, proved independently by Neil Immerman and Róbert Szelepcsényi in 1987, is \\(\\mathrm{NL}=\\mathrm{coNL}\\). Thus nondeterministic logarithmic space is closed under complement, unlike NP, for which the corresponding equality remains unresolved.\n\nAn alternating Turing machine has existential and universal states. An existential state accepts if some successor accepts; a universal state accepts if every successor accepts. Alternating polynomial time equals PSPACE, and alternating polynomial space equals EXP. The truth problem for fully quantified Boolean formulas is PSPACE-complete because a sequence of existential and universal variable choices naturally represents this acceptance structure. The connection also explains why generalized games, planning problems, and logical verification tasks frequently lead to space complexity classes."
    },
    {
      "heading": "Randomized classes and derandomization",
      "text": "A randomized algorithm makes choices according to random bits. Its complexity class depends not only on its resource bound but also on its permitted error. BPP consists of decision problems for which a polynomial-time randomized algorithm gives the correct answer with probability at least \\(2/3\\) on every input. The constant \\(2/3\\) is conventional: independent repetition followed by majority vote reduces the error exponentially while increasing the running time by only a polynomial factor.\n\nOne-sided error defines RP and coRP. For RP, no-instances are always rejected, while yes-instances are accepted with probability at least \\(1/2\\). For coRP, yes-instances are always accepted, while no-instances are rejected with probability at least \\(1/2\\). ZPP consists of problems solvable with zero error in expected polynomial time and satisfies\n\n\\[\\mathrm{ZPP}=\\mathrm{RP}\\cap\\mathrm{coRP}.\\]\n\nExpected polynomial time differs from a polynomial bound on every execution: a zero-error algorithm may occasionally take much longer, provided its expected running time remains polynomial.\n\nPolynomial identity testing is a standard example of randomized computation. Given an arithmetic circuit, the problem asks whether the polynomial it computes is identically zero. Over an appropriate field, evaluating the circuit at randomly chosen points can detect a nonzero polynomial with high probability. The resulting procedure has one-sided error: an identically zero polynomial always evaluates to zero. General efficient deterministic identity testing remains closely connected to major questions about arithmetic circuits.\n\nSome containments follow directly from the definitions. P is contained in BPP, and RP is contained in NP because an accepting random string can serve as a certificate. BPP is contained in the second existential and universal levels of the polynomial hierarchy. Whether P equals BPP remains open. The question asks whether randomness provides an asymptotic advantage for polynomial-time decision computation, rather than whether randomized algorithms are convenient or fast in practice.\n\nDerandomization studies how to replace random choices with deterministic constructions. A pseudorandom generator for this purpose must fool a specified family of computational tests, a stronger and more targeted requirement than merely producing numbers with plausible statistical properties. Hardness-versus-randomness results show that sufficiently strong lower bounds for explicit computational problems imply efficient pseudorandom generators. A celebrated result of Russell Impagliazzo and Avi Wigderson connects exponential circuit hardness for a problem in E with the equality P = BPP. Such results reveal an unexpected dependence: proving that some computations are difficult can establish that randomness is unnecessary for other computations."
    },
    {
      "heading": "Counting, majority acceptance, and interactive proofs",
      "text": "Decision classes record whether an acceptable solution exists. Counting complexity asks how many solutions exist. Leslie Valiant introduced the class \\(\\#\\mathrm{P}\\) in 1979. A function belongs to \\(\\#\\mathrm{P}\\) if its value on an input equals the number of accepting paths of a polynomial-time nondeterministic machine. Counting satisfying assignments of a Boolean formula is a basic example. Unlike P or NP, \\(\\#\\mathrm{P}\\) is a class of functions, not a class of languages.\n\nCounting may remain difficult even when existence is easy to decide. A perfect matching in a bipartite graph can be found in polynomial time, yet counting such matchings is \\(\\#\\mathrm{P}\\)-complete under standard counting reductions. For a zero–one matrix, this count equals its permanent,\n\n\\[\\operatorname{perm}(A)= \\sum_{\\pi\\in S_n}\\prod_{i=1}^{n}a_{i,\\pi(i)}.\\]\n\nThe formula resembles that of the determinant but lacks alternating signs. Valiant proved the \\(\\#\\mathrm{P}\\)-completeness of computing the permanent for zero–one matrices, making it a central example of the distinction between algebraic expressions that look similar and computations that have very different known complexity.\n\nPP is a decision class based on majority acceptance. A language belongs to PP if a polynomial-time probabilistic machine accepts yes-instances with probability strictly greater than \\(1/2\\) and accepts no-instances with probability at most \\(1/2\\). Unlike BPP, PP need not have a fixed gap around \\(1/2\\); the advantage may be exponentially small. Repetition therefore does not generally turn a PP computation into a bounded-error polynomial-time algorithm. Toda’s theorem, proved in 1991, states that the entire polynomial hierarchy is contained in \\(\\mathrm{P}^{\\#\\mathrm{P}}\\), where a polynomial-time machine may make queries to a \\(\\#\\mathrm{P}\\) function oracle.\n\nAn interactive proof system allows a computationally bounded verifier to exchange messages with a computationally unrestricted prover. Completeness requires that true statements can be accepted with high probability by interaction with an appropriate prover. Soundness requires that false statements remain unlikely to be accepted regardless of the prover’s strategy. The class IP permits polynomial-time randomized verification and polynomially many communication rounds.\n\nAdi Shamir’s 1992 theorem established \\(\\mathrm{IP}=\\mathrm{PSPACE}\\). Its proof uses arithmetization, translating logical statements into polynomial identities that can be checked through randomized interaction. This extends verification beyond the single static certificate used to define NP. Separately, the probabilistically checkable proofs theorem characterizes NP through verifiers that use logarithmically many random bits and inspect only constantly many proof positions. These results connect complexity classes to proof structure, error detection, and the difficulty of approximation."
    },
    {
      "heading": "Circuits, nonuniformity, and parallel computation",
      "text": "A Boolean circuit computes a function using gates such as AND, OR, and NOT connected without directed cycles. Its size measures the number of gates, while its depth measures the longest input-to-output dependency chain. A circuit family supplies one circuit \\(C_n\\) for each input length \\(n\\). This differs from an ordinary algorithm, which uses one finite program for inputs of every length.\n\nThe class \\(\\mathrm{P}/\\mathrm{poly}\\) consists of languages with polynomial-size circuit families. Its definition is nonuniform: it does not require an efficient procedure for constructing \\(C_n\\) from \\(n\\). Equivalently, a polynomial-time machine may receive an advice string of polynomial length that depends only on the input length. Because arbitrary information can be encoded into this sequence of advice strings, \\(\\mathrm{P}/\\mathrm{poly}\\) contains some undecidable languages. It is therefore not simply a faster-machine version of P.\n\nUniformity conditions limit how circuit families are generated. Logarithmic-space uniformity, for example, requires a logarithmic-space procedure to produce the circuit description. Such restrictions make circuit classes correspond more closely to effective algorithms. NC consists of problems solvable by uniform polynomial-size circuits of polylogarithmic depth with bounded-fan-in gates. It formalizes efficient parallel computation using polynomially many processors and a small number of synchronized stages. Whether P equals NC remains open.\n\nP-complete problems are the hardest problems in P under an appropriately weak reduction, commonly a logarithmic-space many-one reduction. Circuit value, which asks for the output of a supplied Boolean circuit on specified inputs, is P-complete. If a P-complete problem belonged to standard uniform NC, then P would equal NC. This is a conditional obstacle to highly efficient parallelization, not a theorem that such problems cannot benefit from parallel hardware.\n\nCircuit complexity also studies restricted gate sets and depth bounds. The class \\(\\mathrm{AC}^0\\) permits polynomial-size circuits of constant depth using unbounded-fan-in AND and OR gates, together with NOT gates. Parity cannot be computed by polynomial-size \\(\\mathrm{AC}^0\\) circuits, a major lower-bound result established in the 1980s. Allowing threshold gates yields \\(\\mathrm{TC}^0\\), which can compute parity and many arithmetic functions efficiently. These separations demonstrate the power of particular operations, while emphasizing the difficulty of extending lower-bound techniques to unrestricted polynomial-size circuits."
    },
    {
      "heading": "Quantum complexity classes",
      "text": "Quantum complexity classes use computational models based on quantum mechanics. The standard model is a uniform family of quantum circuits acting on qubits and followed by measurements. BQP consists of decision problems solvable by polynomial-size uniform quantum circuits with bounded error. As with BPP, the error can be reduced through repetition, so the precise fixed success threshold is not fundamental.\n\nQuantum computation does not simply examine all candidate answers and reveal the correct one. Although a quantum state may be a superposition of many basis states, measurement does not provide unrestricted access to all its amplitudes. Algorithms must arrange interference so that useful outcomes become likely. Shor’s algorithm, introduced in 1994, gives polynomial-time quantum algorithms for integer factoring and discrete logarithms, formulated naturally as function problems with associated decision versions. It does not establish that NP-complete problems belong to BQP.\n\nKnown containments include\n\n\\[\\mathrm{BPP}\\subseteq\\mathrm{BQP} \\subseteq\\mathrm{PP}\\subseteq\\mathrm{PSPACE}.\\]\n\nWhether BQP equals BPP is unknown. The relationship between BQP and NP is also unresolved: neither is known to contain the other. Factoring does not settle this comparison because it is not known to be NP-complete. Evidence of quantum advantage therefore concerns particular problems and computational tasks rather than a proved general ability to solve all efficiently verifiable problems.\n\nQMA is a quantum analogue of NP-style verification. A yes-instance has a polynomial-size quantum witness that a polynomial-time quantum verifier accepts with high probability; for a no-instance, every witness is accepted with only low probability. The local Hamiltonian problem is a central QMA-complete problem. In its promise formulation, the task is to distinguish whether the lowest eigenvalue of a sum of local quantum interactions is below one threshold or above another, with a guaranteed gap between the thresholds. Alexei Kitaev established its foundational completeness result.\n\nPromise problems are especially important in quantum complexity. A promise specifies the inputs on which an algorithm must behave correctly; behavior outside that set is unrestricted. This accommodates spectral gaps, approximation tolerances, and distinctions that are not naturally total yes-or-no classifications. Quantum class definitions also specify uniformity and an efficiently implementable gate set. Without such restrictions, arbitrary real-valued amplitudes or nonuniform circuit choices could encode information that is not effectively obtainable by the intended computational model."
    },
    {
      "heading": "Search, approximation, and parameterized classes",
      "text": "Many computational tasks do not return a single decision bit. A search problem may ask for a satisfying assignment, a factor of an integer, or a path through a graph. FP is the class of functions computable deterministically in polynomial time. FNP describes search relations with polynomially bounded outputs whose validity can be checked in polynomial time. These function and relation classes complement decision classes rather than replacing them.\n\nFor some problems, efficient decision enables efficient search. A satisfiability algorithm can construct a satisfying assignment by fixing variables one at a time and querying whether the remaining formula is satisfiable. This property is called self-reducibility. It explains why deciding existence and producing a witness have closely related complexity for many standard NP problems. Such an equivalence must nevertheless be established for the problem or framework in question; it does not follow from the words “search problem” alone.\n\nOptimization introduces another distinction. An exact optimization task asks for a best feasible solution, while an approximation algorithm seeks a solution within a specified factor of optimum. For minimization, an approximation ratio \\(\\rho\\geq1\\) commonly means that the returned cost is at most \\(\\rho\\) times the optimum. APX contains suitable NP optimization problems admitting polynomial-time constant-factor approximations. A polynomial-time approximation scheme provides a \\((1+\\varepsilon)\\)-approximation for every fixed \\(\\varepsilon>0\\), though its dependence on \\(\\varepsilon\\) may be expensive. A fully polynomial-time approximation scheme is polynomial in both input length and \\(1/\\varepsilon\\).\n\nParameterized complexity measures an instance by both its total size \\(n\\) and a designated parameter \\(k\\). A problem is fixed-parameter tractable if it can be solved in time\n\n\\[f(k)n^{O(1)},\\]\n\nwhere the exponent of \\(n\\) is independent of \\(k\\). This differs from a bound such as \\(n^k\\), which belongs to the broader class XP. Vertex cover, parameterized by the allowed cover size, is fixed-parameter tractable: branching on an uncovered edge reduces the remaining parameter by one in each branch, yielding a basic exponential dependence on \\(k\\) but polynomial dependence on graph size. Clique parameterized by clique size is W[1]-complete and is not known to be fixed-parameter tractable.\n\nThese frameworks show why classical worst-case classifications do not exhaust computational behavior. An NP-complete problem may admit useful parameterized algorithms, approximation guarantees, or efficient solutions on restricted instance families. Conversely, average-case claims require an explicit distribution over inputs. A worst-case hardness theorem alone does not establish that randomly generated or practically encountered instances are difficult."
    },
    {
      "heading": "Structural relationships, lower bounds, and proof barriers",
      "text": "Complexity theory studies relationships among classes as much as it studies individual problems. A containment \\(\\mathcal{C}\\subseteq\\mathcal{D}\\) means that every problem meeting the definition of \\(\\mathcal{C}\\) also meets that of \\(\\mathcal{D}\\). A strict containment requires a problem in the larger class that is absent from the smaller. Completeness supplies representative problems for whole classes, but only relative to a specified reduction. Polynomial-time, logarithmic-space, randomized, and counting reductions can yield different classifications.\n\nClosure properties provide structural information. P is closed under complement, union, and intersection. NP is closed under union and intersection, but closure under complement would imply NP = coNP. PSPACE is closed under complement because deterministic deciders can exchange their accepting and rejecting outcomes. These facts constrain possible class relationships even when direct separations remain unavailable. Conditional collapse theorems are especially informative: the Karp–Lipton theorem states that if NP is contained in \\(\\mathrm{P}/\\mathrm{poly}\\), then the polynomial hierarchy collapses to its second level.\n\nRelativization examines machines equipped with an oracle that answers membership queries to some fixed language in one step. In 1975, Theodore Baker, John Gill, and Robert Solovay constructed oracles relative to which P equals NP and others relative to which P differs from NP. Consequently, a proof technique that works unchanged relative to every oracle cannot settle P versus NP. This is a limitation on a broad kind of argument, not evidence that the question lacks a definite mathematical answer.\n\nOther barriers concern lower-bound methods. Alexander Razborov and Steven Rudich’s 1997 natural proofs framework showed, under suitable cryptographic hardness assumptions, that a broad family of constructive and sufficiently large circuit properties cannot establish the desired strong circuit lower bounds. Scott Aaronson and Avi Wigderson introduced algebrization in 2008 to capture limitations of techniques that remain valid under certain algebraic extensions of oracle access. These frameworks differ in scope, and none rules out all possible approaches.\n\nThe distinction between restricted and general models remains crucial. Strong lower bounds are known for constant-depth circuits, monotone circuits, and various other constrained systems, while comparable lower bounds for unrestricted circuits remain much harder. Likewise, the time hierarchy separates P from EXP, but it does not identify which intermediate containments must be strict. A complexity-class claim therefore has several essential components: the input representation, computational model, resource bound, acceptance condition, uniformity requirement, and reduction notion. Altering any of them can change both the class and the meaning of a hardness theorem."
    }
  ],
  "links": [
    "computational-complexity",
    "algorithm",
    "computer-science",
    "p-versus-np-problem",
    "entscheidungsproblem",
    "formal-language",
    "turing-machine",
    "shortest-path-problem",
    "boolean-satisfiability-problem",
    "np-completeness",
    "np-hardness",
    "randomized-algorithm",
    "pseudorandom-number-generator",
    "parallel-computing",
    "quantum-mechanics",
    "quantum-circuit",
    "qubit",
    "shors-algorithm",
    "approximation-algorithm"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}