PL (complexity)

PL, or probabilistic L, is the class of languages recognizable by a polynomial time logarithmic space randomized machine with probability > 1⁄2 (this is called unbounded error). Equivalently, as shown below, PL is the class of languages recognized by unbounded time unbounded error logspace randomized machine.

An example of PL complete problem (under logspace reduction) is finding whether the determinant of a matrix (with integral coefficients) is positive. Given a matrix $M$ and a number $n$ , testing with $|M|>n$ ^{[note 1]} is also PL complete. By contrast, testing whether matrix permanent is positive is PP complete.

PL^PL=PL in the sense that for every f in PL, PL is unchanged if it is extended to allow ⁠ $x\to f(A,x)$ ⁠ as a subroutine, where A is the input string.

PL contains NL and BPL and is contained in NC₂.

Determinant of an integral matrix can be reduced to finding the difference between the number of accepting and rejecting paths on a polynomially sized directed acyclic graph with distinguished start, accept, and reject nodes. ^[1]

Comparing the number of accepting and rejecting paths can be done in PL as follows. Modify the graph to make all paths the same length and for each node to have at most two successors. Take a random path. For each node with just one successor, fail (output random answer) with probability 1⁄2. At the end, accept if we reached Accept node, reject if we reached Reject node, and fail otherwise. Each distinct path will be counted equally — while some paths are more likely to be taken, this is exactly compensated by reduced likelihood of continuing along that path.

Probabilistic logspace without a time limit

If time is unlimited, the machines can run in expected exponential time — for example, keep a counter and increment it with probability 1⁄2 and zero it otherwise; halt when the counter overflows. If zero error (alternatively, one-sided error) is allowed, the class equals NL — the machine can simulate NL by trying random paths for an exponential amount of time and using NL=coNL.

If bounded error is allowed, a complete promise or approximation problem is estimating stationary distribution for an ergodic Markov chain. The complexity class is not known to equal PL, and an attempt to simulate PL through blackbox probability amplification fails: Despite unbounded time, bounded error logspace machines cannot distinguish a random coin from one that lands head ⁠ $1/2+1/s(n)$ ⁠ of the time where ⁠ $s(n)$ ⁠ grows superpolynomially.

For unbounded error logspace machines, unbounded time can be reduced to polynomial time as follows. Computing acceptance probability can be reduced to solving a linear system. For each state $i$ , add a variable $x i$ — probability of acceptance if current state is i. If there is no path from i to Accept, set $x i =0$ , and otherwise express $x i$ in terms of states immediately reachable from state i. The system can be solved using determinants, and testing whether $|A|>2|B|$ is in PL.^{[note 1]} One complication is that the coefficients are in NL (using NL=coNL). We address it by guessing a 'proof' for each coefficient value, failing if the guess does not work, and ensuring that all paths make the same number of guesses for each coefficient.

Notes

1 2 $|A|$ denotes determinant of $A$

v t e Complexity classes
Considered feasible	DLOGTIME AC⁰ ACC⁰ TC TC⁰ L SL RL FL NL NL-complete NC SC CC P P-complete ZPP RP BPP BQP APX FP
Suspected infeasible	UP NP NP-complete NP-hard co-NP co-NP-complete TFNP FNP AM QMA PH ⊕P PP #P #P-complete IP PSPACE PSPACE-complete
Considered infeasible	EXPTIME NEXPTIME EXPSPACE 2-EXPTIME ELEMENTARY PR R RE ALL
Class hierarchies	Polynomial hierarchy Exponential hierarchy Grzegorczyk hierarchy Arithmetical hierarchy Boolean hierarchy
Families of classes	DTIME NTIME DSPACE NSPACE Probabilistically checkable proof Interactive proof system
List of complexity classes

Probabilistic logspace without a time limit

Notes

References

Related Articles