NC (complexity)
Unsolved problem in computer science: (more unsolved problems in computer science)

In complexity theory, the class NC (for "Nick's Class") is the set of decision problems decidable in polylogarithmic time on a 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 O(log^{c} n) using O(n^{k}) 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.^{[1]}
Just as the class 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.^{[2]} NC is a subset of P because polylogarithmic parallel computations can be simulated by polynomialtime sequential ones. It is unknown whether NC = P, but most researchers suspect this to be false, meaning that there are probably some tractable problems that are "inherently sequential" and cannot significantly be sped up by using parallelism. Just as the class NPcomplete can be thought of as "probably intractable", so the class Pcomplete, 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, randomaccess 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 PRAM for descriptions of those models.
Equivalently, NC can be defined as those decision problems decidable by a uniform Boolean circuit (which can be calculated from the length of the input, for NC, we suppose we can compute the Boolean circuit of size n in logarithmic space in n) with polylogarithmic depth and a polynomial number of gates.
RNC is a class extending NC with access to randomness.
Contents
Problems in NC[edit]
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
 Finding a maximal matching.
Often algorithms for those problems had to be separately invented and could not be naïvely adapted from wellknown algorithms – Gaussian elimination and Euclidean algorithm rely on operations performed in sequence. One might contrast ripple carry adder with a carrylookahead adder.
The NC hierarchy[edit]
NC^{i} is the class of decision problems decidable by uniform boolean circuits with a polynomial number of gates of at most two inputs and depth O(log^{i} n), or the class of decision problems solvable in time O(log^{i} n) on a parallel computer with a polynomial number of processors. Clearly, we have
which forms the NChierarchy.
We can relate the NC classes to the space classes L and NL^{[3]} and AC.^{[4]}
The NC classes are related to the AC classes, which are defined similarly, but with gates having unbounded fanin. For each i, we have^{[2]}^{[4]}
As an immediate consequence of this, we have that NC = AC.^{[5]} It is known that both inclusions are strict for i = 0.^{[2]}
Similarly, we have that NC is equivalent to the problems solvable on an alternating Turing machine restricted to at most two options at each step with O(log n) space and alternations.^{[6]}
Open problem: Is NC proper?[edit]
One major open question in complexity theory is whether or not every containment in the NC hierarchy is proper. It was observed by Papadimitriou that, if NC^{i} = NC^{i+1} for some i, then NC^{i} = NC^{j} for all j ≥ i, and as a result, NC^{i} = NC. This observation is known as NChierarchy collapse because even a single equality in the chain of containments
implies that the entire NC hierarchy "collapses" down to some level i. Thus, there are 2 possibilities:
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[edit]
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 ≤ i ≤ n), and p and q are functions from {1, 2, ..., k} to {1, 2, ..., k}. Numbers 1, 2, ..., k are called states of the branching program. 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 the ith variable is 0 or 1.
A family of branching programs consists of a branching program with n variables for each n.
It is easy to show that every language L on {0,1} can be recognized by a family of branching programs of width 5 and exponential length, or by a family of exponential width and linear length.
Every regular language on {0,1} can be recognized by a family of branching programs of constant width and linear number of instructions (since a DFA can be converted to a branching program). BWBP denotes the class of languages recognizable by a family of branching programs of bounded width and polynomial length.^{[7]}
Barrington's theorem^{[8]} says that BWBP is exactly nonuniform NC^{1}. The proof uses the nonsolvability of the symmetric group S_{5}.^{[7]}
The theorem is rather surprising. For instance, it implies that the majority function can be computed by a family of branching programs of constant width and polynomial size, while intuition might suggest that to achieve polynomial size, one needs a linear number of states.
Proof of Barrington's theorem[edit]
A branching program of constant width and polynomial size can be easily converted (via divideandconquer) to a circuit in NC^{1}.
Conversely, suppose a circuit in NC^{1} 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 a permutation P and sometimes as a permutation Q, by rightmultiplying permutations in the first instruction by α, and in the last instruction leftmultiplying by β, we can make a circuit of the same length that behaves as βPα or βQα, respectively.
Call a branching program αcomputing a circuit C if it works as identity when C's output is 0, and as α 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 5cycles α, β, if there exists a branching program αcomputing a circuit C, then there exists a branching program βcomputing the circuit C, of the same length.
Lemma 2: There exist 5cycles γ, δ such that their commutator ε=γδγ^{−1}δ^{−1} is a 5cycle. For example, γ = (1 2 3 4 5), δ = (1 3 5 4 2) giving ε = (1 3 2 5 4).
We will now prove Barrington's theorem by induction:
Suppose we have a circuit C which takes inputs x_{1},...,x_{n} and assume that for all subcircuits D of C and 5cycles α, there exists a branching program αcomputing D. We will show that for all 5cycles α, there exists a branching program αcomputing C.
 If the circuit C simply outputs some input bit x_{i}, the branching program we need has just one instruction: checking x_{i}'s value (0 or 1), and outputting the identity or α (respectively).
 If the circuit C outputs ¬A for some different circuit A, create a branching program α^{−1}computing A and then multiply the output of the program by α. By Lemma 1, we get a branching program for A outputting the identity or α, i.e. αcomputing ¬A=C.
 If the circuit C outputs A∧B for circuits A and B, join the branching programs that γcompute A, δcompute B, γ^{−1}compute A, and δ^{−1}compute B for a choice of 5cycles γ and δ such that their commutator ε=γδγ^{−1}δ^{−1} is also a 5cycle. (The existence of such elements was established in Lemma 2.) If one or both of the circuits outputs 0, the resulting program will be the identity due to cancellation; if both circuits output 1, the resulting program will output the commutator ε. In other words, we get a program εcomputing A∧B. Because ε and α are two 5cycles, they are conjugate, and hence there exists a program αcomputing A∧B by Lemma 1.
By assuming the subcircuits have branching programs so that they are αcomputing for all 5cycles α∈S_{5}, we have shown C also has this property, as required.
The size of the branching program is at most 4^{d}, where d is the depth of the circuit. If the circuit has logarithmic depth, the branching program has polynomial length.
Notes[edit]
 ^ Arora & Barak (2009) p.120
 ^ ^{a} ^{b} ^{c} Arora & Barak (2009) p.118
 ^ Papadimitriou (1994) Theorem 16.1
 ^ ^{a} ^{b} Clote & Kranakis (2002) p.437
 ^ Clote & Kranakis (2002) p.12
 ^ S. Bellantoni and I. Oitavem (2004). "Separating NC along the delta axis". Theoretical Computer Science. 318: 57–78. doi:10.1016/j.tcs.2003.10.021.
 ^ ^{a} ^{b} Clote & Kranakis (2002) p.50
 ^ Barrington, David A. (1989). "BoundedWidth PolynomialSize Branching Programs Recognize Exactly Those Languages in NC^{1}" (PDF). J. Comput. Syst. Sci. 38 (1): 150–164. doi:10.1016/00220000(89)900378. ISSN 00220000. Zbl 0667.68059.
References[edit]
 Arora, Sanjeev; Barak, Boaz (2009). Computational complexity. A modern approach. Cambridge University Press. ISBN 9780521424264. Zbl 1193.68112.
 Clote, Peter; Kranakis, Evangelos (2002). Boolean functions and computation models. Texts in Theoretical Computer Science. An EATCS Series. Berlin: SpringerVerlag. ISBN 3540594361. Zbl 1016.94046.
 Greenlaw, Raymond, James Hoover, and Walter Ruzzo. Limits To Parallel computation; PCompleteness Theory. ISBN 0195085914
 Kozen, Dexter C. (1992). The design and analysis of algorithms. Lectures 28  34 and 36
 Kozen, Dexter C. (2006). Theory of Computation. Texts in Computer Science. SpringerVerlag. ISBN 1846282977. Zbl 1102.68025. Lecture 12: Relation of NC to TimeSpace Classes
 Papadimitriou, Christos (1993). "Section 15.3: The class NC". Computational Complexity (1st ed.). Addison Wesley. pp. 375–381. ISBN 0201530821.
 Straubing, Howard (1994). Finite automata, formal logic, and circuit complexity. Progress in Theoretical Computer Science. Basel: Birkhäuser. ISBN 3764337192. Zbl 0816.68086.
 Vollmer, Heribert (1998). Introduction to circuit complexity. A uniform approach. Texts in Theoretical Computer Science. Berlin: SpringerVerlag. ISBN 3540643109. Zbl 0931.68055.