Unambiguous DNFs and Alon-Saks-Seymour
Kaspars Balodis, Shalev Ben-David, Mika Göös, Siddhartha Jain, Robin Kothari
UUnambiguous DNFs from Hex
Shalev Ben-David Mika G¨o¨os Siddhartha Jain Robin Kothari
University of Waterloo EPFL EPFL Microsoft Quantum
February 17, 2021
Abstract.
We exhibit an unambiguous k -DNF formula that requires CNF width ˜Ω( k . ).Our construction is inspired by the board game Hex and it is vastly simpler than previousones, which achieved at best an exponent of 1 .
22. Our result is known to imply several otherimproved separations in query and communication complexity (e.g., clique vs. independentset problem) and graph theory (Alon–Saks–Seymour problem).
First formulation. An n -variate DNF formula F = C ∨ · · · ∨ C m is said to be unambiguous iffor every input x ∈ { , } n at most one of the conjunctions C i evaluates to true, C i ( x ) = 1. If wethink of the DNF formula as expressing its set of 1-inputs F − (1) as a union of subcubes C − i (1),then F is unambiguous precisely when the subcubes are pairwise disjoint. Unambiguity is a severestructural restriction on DNFs. In particular, every unambiguous DNF formula of bounded width (defined as the maximum number of literals in a conjunction) can be written equivalently as abounded-width CNF formula. Namely, we have the following folklore fact [G¨o¨o15, §III]. Fact 1.
Every unambiguous k -DNF can be written equivalently as a k -CNF. In this paper, we ask: Can this quadratic relationship be improved? Are there k -DNFs thatrequire CNFs of width much larger than k , perhaps even Ω( k )? More formally, for a booleanfunction f : { , } n → { , } we define the following standard complexity measures. − -certificate complexity C ( f ) is the least k such that f can be written as a k -DNF; − -certificate complexity C ( f ) is the least k such that f can be written as a k -CNF; − unambiguous -certificate complexity UC ( f ) is the least k such that f can be written as anunambiguous k -DNF. Puzzle I.
For α > , does there exist a boolean function f with C ( f ) ≥ UC ( f ) α − o (1) ? Here we abused terminology: instead of a single boolean function we really mean an infinitesequence of functions f n satisfying C ( f n ) = ω (1) as n → ∞ . Puzzle I was first asked in [G¨o¨o15],although an analogous question had been studied in communication complexity (under the name clique vs. independent set ; see Section 2.1) since Yannakakis [Yan91]. The paper [G¨o¨o15] gavea complicated recursive construction achieving an exponent α ≈ .
12. This was subsequentlyoptimised (but not simplified) in [BHT17] improving the exponent to α ≈ .
22. Our main result,stated as Theorem 1 in Section 2, gives a new simple construction with α = 1 . a r X i v : . [ c s . CC ] F e b econd formulation. In order to separate boolean function complexity measures it is often a goodidea to proceed in two steps: First construct a partial boolean function f : { , } n → { , , ∗} wheresome inputs x are undefined , f ( x ) = ∗ . Then modify f into a total function by eliminating allthe ∗ -inputs. We proceed to formulate an appropriate partial function version of Puzzle I.We recall the notion of a certificate , adapted here for a partial function f : { , } n → { , , ∗} .Let Σ ⊆ { , , ∗} be a subset of output symbols. We write for short 0 , , , { } , { } , { , ∗} , { , ∗} . A partial input ρ ∈ { , , ∗} n is a Σ -certificate for x ∈ { , } n if ρ is consistentwith x and for every input x consistent with ρ we have f ( x ) ∈ Σ. The size of ρ , denoted | ρ | , isthe number of its non- ∗ entries. The Σ -certificate complexity of x , denoted C Σ ( f, x ), is the leastsize of a Σ-certificate for x . The Σ -certificate complexity of f , denoted C Σ ( f ), is the maximumof C Σ ( f, x ) over all x ∈ f − (Σ); this definition is consistent with the one given at the start of thissection. Finally, we define certificate complexity C( f ) as max { C ( f ) , C ( f ) } . Puzzle II.
For α > , does there exist a partial function f together with an x ∈ f − ( ∗ ) such thatboth C ( f, x ) and C ( f, x ) are at least C( f ) α − o (1) ? We will show in Theorem 2 that Puzzle I and II are in fact equivalent: solving one with anexponent α will imply a solution to the other one with the same α . The implication I ⇒ II iseasy while the converse (converting a partial function into a total one) is non-trivial and uses the cheat sheet framework introduced in [ABK16]. Consequently, we feel that II is the most fruitfulformulation to attack and that is indeed how our new separation result is obtained.
Third formulation.
We present one more equivalent formulation using purely graph theoreticlanguage. While this version is not needed for our separation result, we include it for aestheticreasons. Let G = ( V, E ) be a hypergraph. We say G is intersecting if every two edges e, e ∈ E intersect, e ∩ e = ∅ . A subset U ⊆ V is a hitting set for G if U intersects every edge e ∈ E .Moreover, U is c -monochromatic for a colouring c : V → { , } if c is constant on U . Finally, wedefine the rank of G , denoted r ( G ), as the maximum size | e | of an edge e ∈ E . Puzzle III.
For α > , does there exist an intersecting hypergraph G = ( V, E ) together with acolouring c : V → { , } such every c -monochromatic hitting set has size at least r ( G ) α − o (1) ? Puzzle III obscures the complexity-theoretic origins of the problem, thereby rendering it increas-ingly seductive for, say, an unsuspecting audience of combinatorialists (cf. [Raz11]). In fact, wefound all three formulations and proved them equivalent already in late 2015, and since then wehave been deploying the camouflaged variant III on several occasions, including, notably and mostunsuccessfully, at an open problem seminar at the Institute for Advanced Study in 2018.
Our main results are as follows; here, the notation ˜Ω( n ) hides poly(log n ) factors. Theorem 1.
There exists a boolean function f with C ( f ) ≥ ˜Ω(UC ( f ) . ) . Theorem 2.
Puzzles I, II, III are equivalent: if one of them can be solved with exponent α , then allof them can be solved with exponent α (up to factors logarithmic in input length). To prove Theorem 1 we describe a simple boolean function inspired by the board game Hex.Our construction, in Section 3, is phrased as a solution to Puzzle II. Hence Theorem 1 follows fromthe equivalences in Theorem 2, which are in turn proved in Section 4. We next discuss how ourresults imply several other improved separations in query and communication complexity.2 .1 Applications: Clique vs. independent set and Alon–Saks–Seymour
The original motivation for studying Puzzle I in [G¨o¨o15] was that its solutions imply lower boundsfor two well-studied problems. − Clique vs. independent set problem [Yan91] . This two-party communication problem is definedrelative to an n -vertex graph G = ( V, E ): Alice gets a clique x ⊆ V , Bob gets an independentset y ⊆ V , and their goal is to output CIS G ( x, y ) := | x ∩ y | ∈ { , } . − Alon–Saks–Seymour problem.
For a graph G , how large can the chromatic number χ ( G ) becompared to the biclique partition number bp( G ) (minimum number of complete bipartitegraphs needed to partition the edges of G )?A surprising connection here is that proving lower bounds on the conondeterministic communicationcomplexity of clique vs. independent set is equivalent to constructing separations for the Alon–Saks–Seymour problem; see Bousquet et al. [BLT14] for an excellent survey of this connection. Huangand Sudakov [HS12] were the first to find a polynomial separation between χ ( G ) and bp( G ), whichdisproved a conjectured linear relationship due to Alon, Saks, and Seymour. Subsequent work hasexhibited larger polynomial separations [Ama14, SA15] and even quasi-polynomial ones [G¨o¨o15,BHT17]. If we plug Theorem 1 into the lifting framework of [G¨o¨o15, GLM +
16] we get the followingimprovements over the previous-best lower bounds with exponent 1 .
22 [BHT17].
Corollary 3.
There exist a graph G such that CIS G requires ˜Ω(log . n ) bits of conondeterministiccommunication. Equivalently, there exist a graph H such that χ ( H ) ≥ exp( ˜Ω(log . bp( H ))) . Let us pause here to appreciate how long a chain of reductions we have created to solve a graphtheoretic problem by a reduction to another (hyper)graph theoretic problem, but fundamentallypassing through complexity theory. That is, we have1. Alon–Saks–Seymour problem, reduces to2. clique vs. independent set problem, reduces to3. Puzzle I: separation C (cid:29) UC in query complexity, reduces to4. Puzzle II: separation C , C (cid:29) C for a partial function, reduces to5. Puzzle III: 2-colouring an intersecting hypergraph.Reduction 2-to-3 uses a lifting theorem (which is not known to have a converse) and 3-to-4 usescheat sheets—both of these are inherently query/communication tools that do not have naturalcounterparts in classical combinatorics. The end result can be phrased as its own graph problem:Given an intersecting hypergraph and a 2-colouring whose monochromatic hitting sets are power- α larger than the rank, construct a graph which is an edge-disjoint union of k bicliques but which haschromatic number exp(log α − o (1) k ). It sounds to us magical that this is possible! Other related work.
It is widely conjectured (e.g., [HS12]) that the exponent 1 . CIS G in the deterministic [GPW18] and even randomised [GJPW18] communicationmodels. However, these results do not imply any bounds for the conondeterministic complexity andhence neither for the Alon–Saks–Seymour problem.Given that superpolynomial separations exist for the Alon–Saks–Seymour problem in general,a recent line of work has aimed to find special graph classes where the separation is at mostpolynomial [BLT14, LT16, BLMP18, CS21]. In particular, it remains open whether the separationis polynomial for the class of perfect graphs. 3 .2 Applications: Separations in query complexity In query complexity, we get two improved separations involving the well-studied complexity measures sensitivity s( f ) and approximate degree g deg( f ) (defined in Section 5). The first of these corollariesfollows automatically from [BHT17, Theorem 1] and the second one we prove in Section 5. Corollary 4.
There exists a boolean function f with C( f ) ≥ ˜Ω(s( f ) . ) . Corollary 5.
There exists a boolean function f with C( f ) ≥ ˜Ω( g deg( f ) ) . Previous best separations had exponents 2 .
22 and 2, respectively. See Aaronson et al. [ABK + We conjecture that the puzzles are soluble with exponent α = 2 matching the upper bound in Fact 1.This would yield near-optimal lower bounds for Corollary 3 and 5. There is also an additionalmotivation to seek a solution with α = 2 (which is not afforded by our solution α = 1 . f ) and deg( f ) (degree of f as a multivariate polynomial) quadratically, improving onthe power-1 .
63 separation due to Nisan, Kushilevitz, and Wigderson [NW95].
In this section, we describe our Hex-inspired solution to Puzzle II that achieves exponent α = 1 .
5. Wedefine a partial boolean function
Hex n : { , } n × n → { , , ∗} whose n -bit inputs are interpreted as n × n boolean matrices. We say that two matrix entries in [ n ] × [ n ] are connected if they are adjacenteither horizontally or vertically (but not diagonally). A 1 -path in an input x is top-to-bottom path of1-entries, that is, the path starts on a 1-entry in the topmost row, moves along connected 1-entries,and ends on the bottommost row. Similarly, a 0 -path in x is a left-to-right path of 0-entries. Notethat no x can contain both a 1-path and a 0-path. We define Hex n ( x ) := x contains a 1-path of length at most 2 n, x contains a 0-path of length at most 2 n, ∗ otherwise . Clearly C(
Hex n ) = 2 n . It remains to prove the following lemma. For simplicity, we drop Hex n from notation and write C Σ ( x ) := C Σ ( Hex n , x ). Lemma 6.
There is an x ∈ Hex − n ( ∗ ) such that both C ( x ) and C ( x ) are Ω( n . ) . As a warm-up, we note that it is easy to find inputs x where one of C ( x ) or C ( x ) is large, butnot both. For example, consider the input y depicted in Figure 1a that contains a single spiraling1-path, call it a 1 -spiral for short. The 1-spiral has length Θ( n ) > n and hence Hex n ( y ) = ∗ . Claim 7. C ( y ) ≥ Ω( n ) and C ( y ) ≤ O ( n ) .Proof. For the first claim, we employ a sensitivity argument. Consider any entry e ∈ [ n ] × [ n ] in the1-spiral that is not a corner (where the spiral makes a right-angle turn). Denote by y e the input y but with the entry e flipped (from 1 to 0). Note that flipping e introduces a short ( ≤ n ) 0-pathin y e and thus Hex n ( y e ) = 0. It follows that any 0-certificate for y needs to read all the non-cornerentries of which there are Θ( n ) many. For the second claim, we note that it suffices to include thefive topmost rows in a certificate to prove that any 1-path in y must be of length > n .4a) input y (b) input z Figure 1:
Inputs to
Hex n are n × n boolean matrices. Illustrated are two ∗ -inputs: y consists of a single1-spiral of length Θ( n ), and z consists of √ n many 1-spirals of length Θ( n . ) each. We can similarly find an input y ∗ with large C ( y ∗ ) and small C ( y ∗ ). The challenge in Lemma 6is to find a single input where both 0- and 1-complexities are large. Our solution is to “balance” y .Namely, we let z be the input that consists of √ n many disjoint 1-spirals, each of length Θ( n . );see Figure 1b for an illustration. The following two claims complete the proof of Lemma 6. Claim 8. C ( z ) ≥ Ω( n . ) .Proof. We employ a block sensitivity argument. Let ‘ = Θ( n . ) denote the number of non-cornerentries in each 1-spiral of z . For each i ∈ [ ‘ ], we define a block B i ⊆ [ n ] × [ n ], | B i | = √ n , as the setthat contains the i -th non-corner entry from each 1-spiral (the non-corners of a spiral are orderedtop-to-bottom, say). Denote by z B i the input obtained from z by flipping all the entries in B i (from1 to 0). Flipping any block B i introduces a short ( ≤ n ) 0-path in z B i and hence Hex n ( z B i ) = 0.For example, in the following illustration, the short 0-path (drawn in blue ) is created when we flipthe block consisting of the striped entries:It follows that any 0-certificate for z needs to read at least one entry from each of the blocks. Butsince the blocks are disjoint and there are ‘ = Θ( n . ) many of them, the claim is proved. Claim 9. C ( z ) ≥ Ω( n . ) .Proof. Let ρ be a partial input consistent with z that has size o ( n . ). We show that ρ cannot be a1-certificate. By averaging, there is some “neglected” 1-spiral such that ρ reads o ( n ) many 0-entriesadjacent to the spiral. We will greedily construct a 1-path consistent with ρ by starting at the top ofthe neglected spiral and trying to fit a 1-path straight down the matrix. The 0-entries read by ρ canprevent a direct downward path from working, but every time we encounter such a 0-entry we canavoid it by taking one step to the left or right (following the direction of the spiral). These left/rightsteps make us waste at most o ( n ) extra steps in addition to the n downward steps. This shows thereexists a 1-path of length n + o ( n ) ≤ n consistent with ρ , and hence ρ is not a 1-certificate. Remark . It is easy to see that C ( z ) and C ( z ) are also O ( n . ). We suspect that z is in factextremal for Hex n meaning that no other ∗ -input can witness an exponent larger than α = 1 . Equivalences of puzzles
We now prove our three puzzles equivalent (Theorem 2). The proof comprises of four implications,each proved in its own subsection: II ⇒ I ⇒ II ⇒ III ⇒ II. This is more implications than strictlynecessary, but not all directions are equally good in terms of overheads caused by log factors. ⇒ I Given:
A partial function f : { , } n → { , , ∗} and an input x ∈ f − ( ∗ ). Construct:
A total function g : { , } n log n → { , } such thatC ( g ) ≥ min { C ( f, x ) , C ( f, x ) } and UC ( g ) ≤ f ) log n . Overview.
The basic idea is that we would like to turn regular, ambiguous certificates for f intounambiguous collections of certificates for a modified function g . One way to do so is to give eachcertificate for f a unique identification number; then we can require the new inputs to g to consistof both an input z to f and an identification number (written in binary) for a certificate in z . Wewill let such a new input ( z, k ) evaluate to 1 if the certificate specified by the number k really is in z ,and we will define ( z, k ) to be a 0-input otherwise. Then by reading all of k and the correspondingcertificate in z , we get an unambiguous certificate for ( z, k ) whenever ( z, k ) is a 1-input.This strategy makes 1-certificates unambiguous, but it does not necessarily ensure that thefunction is hard to certify on 0-inputs. The reason is that for the new function, it is conceivablethat we could certify ( z, k ) is a 0-inputs just by reading a few bits of k and a few bits of z , butthat those few bits suffice to prove that the certificate specified by k cannot possibly be found in z .Indeed, it might even be easy to certify that ( z, k ) is a 0-input when z = x , the hard ∗ -input to f .We wish to eliminate this 0-certification strategy so that the new function is hard to certify on atleast one 0-input. To do so, we will use the cheat sheet framework [ABK16]. The idea is to hide theidentification number k of the certificate in one cell of an array consisting of, say, n different cells.We choose n cells because this is large enough so that even reading a single bit from each cell is tooexpensive. But now that we have hidden k in one of n cells, there needs to be a way to find it. So tospecify which cell of the array is the “correct” one, the one where we’ve stored k , we will change theproblem to have log n different instances of f , and we will interpret the f -outputs of these instancesas specifying a binary string of length log n , which can index a specific cell of our array. Now thatthere are log n copies of f , the correct array cell will be required to contain identification numbersfor log n different certificates, one for each instance of f . Now we define this new function g toevaluate to 1 if all the log n f -inputs are 0- or 1-inputs and if the array cell indexed really containsvalid identification numbers of certificates present in the f -inputs. Otherwise, if this doesn’t hold,we define the input to be a 0-input to g .With this construction, the contents of the cell pointed to by the log n -bit string of outputs of f ,along with the certificates in that cell form small unambiguous certificates for 1-inputs to g . On theother hand, the g -input consisting of log n copies of x ∈ f − ( ∗ ) together with any array content willbe a 0-input that is hard to certify: Any certificate must either prove that at least one copy of x is not a 0-input or not a 1-input, which is expensive to do because we assumed that C ( f, x ) andC ( f, x ) are large, or else it must prove that none of the cells in the array contain valid certificates,which requires it to read at least one bit from each of the n cells. We now prove this more formally.6 ormal proof. A certificate of size C( f ) specifies the indices of up to C( f ) input bits and anassignment to those bits. Since an index can be encoded using log n bits, the total number of bitsneeded to represent a certificate is at most ‘ := 2 C( f ) log n ≤ n log n . We choose k := log n asthe number of copies of f that we will use. Let us define g : { , } kn +2 k k‘ → { , } on kn + 2 k k‘ ≤ n log n bits. For an input z to g , we define s z to be the string in { , , ∗} k that we get byapplying f to the first kn bits of z , interpreted as k inputs to f . If s z / ∈ { , } k , we define g ( z ) := 0.Otherwise, if s z ∈ { , } k , we interpret the last 2 k k‘ bits of z as an array of 2 k cells of size k‘ each,and we let C z ∈ { , } k‘ be the contents of the cell indexed by s z . We interpret C z as specifying k different certificates for f , each specified using ‘ bits. We then set g ( z ) := 1 if each of the k inputsfor g in the first part of the string z contains the corresponding certificates specified by C z in order.Otherwise, we set g ( z ) := 0.The following two claims verify that this construction has the desired properties. Claim 11. C ( g ) ≥ min { C ( f, x ) , C ( f, x ) } .Proof. Consider the input to g consisting of k copies of x , followed by an all-0 array. Consider anycertificate c for this input. If c reads fewer than min { C ( f, x ) , C ( f, x ) } bits, then c does not certifythat x is not a 0-input or that x is not a 1-input for any of the k copies of x . Moreover, c also cannotread a bit of each of the 2 k = n array cells, since n is larger than min { C ( f, x ) , C ( f, x ) } . Hencethere is some array cell, indexed by some string s ∈ { , } k , such that c reads no bits of that arraycell. Since c fails to prove anything about the f -outputs of the copies of x , we can find an input y to g which is consistent with c such that the f -inputs in y evaluate to s ; moreover, we can then setthe array cell indexed by s to provide valid certificates for the k inputs to f in y . This causes y tobe a 1-input consistent with c , contradicting the assumption that c was a 0-certificate. Claim 12. UC ( g ) ≤ f ) log n .Proof. Intuitively, the contents of the cell referred to by the string s z and all the certificates init together form an unambiguous certificate for f . So an unambiguous 1-certificate for g has thefollowing form: first, it reads exactly one certificate for each of the k inputs to f ; second, in thearray cell indexed by s z , the log n -bit string of f -outputs, the certificate reads the entire array cell,and the cell has the property that it contains exactly the same certificates read in the k inputs to f (in order). The size of this certificate is k ( ‘ + C( f )) ≤ log n (2 C( f ) log n + C( f )) ≤ f ) log n where k C( f ) bits are used to specify the certificates for k copies of f and k‘ bits are used to readthe full contents of one cell of the array.It remains to show that the above collection of 1-certificates is unambiguous. We claim thatno input z to g can have two different certificates of the type we have just described. To see this,suppose otherwise, and let ρ and ρ be two such certificates consistent with z . Suppose that ρ reads bits in the array cell C and that ρ reads bits in the array cell C . Then since ρ proves thatthe f -inputs in z evaluate to the index of C , and since ρ proves that the f -inputs in z evaluate tothe index of C , we must have C = C . Since ρ reads all of C and ρ reads all of C , we knowthat ρ and ρ are identical on the array part of the input. However, this array cell then specifiesexactly which bits a certificate in this collection must read from the k inputs to f ; it follows that ρ and ρ must be identical. 7 .2 Construction I ⇒ II Given:
A total function f : { , } n → { , } . Construct:
A partial function g : { , } n → { , , ∗} and an input z ∈ g − ( ∗ )such that min { C ( g, z ) , C ( g, z ) } ≥ C ( f ) and C( g ) ≤ ( f ).Let U ⊆ { , , ∗} n be an unambiguous collection of 1-certificates for f so that − for every x ∈ f − (1) there is a unique ρ x ∈ U such that x is consistent with ρ x ; − each ρ ∈ U has size | ρ | ≤ UC ( f ).The function g will be defined on inputs ( x, y ) ∈ { , } n where x, y ∈ { , } n . If x is suchthat f ( x ) = 0, we define g ( x, y ) := ∗ . Otherwise if f ( x ) = 1, we consider the unique ρ x ∈ U consistent with x : Denote by r ( ρ x ) ⊆ [ n ] the set of indices i ∈ [ n ] that are read by ρ x . Wedefine g ( x, y ) := L i ∈ r ( ρ x ) y i , that is, the parity of the bits of y that are indexed by r ( ρ x ).To certify that g ( x, y ) = b for b ∈ { , } , it suffices to read ρ x ∈ U together with the correspondingset of bits r ( ρ x ) in y . This shows that C( g ) ≤ ( f ). We then define the hard ∗ -inputby z := ( x, n ) where x ∈ f − (0) is any input such that C ( f, x ) = C ( f ). Claim 13. min { C ( g, z ) , C ( g, z ) } ≥ C ( f ) .Proof. Let ρ ∈ { , , ∗} n be a partial input consistent with z that has size | ρ | < C ( f ). Our goalis to show that ρ is not a 1-certificate (showing that ρ is not a 0-certificate is analogous). It ispossible that ρ reads some bits in the first half of the input z = ( x, n ) and some bits in the secondhalf. We define a set B := { i ∈ [ n ] : i ∈ r ( ρ ) or i + n ∈ r ( ρ ) } that “shifts” all the query positionsin the second half to the first half. Let ρ ∈ { , } n be the partial input consistent with x suchthat r ( ρ ) = B . Since | ρ | = | B | ≤ | ρ | < C ( f ), we know that ρ does not certify f ( x ) = 0. Thismeans there is some 1-certificate σ ∈ U consistent with ρ and such that r ( σ ) r ( ρ ). Our goalbecomes to use σ to modify z in positions outside r ( ρ ) to obtain a z such that g ( z ) = 1, whichwould show that ρ is not a 1-certificate, concluding the proof. Indeed, starting with z = ( x, n ) wecan modify the first half x to contain σ , and we can modify the bits r ( σ ) \ B = ∅ in the secondhalf 0 n so that the positions r ( σ ) (in the second half) have odd parity. ⇒ III
Given:
A partial function f : { , } n → { , , ∗} and x ∈ f − ( ∗ ). Construct:
An intersecting hypergraph G = ( V, E ) with | V | = 2 n + 2 and r ( G ) = C( f ) + 1 and a colouring c : V → { , } such that every c -monochromatic hitting set has size at least min { C ( f, x ) , C ( f, x ) } .For each i ∈ [ n ], we introduce two vertices v i, and v i, into V . We also have two special vertices,which we denote u and u . For each 0-certificate ρ ∈ { , , ∗} n of size | ρ | ≤ C( f ), we construct anedge S ρ , as follows. For each i ∈ [ n ], if ρ i = 0 we place v i, in S ρ , and if ρ i = 1 we place v i, in S ρ .We also place u in S ρ . Then | S ρ | = | ρ | + 1 ≤ C( f ) + 1.For each 1-certificate ρ of size | ρ | ≤ C( f ), we construct an edge S ρ slightly differently. Essentially,we negate the bits of ρ before creating the edge out of ρ . So if ρ i = 0 we place v i, in S ρ and if ρ i = 18e place v i, in S ρ . We also place u in S ρ . Together, the edges coming from 0- and 1-certificatesconstitute all the edges in E . This defines G = ( V, E ).Note that r ( G ) = C( f ) + 1. Additionally, G is intersecting. To see this, note that if S ρ and S ρ are two edges of G , then there are three options: if ρ and ρ are both 0-certificates, they share u ;if ρ and ρ are both 1-certificates, they share u ; and if ρ and ρ are certificates of opposite types,then they must contradict each other at some index, meaning that ρ i = 0 and ρ i = 1 (or vice versa)for some i ∈ [ n ]. In this last case, S ρ and S ρ either both contain v i, or both contain v i, . In allcases, S ρ and S ρ have a non-empty intersection.We now define the colouring c : V → { , } based on the input x ∈ f − ( ∗ ). We do so by setting c ( v i,x i ) = 0, c ( v i, − x i ) = 1, c ( u ) = 0, and c ( u ) = 1. It remains to prove the following claim. Claim 14. If H is a c -monochromatic hitting set for G , then | H | ≥ min { C ( f, x ) , C ( f, x ) } .Proof. If H uses the colour 1, then it does not contain u ; since it is a hitting set, it mustintersect S ρ for each short 0-certificate ρ in some vertex v i,b (where i ∈ [ n ] and b ∈ { , } ). Since H is monochromatic with colour 1, we must have b = 1 − x i . Since v i, − x i ∈ S ρ , we must have ρ i = 1 − x i . In other words, the hitting set H must define a set of indices in [ n ] such that for eachshort 0-certificate ρ of f , there is some index i in this set on which ρ contradicts x . Since each0-input to f contains a short 0-certificate (of length at most C( f )), we conclude that this set ofindices used by H is such that each 0-input to f conflicts with x in one of those indices. This meansthat we can construct a 0-certificate by reading these indices in the string x ; thus | H | ≥ C ( f, x ).Alternatively, suppose that H uses the colour 0. Then it does not contain u , and must intersecteach S ρ for a short 1-certificate ρ of f in a vertex v i,b . Since H uses the colour 0, we must have b = x i , and since v i,x i ∈ S ρ , we must have ρ i = 1 − x i . As before, this implies that H defines a setof indices such that each short 1-certificate of f contradicts x on one of these indices; hence we canget a 1-certificate by reading those indices in x , which implies that | H | ≥ C ( f, x ). ⇒ II Given:
An intersecting hypergraph G = ( V, E ) and a colouring c : V → { , } such that every c -monochromatic hitting set has size at least h > r ( G ). Construct:
A partial boolean function f : { , } V → { , , ∗} and an input x ∈ f − ( ∗ )such that C( f ) ≤ r ( G ) and min { C ( f, x ) , C ( f, x ) } ≥ h .We define f on n = | V | bits so that an input to f is interpreted as a colouring of V . We define f ( z ) := 0 if the colouring z contains a monochromatic edge of colour 0, and we define f ( z ) := 1if z contains a monochromatic edge of colour 1. Note that both cases cannot hold, because G isintersecting. If neither of these cases holds, we define f ( z ) := ∗ .To certify that f ( z ) = 0 or that f ( z ) = 1, we can just read a monochromatic edge in z ; this onlyuses r ( G ) bits in the worst case over 0- or 1-inputs z , so C( f ) ≤ r ( G ).Next, consider the input x to f which is defined by the colouring c . Since any monochromaticedge is a monochromatic hitting set (since G is intersecting, so every edge is a hitting set), andsince the minimum monochromatic hitting set in c has size h > r ( G ), we conclude that c does nothave a monochromatic edge, and hence f ( x ) = ∗ . Observe that a certificate that x is not a 0-inputis a proof that there is no 0-monochromatic edge in c , and such a proof must necessarily read a1-monochromatic hitting set in c ; hence C ( f, x ) ≥ h . Similarly, we have C ( f, x ) ≥ h .9 emark . We note that f is monotone by construction: flipping any bit in an input z from 0to 1 can only change f ( z ) from 0 to ∗ or 1, or from ∗ to 1. In particular, this means that we cantransform any solution to II into a monotone one via the steps II ⇒ III ⇒ II.
Finally, we prove Corollary 5, which states that there exists a total function f with C( f ) ≥ ˜Ω( g deg( f ) ).Let us quickly recall the definition of the (cid:15) -approximate degree g deg (cid:15) ( f ) of an n -bit boolean function f :it equals the least degree of an n -variate polynomial p : R n → R such that p ( x ) ∈ f ( x ) ± (cid:15) for everyboolean input x ∈ { , } n . We also set g deg( f ) := g deg / ( f ). Proof of Corollary 5.
By applying the construction II ⇒ I (Section 4.1) to our
Hex function(Section 3), we get a total g with C ( g ) ≥ ˜Ω(UC ( g ) . ). All we have to show is that g also has g deg( g ) ≤ ˜ O ( p UC ( g )) . (1)Lets examine the function constructed by II ⇒ I using the notation in that proof. This proof startsout with an original n -bit function f (namely, Hex √ n ) and it defines from it a new function g on O ( n log n ) bits using the cheat sheet framework. An input to g consists of k := log n inputsto f and an array of size n , where each cell of the array is of size k‘ , where ‘ ≤ f ) log n is thenumber of bits needed to specify a certificate of f . In a 1-input to g , the correct cell, which iscell s z , is supposed to contain k certificates for the k instances of f . We did not specify how thecertificates would be described since the construction II ⇒ I applies to a general function f , but nowlet us describe them precisely for f = Hex . Here, a convenient 0-certificate is a list of adjacent0-entries that starts from the left and ends on the right. For a 1-certificate we can have a similarlist that starts at the top and ends at the bottom. Let us modify our function g to require that thecertificates are presented in exactly this format.Now for any cell c , consider the boolean function g c that on an input z to g evaluates to 1 if g ( z ) = 1 and additionally that cell c is the one pointed to by z (that is, s z = c ). We will show thatthis boolean function has an approximating polynomial of degree ˜ O ( p UC ( g )).To check if cell c is the one pointed to by the log n copies of f , we first need to check thatthe certificates contained in c are valid certificates for the log n instances of f , and that log nf -outputs of these certificates, when interpreted as a number is indeed c . First we claim thatchecking if a certificate for a particular f is valid can be done with an approximating polynomialof degree ˜ O ( p UC ( g )). Let us do this for 0-certificates, and the construction for 1-certificates issimilar. Each 0-certificate for an instance of f contains C( f ) many Hex -matrix entries that areadjacent, all having the value 0, and starting at the left and ending at the right. Checking if twoadjacent entries in the list correspond to adjacent matrix entries requires only O (log n ) queries by adeterministic query algorithm (decision tree). There are O ( n ) such checks to be made. Checkingif a matrix entry in the list is 0 requires O (log n ) queries as well. There are O ( n ) such checks tobe made. And finally checking that the first and last entry of the list are on the left and rightrequire O (log n ) queries. In total we have to make O ( n ) checks, each of which cost O (log n ) queries.Equivalently, we want to compute the logical And of O ( n ) many query algorithms, each of whichhas query complexity O (log n ).A deterministic query algorithm of O (log n ) queries can be converted to an exact polynomial ofdegree O (log n ). Nisan and Szegedy [NW95] showed that there is a polynomial of degree O ( √ n ) toapproximate the n -bit And function. Composing this polynomial with a O (log n )-degree polynomialsfor the individual checks gives us an approximating polynomial of degree ˜ O ( √ n ) for checking if10 particular certificate for f is valid. Since there are log n certificates to be checked, checkingall of them does not increase the degree by more than a log factor. Once we have checked if allthe f certificates are valid, we know the outputs and can check if this equals c . Thus we have anapproximating polynomial for g c of degree ˜ O ( √ n ).Now that we know that g c has an approximating polynomial of degree ˜ O ( √ n ), we can constructone for g from such polynomials. First we boost the approximation accuracy of the polynomials weconstructed to have error 1 / n , which only increases the degree by a log factor. Then we observethat g ( z ) = 1 if and only if one of the g c ( z ) functions evaluate to 1, and furthermore, no more thanone of them can evaluate to 1 since these are unambiguous certificates. So we get an approximatepolynomial for g by simply summing up the polynomials for all g c . Since each polynomial had error1 / n , the resulting polynomial has error at most 1 /
3. The degree has not increased, and hence wehave an approximating polynomial for g of degree ˜ O ( √ n ) = ˜ O ( p UC ( f )). This proves (1). Acknowledgements
Thanks to Ryan Alweiss, Harry Buhrman, Nati Linial, and Mario Szegedy for their thoughts onPuzzle III. Thanks to Thomas Watson for many discussions about Hex and complexity classes.
References [ABK16] Scott Aaronson, Shalev Ben-David, and Robin Kothari. Separations in query complexityusing cheat sheets. In
Proceedings of the 48th Symposium on Theory of Computing(STOC) , pages 863–876. ACM, 2016. doi:10.1145/2897518.2897644 .[ABK +
21] Scott Aaronson, Shalev Ben-David, Robin Kothari, Shravas Rao, and Avishay Tal.Degree vs. approximate degree and quantum implications of Huang’s sensitivity theorem.In
Proceedings of the 53rd Symposium on Theory of Computing (STOC) , 2021. Toappear. arXiv:2010.12629 .[Ama14] Kazuyuki Amano. Some improved bounds on communication complexity via newdecomposition of cliques.
Discrete Applied Mathematics , 166(0):249–254, 2014. doi:10.1016/j.dam.2013.09.015 .[BHT17] Shalev Ben-David, Pooya Hatami, and Avishay Tal. Low-sensitivity functions fromunambiguous certificates. In , volume 67, pages 28:1–28:23. Schloss Dagstuhl, 2017. doi:10.4230/LIPIcs.ITCS.2017.28 .[BLMP18] Nicolas Bousquet, Aur´elie Lagoutte, Fr´ed´eric Maffray, and Lucas Pastor. Decompositiontechniques applied to the clique-stable set separation problem.
Discrete Mathematics ,341(5):1492–1501, 2018. doi:10.1016/j.disc.2017.10.014 .[BLT14] Nicolas Bousquet, Aur´elie Lagoutte, and St´ephan Thomass´e. Clique versus independentset.
European Journal of Combinatorics , 40(0):73–92, 2014. doi:10.1016/j.ejc.2014.02.003 .[CS21] Maria Chudnovsky and Paul Seymour. Subdivided claws and the clique-stable setseparation property. , pages 483–487, 2021. doi:10.1007/978-3-030-62497-2 29 . 11GJPW18] Mika G¨o¨os, T. S. Jayram, Toniann Pitassi, and Thomas Watson. Randomized communi-cation vs. partition number.
ACM Transactions on Computation Theory , 10(1):4:1–4:20,2018. doi:10.1145/3170711 .[GLM +
16] Mika G¨o¨os, Shachar Lovett, Raghu Meka, Thomas Watson, and David Zuckerman.Rectangles are nonnegative juntas.
SIAM Journal on Computing , 45(5):1835–1869, 2016. doi:10.1137/15M103145X .[G¨o¨o15] Mika G¨o¨os. Lower bounds for clique vs. independent set. In
Proceedings of the 56thSymposium on Foundations of Computer Science (FOCS) , pages 1066–1076. IEEE, 2015. doi:10.1109/FOCS.2015.69 .[GPW18] Mika G¨o¨os, Toniann Pitassi, and Thomas Watson. Deterministic communication vs.partition number.
SIAM Journal on Computing , 47(6):2435–2450, 2018. doi:10.1137/16M1059369 .[HS12] Hao Huang and Benny Sudakov. A counterexample to the Alon–Saks–Seymour conjectureand related problems.
Combinatorica , 32(2):205–219, 2012. doi:10.1007/s00493-012-2746-4 .[LT16] Aur´elie Lagoutte and Th´eophile Trunck. Clique–Stable Set separation in perfect graphswith no balanced skew-partitions.
Discrete Mathematics , 339(6):1809–1825, 2016. doi:10.1016/j.disc.2016.02.005 .[NW95] Noam Nisan and Avi Wigderson. On rank vs. communication complexity.
Combinatorica ,15(4):557–565, 1995. doi:10.1007/BF01192527 .[Raz11] Ran Raz. How to fool people to work on circuit lower bounds, 2011. Seminar talk. URL: https://youtu.be/nsQzS3IOS6Y .[SA15] Manami Shigeta and Kazuyuki Amano. Ordered biclique partitions and communicationcomplexity problems.
Discrete Applied Mathematics , 184:248–252, 2015. doi:10.1016/j.dam.2014.10.029 .[Yan91] Mihalis Yannakakis. Expressing combinatorial optimization problems by linear programs.
Journal of Computer and System Sciences , 43(3):441–466, 1991. doi:10.1016/0022-0000(91)90024-Ydoi:10.1016/0022-0000(91)90024-Y