NL (complexity)

From Wikipedia, the free encyclopedia

In computational complexity theory, NL is the complexity class containing decision problems which can be solved by a nondeterministic Turing machine using a logarithmic amount of memory space.

NL is a generalization of L, the class for logspace problems on a deterministic Turing machine. Since any deterministic Turing machine is also a nondeterministic Turing machine, we have that L is contained in NL.

NL can be formally defined in terms of the computational resource nondeterministic space (or NSPACE) as NL = NSPACE(log n).

Important results in complexity theory allow us to relate this complexity class with other classes, telling us about the relative power of the resources involved. Results in the field of algorithms, on the other hand, tell us which problems can be solved with this resource. Unfortunately, like much of complexity theory, many important questions about NL are still open (see Open problems in computational complexity theory).

Occasionally NL is referred to as RL due to its probabilistic definition below; however, this name is much more frequently used to refer to RLP.

Contents

[edit] NL-complete problems

The "hardest" or "most expressive" problems in a complexity class are the problems which are complete for that class. Intuitively, if we have a method to quickly solve a complete problem, we can use this to quickly solve any other problem in the class. These problems characterize the power and expressiveness of the complexity class.

Several problems are known to be NL-complete, including ST-connectivity and 2-satisfiability. ST-connectivity is the problem of determining for nodes S and T in a directed graph whether T is reachable from S. Another important NL-complete problem is 2-satisfiability, which asks, given a formula of which each clause is the disjunction of two literals, if there is a variable assignment that makes the formula true. An example instance, where ~ indicates not, might be:

(x1 or ~x3) and (~x2 or x3) and (~x1 or ~x2)

[edit] Containments

It is known that NL is contained in P, since there is a polynomial-time algorithm for 2-satisfiability, but it is not known whether NL = P or whether L = NL. It is known that NL = co-NL, a celebrated result independently discovered by Neil Immerman and Róbert Szelepcsényi in 1987 (Immerman-Szelepcsényi Theorem) and awarded the 1995 Gödel Prize.

In circuit complexity, NL can be placed within the NC hierarchy. In Papadimitriou 1994, Theorem 16.1, we have:

\mathsf{NC_1 \subseteq L \subseteq NL \subseteq NC_2}

However, it is known that NL=RL, the class of problems solvable by probabilistic Turing machines in logarithmic space and unbounded time which incorrectly reject with probability < 1/3. It is also equal to ZPL, the class of problems solvable by randomized algorithms in logarithmic space and unbounded time, with no error. It is not, however, known or believed to be equal to RLP or ZPLP, the polynomial-time restrictions of RL and ZPL which some authors refer to as RL and ZPL.

We can relate NL to deterministic space using Savitch's theorem, which tells us that any nondeterministic algorithm can be simulated by a deterministic machine in at most quadratically more space. From Savitch's theorem, we have directly that \mathbf{NL \subseteq SPACE}(\log^2 n) (equivalently, \mathbf{NL \subseteq L}^2). This was the strongest deterministic-space inclusion known as of 1994 (Papadimitriou 1994 Problem 16.4.10, "Symmetric space"). Since larger space classes are not affected by quadratic increases, the nondeterministic and deterministic classes are known to be equal, so that for example we have PSPACE = NPSPACE.

[edit] Probabilistic definition

Suppose C is the complexity class of problems solvable in logarithmithic space with probabilistic Turing machines that never accept incorrectly but are allowed to reject incorrectly less than 1/3 of the time; this is called one-sided error. The constant 1/3 is arbitrary; any x with 0 ≤ x < 1/2 would suffice.

It turns out that C = NL. Notice that C, unlike its deterministic counterpart L, is not limited to polynomial time, because although it has a polynomial number of configurations it can use randomness to escape an infinite loop. If we do limit it to polynomial time, we get a (possibly) different class RLP.

There is a simple algorithm which establishes that C = NL. Clearly C is contained in NL, since:

  • If the string is not in the language, both reject along all computation paths.
  • If the string is in the language, an NL algorithm accepts along at least one computation path and a C algorithm accepts along at least two-thirds of its computation paths.

To show that NL is contained in C, we simply take an NL algorithm and choose a random computation path of length n, and do this 2n times. Because no computation path exceeds length n, and because there are 2n computation paths in all, we have a good chance of hitting the accepting one (bounded below by a constant).

The only problem is that we don't have room in log space for a binary counter that goes up to 2n. To get around this we replace it with a randomized counter, which simply flips n coins and stops and rejects if they all land on heads. Since this event has probability 2-n, we expect to take 2n steps on average before stopping. It only needs to keep a running total of the number of heads in a row it sees, which it can count in log space.

Thus, when we only look at space alone, it seems that randomization and nondeterminism are equally powerful.

[edit] Descriptive complexity

There is a simple logical characterization of NL: it contains precisely those languages expressible in first-order logic with an added transitive closure operator.

[edit] References

v • d • e
Important complexity classes (more)
P • NP • co-NP • NP-C • co-NP-C • NP-hard • UP • #P • #P-C • L • NL • NC • P-C • PSPACE • PSPACE-C • EXPTIME • NEXPTIME • EXPSPACE • 2-EXPTIME • PR • RE • Co-RE • RE-C • Co-RE-C • R • BQP • BPP • RP • ZPP • PCP • IP • PH