A Casual Tour Around a Circuit Complexity Bound

Recall that NTIME[t(n)] denotes the class of languages (decision problems) solvable by nondeterministic algorithms running in time t(n) on inputs of length n. So L ∈ NTIME[t(n)] provided that there is a nondeterministic algorithm such that for all strings x ∈ L, there is a computation path of t(|x|) steps that results in acceptance of x, and for x / ∈ L, every possible computation path of t(|x|) steps results in rejection of x. We define NEXP = k>0 NTIME[2 n k ]. NEXP informally corresponds to problems with exponentially long solutions which are verifiable in exponential time. This class encompasses everything considered feasibly computable (and more): NP, PSPACE, EXP, etc.

The nondeterministic time hierarchy [SFM78,Zak83] says that, as one permits longer solutions to problems and longer verification time for those solutions, one can always find strictly more problems with verifiable solutions, under the constraints. In notation, NTIME[t(n)] NTIME[T (n)] for t(n + 1) ≤ o(T (n)). One consequence of the nondeterministic time hierarchy is that NEXP = NP. 1

With the usual uniform models of computation (Turing machines, lambda calculus, µ-recursive functions, etc.), a function only counts as computable provided we can find a single algorithm in the model that computes the function on all possible finite inputs. Similarly, in complexity theory, a function is only efficiently computable if a single algorithm runs efficiently on all finite inputs. Suppose I allow you to run a different algorithm A n for every distinct input length n. This amounts to having a countably infinite set of algorithms, which looks unrealistic. 2 But by permitting the length of a program to grow with the input length, we can more accurately model algorithms in practice that exploit the fact that there is an upper bound on the inputs they receive. Could there be a program for 3SAT with a billion lines of code that rapidly solves 3SAT on all formulas with less than a billion clauses? Nonuniform complexity can address questions of this form.

We will imagine an infinite family of algorithms {A n } as a family of logical circuits, where A n takes n bits of input and returns a bit. (We’ll work exclusively over the binary alphabet, for simplicity.) The classes of circuits considered in this article are, in increasing order of expressiveness:

• AC 0 , the class of circuits with constant depth and polynomial size, having unbounded fan-in AND, OR, and NOT gates,

, the class of circuits with constant depth and polynomial size, having unbounded fan-in MODm, AND, OR, and NOT gates (where a MODm gate outputs 1 iff the sum of its inputs is divisible by m),

• ACC, the union over all m of the classes AC 0 [m],3 and

• P/poly, the class consisting of arbitrary polynomial size Boolean circuits with bounded fan-in AND and OR gates, and NOT gates.

(One can take the “size” of a circuit to be either the number of gates or the number of wires; for us, the choice won’t matter.) We will identify the circuit classes above with their corresponding language classes, which consists of all decision problems solvable with an infinite family of such circuits. So, “NP ⊂ P/poly” states that every problem in NP can be solved with an infinite circuit family {C n } drawn from P/poly, where each C n is run on inputs of length n.

A routine fact is that P ⊂ P/poly: problems solvable in polynomial time by some algorithm can be solved by an infinite family of polynomial size circuits. Therefore, our restriction to considering circuits rather than arbitrary “growing” programs is actually without loss of generality: a poly(n)-time program with poly(n) lines of code can be simulated by a poly(n)-size circuit on all n-bit inputs, although the underlying polynomials may not have the same degrees.4

What uniform computations can be simulated in P/poly? This is largely open. Randomized complexity classes like RP and BPP are in P/poly, but we do not believe that NP-complete problems can be solved with polynomial size circuit families. However, proving NP ⊂ P/poly is only stronger than P = NP. The “smallest” uniform complexity class that we know is not contained in P/poly is MA EXP , the exponentialtime version of Merlin-Arthur games [BFT98]. Kabanets and Impagliazzo [KI04] “almost” proved that the slightly smaller class NEXP RP (nondeterministic exponential time with an RP oracle) isn’t in P/poly: either NEXP RP doesn’t have arithmetic polysize circuits, or it doesn’t have (the usual Boolean) polysize circuits. Both MA EXP and NEXP RP are enormous classes, containing NEXP and more.

So while we can show that certain functions cannot have polynomial size circuits, those functions are extremely difficult for uniform algorithms to compute. But it could still be true that EXP NP ⊂ P/poly. This looks crazy; if true, it would not only mean that every problem with exponentially long solutions can be solved with polynomial size circuits, but that every problem in EXP NP has “highly compres

This content is AI-processed based on open access ArXiv data.