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.

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

PL contains NL and BPL and is contained in NC2.

## Contents

* 1 Approximating determinant in PL
* 2 Probabilistic logspace without a time limit
* 3 Notes
* 4 References

## Approximating determinant in PL

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 xi -- probability of acceptance if current state is i. If there is no path from i to Accept, set xi=0, and otherwise express xi 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. ↑ 1.0 1.1 |A| denotes determinant of A

## References

1. ↑ Meena Mahajan and V Vinay (1997). "A Combinatorial Algorithm for the Determinant". ACM/SIAM. pp. 730–738.

* v
* t
* e

Important complexity classes (more)

Considered feasible|

* DLOGTIME
* AC0
* ACC0
* TC0
* L
* SL
* RL
* NL
* NC
* SC
* CC
* P
* P-complete
* ZPP
* RP
* BPP
* BQP
* APX

Suspected infeasible|

* UP
* NP
* NP-complete
* NP-hard
* co-NP
* co-NP-complete
* 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

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/PL (complexity). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=PL_(complexity)&oldid=259664"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template