Enumeration of Boolean Functions of Sensitivity Three and Inheritance of Nondegeneracy

Transcription

1 Enumeration of Boolean Functions of Sensitivity Three and Inheritance of Nondegeneracy Kazuyuki Amano Department of Computer Science, Gunma University Tenjin, Kiryu, Gunma , Japan October 9, 2016 Abstract The sensitivity of a Boolean function is the maximum, over all inputs, of the number of input bits which when flipped change the output of the function. We enumerate all Boolean functions of sensitivity at most three and investigate their properties with a computer. The number of NPN equivalence classes of nondegenerate n-variable Boolean functions of sensitivity three is 7, 80, 4215, , 65694, 8873, 848, 64 and 8 for n = 3, 4,..., 11 and zero for n 12. We verify that, over all these functions, the maximum of block sensivitity, certificate complexity, decision tree complexity and degree is 6, 6, 9 and 9, respectively. A key to making this enumeration possible is the fact that, for every nondegenerate Boolean function f, a subfunction f xi=0 or f xi=1 is nondegenerate for some variable x i, which is recently shown by Lee, Lokam, Tsai and Yang [10]. We extend this result by showing that, the minimum number of nondegenerate subfunctions in {f xi=0, f xi=1} 1 i n is, in fact, four. Keywords: Computational complexity, Boolean functions, sensitivity, nongenerate functions 1 Introduction The sensitivity s(f) of a Boolean function f is the maximum, over all inputs, of the number of input bits which when flipped change the output of f. Although many other well-investigated complexity measures, including block sensitivity, certificate complexity, decision tree complexity and degree, are known to be polynomially related, the relationship between the sensitivity and these measures are highly unknown. The Sensitivity Conjecture posed by Nisan and Szegedy [12] asserts that the Corresponding author. amano@gunma-u.ac.jp 1

2 sensitivity is also polynomially related to the block sensitivity and hence other abovementioned measures. Despite a large effort, the conjeture is widely open. The best upper bounds on block sensivitity in terms of sensivitiy is exponential [3, 8, 9, 16]. The largest known gap between sensitivity and block sensitivity is quadratic [2, 14, 19]. See [7] for an excellent survey on the sensitivity conjecture and e.g., [4, 11, 18] for more recent developments. The main aim of this paper is to enumerate all Boolean functions of sensitivity at most three and investigate their properties. A Boolean function has sensitivity one if and only if it is a literal, and the enumeration of sensitivity two functions is easy since such a function depends on at most four variables. So the case s(f) = 3 is the first interesting case. The task is fundamental, but we do not aware of such an attempt. We believe that the result of enumeration would be helpful for obtaining properties of more general cases. For example, a small function have sometimes been used as a gadget in a proof of a separation result between complexity measures. We write a computer program to obtain a complete list of Boolean functions of s(f) 3. The number of NPN equivalence classes of n-variable nondegenerate (i.e., a function depending on all input variables) Boolean functions with s(f) = 3 is shown to be 7, 80, 4215, , 65694, 8873, 848, 64 and 8 for n = 3, 4,..., 11 and zero for n 12. We provide the list of these functions on the web ( We also compute the values of other complexity measures; the block sensitivity bs(f), certificate complexity C(f), decision tree complexity D(f) and degree deg(f), for all these functions. We verify that the maximum of bs(f), C(f), D(f) and deg(f) is 6, 6, 9 and 9, respectively. Although these functions do not give a new separation between various complexity measures, we found several interesting functions. One of such is a function on 9 variables that yields a power log 3 6 separation between deg(f) and bs(f), and deg(f) and C(f). This gives an alternative proof of the same result by Nisan and Wigderson using a 6-variable gadget due to Kushilevitz [13]. See Section 5 for more detail on this. A key to making this enumeration possible is the fact that, for every nondegenerate Boolean function f, a subfunction f xi=0 or f xi=1 is nondegenerate for some variable x i, which is recently shown by Lee, Lokam, Tsai and Yang [10]. In this paper, we also extend this result by showing that, the minimum number of nondegenerate subfunctions in {f xi=0, f xi=1} 1 i n is, in fact, four. The organization of the paper is as follows: In Section 2, we give some notations. In Section 3, we discuss the number of nondegenerate subfunctions contained in a nondegenerate Boolean function. In Section 4, we describe the method of our enumeration and the result. Finally in Section 5, we provide several facts on Boolean functions of sensitivity three. 2 Preliminaries Let [n] := {1, 2,..., n}. Let F n denote the set of all n-variable Boolean functions f : {0, 1} n {0, 1}. For an n-bit string x {0, 1} n, x denotes the number of 1 s in x. 2

3 Let f be a Boolean function on n variables. For a string x = (x 1,..., x n ) {0, 1} n and i [n], let x i denote the string obtained from x by flipping the i-th bit. We say that a coordinate i [n] is sensitive for f on input x if f(x) f(x i ). The sensitivity of f on input x, denoted by s(f, x), is the number of sensitive bits for f on x, i.e., s(f, x) := {i [n] f(x) f(x i )}. The sensitivity of f, denoted by s(f) is the maximum value of s(f, x) over all inputs x. We say that f depends on the i-th variable x i if f(x) f(x i ) for some x. The function f is called nondegenerate if f depends on all its variables; otherwise f is called degenerate. For i [n] and b {0, 1}, let f xi=b denote the subfunction of f on (n 1) variables {x 1,..., x i 1, x i+1,..., x n } obtained by fixing x i = b. 3 Nondegeneracy of Subfunctions The purpose of this section is to give a quantitative improvement of the result of Lee, Lokam, Tsai and Yang [10], in which they showed that every nondegenerate Boolean function contains at least one nondegenerate subfunction. Theorem 1 Let n 4. For every n-variable nondegenerate Boolean function f, at least four subfunctions in {f xi=b i [n], b {0, 1}} are nondegenerate. Note that the condition n 4 in the theorem is necessary since, e.g., the AND of three variables x 1 x 2 x 3 has only three nondegenerate subfunctions. Before proving the theorem, we show that the value four in the theorem is tight. Fact 2 For n 3, the Boolean function f(x 1, x 2,... x n ) := (x 1 x 3 x 4 x n ) (x 2 x 3 x 4 x n ) is nondegenerate and has exactly four nondegenerate (n 1)-variable subfunctions. Proof It is easy to check that f itself is nondegenerate, all of f x1=0, f x1=1, f x2=0 and f x2=1 are nondegenerate, and all of the other subfunctions are degenerate. Following to Lee, Lokam, Tsai and Yang [10], we introduce a graph representing the nondegeneracy of subfunctions. Given a Boolean function f : {0, 1} n {0, 1}, we construct a labeled digraph G f = (V, E) with V = [n]. A labeled edge i b j is in E if and only if f xi=b does not depend on x j. We call an edge labeled by b a b-edge for b {0, 1}. We say that the variable x i is useful for f if f depends on x i ; otherwise, x i is useless for f. The following is the key observation of the property of G f whose proof is in [10]. Proposition 3 P0 (Confluence): If there are two edges i 0 j and i 1 j for some j, then the variable x j is useless for f. P1 (Transitivity): Suppose in G f, we have a path i bi j bj k for distinct i, j, k [n]. Then the edge i bi k is also in G f, i.e., x k is useless for f xi=b i. More generally, if a path of distinct variables i bi b j1 b jt 1 j 1 j t exists in G f, then all variables in {j 1,..., j t } are useless for f xi=b i. 3

4 P2 (Cycles): If there are two cycles through i containing edges i 0 j and i 1 k, then all three variables x i, x j and x k are useless for f. In addition to Proposition 3, we need the following. Proposition 4 Suppose that there are edges i 0 j and i 1 k for distinct i, j, k [n]. If there is an edge j 0 i or j 1 i in G f then x k is useless for f. Similarly, if there is an edge k 0 i or k 1 i in G f then x j is useless for f. Proof For notational simplicity, we write f xi=b i,x j=b j,x k =b k as f (bi,b j,b k ). First we consider the case that j 0 i exists. We have f (0,0,0) = f (0,0,1) = f (0,1,0) = f (0,1,1) = f (1,0,0) = f (1,0,1) and f (1,1,0) = f (1,1,1), which says that x k is useless. If there is an edge j 1 i, then f (0,0,0) = f (0,0,1) = f (0,1,0) = f (0,1,1) = f (1,1,0) = f (1,1,1) and f (1,0,0) = f (1,0,1), which again says x k that is useless. The other cases are similar. We define the type of a vertex in G f as follows: For a vertex v [n] in G f, we say that (i) v is Type 2 if there are both of 0-edges and 1-edges starting from v, (ii) v is Type 1 if there are exactly one of 0-edges or 1-edges starting from v, and (iii) v is Type 0 if there are no outgoing edges from v. Proof Let n 4. Suppose for the contrary that f is nondegenerate but has at most three nondegenerate subfunctions (*). Then, for some i [n], there are two edges i 0 v 0 and i 1 v 1 for some v 0, v 1 [n]. By the Confluence condition (P0 in Proposition 3), we can assume v 0 v 1. The proof will be proceeded by an inductive argument. In the inductive step, we maintain a labeled rooted tree T f whose edge set is a subset of the edge set of G f. Initially, T f consists of the root vertex i and a 0-edge from i to v 0 and a 1-edge from i to v 1. Then, for each leaf v b (b {0, 1}) in T f, we do the following: 0 If the type of v b is 2, then pick an arbitrary 0-edge, say v b u0, and an 1-edge, 1 say v b u1, in G f. Then, add these two edges to T f. If the type of v b is 1, then pick an arbitrary edge in G f and add it to T f. If type of v b is 0, we do nothing. Notice that the resulting graph T f is a tree, since if a cycle is generated, then Propositions 3 and 4 would imply that there exists a useless variable. We observe that, at this moment, the number of leaves at depth two in T f is equal to type(v 0 ) + type(v 1 ). Since the number of nondegenerate subfunctions in {f xv0 =0, f xv0 =1, f xv1 =0, f xv1 =1} is 4 (type(v 0 ) + type(v 1 )), at least one of the leaves at depth two or greater in T f must be Type 2 in G f by (*). We set this condition as an invariant in the following inductive step. (Inductive Step): Repeat the following procedure: Pick an arbitrary leaf of type 2, say u, in T f. The existence of such a leaf is guaranteed by (*). Pick arbitrary one 0-edge and one 1-edge both starting from u in G f. We write these edges by u 0 s and u 1 t. If both of s and t lie on the path from the root of T f, then the Cycle condition (P2 in Proposition 3) says that there are useless variables. Hence at least one of s and t does not lie on the path. Suppose that s is not on the path. The other case is analogous. 4

5 We will show that s V (T f ). Suppose for the contrary that s V (T f ). Let w be the first common ancestor of u and s in T f. We can see that there are two edges w 0 s and w 1 s in G f by the Transitivity (P1 in Proposition 3), and hence x s is useless by the Confluence (P0 in Proposition 3). Hence we can conclude that there is an edge u a s such that s V (T f ). We add this edge to T f. Since the number of leaves in T f never decreases, the invariant condition on T f fulfills. Go back to the beginning of the procedure and repeat. (End of Inductive Step) The number of vertices in V (T f ) increases by at least one in each iteration but must not exceed n. Hence we can eventually reach a contradiction. 4 Enumeration The main goal of the current work is to enumerate all Boolean functions f with s(f) 3. Let F(s, n) denote the set of all nondegenerate Boolean functions on n-variables whose sensitivity is at most s. For notational simplicity, we write F(3, n) as F(n). At a first glance, the feasibility of enumeration strongly depends on the largest value of n with F(n). Prior to our experiment, we only know F(10) (by the monotone addressing function due to Wegener [20]), and F(49) = (by the inequality s(f)2 n 1 n2 n 2s(f)+1 due to Simon [16]). Enumerating 49-variable functions seems to be out of reach. But fortunately, we will see that F(n) = for n 12. We use the notion of NPN equivalence to reduce the search space. Two Boolean functions are NPN equivalent if one can be obtained from the other by negating input variables, permuting input variables and negating the output. A set of all NPN equivalent functions form an NPN equivalence class. The number of NPN equivalence classes of (not necessarily nondegenerate) n-variable Boolean functions is 2, 4, 14, 222, for n = 1,..., 5 [15, A000370], which is significantly smaller than 2 2n ; the total number of n-variable Boolean functions. Many natural complexity measures of Boolean functions including the sensitivity, block sensitivity, certificate complexity, decision tree complexity and degree are invariant under the NPN equivalence. We enumerate all NPN representative of F(n) incrementally on n. Given an NPN equivalence class, the representative f R of the class is a Boolean function in the class whose truth table is a minimum when we read the truth table as a 2 n bit integer. Suppose we have a list of representative of all NPN equivalence classes of F(n 1). For each representative f R in F(n 1), we enumerate all n-variable functions g such that g is nondegenerate, s(g) 3 and g x1=0 f R to get the list L(n). This can be done by a simple back-track algorithm. By Theorem 1 (or the original version of the theorem [10, Theorem 1] suffices), for every f F(n), some subfunction f xi=b must be nongenerate and hence in F(n 1). This guarantees that L(n) contains at least one function from each NPN equivalence class of F(n). Hence we can obtain a list of all representatives in F(n) by computing a minimum NPN equivalent function for each function in L(n). The number of NPN equivalence classes of F(n) peaks out at n = 6, which makes our enumeration feasible. See Table 4. 5

6 Table 1: The number of nondegenerate Boolean functions of sensitivity three. The third column shows the number of their NPN equivalence classes. The last column shows the total number of NPN equivalence classes of n-variable nondegenerate Boolean functions. The value is from [15, A000370] for n 8 and is an approximation by 2 2n /2 n+1 n! for n 9. n {f F n s(f) = 3} NPN (Total NPN) (10) 4 27, (208) 5 25, 707, 648 4, 215 (615, 904) 6 16, 687, 858, , 221 ( ) 7 73, 877, 696, , 694 ( ) 8 128, 080, 457, 344 8, 873 ( ) 9 129, 853, 180, ( ) 10 40, 515, 189, ( ) 11 14, 769, 216, ( ) Once we have a representative f R of an NPN equivalence class, the number of functions belonging to the class is given by by 2 n+1 n!/m where m is the number of mapping π (over all input/output negations and variable permutations) such that π(f R ) f R. The result of our enumeration is shown in Table 4. All computation can be done within a few days using a single core of a standard PC. Note that the number of Boolean functions (NPN equivalence classes, respectively) with s(f) = 2 is 10 (2 classes), 80 (3 classes), 312 (3 classes) for n = 2, 3, 4 and zero for n 5. 5 Fact Sheet Now we have a complete list of functions f with s(f) 3. Below we describe several facts on these functions focusing on the other complexity measures for Boolean functions; block sensitivity, certificate complexity, decision tree complexity and degree. Let f : {0, 1} n {0, 1} be a Boolean function and let x {0, 1} n be a string. (Block sensitivity): A block is a subset of [n]. For a block B, let x B denote the string obtained from x by flipping all the bits in B. We say that a block B is sensitive for f on x if f(x) f(x B ). The block sensitivity of f on x, denoted by bs(f, x), is the maximum number of disjoint blocks that are all sensitive for f on x. The block sensitivity of f, denoted by bs(f), is the maximum of bs(f, x) over all inputs x. (Certificate Complexity): Let S be a subset of {x 1,..., x n }. Let p be a partial 6

7 assignment p : S {0, 1} of values to S. The size of p is the cardinality of S. We say p is consistent with x {0, 1} n if x i = p(i) for all i S. For b {0, 1}, a b- certificate for f is an assignment p such that f(x) = b whenever x is consistent with p. The certificate complexity of f on x, denoted by C(f, x), is the size of a smallest f(x)-certificate that is consistent with x. The certificate complexity of f, denoted by C(f), is the maximum of C(f, x) over all inputs x. (Decision Tree Complexity): A (deterministic) decision tree is a rooted binary tree T. Each internal node of T is labeled with a variable x i and each leaf is labeled with a constant 0 or 1. The tree computes a Boolean function in a natural way. The decision tree complexity, denoted by D(f), is the minimum depth of a tree that computes f. (Degree): A polynomial p(x) on n variables x = (x 1,..., x n ) over the reals represents f if p(x) = f(x) for every x {0, 1} n. The degree of f, denoted by deg(f), is the degree of the (unique) multilinear polynomial that represents f. The measures bs(f), C(f), D(f) and deg(f) are polynomially related, but the problem to decide whether s(f) and bs(f) (or, equivalently, other measures) is polynomially related is a long standing open problem. It is well known that s(f) bs(f) C(f) D(f), and deg(f) D(f). A nice table on the best known separations between these measures can be found in [1]. We compute all these measures for all functions we enumerated. We list some of the facts obtained through our experiments. The maximum number of useful variables is 11. There are eight such classes. An example is (x 1 x 3 x 4 x 5 ) (x 1 x 3 x 6 x 7 ) (x 1 x 2 (x 3 x 8 x 9 )) (x 1 x 2 (x 3 x 10 x 11 )). (1) The values of (bs(f), C(f), D(f), deg(f)) are: (4,4,5,5) (2 classes, including Eq.(1)), (4,4,6,6) (3 classes), (5,5,5,4) (1 class), (5,5,5,5) (1 class) and (5,5,6,6) (1 class). The experiment shows that, for every function f with s(f) 3, bs(f) = C(f). Note that this is a special property for s(f) 3. The Paterson s function (see [6, p.58 59]) satisfies s(f) = 4, bs(f) = 4 and C(f) = 5. The maximum block sensitivity as well as the maximum certificate complexity is 6. There are two such classes. One of them is ((x 3i+1 x 3i+2 x 3i+3 ) (x 3i+1 x 3i+2 x 3i+3 )), (2) i [3] which has (bs(f), C(f), D(f), deg(f)) = (6, 6, 9, 6). The other function g also has 9 useful variables and (bs(g), C(g), D(g), deg(g)) = (6, 6, 6, 3). Currently, we do not have a compact description of g. The truth table of g (in hexadecimal form) is 7

8 00000c3fa0f5ac355f0a5c3afffffc30f3c0ffffa3c5af0553ca50fa03cf0000 ffff0c3fa0f5ac355f0a5c3a0000fc30f3c00000a3c5af0553ca50fa03cfffff. The function g has many symmetries. Out of all 2 n+1 n! NPN transformations, 192 transformations map g to itself. The sensitivity of g is 3 on every input. By the composition theorem by Tal [17], the iterated composition of a good form function (in a sense of Tal [17, Definition 2.11]) obtained from g satisfies bs( ) = Ω((deg( )) log 3 6 ) and C( ) = Ω((deg( )) log 3 6 ). These match the best known separations shown by Nisan and Wigderson using a 6-variable gadget due to Kushilevitz (see [13]). This function gives an alternative proof of the same result. The maximum decision tree complexity is 9. There are eight such classes; all of them have 9 useful variables. The values of (bs(f), C(f), D(f), deg(f)) are: (3,3,9,9) (3 classes, shown below), (4,4,9,8) (3 classes), (5,5,9,7) (1 classes) and (6,6,9,6) (1 classes, Eq. (2)). The maximum degree is 9. There are three such classes; all of them have (bs(f), C(f), D(f), deg(f)) = (3, 3, 9, 9), and hence have the maximum decision tree complexity. These are: (x 1 x 2 x 3 ) (x 4 x 5 x 6 ) (x 7 x 8 x 9 ), (x 1 x 2 ) ((x 3 x 4 ) (x 5 x 6 )) (x 7 x 8 x 9 ), ((x 1 x 2 ) (x 3 x 4 ) (x 5 x 6 )) (x 7 x 8 x 9 ). Acknowledgement A part of this work was supported by JSPS KAKENHI Grant Number JP15K00006 and JP References [1] Scott Aaronson, Shalev Ben-David and Robin Kothari, Separations in query complexity using cheat sheets, In Proc. of STOC 2016, (2016) [2] Andris Ambainis and Xiaoming Sun, New separation between s(f) and bs(f), ECCC TR (2011) [3] Andris Ambainis, Krišjānis Prūsis and Jevgēnijs Vihrovs, Sensitivity versus certificate complexity of Boolean functions, Proc. of CSR 16, LNCS 9691, (2016) [4] Mitali Bafna, Satyanarayana V. Lokam, Sébastien Tavenas and Ameya Velingker, On the sensitivity conjectur for read-k formulas, Proc. of MFCS 16, pp. 16:1 16:14 (2016) [5] Shalev Ben-David, Low-sensitivity functions from unambiguous certificate, arxiv: (2016) 8

9 [6] Siegfried Bublitz, Ute Schürfeld, Ingo Wegener and Bernd Voigt, Properties of complexity measures for PRAMs and WRAMs, Theoretical Computer Science, 48, (1986) [7] Pooya Hatami, Raghav Kulkarni and Denis Pankratov, Variations on the sensitivity conjecture, Theory of Computing Library, Graduate Surveys 4, 1 27 (2011) [8] Kun He, Qian Li and Xiaoming Sun, A tighter relation between sensitivity and certificate complexity, ArXiv: (2016) [9] Claire Kenyon and Samuel Kutin, Sensitivity, block sensitivity, and l-block sensitivity of Boolean functions, Information and Computation, 189, (2004) [10] Chia-Jung Lee, Satyanarayana V. Lokam, Shi-Chun Tsai and Min-Chuan Yang, Restrictions of nondegenerate Boolean functions and degree lower bounds over different rings, Proc. of IEEE International Symposium on Information Theory (ISIT 15), (2015) [11] Chengyu Lin and Shengyu Zhang, Sensitivity conecjture and log-rank conjecture for functions with small alternating numbers, Arxiv: (2016) [12] Noam Nisan and Mario Szegedy, On the degree of Boolean functions as real polynomials, Computational Complexity, 4, (1994) [13] Noam Nisan and Avi Wigderson, On rank vs. communication complexity, Combinatorica, 15(4), (1995) [14] David Rubinstein, Sensitivity vs. block sensitivity of Boolean functions, Combinatorica, 15(2), (1995) [15] N. J. A. Sloane, editor, The On-Line Encyclopedia of Integer Sequences, published electronically at [16] Hans-Ulrich Simon, A tight Ω(log log n)-bound on the time for parables RAM s to compute nondegenerate Boolean functions, Information and Control, 55, (1982) [17] Avishay Tal, Properties and applications of Boolean function composition, Proc. of ITCS 13, (2013) [18] Avishay tal, On the sensitivity conjecture, Proc. of ICALP 16, 38:1 38:13 (2016) [19] Madars Virza, Sensitivity versus Block sensitivity of Boolean functions, Information Processing Letters, 111, (2011) [20] Ingo Wegener, The critical complexity of all (monotone) Boolean functions and monotone graph properties, Information and Control, 67(1-3), (1985) 9