Revision 108480418 of "Benutzer:Schreiber/NC (complexity)" on dewiki

{{unsolved|computer science|Is '''NC''' {{=}} '''P''' ?}}
In [[computational complexity theory|complexity theory]], the class '''NC''' (for "Nick's Class") is the set of [[decision problem]]s decidable in [[polylogarithmic time]] on a [[parallel computing|parallel computer]] with a polynomial number of processors.  In other words, a problem is in '''NC''' if there exist constants ''c'' and ''k'' such that it can be solved in time [[Big O notation|''O'']](log<sup>''c''</sup>&nbsp;''n'') using [[Big O notation|''O'']](''n''<sup>''k''</sup>) parallel processors. [[Stephen Cook]] coined the name "Nick's class" after [[Nick Pippenger]], who had done extensive research on circuits with polylogarithmic depth and polynomial size.  

Just as the class '''[[P (complexity)|P]]''' can be thought of as the tractable problems ([[Cobham's thesis]]), so '''NC''' can be thought of as the problems that can be efficiently solved on a parallel computer.  It is unknown whether '''P''' is contained in '''NC''', but most researchers suspect this to be false, meaning that there are probably some tractable problems which are "inherently sequential" and cannot significantly be sped up by using parallelism. Just as the class '''[[NP-Complete]]''' can be thought of as "probably intractable", so the class '''[[P-Complete]]''', when using '''NC''' reductions, can be thought of as "probably not parallelizable" or "probably inherently sequential".

The parallel computer in the definition can be assumed to be a ''parallel, random-access machine'' ([[parallel random access machine|PRAM]]).  That is a parallel computer with a central pool of memory, and any processor can access any bit of memory in constant time.  The definition of '''NC''' is not affected by the choice of how the PRAM handles simultaneous access to a single bit by more than one processor. It can be CRCW, CREW, or EREW. See [[parallel random access machine|PRAM]] for descriptions of those models.  

Equivalently, '''NC''' can be defined as those decision problems decidable by a [[Boolean circuit|uniform Boolean circuit]] (which can be calculated from the length of the input) with [[polylogarithmic]] depth and a polynomial number of gates.

[[RNC (complexity)|RNC]] is a class extending NC with access to randomness.

== Problems in NC ==
As with '''P''', by a slight abuse of language, one might classify function problems and search problems as being in '''NC'''. '''NC''' is known to include many problems, including
* Integer addition, multiplication and division;
* Matrix multiplication, determinant, inverse, rank;
* Polynomial GCD, by a reduction to linear algebra using [[Sylvester matrix]] (it is open whether integer GCD is in NC);
* Finding a maximal matching.

Often algorithms for those problems had to be separately invented and could not be naively adapted from well-known algorithms - Gaussian elimination and Euclidean algorithm rely on operations performed in sequence. One might contrast [[ripple carry adder]] with a [[carry-lookahead adder]].

== The NC Hierarchy ==
'''NC'''<sup>''i''</sup> is the class of decision problems decidable by uniform boolean circuits with a polynomial number of gates and depth ''O''(log<sup>''i''</sup>&nbsp;''n''), or the class of decision problems solvable in time ''O''(log<sup>''i''</sup>&nbsp;''n'') on a parallel computer with a polynomial number of processors. Clearly, we have

:<math>\textbf{NC}^1 \subseteq \textbf{NC}^2 \subseteq \cdots \subseteq \textbf{NC}^i \subseteq \cdots \textbf{NC}</math>

which forms the '''NC'''-hierarchy.

We can relate the '''NC''' classes to the space classes '''[[L (complexity)|L]]''' and '''[[NL (complexity)|NL]]'''.  From Papadimitriou 1994, Theorem 16.1:

:<math> \mathbf{NC}^1 \subseteq \mathbf{L} \subseteq \mathbf{NL} \subseteq \mathbf{NC}^2 \subseteq \mathbf{P}.</math>

Similarly, we have that '''NC''' is equivalent to the problems solvable on an [[alternating Turing machine]] with <math>O(\log n)</math> space and <math>(\log n)^{O(1)}</math> alternations.<ref>{{cite journal|author=S. Bellantoni and I. Oitavem|title=Separating NC along the delta axis|journal=Theoretical Computer Science|volume=318|year=2004|pages=57–78}}</ref>

=== Open problem: Is NC proper? ===
One major open question in [[computational complexity theory|complexity theory]] is whether or not every containment in the '''NC''' hierarchy is proper. It was observed by Papadimitriou that, if '''NC'''<sup>''i''</sup> = '''NC'''<sup>''i''+1</sup> for some ''i'', then '''NC'''<sup>''i''</sup> = '''NC'''<sup>''j''</sup> for all ''j''&nbsp;≥&nbsp;''i'', and as a result, '''NC'''<sup>''i''</sup> = '''NC'''. This observation is known as '''NC'''-hierarchy collapse because even a single equality in the chain of containments
:<math>\textbf{NC}^1 \subseteq \textbf{NC}^2 \subseteq \cdots</math>
implies that the entire '''NC''' hierarchy "collapses" down to some level ''i''. Thus, there are 2 possibilities:

# <math>\textbf{NC}^1 \subset \cdots \subset \textbf{NC}^i \subset ... \subset \textbf{NC}^{i+j} \subset \cdots \textbf{NC}</math>
# <math>\textbf{NC}^1 \subset \cdots \subset \textbf{NC}^i = ... = \textbf{NC}^{i+j} = \cdots \textbf{NC}</math>

It is widely believed that (1) is the case, although no proof as to the truth of either statement has yet been discovered.

==Barrington's theorem==
A '''branching program''' with ''n'' variables of width ''k'' and length ''m'' consists of a sequence of ''m'' instructions. Each of the instructions is a tuple (''i'', ''p'', ''q'') where ''i'' is the index of variable to check (1 &le; ''i'' &le; ''n''), and ''p'' and ''q'' are functions from {1,2,...,''k''} to {1,2,...,''k''}. The program initially starts in state 1, and each instruction (''i'', ''p'', ''q'') changes the state from ''x'' to ''p''(''x'') or ''q''(''x''), depending on whether ''i''-th variable is 0 or 1.

A family of branching programs consists of a branching program with ''n'' variables for each ''n''.

It's easy to show that every language ''L'' on {0,1} can be decided using a family of branching programs of width 4 and exponential length, or using a family of exponential width and linear length.

Every regular language on {0,1} can be recognized with a family of branching programs of constant width and linear number of instructions (since a DFA can be converted to a branching program).

'''Barrington's theorem'''<ref>D. A. Barrington. [http://www.cs.umass.edu/~barring/publications/bwbp.pdf Bounded-Width Polynomial-Size Branching Programs Recognize Exactly Those Languages in NC<sup>1</sup>]</ref> says that the class of languages recognized with a family of branching programs of width 5 and polynomial length is exactly nonuniform NC<sup>1</sup>. The proof uses [[solvable group|nonsolvability]] of symmetric group S<sub>5</sup>.

The theorem is rather surprising. It implies that majority function can be computed with a family of branching programs of constant width and polynomial size, while intuition might suggest that to achieve polynomial size, one needs linear number of states.

===Proof of Barrington's theorem===
A branching program of constant width and polynomial size can be easily converted (via divide-and-conquer) to a circuit in NC<sup>1</sup>.

Conversely, suppose a circuit in NC<sup>1</sup> is given. Without loss of generality, assume it uses only AND and NOT gates.

Lemma 1: If there exists a branching program that sometimes works as permutation ''P'' and sometimes as ''Q'', by right-multiplying permutations in first instruction by <math>\alpha</math>, and in last instruction left-multiplying by <math>\beta</math>, we can make a circuit of the same length that behaves as <math>\beta P \alpha</math> or <math>\beta Q \alpha</math> respectively.

Call a branching program <math>\alpha</math>-computing a circuit <math>C</math> if it works as identity when C's output is 0, and as <math>\alpha</math> when C's output is 1.

As a consequence of lemma 1 and the fact that all cycles of length 5 are conjugate, for any two 5-cycles <math>\alpha, \beta</math> if there exists a branching program <math>\alpha</math>-computing a circuit ''C'', then there exists a branching program <math>\beta</math>-computing the circuit ''C'', of the same length.

Lemma 2: There exists 5-cycles <math>\gamma, \delta</math> such that their [[commutator]] <math>\gamma \delta \gamma^{-1} \delta^{-1} = \epsilon</math> is a 5-cycle. For example, <math>\gamma = (1 2 3 4 5)</math>, <math>\delta = (1 3 5 4 2)</math>.

We will now prove Barrington's theorem by induction.

Assume that for all subcircuits <math>D</math> of <math>C</math> and 5-cycles <math>\alpha</math>, there exists a branching program <math>\alpha</math>-computing <math>C</math>. We will show that for all 5-cycles <math>\alpha</math>, there exists a branching program <math>\alpha</math>-computing <math>C</math>.

* If the circuit outputs <math>x_i</math>, the branching program has one instruction checking <math>x_i</math> and outputting identity or <math>\alpha</math> respectively.
* If the circuit outputs <math>\neg C</math>, where <math>C</math> is a different circuit. Create a branching program <math>\alpha^{-1}</math>-computing <math>C</math>, and multiply output of the program (using lemma 1) by <math>\alpha</math> to get a branching program outputting <math>id</math> or <math>\alpha</math>, i.e. <math>\alpha</math>-computing <math>\neg C</math>.
* If the circuit outputs <math>C \wedge D</math>, join the branching programs that <math>\delta^{-1}</math>-compute D, <math>{\gamma}^{-1} </math>-compute C,<math>\delta</math>-compute D, <math>\gamma</math>-compute C. If one of the circuits outputs 0, the resulting program will be identity; if both circuits output 1, the resulting program will work as <math>\epsilon</math>. In other words, we get a program <math>\epsilon</math>-computing <math>C \wedge D</math>. Because <math>\epsilon</math> and <math>\alpha</math> are two 5-cycles, they are conjugate, and there exists a program <math>\alpha</math>-computing <math>C \wedge D</math>.

The size of the branching program is at most <math>4^d</math>, where ''d'' is the depth of the circuit. If the circuit has logarithmic depth, the branching program has polynomial length.

==References==
<references/>
* [http://www.cs.armstrong.edu/greenlaw/research/PARALLEL/limits.pdf Greenlaw, Raymond, James Hoover, and Walter Ruzzo. ''Limits To Parallel computation; P-Completeness Theory''. ISBN 0-19-508591-4]
* Heribert Vollmer. ''Introduction to Circuit Complexity -- A Uniform Approach''. ISBN 3-540-64310-9
* {{cite book|author = [[Christos Papadimitriou]] | year = 1993 | title = Computational Complexity | publisher = Addison Wesley | edition = 1st edition | isbn = 0-201-53082-1}} Section 15.3: The class '''NC''', pp.375&ndash;381.
* {{cite book|author = [[Dexter Kozen]] | year = 1992 | title = The design and analysis of algorithms}} Lectures 28 - 34 and 36
* {{cite book|author = [[Dexter Kozen]] | year = 2006 | title = Theory of Computation | publisher = Springer | isbn = 1-84628-297-7}} Lecture 12: Relation of ''NC'' to Time-Space Classes

{{ComplexityClasses}}

{{DEFAULTSORT:Nc (Complexity)}}
[[Category:Complexity classes]]
[[Category:Circuit complexity]]

[[de:NC (Komplexitätsklasse)]]
[[es:NC (clase de complejidad)]]
[[ko:NC (복잡도)]]
[[it:NC (complessità)]]
[[ja:NC (計算複雑性理論)]]
[[vi:NC (độ phức tạp)]]