DOCSLIB.ORG

Circuit Complexity Circuit Model Aims to Offer Unconditional Lower Bound Results

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Circuit Complexity Circuit Model Aims to Offer Unconditional Lower Bound Results Circuit Complexity Circuit model aims to offer unconditional lower bound results. Computational Complexity, by Fu Yuxi Circuit Complexity 1 / 58 Synopsis 1. Boolean Circuit Model 2. Uniform Circuit 3. P=poly 4. Karp-Lipton Theorem 5. NC and AC 6. P-Completeness Computational Complexity, by Fu Yuxi Circuit Complexity 2 / 58 Boolean Circuit Model Computational Complexity, by Fu Yuxi Circuit Complexity 3 / 58 Boolean circuit is a nonuniform computation model that allows a different algorithm to be used for each input size. Boolean circuit model appears mathematically simpler, with which one can talk about combinatorial structure of computation. Computational Complexity, by Fu Yuxi Circuit Complexity 4 / 58 Boolean Circuit An n-input, single-output boolean circuit is a dag with I n sources (vertex with fan-in 0), and I one sink (vertex with fan-out 0). All non-source vertices are called gates and are labeled with I _; ^ (vertex with fan-in 2), and I : (vertex with fan-in 1). A Boolean circuit is monotone if it contains no :-gate. If C is a boolean circuit and x 2 f0; 1gn is some input, then the output of C on x, denoted by C(x), is defined in the natural way. Computational Complexity, by Fu Yuxi Circuit Complexity 5 / 58 Example 1. f1n j n 2 Ng. 2. fhm; n; m+ni j m; n 2 Ng. Computational Complexity, by Fu Yuxi Circuit Complexity 6 / 58 Boolean Circuit Family The size of a circuit C, notation jCj, is the number of gates in it. Let S : N ! N be a function. An S(n)-size boolean circuit family is a sequence fCngn2N of boolean circuits, where Cn has n inputs and a single output, and jCnj ≤ S(n) for every n. Computational Complexity, by Fu Yuxi Circuit Complexity 7 / 58 Circuit Model Accepts Undecidable Language A unary language L is such that L ⊆ f1n j n 2 Ng. It is accepted by a linear size boolean circuit. Fact. Not every unary language is decidable. Computational Complexity, by Fu Yuxi Circuit Complexity 8 / 58 Nonuniform Complexity Class A problem L is in SIZE(S(n)) if there exists an S(n)-size circuit family fCngn2N such n that for each x 2 f0; 1g , x 2 L iff Cn(x) = 1. Unlike in a uniform model, SIZE(cS(n)) 6= SIZE(S(n)) generally. This follows from Circuit Hierarchy Theorem. Computational Complexity, by Fu Yuxi Circuit Complexity 9 / 58 Boolean Functions are Hard 2n 2n Shannon. Most n-ary boolean functions have circuit complexity > n − o( n ). 2n 2n Lupanov. The size complexity of the hardest n-ary boolean function is < n + o( n ). 2n log n Lutz. The size complexity of the hardest n-ary boolean function is > n (1 + c n ) for some c < 1 and all large n. 1. C. Shannon. The Synthesis of Two-Terminal Switching Circuits. Bell System Technical Journal. 28:59-98, 1949. 2. O. Lupanov. The Synthesis of Contact Circuits. Dokl. Akad. Nauk SSSR (N.S.) 119:23-26, 1958. 3. J. Lutz. Almost Everywhere High Nonuniform Complexity. JCSS, 1992. Computational Complexity, by Fu Yuxi Circuit Complexity 10 / 58 Shannon's Counting Argument Fixing an output gate, the number of functions defined by S-size circuits is bounded by (S + n + 2)2S 3S (S + n + 2)2S (3e)S < S (S − 1)! S S n + 2 = (1 + )S (3e(S + n + 2))S S S n+2 S < (e S 3e(S + n + 2)) S < (3e2(S + n + 2))S S < (6e2S)S S: To define an -fraction of the functions, (7e2S)S ≥ 22n must be valid. It follows that S(log(7e2) + log S) ≥ 2n − log −1: (1) 2n 1 It is easy to see that S ≤ n − log( ) would contradict (1). Computational Complexity, by Fu Yuxi Circuit Complexity 11 / 58 By Shannon Theorem and Lupanov Theorem, the circuit Cf for the hardest n-ary boolean function f has the following bounds: 2n 2n jC j = ± o : f n n Frandsen and Miltersen have provided a proof of the following. 2n log n 1 2n log n 1 1 + − O ≤ jC j ≤ 1 + 3 + O : n n n f n n n 1. G. Frandsen and P. Miltersen. Reviewing Bounds on the Circuit Size of the Hardest Functions. Information Processing Letters, 2005. Computational Complexity, by Fu Yuxi Circuit Complexity 12 / 58 Lower Bound Frandsen and Miltersen translate a circuit into a stack machine, and bound the length of the machine by a combinatorial argument. I Inputs are numbered 1;:::; n. I Boolean operations are numbered n + 1;:::; n + s. I A program is a finite sequence of push and Boolean operation. I Push i, where i is a number for an input or an early Boolean operation. I A Boolean operation pops two elements and pushes one element. I After the execution of a program, there is exactly one element left in the stack. continued on the next two slides. Computational Complexity, by Fu Yuxi Circuit Complexity 13 / 58 Sn+s Input: A circuit C = f1;:::; ng [ i=n+1fgi = gi1 op gi2 g, where g1;:::; gn are inputs. Output: A program P that computes the same boolean function as C. Procedure: begin P is initially empty; SM(n + s) end SM(i). 1. If gi is an input, add \Push i" to P. 2. If gi has been computed by the j-th Boolean operation in P, add \Push n + j" to P. 3. If gi = gi1 op gi2 has not been computed yet, then 3.1 SM(i1). 3.2 SM(i2). 3.3 Add \op" to P. Each push increases stack size by one, and each operation decreases stack size by at most one. Since the machine stops with one value in the stack, P has precisely s + 1 push operations. Computational Complexity, by Fu Yuxi Circuit Complexity 14 / 58 jPj < (s + 1)(c + log(n + s)) for some c since the size of the argument of Push is log(n + s). n There are 22 Boolean functions. So for some function the optimal circuit has size s such that (s + 1)(c + log(n + s)) ≥ 2n: (2) 2n log(n) c We show that (2) implies the lower bound inequality s > n (1 + n − n ) for large n. 2n log(n) c 2n log(n) c n2 If s ≤ n (1 + n − n ), then n + s ≤ n (1 + n − n + 2n ). By log(1+x) < x log(e), 2n ≤ (s + 1)(c + log(n + s)) 2n log(n) c n log n c n2 ≤ (1 + − + )(n − log n + c + ( − + ) log e) n n n 2n n n 2n 2n n2 log n c n2 ≤ (n + log(n) − c + )(n − log n + c + ( − + ) log e) n2 2n n n 2n ≤ (2n=n2)(n2 − log2(n) + O(log n)) < 2n: Computational Complexity, by Fu Yuxi Circuit Complexity 15 / 58 Upper Bound (k; s)-Lupanov representation of n-ary boolean function f . _ _ r c f (x) = fi;v (a) ^ fi;v (b): i2[p] v2f0;1gs k n−k k I x = ab where a 2 f0; 1g and b 2 f0; 1g ; and p = 2 =s. k I A1; A2;:::; Ap are a partition of f0; 1g , s = jA1j = ::: = jAp−1j ≥ jApj > 0. c I fi;v (b) = 1 if v is the function table of f ( ; b) on Ai . r I fi;v (a) = 1 if a = Ai (j) for j 2 [s], necessarily unique, and v(j) = 1. Computational Complexity, by Fu Yuxi Circuit Complexity 16 / 58 Upper Bound A Circuit for f can be constructed in three steps. 1. Use 2(2k + 2n−k ) gates to compute all minterms over a and b. n−k s (c) (r) 2. Use p2 , respectively p2 , or-gates to compute fi;v , respectively fi;v , for all i; v. 3. Use 2p2n−k gates to compute f . So we may use at most 2(2k + 2n−k ) + p2n−k + 3p2n−k gates to compute f . k n k n−k s k+s I Using p ≤ 1 + 2 =s, we get the upper bound 2 =s + 2 · 2 + 3(2 + 2 + 2 =s). n I Set k = 2 log n and s = n − 3 log n. The upper bound is dominated by 2 =s. Now !! 2n 2n 2n 3 log n 2n log n log2 n ≤ = 1 + = 1 + 3 + O : s n − 3 log n n n − 3 log n n n n2 Computational Complexity, by Fu Yuxi Circuit Complexity 17 / 58 Circuit Hierarchy Theorem Theorem. If n < (2 + )S(n) < S 0(n) 2n=n for > 0, then SIZE(S(n)) ( SIZE(S 0(n)). Let 2m m = max m: S 0(n) ≥ 1 + : 4 m It follows from the assumption that 2m S(n) < 1 − : 4 + 2 m Consider the set Bn of all n-ary Boolean functions that depend on the first m inputs. 0 I By Lupanov Theorem, Bn ⊆ SIZE(S (n)) for large n. I By Shannon Theorem, Bn 6⊆ SIZE(S(n)) for large n. Computational Complexity, by Fu Yuxi Circuit Complexity 18 / 58 Uniform Circuit Computational Complexity, by Fu Yuxi Circuit Complexity 19 / 58 A boolean circuit family fCngn2N is uniform if there is an implicitly logspace n computable function mapping 1 to Cn. Computational Complexity, by Fu Yuxi Circuit Complexity 20 / 58 Uniform Circuit Family and P Theorem. A language is accepted by a uniform circuit family if and only if it is in P. `)': Trivial. `(': A detailed proof is given next. Computational Complexity, by Fu Yuxi Circuit Complexity 21 / 58 From P to Uniform Circuit Family c Suppose M is a one tape TM bounded in time by T (n) = cn .
Load more

Recommended publications
  • On Uniformity Within NC
    On Uniformity Within NC David A Mix Barrington Neil Immerman HowardStraubing University of Massachusetts University of Massachusetts Boston Col lege Journal of Computer and System Science Abstract In order to study circuit complexity classes within NC in a uniform setting we need a uniformity condition which is more restrictive than those in common use Twosuch conditions stricter than NC uniformity RuCo have app eared in recent research Immermans families of circuits dened by rstorder formulas ImaImb and a unifor mity corresp onding to Buss deterministic logtime reductions Bu We show that these two notions are equivalent leading to a natural notion of uniformity for lowlevel circuit complexity classes Weshow that recent results on the structure of NC Ba still hold true in this very uniform setting Finallyweinvestigate a parallel notion of uniformity still more restrictive based on the regular languages Here we givecharacterizations of sub classes of the regular languages based on their logical expressibility extending recentwork of Straubing Therien and Thomas STT A preliminary version of this work app eared as BIS Intro duction Circuit Complexity Computer scientists have long tried to classify problems dened as Bo olean predicates or functions by the size or depth of Bo olean circuits needed to solve them This eort has Former name David A Barrington Supp orted by NSF grant CCR Mailing address Dept of Computer and Information Science U of Mass Amherst MA USA Supp orted by NSF grants DCR and CCR Mailing address Dept of
    [Show full text]
  • Week 1: an Overview of Circuit Complexity 1 Welcome 2
    Topics in Circuit Complexity (CS354, Fall’11) Week 1: An Overview of Circuit Complexity Lecture Notes for 9/27 and 9/29 Ryan Williams 1 Welcome The area of circuit complexity has a long history, starting in the 1940’s. It is full of open problems and frontiers that seem insurmountable, yet the literature on circuit complexity is fairly large. There is much that we do know, although it is scattered across several textbooks and academic papers. I think now is a good time to look again at circuit complexity with fresh eyes, and try to see what can be done. 2 Preliminaries An n-bit Boolean function has domain f0; 1gn and co-domain f0; 1g. At a high level, the basic question asked in circuit complexity is: given a collection of “simple functions” and a target Boolean function f, how efficiently can f be computed (on all inputs) using the simple functions? Of course, efficiency can be measured in many ways. The most natural measure is that of the “size” of computation: how many copies of these simple functions are necessary to compute f? Let B be a set of Boolean functions, which we call a basis set. The fan-in of a function g 2 B is the number of inputs that g takes. (Typical choices are fan-in 2, or unbounded fan-in, meaning that g can take any number of inputs.) We define a circuit C with n inputs and size s over a basis B, as follows. C consists of a directed acyclic graph (DAG) of s + n + 2 nodes, with n sources and one sink (the sth node in some fixed topological order on the nodes).
    [Show full text]
  • A Short History of Computational Complexity
    The Computational Complexity Column by Lance FORTNOW NEC Laboratories America 4 Independence Way, Princeton, NJ 08540, USA [email protected] http://www.neci.nj.nec.com/homepages/fortnow/beatcs Every third year the Conference on Computational Complexity is held in Europe and this summer the University of Aarhus (Denmark) will host the meeting July 7-10. More details at the conference web page http://www.computationalcomplexity.org This month we present a historical view of computational complexity written by Steve Homer and myself. This is a preliminary version of a chapter to be included in an upcoming North-Holland Handbook of the History of Mathematical Logic edited by Dirk van Dalen, John Dawson and Aki Kanamori. A Short History of Computational Complexity Lance Fortnow1 Steve Homer2 NEC Research Institute Computer Science Department 4 Independence Way Boston University Princeton, NJ 08540 111 Cummington Street Boston, MA 02215 1 Introduction It all started with a machine. In 1936, Turing developed his theoretical com- putational model. He based his model on how he perceived mathematicians think. As digital computers were developed in the 40's and 50's, the Turing machine proved itself as the right theoretical model for computation. Quickly though we discovered that the basic Turing machine model fails to account for the amount of time or memory needed by a computer, a critical issue today but even more so in those early days of computing. The key idea to measure time and space as a function of the length of the input came in the early 1960's by Hartmanis and Stearns.
    [Show full text]
  • Multiparty Communication Complexity and Threshold Circuit Size of AC^0
    2009 50th Annual IEEE Symposium on Foundations of Computer Science Multiparty Communication Complexity and Threshold Circuit Size of AC0 Paul Beame∗ Dang-Trinh Huynh-Ngoc∗y Computer Science and Engineering Computer Science and Engineering University of Washington University of Washington Seattle, WA 98195-2350 Seattle, WA 98195-2350 [email protected] [email protected] Abstract— We prove an nΩ(1)=4k lower bound on the random- that the Generalized Inner Product function in ACC0 requires ized k-party communication complexity of depth 4 AC0 functions k-party NOF communication complexity Ω(n=4k) which is in the number-on-forehead (NOF) model for up to Θ(log n) polynomial in n for k up to Θ(log n). players. These are the first non-trivial lower bounds for general 0 NOF multiparty communication complexity for any AC0 function However, for AC functions much less has been known. for !(log log n) players. For non-constant k the bounds are larger For the communication complexity of the set disjointness than all previous lower bounds for any AC0 function even for function with k players (which is in AC0) there are lower simultaneous communication complexity. bounds of the form Ω(n1=(k−1)=(k−1)) in the simultaneous Our lower bounds imply the first superpolynomial lower bounds NOF [24], [5] and nΩ(1=k)=kO(k) in the one-way NOF for the simulation of AC0 by MAJ ◦ SYMM ◦ AND circuits, showing that the well-known quasipolynomial simulations of AC0 model [26]. These are sub-polynomial lower bounds for all by such circuits are qualitatively optimal, even for formulas of non-constant values of k and, at best, polylogarithmic when small constant depth.
    [Show full text]
  • Lecture 13: Circuit Complexity 1 Binary Addition
    CS 810: Introduction to Complexity Theory 3/4/2003 Lecture 13: Circuit Complexity Instructor: Jin-Yi Cai Scribe: David Koop, Martin Hock For the next few lectures, we will deal with circuit complexity. We will concentrate on small depth circuits. These capture parallel computation. Our main goal will be proving circuit lower bounds. These lower bounds show what cannot be computed by small depth circuits. To gain appreciation for these lower bound results, it is essential to first learn about what can be done by these circuits. In next two lectures, we will exhibit the computational power of these circuits. We start with one of the simplest computations: integer addition. 1 Binary Addition Given two binary numbers, a = a1a2 : : : an−1an and b = b1b2 : : : bn−1bn, we can add the two using the elementary school method { adding each column and carrying to the next. In other words, r = a + b, an an−1 : : : a1 a0 + bn bn−1 : : : b1 b0 rn+1 rn rn−1 : : : r1 r0 can be accomplished by first computing r0 = a0 ⊕ b0 (⊕ is exclusive or) and computing a carry bit, c1 = a0 ^ b0. Now, we can compute r1 = a1 ⊕ b1 ⊕ c1 and c2 = (c1 ^ (a1 _ b1)) _ (a1 ^ b1), and in general we have rk = ak ⊕ bk ⊕ ck ck = (ck−1 ^ (ak _ bk)) _ (ak ^ bk) Certainly, the above operation can be done in polynomial time. The main question is, can we do it in parallel faster? The computation expressed above is sequential. Before computing rk, one needs to compute all the previous output bits.
    [Show full text]
  • Parameterized Circuit Complexity and the W Hierarchy
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Elsevier - Publisher Connector Theoretical Computer Science ELSEVIER Theoretical Computer Science 191 (1998) 97-115 Parameterized circuit complexity and the W hierarchy Rodney G. Downey a, Michael R. Fellows b,*, Kenneth W. Regan’ a Department of Mathematics, Victoria University, P.O. Box 600, Wellington, New Zealand b Department of Computer Science, University of Victoria, Victoria, BC, Canada V8W 3P6 ‘Department of Computer Science, State University of New York at Buffalo, 226 Bell Hall, Buffalo, NY 14260-2000 USA Received June 1995; revised October 1996 Communicated by M. Crochemore Abstract A parameterized problem (L,k) belongs to W[t] if there exists k’ computed from k such that (L, k) reduces to the weight-k’ satisfiability problem for weft-t circuits. We relate the fundamental question of whether the w[t] hierarchy is proper to parameterized problems for constant-depth circuits. We define classes G[t] as the analogues of AC0 depth-t for parameterized problems, and N[t] by weight-k’ existential quantification on G[t], by analogy with NP = 3 . P. We prove that for each t, W[t] equals the closure under fixed-parameter reductions of N[t]. Then we prove, using Sipser’s results on the AC0 depth-t hierarchy, that both the G[t] and the N[t] hierarchies are proper. If this separation holds up under parameterized reductions, then the kF’[t] hierarchy is proper. We also investigate the hierarchy H[t] defined by alternating quantification over G[t].
    [Show full text]
  • Time, Hardware, and Uniformity
    This is page Printer Opaque this Time Hardware and Uniformity David Mix Barrington Neil Immerman ABSTRACT We describ e three orthogonal complexity measures parallel time amount of hardware and degree of nonuniformity which together parametrize most complexity classes Weshow that the descriptive com plexity framework neatly captures these measures using three parameters quantier depth number of variables and typ e of numeric predicates re sp ectively A fairly simple picture arises in which the basic questions in complexity theory solved and unsolved can b e understo o d as ques tions ab out tradeos among these three dimensions Intro duction An initial presentation of complexity theory usually makes the implicit as sumption that problems and hence complexity classes are linearly ordered by diculty In the Chomsky Hierarchyeach new typ e of automaton can decide more languages and the Time Hierarchy Theorem tells us that adding more time allowsaTuring machine to decide more languages In deed the word complexity is often used eg in the study of algorithms to mean worstcase Turing machine running time under which problems are linearly ordered Those of us who study structural complexityknow that the situation is actually more complicated For one thing if wewant to mo del parallel com putation we need to distinguish b etween algorithms whichtakethesame amountofwork ie sequential time wecarehowmany pro cesses are op erating in parallel and howmuch parallel time is taken These two dimen sions of complexity are identiable in all the usual mo
    [Show full text]
  • Circuit Complexity Contents 1 Announcements 2 Relation to Other
    CS221: Computational Complexity Prof. Salil Vadhan Lecture 19: Circuit Complexity 11/6 Scribe: Chris Crick Contents 1 Announcements ² Problem Set 3, problem 2: You may use ², the regular expression for the empty string. ² PS3 due tomorrow. ² Be aware that you do not necessarily have to solve all of the problems on the problem set — the point is to get you to think about them. ² Reading: Papadimitriou x4.3, x11.4 2 Relation to other complexity measures Definition: The circuit complexity or circuit size of a function f : f0; 1gn ! f0; 1g is the number of gates in the smallest boolean circuit that computes f. Circuit complexity depends our choice of a universal basis, but only up to a constant. We can therefore use any such basis to represent our circuit. Because it’s familiar and convenient, then, we will usually use AND, OR and NOT, though sometimes the set of all boolean functions of two inputs and one output is more natural. Example: To provide a sense for how one programs with circuits, we will examine the thresh- 1 if at least two x s are 1 old function Th (x ; ¢ ¢ ¢ ; x ) = f i g. Figure 1 shows a simple circuit to 2 1 n 0 otherwise compute this function. In this circuit, li = 1 if at least one of (x1; : : : ; xi) = 1. ri becomes 1 once two xis equal 1. li is just xi _ li¡1, and ri is ri¡1 _ (li¡1 ^ xi). The output node is rn. Conventions for counting circuit gates vary a little – for example, some people count the inputs in the total, while others don’t.
    [Show full text]
  • Circuit Complexity and Computational Complexity
    Circuit Complexity and Computational Complexity Lecture Notes for Math 267AB University of California, San Diego January{June 1992 Instructor: Sam Buss Notes by: Frank Baeuerle Sam Buss Bob Carragher Matt Clegg Goran Gogi¶c Elias Koutsoupias John Lillis Dave Robinson Jinghui Yang 1 These lecture notes were written for a topics course in the Mathematics Department at the University of California, San Diego during the winter and spring quarters of 1992. Each student wrote lecture notes for between two and ¯ve one and one half hour lectures. I'd like to thank the students for a superb job of writing up lecture notes. January 9-14. Bob Carragher's notes on Introduction to circuit complexity. Theorems of Shannon and Lupanov giving upper and lower bounds of circuit complexity of almost all Boolean functions. January 14-21. Matt Clegg's notes on Spira's theorem relating depth and formula size Krapchenko's lower bound on formula size over AND/OR/NOT January 23-28. Frank Baeuerle's notes on Neciporuk's theorem Simulation of time bounded TM's by circuits January 30 - February 4. John Lillis's notes on NC/AC hierarchy Circuit value problem Depth restricted circuits for space bounded Turing machines Addition is in NC1. February 6-13. Goran Gogi¶c's notes on Circuits for parallel pre¯x vector addition and for symmetric functions. February 18-20. Dave Robinson's notes on Schnorr's 2n-3 lower bound on circuit size Blum's 3n-o(n) lower bound on circuit size February 25-27. Jinghui Yang's notes on Subbotovskaya's theorem Andreev's n2:5 lower bound on formula size with AND/OR/NOT.
    [Show full text]
  • BQP and the Polynomial Hierarchy∗
    BQP and the Polynomial Hierarchy∗ Scott Aaronson† MIT ABSTRACT 1. INTRODUCTION The relationship between BQP and PH has been an open A central task of quantum computing theory is to un- problem since the earliest days of quantum computing. We derstand how BQP—Bounded-Error Quantum Polynomial- present evidence that quantum computers can solve prob- Time, the class of all problems feasible for a quantum computer— lems outside the entire polynomial hierarchy, by relating this fits in with classical complexity classes. In their original question to topics in circuit complexity, pseudorandomness, 1993 paper defining BQP, Bernstein and Vazirani [9] showed #P 1 and Fourier analysis. that BPP BQP P . Informally, this says that quan- ⊆ ⊆ First, we show that there exists an oracle relation problem tum computers are at least as fast as classical probabilistic (i.e., a problem with many valid outputs) that is solvable in computers and no more than exponentially faster (indeed, BQP, but not in PH. This also yields a non-oracle relation they can be simulated using an oracle for counting). Bern- problem that is solvable in quantum logarithmic time, but stein and Vazirani also gave evidence that BPP = BQP, 6 not in AC0. by exhibiting an oracle problem called Recursive Fourier Ω(log n) Second, we show that an oracle decision problem separat- Sampling that requires n queries on a classical com- ing BQP from PH would follow from the Generalized Linial- puter but only n queries on a quantum computer. The Nisan Conjecture, which we formulate here and which is evidence for the power of quantum computers became dra- likely of independent interest.
    [Show full text]
  • 1 Circuit Complexity
    CS 6743 Lecture 15 1 Fall 2007 1 Circuit Complexity 1.1 Definitions A Boolean circuit C on n inputs x1, . , xn is a directed acyclic graph (DAG) with n nodes of in-degree 0 (the inputs x1, . , xn), one node of out-degree 0 (the output), and every node of the graph except the input nodes is labeled by AND, OR, or NOT; it has in-degree 2 (for AND and OR), or 1 (for NOT). The Boolean circuit C computes a Boolean function f(x1, . , xn) in the obvious way: the value of the function is equal to the value of the output gate of the circuit when the input gates are assigned the values x1, . , xn. The size of a Boolean circuit C, denoted |C|, is defined to be the total number of nodes (gates) in the graph representation of C. The depth of a Boolean circuit C is defined as the length of a longest path (from an input gate to the output gate) in the graph representation of the circuit C. A Boolean formula is a Boolean circuit whose graph representation is a tree. Given a family of Boolean functions f = {fn}n≥0, where fn depends on n variables, we are interested in the sizes of smallest Boolean circuits Cn computing fn. Let s(n) be a function such that |Cn| ≤ s(n), for all n. Then we say that the Boolean function family f is computable by Boolean circuits of size s(n). If s(n) is a polynomial, then we say that f is computable by polysize circuits.
    [Show full text]
  • On AC0[⊕] and Variants of the Majority Function
    Electronic Colloquium on Computational Complexity, Report No. 133 (2019) More on AC0[⊕] and Variants of the Majority Function Nutan Limaye∗ Srikanth Srinivasan y Utkarsh Tripathi z Abstract In this paper we prove two results about AC0[⊕] circuits. 1=d2 • We show that for d(N) = o(plog N= log log N) and N ≤ s(N) ≤ 2dN there is an N explicit family of functions ffN : f0; 1g ! f0; 1gg such that 0 { fN has uniform AC formulas of depth d and size at most s; 0 " { fN does not have AC [⊕] formulas of depth d and size s , where " is a fixed absolute constant. This gives a quantitative improvement on the recent result of Limaye, Srinivasan, Sreenivasaiah, Tripathi, and Venkitesh, (STOC, 2019), which proved a similar Fixed- Ω(d) Depth Size-Hierarchy theorem but for d log log N and s exp(N 1=2 ). As in the previous result, we use the Coin Problem to prove our hierarchy theorem. Our main technical result is the construction of uniform size-optimal formulas for solving O(d) the coin problem with improved sample complexity (1/δ)d+4 (down from (1/δ)2 in the previous result). • In our second result, we show that randomness buys depth in the AC0[⊕] setting. Formally, we show that for any fixed constant d ≥ 2, there is a family of Boolean functions that has polynomial-sized randomized uniform AC0 circuits of depth d but no polynomial-sized (deterministic) AC0[⊕] circuits of depth d. Previously Viola (Computational Complexity, 2014) showed that an increase in depth (by at least 2) is essential to avoid superpolynomial blow-up while derandomizing randomized AC0 circuits.
    [Show full text]