Computational complexity theory

Computational complexity theory is a branch of the theory of computation in theoretical computer science That Focuses we Classifying computational problems selon Their inherent difficulty, and Relating Those classes to Each Other. A computational problem is understood to be a task which is in principle amenable to being solved by a computer, which is equivalent to stating that the problem may be solved by mechanical application of mathematical steps, such as an algorithm .

A problem is considered to be inherently difficult if its solution requires significant resources, whatever the algorithm used. The theory formalizes this intuition, by introducing mathematical models of computation to study these problems and quantifying the amount of resources needed to solve them, such as time and storage. Other complexity Measures sont également used, Such As the amount of communication (used in communication complexity ), the number of gates in a circuit (used in the circuit complexity ) and the number of processors (used in parallel computing ). One of the roles of computational complexity theory is to determine the practical limits of what can and can not do.

Closely related fields in computer science are analysis of algorithms and computability theory. A key distinction between analysis of algorithms and computational complexity theory is that the problem is that of computing a problem. solve the same problem. More precisely, computational complexity theory tries to classify problems that can not be solved with appropriately restricted resources. In turn, computational computational complexity computationally computational theories

Computational problems

Problem instances

A computational problem can be viewed as an infinite collection of instances together with a solution for every instance. The input string for a computational problem is referred to as a problem instance, and should not be confused with the problem itself. In computational complexity theory, a problem is related to the abstract question to be solved. In contrast, an instance of this problem is a rather concrete utterance, which can serve the input for a decision problem. For example, consider the problem of primality testing . The instance is a number (eg 15) and the solution is “yes” if the number is prime and “no” otherwise (in this case “no”). Stated another way, the instanceis a particular input to the problem, and the solution is the corresponding corresponding to the input input.

To highlight the further Top différence entre a problem and an instance Consider The Following pending release of the decision of the traveling salesman problem : Is there a way of MOST at 2000 km passing through all of Germany’s 15 Largest cities? The quantitative answer to this particular problem is, as it was asked for a round trip to all sites in Milan whose total length is at most 10 km. For this reason, computational problems and problems.

Representing problem instances

When considering computational problems, a problem is a string over an alphabet . Usually, the alphabet is taken to be the binary alphabet (ie, the set {0,1}), and thus the strings are bitstrings . As in a real-world computer , mathematical objects other than bitstrings must be suitably encoded. For example, integers can be represented in binary notation , and graphs can be encoded directly through their adjacency matrices , or by encoding their adjacency lists in binary.

Even though some proofs of complexity-theoretic theorems regularly assumes some concrete choice of input encoding, one tries to keep the discussion abstract rather than independent of the choice of encoding. It can be achieved by ensuring that different representations can be transformed into another.

Decision problems as formal languages

The problems are one of the central objects of study in computational complexity theory. A decision problem is a special type of computational problem or answer is yes or no , or alternately or 1 or 0. A decision problem can be viewed as a formal language , where the members of the language are instances whose output is yes, and the non-members are those instances whose output is no. The objective is to decide, with the aid of an algorithm , whether a given input is a member of the formal language under consideration. If the algorithm deciding this problem returns the answer yes , the algorithm is said to accept the input string, otherwise it is said to reject the input.

An example of a decision problem is the following. The input is an arbitrary graph . The problem is in deciding whether the graph is connected , or not. The formal language associated with this decision is the set of all connected graphs-of course, to obtain a precise definition of this language, one has to decide which graphs are encoded as binary strings.

Function problems

A function problem is a computational problem where a single output (of a total function ) is expected for every input, but the output is more complex than that of a decision problem , that is, it is not just yes or no. Notable examples include the problem and the problem .

It is tempting to think that the notion of function problems is much worse than the notion of decision problems. However, this is not really the case, since problems can be resolved. For example, the multiplication of two integers can be Expressed as the set of triples ( a , b , c ) Such que la relationship was × b = c holds. Deciding whether a triple is a member of this set corresponding to the problem of multiplying two numbers.

Measuring the size of an instance

To measure the difficulty of solving a computational problem, one may wish to see how much time the best algorithm requires to solve the problem. However, the running time may, in general, depend on the instance. In particular, larger instances will require more time to solve. Thus the time required to solve a problem (or the space required, or any measure of complexity) is calculated as a function of the size of the instance. This is usually taken to be the size of the input in bits. Complexity theory is interested in how to scale with an increase in the input size. For instance, in the problem of finding a graph is connected, how much more time does it take to solve a problem for a graph with 2 n vertices compared to the time taken for a graph with n vertices?

If the input size is n , the time taken can be expressed as a function of n . Since the time taken on different inputs of the same size can be different, the worst-case time complexity T ( n ) is defined to be the maximum time taken over all inputs of size n . If T ( n ) is a polynomial in n , then the algorithm is said to be a polynomial time algorithm. Cobham’s thesis says that it can be solved with a possible amount of resources if it admits a polynomial time algorithm.

Machine models and complexity measures

Turing machine

A Turing machine is a mathematical model of a general computing machine. It is a machine that manipulates the symbols contained on a strip of tape. Turing machines are not intended as a practical computing technology, but rather as a thought experiment representing a computing machine-anything from an advanced supercomputer to a mathematician with a pencil and paper. It is believed that a problem can be solved by an algorithm, there exists a Turing machine that solves the problem. Indeed, this is the statement of the Church-Turing thesis . In addition, it is known that everything is a machine , Conway’s Game of Life , cellular automataany programming language can be computed on a Turing machine. Since Turing machines are easy to analyze mathematically, and are believed to be as powerful as any other model of computation, the Turing machine is the most commonly used model in complexity theory.

Many types of Turing machines are used to define such classes, such as deterministic Turing machines , probabilistic Turing machines , non-deterministic Turing machines , quantum Turing machines , symmetric Turing machinesand alternating Turing machines . They are all but powerful in principle, but when resources (such as time or space) are bounded, some of these may be more powerful than others.

A deterministic Turing machine is the most basic Turing machine, which uses a fixed set of rules to determine future actions. A probabilistic Turing machine is a deterministic Turing machine with an extra supply of random bits. The ability to make probabilistic decisions often helps algorithms solve problems more efficiently. Algorithms that use random bits are called randomized algorithms. A non-deterministic Turing machine has a deterministic Turing machine with a feature of non-determinism, which allows a Turing machine to have multiple possible future actions from a given state. One way to view non-determinism is that the Turing machine branches into many possible computational paths at each step, and if it solves the problem in any of these branches, it is said to have solved the problem. Clearly, this model is not necessarily a particularly realizable model, it is just a theoretically interesting abstract machine that gives rise to particularly interesting complexity classes. For examples, see non-deterministic algorithm .

Other machine models

Many machine models differ from the standard multi-tape Turing machines have been proposed in the literature, for example random access machines . Unexpectedly, each of these models may be converted to another without any additional computational power. The time and memory consumption of these alternate models may vary. [1] What all these models have in common is that the machines operate deterministically .

However, some computational problems are easier to analyze. For example, a non-deterministic Turing machine is a computational model that is allowed to branch out to many different possibilities at once. The non-deterministic Turing Machine HAS very little to do with how we PHYSICALLY want to compute algorithms, goal icts branching exactly captures Many of the mathematical models we want to analyze, so That non-deterministic time is a significant very resource in Analyzing computational problems .

Complexity measures

For a precise definition of what it means to solve a problem using a given amount of time and space, a computational model such as the deterministic Turing machine is used. The time required by a deterministic Turing machine Mon input x is the total number of state transitions, or steps, the machine makes before it halts and outputs the answer (“yes” or “no”). A Turing Machine M is Said to operate Within time f ( n ), if the time required by M were Each input of length n is at MOST f ( n ). A decision problem A can be solved in timef ( n ) if there is a Turing machine operating in time f ( n ) that solves the problem. Since complexity theory is interested in classifying problems based on their difficulty, For instance, the set of problems solvable Within time f ( n ) was deterministic Turing Machine is denoted by Then DTIME ( f ( n )).

Analogous definitions can be made for space requirements. ALTHOUGH time and space are The Most well-known complexity resources, any complexity measure can be viewed as a computational resource. Complexity measures are very generally defined by the Blum complexity axioms . Other methods used in complexity theory, communication complexity , complexity and decision tree complexity .

The complexity of an algorithm is often expressed using big O notation .

Best, worst and average case complexity

The best, worst and average case complexity of different modes of measuring the time (or any other complexity) of different inputs of the same size. Since Some inputs of size n May be faster to solve than others, we define The Following Complexities:

  • Best-case complexity: This is the complexity of solving the problem for the best input of size n .
  • Worst-case complexity: This is the complexity of solving the problem for the worst input of size n .
  • Average-case complexity: This is the complexity of solving the problem on an average. This complexity is only defined with respect to a probability distribution over the inputs. For instance, the average case complexity can be defined with respect to the uniform distribution over all inputs of size n .

For example, consider the deterministic sorting algorithm quicksort . This solves the problem of sorting a list of integers that is given as input. The worst case is when the input is sorted out in reverse order, and the algorithm takes time O ( 2 ) for this case. If we assume that all possible permutations of the input list are likely, the average time taken for sorting is O ( nlog n ). The best case occurs when each pivoting divides the list in half, also requiring O ( n log n ) time.

Upper and lower bounds on the complexity of problems

To classify the computation time (or similar resources, such as space consumption), one of the most efficient algorithm solving a given problem. The complexity of an algorithm is usually taken to be its worst case complexity, unless specified otherwise. Analyzing a particular algorithm falls under the field of analysis of algorithms . To show an upper bound T ( n ) on the time of a problem, one needs a particular algorithm with running time at most T ( n)). However, proving lower bounds is much more difficult, since lower bounds make a statement about all possible algorithms that solve a given problem. The phrase “all possible algorithms” includes the algorithm known today, but any algorithm that might be discovered in the future. To show a lower bound of T ( n ) for a problem requires that no algorithm can have time complexity lower than T ( n ).

Upper and lower bounds are usually stated using the big O notation , which hides constant factors and smaller terms. This makes the bounds independent of the specific details of the computational model used. For instance, if T ( n ) = 7 2 + 15 n + 40, in big O notation one would write T ( n ) = O ( 2 ).

Complexity classes

Main article: Complexity class

Defining complexity classes

complexity class is a set of problems of related complexity. Simpler complexity classes are defined by the following factors:

  • The most commonly used problems are decision problems. However, complexity classes can be defined based on function problems , problem solving , optimization problems , promised problems , and so on.
  • The model of computation: The most common model of computation is the deterministic Turing machine, but many methods are based on non-deterministic Turing machines, Boolean circuits , quantum Turing machines , monotonous circuits , etc.
  • The resource (or resources) are typically bound together, such as “polynomial time”, “logarithmic space”, “constant depth”, and so on.

Of course, some complexity classes have not been made into this framework. Thus, a typical complexity has the following definition:

The set of decision problems solvable by a deterministic Turing machine within time f ( n ). (This complexity is known as DTIME ( f ( n )).

Purpose bounding the computation time by Above Some concrete function f ( n ) Often yields complexity classes That depends on the Machine Chosen model. For instance, the language { xx | x is any binary string can be solved in linear time on a multi-stage Turing machine, but necessarily requires quadratic time in the model of single-tape Turing machines. If we allow polynomial variations in running time, Cobham-Edmonds thesis states that “the time complexities in any two reasonable and general models of computation are polynomially related” ( Goldreich 2008 , Chapter 1.2). This forms the basis for the class P complexity, which is the set of decision problems solvable by a deterministic Turing machine within polynomial time. The corresponding set of function problems is FP .

Important complexity classes

Many important classes can be defined by the time or space used by the algorithm. Some important features of the following are the following:

Complexity class Model of computation Resource constraint
Deterministic time
DTIME ( f ( n )) Deterministic Turing machine Time f ( n )
P Deterministic Turing machine Time poly ( n )
EXPTIME Deterministic Turing machine Time 2 poly ( n )
Non-deterministic time
NTIME ( f ( n )) Non-deterministic Turing machine Time f ( n )
NP Non-deterministic Turing machine Time poly ( n )
NEXPTIME Non-deterministic Turing machine Time 2 poly ( n )
Complexity class Model of computation Resource constraint
Deterministic space
DSPACE ( f ( n )) Deterministic Turing machine Space f ( n )
The Deterministic Turing machine Space O (log n )
PSPACE Deterministic Turing machine Space poly ( n )
EXPSPACE Deterministic Turing machine Space 2 poly ( n )
Non-deterministic space
NSPACE ( f ( n )) Non-deterministic Turing machine Space f ( n )
NL Non-deterministic Turing machine Space O (log n )
NPSPACE Non-deterministic Turing machine Space poly ( n )
NEXPSPACE Non-deterministic Turing machine Space 2 poly ( n )

The logarithmic-space classes (necessarily) do not take into account the space needed to represent the problem.

It turns out that PSPACE = NPSPACE and EXPSPACE = NEXPSPACE by Savitch’s theorem .

Other important classes include BPP , ZPP and RP , which are defined using probabilistic Turing machines ; AC and NC , which are defined using Boolean circuits; and BQP and QMA , which are defined using quantum Turing machines. #P is an important complexity class of accounting problems (not decision problems). Classes like IP and AM are defined using Interactive proof systems . ALL is the class of all decision problems.

Hierarchy theorems

Main articles: theorem and space hierarchy

For example, it is desirable to compute time and define a set of problems. In particular, although DTIME ( n ) is contained in DTIME ( 2), it would be interesting to know if the inclusion is strict. For time and space requirements, the answer to such questions is given by the time and space hierarchy theorems respectively. They are called hierarchy theorems because they have a proper hierarchy of the classes defined by constraining the respective resources. There are so many classes of such classes that they are properly included in the other. Having included such a set of inclusions, we can proceed to make quantitative statements about how much more time is needed.

More precisely, the time hierarchy theorem states that

{\ displaystyle {\ mathsf {DTIME}} {\ big (} f (n) {\ big)} \ subsetneq {\ mathsf {DTIME}} {\ big (} f (n) \ cdot \ log ^ {2} (f (n)) {\ big)}}.

The space hierarchy theorem states that

{\ displaystyle {\ mathsf {DSPACE}} {\ big (} f (n) {\ big)} \ subsetneq {\ mathsf {DSPACE}} {\ big (} f (n) \ cdot \ log (f (n )) {\ big)}}.

The time and space hierarchy theorems form the basis for the most separation results of complexity classes. For instance, the time hierarchy theorem tells us that it is strictly contained in EXPTIME, and the space hierarchy theorem tells us that it is strictly contained in PSPACE.


Main article: Reduction (complexity)

Many complexity classes are defined using the concept of a reduction. A reduction is a transformation of one problem into another problem. It captures the idea of ​​a problem being at least as difficult as another problem. For instance, if a problem X can be solved using an algorithm for Y , X is no more difficulty than Y , and we Say That Reduces to Y . There are many different types of reductions, based on the method of reduction, such as Cook reductions, Karp reductions and Levin reductions, and the bound on the complexity of reductions, such as polynomial-time reductions or log-space reductions .

The most commonly used reduction is a polynomial-time reduction. This means that the reduction process takes polynomial time. For example, the problem of squaring an integer can be reduced to the problem of multiplying two integers. This means an algorithm for multiplying two integers can be used to square an integer. Indeed, this can be done by giving the same input to the multiplication algorithm. Thus we see that squaring is not more difficult than multiplication, since squaring can be reduced to multiplication.

This motivates the concept of a problem for a class. A problem X is hard for a class of problems C if every problem in C Can Be Reduced to X . THUS no problem in C is harder than X , since an algorithm for X Allows us to solve Any problem in C . Of course, the notion of hard problems depends on the type of reduction being used. For complexity classes larger than P, polynomial-time reductions are commonly used. In particular, the set of problems that are hard for NP is the set of NP-hard problems.

If a problem X is in C and hard for C , Then X is Said to be full for C . This means clustering That X is the hardest problem in C . (Since many problems could be so hard, one might say that X is one of the hardest problems in C. ) Thus the class of NP-complete problems contains the most difficult problems in NP, in the sense that they are the ones most likely Not to be in P. Because the problem is not solved, being able to reduce to known NP-complete problem, Π 2 , to another problem, Π 1would not know polynomial-time solution for Π 1 . This is because a polynomial-time solution to Π 1 would yield a polynomial-time solution to Π 2 . Similarly, because NP can be reduced to a set, finding an NP-complete problem that can be solved in a polynomial time would mean that P = NP. [2]

Important open problems

Diagram of complexity classes provided P ≠ NP. The existence of problems in NP outside both P and NP-complete in this case was established by Ladner. [3]

P versus NP problem

Main article: P versus NP problem

The complexity class is often seen as a mathematical abstraction modeling. This hypothesis is called the Cobham-Edmonds thesis . The complexity class NP , on the other hand, contains many problems which people would like to effectively solve, but for which no efficient algorithm is known, such as the Boolean satisfiability problem , the Hamiltonian path problem and the vertex cover problem . Since deterministic Turing machines are special non-deterministic Turing machines, it is easily observed that each problem is also part of the NP class.

The question of whether or not the equation is one of the most important open questions in computer science because of the wide implications of a solution. [2] If the answer is yes, many important problems can be shown to have more efficient solutions. These include various types of integer programming problems in operations research , many problems in logistics , protein structure prediction in biology , [4] and the ability to find formal proofs of pure mathematical theorems. [5] The P versus NP problem is one of the Millennium Prize Problems proposed by theClay Mathematics Institute . There is a US $ 1,000,000 prize for resolving the problem. [6]

Problems in NP or NP-complete

It was shown by Ladner That if P ≠ NP Then There exist problems in NP That are Neither in P nor NP-complete . [3] Such problems are called NP-intermediate problems. The graph isomorphism problem , the discrete logarithm problem and the integer factorization problem are examples of problems believed to be NP-intermediate. They are very FEW Reviews some of the problems NP Not Known to be in P or to be NP-complete .

The graph isomorphism problem is the problem of computational Determining whether two finite graphs are isomorphic . An important problem in complexity theory is whether the graph isomorphism is P , NP-complete , or NP-intermediate. The answer is not known, but it is believed that the problem is at least not NP-complete. [7] If graph isomorphism is NP-complete, the polynomial time hierarchy collapses to its second level. [8]Since it is widely believed that the polynomial hierarchy does not collapse to any finite level, it is believed that isomorphism is not NP-complete. The best algorithm for this problem, due to László Babai and Eugene Luks has run time{\ displaystyle O (2 ^ {\ sqrt {n \ log n}})}for graphs with n vertices, although some recent work by Babai [9]

The integer factorization problem is the computational problem of determining the factorization of a given integer. Phrased as a decision problem, it is the problem of deciding whether the input has a prime factor less than k . No effective integer factorization algorithm is known, and this fact forms the basis of several modern cryptographic systems, such as the RSA algorithm. The integer factorization problem is in NP and in co-NP (and even in UP and co-UP [10] ). If the problem is NP-complete , the polynomial time hierarchy will be collapsed to its first level (ie, NP will equal co-NP). The best known algorithm for integer factorization is the general number field sieve , which takes time{\ displaystyle O (e ^ {\ left ({\ frac {64} {9}} \ right) ^ {1/3} (\ log n) ^ {1/3} (\ log \ log n) ^ { 2/3}})}[11] to factor an integer n . However, the best known quantum algorithm for this problem, Shor’s algorithm , does run in polynomial time. Unfortunately, this fact does not matter much where the problem lies with respect to non-quantum complexity classes.

Separations between other complexity classes

Many known complexity classes are suspected to be unequal, but this has not been proved. For instance P ⊆ NP ⊆ PP ⊆ PSPACE , but it is possible that P = PSPACE . If P is not equal to NP , then P is not equal to PSPACE . Since there are Many Known entre complexity classes P and PSPACE , Such As RP , BPP , PP , BQP , MA , PH, etc., it is possible that all these classes collapse to one class. Proving that any of these classes are a major breakthrough in complexity theory.

Along the lines Sami, co-NP is the class Containing the complement problems (ie problems with the yes / no answers reversed) of NP problems. It is believed [12] that NP is not equal to co-NP ; however, it has not yet been proven. It is clear that these two complexity classes are not equal then P is not equal to NP , since if P = NP we would also have P = co-NP , since problems in NP are dual to those in co-NP .

Similarly, it is Not Known if L (the set of all problems can be solved That in logarithmic space) is strictly contained in P or equal to P . Again, there are many different classes between the two, such as NL and NC , and they are not known if they are distinct or equal classes.

It is suspected that P and BPP are equal. However, it is currently open if BPP = NEXP .


See also: Combinatorial explosion
Look up towable , feasible ,intractability , or infeasiblein Wiktionary, the free dictionary.

A problem can be solved That in theory (eg broad goal Given finite resources, Especially time), aim for qui in Practice Any solution takes too many resources to be Useful, is Known as an intractable problem . [13] Conversely, a problem that can be solved in practice is called a tractable problem , literally “a problem that can be handled”. The infeasible term (literally “can not be done”) is sometimes used interchangeably with intractable , [14] although this risks a possible solution in mathematical optimization . [15]

Tractable problems are frequently identified with problems that have polynomial-time solutions ( P , PTIME ); this is known as Cobham-Edmonds thesis . Problems that are known to be intractable in this sense include those that are EXPTIME -hard. If NP is not the same as P, then NP-hard problems are also intractable in this sense.

However, this identification is inaccurate: a polynomial-time solution with large exponent or large constant grows quickly, and may be impractical for practical size problems; Conversely, an exponential-time solution that grows slowly can be used on a realistic time, or a solution that takes a long time in the worst case, Saying that a problem is not in fact that all of the larger cases of the problem are more likely than most of them. For example, the decision problem in Presburger arithmetic has been shown to be in P, yet algorithms have been written that solve the problem in most cases. Similarly, algorithms can solve the NP-complete knapsack problemover a wide-range of sizes in less than quadratic time and SAT solvers Routinely wide handle instances of the NP-complete Boolean satisfiability problem .

To see why exponential-time algorithms are unusable in practice, consider a program that makes 2 n operations before halting. For small n , say 100, and assuming for the sake of the sake of example that the computer does 10 12operations each second, the program would run for about 4 × 10 10 years, which is the same order of magnitude as the age of the universe . Even with a much faster computer, the program would only be useful for very small instances and in that sense the intractability of a problem is somewhat independent of progress. However, an exponential-time algorithm that takes 1.0001 n operations is practical until n gets relatively large.

Similarly, a polynomial time algorithm is not always practical. If its running time is, say, 15 , it is unreasonable to consider it efficient and it is still useless except on small instances. Indeed, in practice Even No. 3 or No. 2 algorithms are impractical Often it realistic sizes of problems.


An early example of algorithmic computation is the running time of the Euclidean algorithm done by Gabriel Lamé in 1844.

Numerous researches on the complexity of algorithmic problems started off. Most influential among these was the definition of Turing machines by Alan Turing in 1936, which turns out to be a very robust and flexible simplification of a computer.

The beginning of systematic studies in computational complexity is attributed to the seminal 1965 paper “On the Computational Complexity of Algorithms” by Juris Hartmanis and Richard E. Stearns , which is unpacked by the definitions of complexity and complexity . [16] In addition, in 1965 Edmonds suggests to consider a “good” algorithm with a polynomial of input size. [17]

Earlier papers dealing with solvable problems by Turing machines with specific bounded resources include [16] John Myhill ‘s definition of linear bounded automata (Myhill 1960), Raymond Smullyan ‘ s study of rudimentary sets (1961), Hisao Yamada ‘s paper [18] on real-time computations (1962). Somewhat earlier, Boris Trakhtenbrot (1956), a pioneer in the field of the USSR, another relevant complexity measure. [19] As he remembers:

However, [my] initial interest [in automata theory] was in favor of computational complexity, an exciting fusion of combinatorial methods, an inheritance of switching theory , and the conceptual arsenal of the theory of algorithms. These ideas were made earlier in 1955 when I coined the term “signalizing function”, which is nowadays commonly known as “complexity measure”. [20]

In 1967, Manuel Blum developed an axiomatic complexity theory based on his axioms and proved an important result, the so-called, speed-up theorem . The field really began to flourish in 1971 when the US researcher Stephen Cook and, working independently, Leonid Levin in the USSR, proved that there exist practically relevant problems that are NP-complete . In 1972, Richard Karp took this idea to a leap forward with his landmark paper, “Reducibility Among Combinatorial Problems”, in which he showed that 21 diverse combinatorial and graphicalproblems, each infamous for its computational intractability, are NP-complete. [21]

See also

  • Category: Computational problems
  • Context of computational complexity
  • Descriptive complexity theory
  • Game complexity
  • List of complexity classes
  • List of computability and technical topics
  • List of important publications in scientific computer science
  • List of unsolved problems in computer science
  • Parameterized complexity
  • Proof complexity
  • Quantum complexity theory
  • Structural complexity theory
  • Transcomputational problem



  1. Jump up^ SeeArora & Barak 2009, Chapter 1: The computational model and why it does not matter
  2. ^ Jump up to:b See Sipser 2006 , Chapter 7: Time complexity
  3. ^ Jump up to:b Ladner, Richard E. (1975), “On the structure of polynomial time reducibility” (PDF) , Journal of the ACM , 22 (1): 151-171, doi : 10.1145 / 321864.321877 .
  4. Jump up^ Berger, Bonnie A .; Leighton, T (1998), “Protein folding in the hydrophilic-hydrophilic (HP) model is NP-complete”, Journal of Computational Biology , 5 (1): 27-40, doi : 10.1089 / cmb.1998.5.27 ,PMID  9541869 .
  5. Jump up^ Cook, Stephen (April 2000), The P versus NP Problem (PDF) , Clay Mathematics Institute , retrieved 2006-10-18 .
  6. Jump up^ Jaffe, Arthur M. (2006), “The Millennium Grand Challenge in Mathematics” (PDF) , Notices of the AMS , 53 (6) , retrieved 2006-10-18.
  7. Jump up^ Arvind, Vikraman; Kurur, Piyush P. (2006), “Graph isomorphism is in SPP”, Information and Computation , 204 (5): 835-852, doi : 10.1016 / j.ic.2006.02.002 .
  8. Jump up^ Schöning, Uwe (1987). “Graph isomorphism is in the low hierarchy”. Proceedings of the 4th Annual Symposium on Theoretical Aspects of Computer Science . Reading Notes in Computer Science. 1987 : 114-124. doi : 10.1007 / bfb0039599 . ISBN  3-540-17219-X . ; also:Schöning, Uwe (1988). “Graph isomorphism is in the low hierarchy”. Journal of Computer and System Sciences . 37 (3): 312-323. doi : 10.1016 / 0022-0000 (88) 90010-4 .
  9. Jump up^ Babai, László (2016). “Graph Isomorphism in Quasipolynomial Time”. arXiv : 1512.03547  [ cs.DS ].
  10. Jump up^ Lance Fortnow. Computational Complexity Blog: Complexity Class of the Week: Factoring. September 13, 2002.
  11. Jump up^ Wolfram MathWorld:Number Field Sieve
  12. Jump up^ Barak’s Boaz race on Computational Complexity Play 2
  13. Jump up^ Hopcroft, JE, Motwani, R. and Ullman, JD (2007)Introduction to Automata Theory, Languages, and Computation, Addison Wesley, Boston / San Francisco / New York (page 368)
  14. Jump up^ Meurant, Gerard (2014). Algorithms and Complexity . p. p. 4 . ISBN  978-0-09093391-7 .
  15. Jump up^ Zobel, Justin (2015). Writing for Computer Science . p. 132 . ISBN  978-1-44716639-9 .
  16. ^ Jump up to:b Fortnow & Homer (2003)
  17. Jump up^ Richard M. Karp, “Combinatorics, Complexity, and Randomness”, 1985 Turing Award Lecture
  18. Jump up^ Yamada, H. (1962). “Real-Time Computation and Recursive Functions Not Real-Time Computable”. IEEE Transactions on Electronic Computers. EC-11 (6): 753-760. doi : 10.1109 / TEC.1962.5219459 .
  19. Jump up^ Trakhtenbrot, BA: signalizing functions and tabular operators. Uchionnye Zapiski Penzenskogo Pedinstituta (Transactions of the Penza Pedagogical Institute) 4, 75-87 (1956) (in Russian)
  20. Jump up^ Boris Trakhtenbrot, “From Logic to Theoretical Computer Science – An Update”. In:Pillars of Computer Science, LNCS 4800, Springer 2008.
  21. Jump up^ Richard M. Karp (1972), “Reducibility Among Combinatorial Problems”(PDF) , in Miller RE, and JW Thatcher (editors), Complexity of Computer Computations , New York: Plenum, pp. 85-103