User:Jaydavidmartin/Circuit complexity

In computational complexity theory, a circuit family is an infinite list of Boolean circuits that represents a formal language. Each circuit in the circuit family has a different input size.

Boolean circuits
Boolean circuits are simplified models of the digital circuits used in modern computers. Formally, a Boolean circuit $$C$$ is a directed acyclic graph in which edges represent wires (which carry the bit values 0 and 1), the input bits are represented by source vertices (vertices with no incoming edges), and all non-source vertices represent logic gates (generally the AND, OR, and NOT gates). One logic gate is designated the output gate, and represents the end of the computation. The input/output behavior of a circuit $$C$$ with $$n$$ input variables is represented by the Boolean function $$f_C:\{0,1\}^n \to \{0,1\}$$; for example, on input bits $$x_1,x_2,...,x_n$$, the output bit $$b$$ of the circuit is represented mathematically as $$b = f_C(x_1,x_2,...,x_n)$$. The circuit $$C$$ is said to compute the Boolean function $$f_C$$.

Formal languages
Computational problems are represented as collections of strings known as languages. In the Turing machine model, a particular language can be defined as the set of input strings that a Turing machine running a particular algorithm accepts. For example, a Turing machine can run an algorithm that accepts all strings that contain only zeros; this Turing machine is said to accept the language $$L=\{0^n|n \geq 0\}$$. It will be shown below how a circuit family can similarly be used to define a language.

Formal definition
A circuit family is an infinite list of circuits $$(C_0,C_1,C_2,...)$$, where $$C_n$$ has $$n$$ input variables. In other words, for every possible input size there is exactly one corresponding circuit in the circuit family.

A circuit family is said to decide a language $$L$$ if, for every string $$w$$, $$w \in L$$ if and only if $$C_n(w)=1$$, where $$n$$ is the length of $$w$$. In other words, a language is the set of strings which, when applied to the circuit corresponding to their length, evaluate to 1.

Complexity measures
The complexity measures of Boolean circuits naturally extend to circuit families. The two most important such complexity measures are size (the number of nodes in a circuit) and depth (the length of the longest directed path from an input node to the output node).

Circuit size generalizes in the following way: the size complexity of a circuit family $$(C_0,C_1,...)$$ is the function $$f:\mathbb{N} \to \mathbb{N}$$, where $$f(n)$$ is the circuit size of $$C_n$$. In other words, the size complexity of a circuit family is a function that maps the input size to the number of nodes in the circuit in the circuit family corresponding to that input size. Circuit depth extends to circuit families in a similar manner.

Complexity classes
The complexity measures described above enable the use of different classes of functions to define complexity classes over circuit families. One essential such class, known as P/poly, is the circuit analogue to the time-complexity class P. This class is defined as the class of circuits for which the circuit size complexity function $$f$$ is a polynomial. P/poly is not only an intuitive analogue to P, but it also has number of properties that make it highly useful in the study of the relationships between complexity classes. In particular, it is helpful in investigating problems related to P versus NP. For example, it is known that if there is any language in NP that is not in P/poly, then P$$\neq$$NP. P/poly also aids in the general study of Turing machines, for it can be equivalently be defined as the class of languages recognized by a polynomial-time Turing machine with a polynomial-bounded advice function.

Relation to time complexity
There turns out to be a natural connection between circuit size complexity and time complexity. Intuitively, a language with small time complexity (that is, requires relatively few sequential operations on a Turing machine), also has a small circuit complexity (that is, requires relatively few Boolean operations). More explicitly, it can be shown that if a language is in $$\mathsf{TIME}(t(n))$$, where $$t$$ is a function $$t:\mathbb{N} \to \mathbb{N}$$, then it has circuit complexity $$O(t^2(n))$$.

It follows directly from this result that P$$\subseteq$$P/poly. It is further known that P/poly is strictly larger than P (i.e. P$$\subsetneq$$P/poly); that is, there are languages that are known to be in P/poly that are not in P.