# Circuit complexity

In theoretical computer science, **circuit complexity** is a branch of computational complexity theory in which Boolean functions are classified according to the size or depth of Boolean circuits that compute them. One speaks of the circuit complexity of a Boolean circuit. A related notion is the circuit complexity of a recursive language that is decided by a **uniform** family of circuits (see below).

Complexity classes defined in terms of Boolean circuits include AC^{0}, AC, TC^{0} and NC.

## Size and Depth

A Boolean circuit with input bits is a directed acyclic graph in which every node (usually called *gates* in this context) is either an input node of in-degree 0 labelled by one of the input bits, an AND gate, an OR gate, or a NOT gate. One of these gates is designated as the output gate. Such a circuit naturally computes a function of its inputs. The size of a circuit is the number of gates it contains and its depth is the maximal length of a path from an input gate to the output gate.

There are two major notions of circuit complexity (these are outlined in Sipser (1997)[1]^{:324}). The **circuit-size complexity** of a Boolean function is the minimal size of any circuit computing . The **circuit-depth complexity** of a Boolean function is the minimal depth of any circuit computing .

These notions generalize when one considers the circuit complexity of any language that contains strings with different bit lengths, especially infinite formal languages. Boolean circuits, however, only allow a fixed number of input bits. Thus no single Boolean circuit is capable of deciding such a language. To account for this possibility, one considers families of circuits where each accepts inputs of size . Each circuit family will naturally generate the language by circuit outputting when a length string is a member of the family, and otherwise. We say that a family of circuits is **size minimal** if there is no other family that decides on inputs of any size, , with a circuit of smaller size than (respectively for **depth minimal** families). Thus circuit complexity is meaningful even for non-recursive languages. The notion of a **uniform family** (see below) enables variants of circuit complexity to be related to algorithm based complexity measures of recursive languages. However, the non-uniform variant is helpful to find lower bounds on how complex any circuit family must be in order to decide given languages.

Hence, the **circuit-size complexity** of a formal language is defined as the function , that relates a bit length of an input, , to the circuit-size complexity of a minimal circuit that decides whether inputs of that length are in . The **circuit-depth complexity** is defined similarly.

## Uniformity

Boolean circuits are one of the prime examples of so-called non-uniform models of computation in the sense that inputs of different lengths are processed by different circuits, in contrast with uniform models such as Turing machines where the same computational device is used for all possible input lengths. An individual computational problem is thus associated with a particular *family* of Boolean circuits where each is the circuit handling inputs of *n* bits. A *uniformity* condition is often imposed on these families, requiring the existence of some possibly resource-bounded Turing machine that, on input *n*, produces a description of the individual circuit . When this Turing machine has a running time polynomial in *n*, the circuit family is said to be P-uniform. The stricter requirement of DLOGTIME-uniformity is of particular interest in the study of shallow-depth circuit-classes such as AC^{0} or TC^{0}. When no resource bounds are specified, a language is recursive (i.e., decidable by a Turing machine) if and only if the language is decided by a uniform family of Boolean circuits.

### Polynomial-time uniform

A family of Boolean circuits is *polynomial-time uniform* if there exists a deterministic Turing machine *M*, such that

*M*runs in polynomial time- For all ,
*M*outputs a description of on input

### Logspace uniform

A family of Boolean circuits is *logspace uniform* if there exists a deterministic Turing machine *M*, such that

*M*runs in logarithmic space- For all ,
*M*outputs a description of on input

## History

Circuit complexity goes back to Shannon (1949), who proved that almost all Boolean functions on *n* variables require circuits of size Θ(2^{n}/*n*). Despite this fact, complexity theorists have not been able to prove superpolynomial circuit lower bounds for specific Boolean functions.

On the other hand, superpolynomial lower bounds have been proved under certain restrictions on the family of circuits used. The first function for which superpolynomial circuit lower bounds were shown was the parity function, which computes the sum of its input bits modulo 2. The fact that parity is not contained in AC^{0} was first established independently by Ajtai (1983)[2] and by Furst, Saxe and Sipser (1984).[3] Later improvements by Håstad (1987) in fact establish that any family of constant-depth circuits computing the parity function requires exponential size. Smolensky (1987) proved that this is true even if the circuit is augmented with gates computing the sum of its input bits modulo some odd prime *p*.

The *k*-clique problem is to decide whether a given graph on *n* vertices has a clique of size *k*. For any particular choice of the constants *n* and *k*, the graph can be encoded in binary using bits, which indicate for each possible edge whether it is present. Then the *k*-clique problem is formalized as a function such that outputs 1 if and only if the graph encoded by the string contains a clique of size *k*. This family of functions is monotone and can be computed by a family of circuits, but it has been shown that it cannot be computed by a polynomial-size family of monotone circuits (that is, circuits with AND and OR gates but without negation). The original result of Razborov (1985) was later improved to an exponential-size lower bound by Alon and Boppana (1987). Rossman (2008) shows that constant-depth circuits with AND, OR, and NOT gates require size to solve the *k*-clique problem even in the average case. Moreover, there is a circuit of size that computes .

Raz and McKenzie later showed that the monotone NC hierarchy is infinite (1999).

The Integer Division Problem lies in uniform TC^{0} (Hesse 2001).

## Circuit lower bounds

Circuit lower bounds are generally difficult. Known results include

- Parity is not in nonuniform AC
^{0}, proved by Ajtai (1983) and by Furst, Saxe and Sipser. - Uniform TC
^{0}is strictly contained in PP, proved by Allender. - The classes S
^{P}_{2}, PP[4] and MA/1[5] (MA with one bit of advice) are not in**SIZE**(n^{k}) for any constant k. - While it is suspected that the nonuniform class ACC
^{0}does not contain the majority function, it was only in 2010 that Williams proved that .[6]

It is open whether NEXPTIME has nonuniform TC^{0} circuits.

Proofs of circuit lower bounds are strongly connected to derandomization. A proof that would imply that either or that permanent cannot be computed by nonuniform arithmetic circuits (polynomials) of polynomial size and polynomial degree.[7]

## Complexity classes

Many circuit complexity classes are defined in terms of class hierarchies. For each nonnegative integer *i*, there is a class NC^{i}, consisting of polynomial-size circuits of depth , using bounded fan-in AND, OR, and NOT gates. We can talk about the union NC of all of these classes. By considering unbounded fan-in gates, we construct the classes AC^{i} and AC (which is equal to NC). We may construct many other circuit complexity classes with the same size and depth restrictions by allowing different sets of gates.

## Relation to time complexity

Say that a certain language, , belongs to the time-complexity class for some function . Then has circuit complexity .[1]

## Notes

- Sipser, M. (1997). 'Introduction to the theory of computation.' Boston: PWS Pub. Co.
- Ajtai, Miklós; Komlós, János; Szemerédi, Endre (1983).
*An 0(n log n) sorting network*.*STOC '83 Proceedings of the Fifteenth Annual ACM Symposium on Theory of Computing*. pp. 1–9. ISBN 978-0-89791-099-6. - Furst, Merrick; Saxe, James B.; Sipser, Michael (1984). "Parity, circuits, and the polynomial-time hierarchy".
*Mathematical Systems Theory*.**17**(1): 13–27. doi:10.1007/BF01744431. MR 0738749. - See proof
- Santhanam, Rahul (2007). "Circuit lower bounds for Merlin-Arthur classes".
*STOC 2007: Proceedings of the thirty-ninth annual ACM symposium on Theory of computing*. pp. 275–283. CiteSeerX 10.1.1.92.4422. doi:10.1145/1250790.1250832. - Williams, Ryan (2011). "Non-Uniform ACC Circuit Lower Bounds" (PDF).
*CCC 2011: Proceedings of the 26th Annual IEEE Conference on Computational Complexity*. pp. 115–125. doi:10.1109/CCC.2011.36. - Kabanets, V.; Impagliazzo, R. (2004). "Derandomizing polynomial identity tests means proving circuit lower bounds".
*Computational Complexity*.**13**(1): 1–46. doi:10.1007/s00037-004-0182-6.

## References

- Ajtai, Miklós (1983). "-formulae on finite structures".
*Annals of Pure and Applied Logic*.**24**: 1–24. doi:10.1016/0168-0072(83)90038-6. - Alon, Noga; Boppana, Ravi B. (1987). "The monotone circuit complexity of Boolean functions".
*Combinatorica*.**7**(1): 1–22. CiteSeerX 10.1.1.300.9623. doi:10.1007/bf02579196. - Furst, Merrick L.; Saxe, James B.; Sipser, Michael (1984). "Parity, circuits, and the polynomial-time hierarchy".
*Mathematical Systems Theory*.**17**(1): 13–27. doi:10.1007/bf01744431. - Håstad, Johan (1987),
*Computational limitations of small depth circuits*(PDF), Ph.D. thesis, Massachusetts Institute of Technology. - Hesse, William (2001). "Division is in uniform TC
^{0}".*Proc. 28th International Colloquium on Automata, Languages and Programming*. Springer. pp. 104–114. - Raz, Ran; McKenzie, Pierre (1999). "Separation of the monotone NC hierarchy".
*Combinatorica*.**19**(3): 403–435. doi:10.1007/s004930050062. - Razborov, Alexander A. (1985). "Lower bounds on the monotone complexity of some Boolean functions".
*Mathematics of the USSR, Doklady*.**31**: 354–357. - Rossman, Benjamin (2008). "On the constant-depth complexity of k-clique".
*STOC 2008: Proceedings of the 40th annual ACM symposium on Theory of computing*. ACM. pp. 721–730. doi:10.1145/1374376.1374480. - Shannon, Claude E. (1949). "The synthesis of two-terminal switching circuits".
*Bell System Technical Journal*.**28**(1): 59–98. doi:10.1002/j.1538-7305.1949.tb03624.x. - Smolensky, Roman (1987). "Algebraic methods in the theory of lower bounds for Boolean circuit complexity".
*Proc. 19th Annual ACM Symposium on Theory of Computing*. ACM. pp. 77–82. doi:10.1145/28395.28404. - Vollmer, Heribert (1999).
*Introduction to Circuit Complexity: a Uniform Approach*. Springer Verlag. ISBN 978-3-540-64310-4. - Wegener, Ingo (1987).
*The Complexity of Boolean Functions*. John Wiley and Sons Ltd, and B. G. Teubner, Stuttgart. ISBN 978-3-519-02107-0. At the time an influential textbook on the subject, commonly known as the "Blue Book". Also available for download (PDF) at the Electronic Colloquium on Computational Complexity. - Lecture notes for a course of Uri Zwick on circuit complexity
*Circuit Complexity before the Dawn of the New Millennium*, a 1997 survey of the field by Eric Allender slides.