P (complexity)

In computational complexity theory, P is the complexity class containing decision problems which can be solved by a deterministic Turing machine using a polynomial amount of computation time, or polynomial time.
P is known to contain many natural problems, including linear programming, calculating the greatest common divisor, and finding a maximum matching. In 2002, it was shown that the problem of determining if a number is prime is in P. The related class of function problems is FP.
P is often taken to be the class of computational problems which are "efficiently solvable" or "tractable", although there are potentially larger classes that are also considered tractable such as RP and BPP. Also, there exist problems in P which are intractable in practical terms; for example, some require at least n^{1000000 operations. See Complexity classes P and NP#Still_harder_problems for further discussion of this. }
Relationships to other classes
A generalization of P is NP, which is the class of languages decidable in polynomial time on a nondeterministic Turing machine. We then trivially have P is a subset of NP. One of the largest open problems currently in theoretical computer science is whether P = NP; see Complexity classes P and NP.
P is also known to be at least as large as L, the class of problems decidable in a logarithmic amount of memory space. A decider using O(log n) space cannot use more than 2^{O(log n)}=n^{O(1)} time, because this is the total number of possible configurations; thus, L is a subset of P. Another important problem is whether L = P. We do know that P = ALOGSPACE, the set of problems solvable in logarithmic memory by alternating Turing machines. P is also known to be no larger than PSPACE, the class of problems decidable in polynomial space. Again, whether P = PSPACE is an open problem. To summarize:
 <math>\mbox{L} \subseteq \mbox{ALOGSPACE} = \mbox{P} \subseteq \mbox{NP} \subseteq \mbox{PSPACE} \subseteq \mbox{EXPTIME}<math>
Here, EXPTIME is the class of problems solvable in exponential time. Of all the classes shown above, only two strict containments are known:
 P is strictly contained in EXPTIME. Consequently, all EXPTIMEhard problems lie outside P, and at least one of the containments to the right of P above is strict (in fact, it is widely believed that all three are strict).
 L is strictly contained in PSPACE.
Another generalization of P is P/poly, or Nonuniform PolynomialTime. If a problem is in P/poly, then it can be solved in deterministic polynomial time provided that an advice string is given that depends only on the length of the input. Unlike for NP, however, the polynomialtime machine need not detect fraudulent advice strings; it is not a verifier. P/poly is a large class containing nearly all practical algorithms, including all of BPP. If it contains NP, then the polynomial hierarchy collapses to the second level. On the other hand, it also contains some impractical algorithms, including some undecidable problems such as the unary version of any undecidable problem.
Properties
Polynomialtime algorithms are closed under composition. Intuitively, this says that if I write a function which is polynomialtime assuming that function calls are constanttime, and if those called functions themselves require polynomial time, then the entire algorithm takes polynomial time. One consequence of this is that P is low for itself. This is also one of the main reasons that P is considered to be a machineindependent class; any machine "feature", such as random access, which can be simulated in polynomial time can simply be composed with the main polynomialtime algorithm to reduce it to a polynomialtime algorithm on a more basic machine.
References
 C. Papadimitriou. Computational Complexity. AddisonWesley, 1994. ISBN 0201530821.
 Complexity Zoo: P (http://www.complexityzoo.com/#p), P/poly (http://www.complexityzoo.com/#p/poly)
Important complexity classes (more) 
P  NP  CoNP  NPC  CoNPC  NPhard  UP  #P  #PC  L  NC  PC 
PSPACE  PSPACEC  EXPTIME  EXPSPACE  BQP  BPP  RP  ZPP  PCP  IP  PH 