Constant-depth Circuits Research Articles

New degree bounds for polynomial threshold functions

A real multivariate polynomial p(x 1, …, x n ) is said to sign-represent a Boolean function f: {0,1}n →{−1,1} if the sign of p(x) equals f(x) for all inputs x∈{0,1}n . We give new upper and lower bounds on the degree of polynomials which sign-represent Boolean functions. Our upper bounds for Boolean formulas yield the first known subexponential time learning algorithms for formulas of superconstant depth. Our lower bounds for constant-depth circuits and intersections of halfspaces are the first new degree lower bounds since 1968, improving results of Minsky and Papert. The lower bounds are proved constructively; we give explicit dual solutions to the necessary linear programs.

Amplifying lower bounds by means of self-reducibility

We observe that many important computational problems in NC 1 share a simple self-reducibility property. We then show that, for any problem A having this self-reducibility property, A has polynomial-size TC 0 circuits if and only if it has TC 0 circuits of size n 1+ϵ for every ϵ> 0 (counting the number of wires in a circuit as the size of the circuit). As an example of what this observation yields, consider the Boolean Formula Evaluation problem (BFE), which is complete for NC 1 and has the self-reducibility property. It follows from a lower bound of Impagliazzo, Paturi, and Saks, that BFE requires depth d TC 0 circuits of size n 1+ϵ d . If one were able to improve this lower bound to show that there is some constant ϵ> 0 (independent of the depth d ) such that every TC 0 circuit family recognizing BFE has size at least n 1+ϵ , then it would follow that TC 0 ≠ NC 1 . We show that proving lower bounds of the form n 1+ϵ is not ruled out by the Natural Proof framework of Razborov and Rudich and hence there is currently no known barrier for separating classes such as ACC 0 , TC 0 and NC 1 via existing “natural” approaches to proving circuit lower bounds. We also show that problems with small uniform constant-depth circuits have algorithms that simultaneously have small space and time bounds. We then make use of known time-space tradeoff lower bounds to show that SAT requires uniform depth d TC 0 and AC 0 [6] circuits of size n 1+ c for some constant c depending on d .

Hardness Amplification Proofs Require Majority

Hardness amplification is the fundamental task of converting a $\delta$-hard function $f:\{0,1\}^n\to\{0,1\}$ into a $(1/2-\epsilon)$-hard function $\mathit{Amp}(f)$, where $f$ is $\gamma$-hard if small circuits fail to compute $f$ on at least a $\gamma$ fraction of the inputs. In this paper we study the complexity of black-box proofs of hardness amplification. A class of circuits $\mathcal{D}$ proves a hardness amplification result if for any function $h$ that agrees with $\mathit{Amp}(f)$ on a $1/2+\epsilon$ fraction of the inputs there exists an oracle circuit $D\in\mathcal{D}$ such that $D^h$ agrees with $f$ on a $1-\delta$ fraction of the inputs. We focus on the case where every $D\in\mathcal{D}$ makes nonadaptive queries to $h$. This setting captures most hardness amplification techniques. We prove two main results: (1) The circuits in $\mathcal{D}$ “can be used” to compute the majority function on $1/\epsilon$ bits. In particular, when $\epsilon\leq1/\log^{\omega(1)}n$, $\mathcal{D}$ cannot consist of oracle circuits that have unbounded fan-in, size $\mathrm{poly}(n)$, and depth $O(1)$. (2) The circuits in $\mathcal{D}$ must make $\Omega\left(\log(1/\delta)/\epsilon^2\right)$ oracle queries. Both our bounds on the depth and on the number of queries are tight up to constant factors. Our results explain why hardness amplification techniques have failed to transform known lower bounds against constant-depth circuit classes into strong average-case lower bounds. Our results reveal a contrast between Yao's XOR lemma ($\mathit{Amp}(f):=f(x_1)\oplus\cdots\oplus f(x_t)\in\{0,1\}$) and the direct-product lemma ($\mathit{Amp}(f):=f(x_1)\circ\cdots\circ f(x_t)\in\{0,1\}^t$; here $\mathit{Amp}(f)$ is non-Boolean). Our results (1) and (2) apply to Yao's XOR lemma, whereas known proofs of the direct-product lemma violate both (1) and (2). One of our contributions is a new technique for handling “nonuniform” reductions, i.e., the case when $\mathcal{D}$ contains many circuits.

Efficient one-way quantum computations for quantum error correction

We show how to explicitly construct an O(nd) size and constant quantum depth circuit which encodes any given n-qubit stabilizer code with d generators. Our construction is derived using the graphic description for stabilizer codes and the one-way quantum computation model. Our result demonstrates how to use cluster states as scalable resources for many multi-qubit entangled states and how to use the one-way quantum computation model to improve the design of quantum algorithms.

Learning a circuit by injecting values

We propose a new model for exact learning of acyclic circuits using experiments in which chosen values may be assigned to an arbitrary subset of wires internal to the circuit, but only the value of the circuit's single output wire may be observed. We give polynomial time algorithms to learn (1) arbitrary circuits with logarithmic depth and constant fan-in and (2) Boolean circuits of constant depth and unbounded fan-in over AND, OR, and NOT gates. Thus, both AC0 and NC1 circuits are learnable in polynomial time in this model. Negative results show that some restrictions on depth, fan-in and gate types are necessary: exponentially many experiments are required to learn AND/OR circuits of unbounded depth and fan-in; it is NP-hard to learn AND/OR circuits of unbounded depth and fan-in 2; and it is NP-hard to learn circuits of constant depth and unbounded fan-in over AND, OR, and threshold gates, even when the target circuit is known to contain at most one threshold gate and that threshold gate has threshold 2. We also consider the effect of adding an oracle for behavioral equivalence. In this case there are polynomial-time algorithms to learn arbitrary circuits of constant fan-in and unbounded depth and to learn Boolean circuits with arbitrary fan-in and unbounded depth over AND, OR, and NOT gates. A corollary is that these two classes are PAC-learnable if experiments are available. Finally, we consider an extension of the model called the synchronous model. We show that an even more general class of circuits are learnable in this model. In particular, we are able to learn circuits with cycles.

Randomness-Efficient Sampling within NC1

We construct a randomness-efficient averaging sampler that is computable by uniform constant-depth circuits with parity gates (i.e., in uniform AC 0[⊕]). Our sampler matches the parameters achieved by random walks on constant-degree expander graphs, allowing us to apply a variety expander-based techniques within NC 1. For example, we obtain the following results: Our sampler is based on the zig-zag graph product of Reingold, Vadhan & Wigderson (Annals of Math 2002) and as part of our analysis we givean elementary proof of a generalization of Gillman’s Chernoff Bound for Expander Walks (SIAM Journal on Computing 1998).

Random Access to Advice Strings and Collapsing Results

We propose a model of computation where a Turing machine is given random access to an advice string. With random access, an advice string of exponential length becomes meaningful for polynomially bounded complexity classes. We compare the power of complexity classes under this model. It gives a more stringent notion than the usual model of computation with relativization. Under this model of random access, we prove that there exist advice strings such that the polynomial-time hierarchy PH and parity polynomial-time ⊕P all collapse to P. Our main proof technique uses the decision tree lower bounds for constant depth circuits [Y], [C], [Ha], and the algebraic machinery of Razborov [R] and Smolensky [S].

Quantum lower bounds for fanout

We consider the resource bounded quantum circuit model with circuits restricted by the number of qubits they act upon and by their depth. Focusing on natural universal sets of gates which are familiar from classical circuit theory, several new lower bounds for constant depth quantum circuits are proved. The main result is that parity (and hence fanout) requires log depth quantum circuits, when the circuits are composed of single qubit and arbitrary size Toffoli gates, and when they use only constantly many ancill\ae. Under this constraint, this bound is close to optimal. In the case of a non-constant number $a$ of ancill\ae\ and $n$ input qubits, we give a tradeoff between $a$ and the required depth, that results in a non-constant lower bound for fanout when $a = n^{1-o(1)}$. We also show that, regardless of the number of ancill\ae\, arbitrary arity Toffoli gates cannot be simulated exactly by a constant depth circuit family with gates of bounded arity.

The complexity of constructing pseudorandom generators from hard functions

We study the complexity of constructing pseudorandom generators (PRGs) from hard functions, focussing on constant-depth circuits. We show that, starting from a function $$f:\{ 0,1\} ^l \to \{ 0,1\} $$ computable in alternating time O(l) with O(1) alternations that is hard on average (i.e. there is a constant $$\epsilon > 0$$ such that every circuit of size $$2^{\epsilon l} $$ fails to compute f on at least a 1/poly(l) fraction of inputs) we can construct a $${\text{PRG}}:\{ 0,1\} ^{O(\log n)} \to \{ 0,1\} ^n $$ computable by DLOGTIME-uniform constant-depth circuits of size polynomial in n. Such a PRG implies $$BP \cdot AC^0 = AC^0 $$ under DLOGTIME-uniformity. On the negative side, we prove that starting from a worst-case hard function $$f:\{ 0,1\} ^l \to \{ 0,1\} $$ (i.e. there is a constant $$\epsilon > 0$$ such that every circuit of size $$2^{\epsilon l} $$ fails to compute f on some input) for every positive constant $$\delta < 1$$ there is no black-box construction of a $${\text{PRG}}:\{ 0,1\} ^{\delta n} \to \{ 0,1\} ^n $$ computable by constant-depth circuits of size polynomial in n. We also study worst-case hardness amplification, which is the related problem of producing an average-case hard function starting from a worst-case hard one. In particular, we deduce that there is no blackbox worst-case hardness amplification within the polynomial time hierarchy. These negative results are obtained by showing that polynomialsize constant-depth circuits cannot compute good extractors and listdecodable codes.

A Note on MODp - MODm Circuits

We give a new proof of recent results of Grolmusz and Tardos on the computing power of constant-depth circuits consisting of a single layer of $MOD_m$ gates followed by a fixed number of layers of $MOD_{p^k}$ -gates, where p is prime.

A Superpolynomial Lower Bound for a Circuit Computing the Clique Function with at most (1/6)log log n Negation Gates

In this paper, we investigate the lower bound on the number of gates in a Boolean circuit that computes the clique function with a limited number of negation gates. To derive strong lower bounds on the size of such a circuit we develop a new approach by combining three approaches: the restriction applied to constant depth circuits due to Hastad, the approximation method applied to monotone circuits due to Razborov, and the boundary covering developed in the present paper. We prove that if a circuit $C$ with at most $\floor{(1/6) \log \log m}$ negation gates detects cliques of size $(\log m)^{3(\log m)^{1/2}}$ in a graph with $m$ vertices, then $C$ contains at least $2^{(1/5)(\log m)^{(\log m)^{1/2}}}$ gates. No nontrivial lower bounds on the size of such circuits were previously known, even if we restrict the number of negation gates to be a constant. Moreover, it follows from a result of Fischer [{\it Lect. Notes Comput. Sci.,} 33 (1974), pp. 71--82] that if one can improve the number of negation gates from $\floor{(1/6)\log\log m}$ to $\floor{2\log m}$ in the statement, then we have P $\neq$ NP. We also show that the problem of lower bounding the negation-limited circuit complexity can be reduced to the one of lower bounding the maximum of the monotone circuit complexity of the functions in a certain class of monotone functions.

On learning monotone DNF under product distributions

We show that the class of monotone 2 O ( log n ) -term DNF formulae can be PAC learned in polynomial time under the uniform distribution from random examples only. This is an exponential improvement over the best previous polynomial-time algorithms in this model, which could learn monotone o(log 2 n )-term DNF. We also show that various classes of small constant-depth circuits which compute monotone functions are PAC learnable in polynomial time under the uniform distribution. All of our results extend to learning under any constant-bounded product distribution.

Number-theoretic constructions of efficient pseudo-random functions

We describe efficient constructions for various cryptographic primitives in private-key as well as public-key cryptography. Our main results are two new constructions of pseudo-random functions. We prove the pseudo-randomness of one construction under the assumption that factoring (Blum integers) is hard while the other construction is pseudo-random if the decisional version of the Diffie--Hellman assumption holds. Computing the value of our functions at any given point involves two subset products. This is much more efficient than previous proposals. Furthermore, these functions have the advantage of being in TC 0 (the class of functions computable by constant depth circuits consisting of a polynomial number of threshold gates). This fact has several interesting applications. The simple algebraic structure of the functions implies additional features such as a zero-knowledge proof for statements of the form " y = f s ( x )" and " y ≠ f s ( x )" given a commitment to a key s of a pseudo-random function f s .

On Proving Circuit Lower Bounds against the Polynomial-Time Hierarchy

We consider the problem of proving circuit lower bounds against the polynomial-time hierarchy. We give both positive and negative results. For the positive side, for any fixed integer k>>0, we give an explicit $\Sigma^{\rm p}_2$ language, acceptable by a $\Sigma^{\rm p}_2$ machine with running time O(nk2+k ), that requires circuit size >nk. This provides a constructive version of an existence theorem of R. Kannan [Inform. and Control, 55 (1982), pp. 40--56]. Our main theorem is on the negative side. We give evidence that it is infeasible to give relativizable proofs that any single language in the polynomial-time hierarchy requires superpolynomial circuit size. Our proof techniques are based on the decision tree version of the Switching Lemma for constant depth circuits and the Nisan--Wigderson pseudorandom generator. We also take this opportunity to publish some previously unpublished older results of the first author on constant depth circuits, both straight lower bounds and inapproximability results based on decision tree--type Switching Lemmas.

Lower Bounds for Matrix Product in Bounded Depth Circuits with Arbitrary Gates

We prove superlinear lower bounds for the number of edges in constant depth circuits with n inputs and up to n outputs. Our lower bounds are proved for all types of constant depth circuits, e.g., constant depth arithmetic circuits and constant depth Boolean circuits with arbitrary gates. The bounds apply for several explicit functions and, most importantly, for matrix product. In particular, we obtain the following results: We show that the number of edges in any constant depth arithmetic circuit for matrix product (over any field) is superlinear in m2 (where m × m is the size of each matrix). That is, the lower bound is superlinear in the number of input variables. Moreover, if the circuit is bilinear, the result applies also for the case in which the circuit gets any product of two linear functions for free. We show that the number of edges in any constant depth arithmetic circuit for the trace of the product of three matrices (over fields with characteristic 0) is superlinear in m2. (Note that the trace is a single-output function.) We give explicit examples for n Boolean functions f1,. . .,fn, such that any constant depth Boolean circuit with arbitrary gates for f1,. . .,fn has a superlinear number of edges. The lower bound is also proved for circuits with arbitrary gates over any finite field. The bound applies for matrix product over finite fields as well as for several other explicit functions.

Counting, fanout and the complexity of quantum ACC

We propose definitions of QAC0, the quantum analog of the classical class AC0 of constant-depth circuits with AND and OR gates of arbitrary fan-in, and QACC[q], the analog of the class ACC[q] where...

Uniform constant-depth threshold circuits for division and iterated multiplication

It has been known since the mid-1980s (SIAM J. Comput. 15 (1986) 994; SIAM J. Comput. 21 (1992) 896) that integer division can be performed by poly-time uniform constant-depth circuits of Majority gates; equivalently, the division problem lies in P-uniform TC 0. Recently, this was improved to L-uniform TC 0 (RAIRO Theoret. Inform. Appl. 35 (2001) 259), but it remained unknown whether division can be performed by DLOGTIME-uniform TC 0 circuits. The DLOGTIME uniformity condition is regarded by many as being the most natural notion of uniformity to apply to small circuit complexity classes such as TC 0; DLOGTIME-uniform TC 0 is also known as FOM, because it corresponds to first-order logic with Majority quantifiers, in the setting of finite model theory. Integer division has been the outstanding example of a natural problem known to be in a P-uniform circuit complexity class, but not known to be in its DLOGTIME-uniform version. We show that indeed division is in DLOGTIME-uniform TC 0. First we show that division lies in the complexity class FOM+POW obtained by augmenting FOM with a predicate for powering modulo small primes. Then we show that the predicate POW itself lies in FOM. (In fact, it lies in FO, or DLOGTIME-uniform AC 0.) The essential idea in the fast parallel computation of division and related problems is that of Chinese remainder representation (CRR)—storing a number in the form of its residues modulo many small primes. The fact that CRR operations can be carried out in log space has interesting implications for small space classes. We define two versions of s( n) space for s(n)=o( log n) : dspace( s( n)) as the traditional version where the worktape begins blank, and DSPACE( s( n)) where the space bound is established by endmarkers before the computation starts. We present a new translational lemma characterizing the unary languages in the DSPACE classes. It is known (Theoret. Comput. Sci. 3 (1976) 213) that {0 n : n is prime} ∉ dspace( log log n) . We show that if this can be improved to {0 n : n is prime} ∉ DSPACE( log log n) , it follows that L≠NP.

Counting, fanout and the complexity of quantum ACC

We propose definitions of QAC^0, the quantum analog of the classical class AC^0 of constant-depth circuits with AND and OR gates of arbitrary fan-in, and QACC[q], the analog of the class ACC[q] where Mod_q gates are also allowed. We prove that parity or fanout allows us to construct quantum MOD_q gates in constant depth for any q, so QACC[2] = QACC. More generally, we show that for any q,p &gt; 1, MOD_q is equivalent to MOD_p (up to constant depth and polynomial size). This implies that QAC^0 with unbounded fanout gates, denoted QACwf^0, is the same as QACC[q] and QACC for all q. Since \ACC[p] \ne ACC[q] whenever p and q are distinct primes, QACC[q] is strictly more powerful than its classical counterpart, as is QAC^0 when fanout is allowed. This adds to the growing list of quantum complexity classes which are provably more powerful than their classical counterparts. We also develop techniques for proving upper bounds for QACC in terms of related language classes. We define classes of languages closely related to QACC[2] and show that restricted versions of them can be simulated by polynomial-size circuits. With further restrictions, language classes related to QACC[2] operators can be simulated by classical threshold circuits of polynomial size and constant depth.

An exact characterization of symmetric functions in qAC0[2

qAC 0[2] is the class of languages computable by circuits of constant depth and quasi-polynomial (2 log O(1) n ) size with unbounded fan-in AND, OR, and PARITY gates. Symmetric functions are those functions that are invariant under permutations of the input variables. Thus, a symmetric function f n : {0,1} n→{0,1} can also be seen as a function f n : {0,1,…,n}→{0,1} . We give the following characterization of symmetric functions in qAC 0[2], according to how f n ( x) changes as x grows from 0 to n. A symmetric function f=(f n) n∈ N is in qAC 0[2] if and only if f n has period 2 t( n) =log O(1) n except within both ends of length log O(1) n.

Lower bounds for modular counting by circuits with modular gates

We prove that constant depth circuits, with one layer of MOD m gates at the inputs, followed by a fixed number of layers of MOD p gates, where p is prime, require exponential size to compute the MOD q function, if q is a prime that divides neither p nor q.