Automating Cutting Planes is NP-Hard}
AAutomating Cutting Planes is NP -Hard Mika G¨o¨os † Sajin Koroth Ian Mertz Toniann Pitassi
Stanford University Simon Fraser University Uni. of Toronto Uni. of Toronto & IAS
April 20, 2020
Abstract
We show that Cutting Planes (CP) proofs are hard to find: Given an unsatisfiable formula F ,(1) it is NP -hard to find a CP refutation of F in time polynomial in the length of theshortest such refutation; and(2) unless Gap-Hitting-Set admits a nontrivial algorithm, one cannot find a tree-like
CP refutation of F in time polynomial in the length of the shortest such refutation.The first result extends the recent breakthrough of Atserias and M¨uller ( FOCS 2019 ) thatestablished an analogous result for Resolution. Our proofs rely on two new lifting theorems:(1) Dag-like lifting for gadgets with many output bits . (2) Tree-like lifting that simulates an r -round protocol with gadgets of query complexity O (log r ) independent of input length. Contents
A Proof of Large Index Lemma 21B Proof of Simplex Lemma 23References 25 † Part of the work done while at Institute for Advanced Study. a r X i v : . [ c s . CC ] A p r Introduction
Propositional proof systems are by nature non-deterministic : a short refutation of a formula F in aparticular proof system constitutes an easy-to-check certificate (an NP -witness) of F ’s unsatisfiability(which is a coNP -property). The question of efficiently finding such refutations is the foundationalproblem of automated theorem proving with applications to algorithm design, e.g., for combinatorialoptimization [FKP19]. The following definition is due to Bonet et al. [BPR00]. Automatability.
A proof system P is automatable if there is an algorithm that oninput an unsatisfiable CNF formula F outputs some P -refutation of F in time polynomialin the length (or size) of the shortest P -refutation of F . Algorithms.
Several basic propositional proof systems are automatable when restricted to proofsof bounded width or degree . For example, Resolution refutations of width w can be found intime n O ( w ) for n -variate formulas [BW01]. Efficient algorithms also exist for finding bounded-degree refutations in algebraic proof systems such as Nullstellensatz, Polynomial Calculus [CEI96],Sherali–Adams, and Sum-of-Squares (under technical assumptions) [O’D17, RW17]. Hardness.
Without restrictions on width or degree, many of these systems are known not tobe automatable. For the most basic system, Resolution, a long line of work [Iwa97, ABMP01,AR08, MPW19] recently culminated in an optimal non-automatability result by Atserias andM¨uller [AM19]. They showed that Resolution is not automatable unless P = NP . Under strongerhardness assumptions non-automatability results are known for Nullstellensatz and PolynomialCalculus [GL10, MPW19] as well as for various Frege systems [KP98, BPR97b, BDG + This work.
The above list conspicuously omits to mention any hardness results for the CuttingPlanes (CP) proof system (defined in Section 1.1 below). Indeed, we show the first such results:( § NP -hard to automate CP. This is an Atserias–M¨uller style result for CP.( § tree-like CP.One reason Cutting Planes has been lacking non-automatability results is because of the shortageof techniques to prove lower bounds on CP refutation length. Virtually the only known methodhas been to find reductions to monotone circuit lower bounds (for example, via monotone feasibleinterpolation). Our proofs rely on two new lifting theorems , one of which bypasses the need formonotone circuit lower bounds. See Section 2 for an overview of our techniques.
Cook, Coullard, and Tur´an [CCT87] introduced Cutting Planes as a propositional proof systeminspired by a like-named method to solve integer linear programs. The method uses rounding oflinear inequalities (Chv´atal–Gomory cuts) to reason about the integral solutions to a linear program.The proof system version of CP is defined as follows. Suppose we are given a CNF formula F over variables x , . . . , x n . A (dag-like) Cutting Planes refutation of F is a sequence of lines ‘ , . . . , ‘ m (where m is the length ), each line being a linear inequality, P i a i x i ≥ b , with integer coefficients, a i , b ∈ Z . We require that the sequence ends with the contradictory inequality ‘ m := [ 0 ≥ ‘ i satisfies one of the following: − Axiom.
Line ‘ i is either a boolean axiom ( x i ≥ − x i ≥ −
1) or an encoding of a clauseof F (for example, clause ( x ∨ ¯ x ) gets encoded as x + (1 − x ) ≥ Derivation.
Line ‘ i is deduced from two premises ‘ j , ‘ j where j, j < i (perhaps j = j ) byan application of a sound rule . (A refutation is tree-like if each line appears at most once as apremise.)In the original paper [CCT87] the rules were: (1) deriving from ‘ j , ‘ j any nonnegative integerlinear combination of them, and (2) deriving from P a i x i ≥ b the line P ( a i /c ) x i ≥ d b/c e where c := gcd( a , . . . , a n ). Stronger rules have also been studied, e.g., [CKS90, BCC93], the most generalbeing the semantic rule , which allows any sound inference: ‘ i can be derived from ‘ j , ‘ j providedevery boolean vector x ∈ { , } n that satisfies both ‘ j and ‘ j also satisfies ‘ i . In this paper, weadopt the best of all possible worlds: our lower bounds on CP refutation length will hold evenagainst the semantic system and our upper bounds use the weakest possible rules (in fact, our upperbounds hold for Resolution, which is simulated by every variety of CP). Our first main result is a CP analogue of the Atserias–M¨uller theorem [AM19].
Theorem 1 (Dag-like) . There is a polynomial-time algorithm A that on input an n -variate 3-CNFformula F outputs an unsatisfiable CNF formula A ( F ) such that: − If F is satisfiable , then A ( F ) admits a CP refutation of length at most n O (1) . − If F is unsatisfiable , then A ( F ) requires CP refutations of length at least n Ω(1) . Consequently, it is NP -hard to approximate the minimum CP proof length up to a factor of 2 n ε for some ε >
0. In particular, CP is not automatable unless P = NP . Our second result is a similar theorem for tree-like
Cutting Planes. However, we need a strongerhardness assumption (which is morally necessary; see Section 2.2) that we now formulate.An n -set system is a collection S = { S , . . . , S n } where S i ⊆ [ n ] for each i ∈ [ n ]. A subset H ⊆ [ n ] is a hitting set for S if H ∩ S i = ∅ for all i ∈ [ n ]. The hitting set number of S , denoted γ ( S ),is the minimum size of a hitting set for S . The k - Gap-Hitting-Set promise problem is todistinguish between the cases γ ( S ) ≤ k versus γ ( S ) ≥ k . A trivial algorithm can solve thisproblem in time n O ( k ) . It is conjectured that there are no nontrivial algorithms for k as large as(1 − (cid:15) ) log n . Under the Exponential-Time Hypothesis [IP01], the problem is known to be hard upto k ≤ (log log n ) − o (1) [Lin19]. We need an assumption that is stronger by a hair’s breadth. Conjecture 1.
The k - Gap-Hitting-Set problem requires time n Ω( k ) for some k = k ( n ) with ω (log log n ) ≤ k ( n ) ≤ log / n. ( † )Our second main result says that tree-like CP is not automatable under Conjecture 1. Theorem 2 (Tree-like) . Let k = k ( n ) satisfy ( † ) . There is an n o ( k ) -time algorithm A that on inputan n -set system S , outputs a CNF formula A ( S ) such that: − If γ ( S ) ≤ k , then A ( S ) admits a tree-like CP refutation of length at most n o ( k ) . − If γ ( S ) ≥ k , then A ( S ) requires tree-like CP refutations of length at least n ω ( k ) . Overview of proofs
In this section, we explain why both of our main results (dag-like and tree-like) follow fromappropriate kinds of lifting theorems . Abstractly speaking, a lifting theorem is a tool that translatesa lower-bound result for a weak model of computation (for us, Resolution) into an analogouslower-bound result for a strong model of computation (for us, Cutting Planes). Starting with Razand McKenzie [RM99] such theorems now exist for an enormous variety of computational models.In proof complexity alone, prior examples of lifting applications include [BEGJ00, HN12, GP18,dRNV16, GGKS18, GKRS19, dRMN + Our proof of Theorem 1 builds directly on top of the breakthrough of Atserias and M¨uller [AM19].Given an n -variate 3-CNF formula F , they construct a formula Ref( F ), which is an intricate CNFencoding of the claim “ F admits a short Resolution refutation.” Luckily, the exact details of Ref( F )are not important for us. We only need a few high-level properties of their construction. Block-width.
The variables of Ref( F ) come partitioned into some number of blocks . Given aclause D over the variables of Ref( F ), we define its block-width as the number of blocks that D touches , that is, contains a variable (or its negation) from that block. The block-width of a Resolutionrefutation is the maximum block-width of any of its clauses. Lemma 3 (Atserias–M¨uller [AM19]) . There is a polynomial-time algorithm that on input an n -variate 3-CNF formula F outputs an unsatisfiable CNF formula
Ref( F ) such that − If F is satisfiable , then Ref( F ) admits a n O (1) -length O (1) -block-width Resolution refutation. − If F is unsatisfiable , then Ref( F ) requires Resolution refutations of block-width at least n Ω(1) . Atserias and M¨uller finish their proof by modifying Ref( F ) slightly via relativization , an operationdue to Danchev and Riis [DR03] (see also [Gar19]). What this operation achieves is to turn aformula requiring block-width b into a formula requiring Resolution length 2 Ω( b ) . If F is unsatisfiable,relativized-Ref( F ) will have exponential length complexity. On the other hand, if F is satisfiable,relativized-Ref( F ) continues to have a short Resolution refutation, inherited from Ref( F ).In this paper, in order to make Ref( F ) hard for Cutting Planes (when F is unsatisfiable), wewill modify the formula by block-wise composing (aka lifting) it with a small gadget, an operationsimilar to relativization. Lifting width.
Recently, Garg et al. [GGKS18] introduced a new lifting-based lower-boundtechnique for Cutting Planes: they showed how to lift Resolution width to Cutting Planes length.Namely, if F is an n -variate formula requiring Resolution width w , then for a careful choice ofa gadget g : { , } m → { , } , m = n O (1) , the composed formula F ◦ g n —obtained from F bysubstituting each of its variables with a copy of g —has Cutting Planes length complexity n Θ( w ) .What would happen if we tried to apply the lifting result of [GGKS18] to the formula Ref( F )?When F is unsatisfiable, we indeed do get (using width ≥ block-width) that Ref( F ) ◦ g n requiresexponential-length CP refutations. However, when F is satisfiable, even though Ref( F ) is promised Strictly speaking, Ref( F ), as defined in [AM19], may sometimes be satisfiable, in which case its Resolutionwidth/length complexity is understood as ∞ . However this case is equivalent to our reformulation, as we can guaranteethat Ref( F ) is always unsatisfiable by consider instead the CNF formula Ref( F ) ∧ T where T is some formula overdisjoint variables known to require large width (e.g., Tseitin contradictions [Urq87]).
3o have block-width O (1), its usual width still turns out to be n Ω(1) . Therefore the compositionwith g would blow up the length complexity, not creating the desired gap in CP proof length. Lifting block-width.
Our idea, in short, is to build on [GGKS18] and prove a lifting theoremfor block-width (instead of width). Suppose F is a formula whose n‘ variables are partitionedinto n many blocks of ‘ variables each (typically ‘ = n Θ(1) ). We will consider compositions F ◦ g n‘ with a multi-output gadget g ‘ : { , } m → { , } ‘ , one gadget for each block; see Section 3.4 forthe formal definition. Below, res ( · ) denotes Resolution length complexity, cut ( · ) denotes CuttingPlanes length complexity, and bw ( · ) denotes Resolution block-width complexity. Theorem 4 (Block lifting) . Fix an unsatisfiable CNF formula F having n many blocks of ‘ variableseach. There is a gadget g ‘ : { , } m → { , } ‘ where m := ( n‘ ) Θ(1) such that m Ω( bw ( F )) ≤ cut ( F ◦ g n‘ ) ≤ res ( F ◦ g n‘ ) ≤ m O ( bw (Π)) · | Π | , where Π is any Resolution refutation of F of length | Π | and block-width bw (Π) . Our main dag-like theorem (Theorem 1) now follows immediately by combining Lemma 3 andTheorem 4. Namely, consider the algorithm A that on input an n -variate 3-CNF formula F outputsthe CNF formula A ( F ) := Ref( F ) ◦ g k‘ where Ref( F ) has k ≤ n O (1) many blocks with ‘ ≤ n O (1) variables each. We only need to note that this composed formula is constructible in polynomialtime, which will be evident from the formal definition; see Fact 7 in Section 3.5. Therefore, to proveTheorem 1 it remains to prove Theorem 4, which we do in Section 4. Relation to monotone circuits.
To conclude this subsection, we offer some philosophicalmusings on the techniques used to prove Theorem 4. Non-automatability results for Cutting Planeshave been elusive in part because of the limitations of existing techniques to prove lower boundson refutation length (as required by the second item in Theorem 1). The only technique availablefor some twenty years has been monotone feasible interpolation [BPR97a, Kra97, HP18], whichtranslates lower bounds for (real) monotone circuits to lower bounds on Cutting Planes length.Historically, the downside with the technique was that it only seemed to apply to highly specializedformulas (e.g., clique-vs-coloring). However, the technique was recently extended to handle amore general class of formulas, random Θ(log n )-CNFs [HP17, FPPR17]. The only other availablelower-bound technique is the aforementioned lifting theorem [GGKS18]. That technique is alsopowerful enough to prove lower bounds not only on CP length, but also on monotone circuit size.(Whether lifting should be classified under monotone interpolation is up for debate, since thisdepends on how broadly one defines monotone interpolation.)In contrast, our Theorem 4 is not proved through monotone circuit lower bounds, but througha new weaker model of computation, dubbed simplex-dags in Section 3.2. At the heart ofmonotone interpolation is a characterization of monotone circuits by a two-party communica-tion game [Raz95, Pud10, Sok17]. In this language, our Theorem 4 is obtained not by studying atwo-party communication model, but rather a multi-party model. Considering a large number ofcommunicating parties is what allows us to analyze multi-output gadgets; we do not know how todo this with only two parties. Our proof of Theorem 2 builds on the important paper by Alekhnovich and Razborov [AR08] (whichhas been followed up by [GL10, MPW19]). They show that tree-like Resolution is not automatable4ssuming the fixed parameter hierarchy does not collapse (which is implied by the Exponential-TimeHypothesis). Since tree-like Resolution proofs can be found in quasipolynomial-time (we say tree-likeResolution is quasipolynomially automatable), they need to assume more than NP -hardness. Ourresults will inherit this need for a stronger assumption (namely, Conjecture 1), even though tree-likeCP is not known to be quasipolynomially automatable.The reduction of Alekhnovich and Razborov is somewhat complicated, but luckily we will onlyneed as our starting point the following lemma from the follow-up work [MPW19]. Lemma 5 (Mertz et al. [MPW19]) . Let k ≤ log / n . There is a polynomial-time algorithm B thaton input a n -set system S outputs an unsatisfiable O (log n ) -CNF formula B ( S ) such that − If γ ( S ) ≤ k , then B ( S ) admits a Resolution refutation of depth O (log n ) . − If γ ( S ) ≥ k , then B ( S ) requires Resolution refutations of depth Ω( k log n ) . To prove Theorem 2, our plan is once again to compose the formula B ( S ) with a (single-output-bit) gadget in order to lift the Resolution depth gap in Lemma 5 into tree-like CP length gap. Tothis end, we develop a new lifting theorem for “small” gadgets. Limitations of existing methods.
Let F be an unsatisfiable n -variate formula with Resolutiondepth complexity d ( F ). Existing lifting theorems [BEGJ00, dRNV16] when applied to F wouldrequire a gadget g : { , } poly( n ) → { , } that can be computed by a decision tree of depth Θ(log n )and hence of size poly( n ). Writing res-tree ( · ) for tree-like Resolution length complexity, and cut-tree ( · ) for tree-like CP length complexity, the lifting theorems [BEGJ00, dRNV16] show cut-tree ( F ◦ g n ) = res-tree ( F ◦ g n ) Θ(1) = n Θ( d ( F )) . (1)The base of the exponent above (namely, poly( n )) is the decision tree size of g . If we applied (1) toLemma 5, we would only end up with a length gap of n O (log n ) versus n ω (log n ) . But these lengths—andhence running times for the automating algorithm—are enough to solve the k - Gap-Hitting-Set problem, which prevents us from getting a hardness result.
Small gadget lifting.
What we need is a lifting theorem for small gadgets, that is, gadgetscomputed by small decision trees. It is an important open problem whether tree-like lifting ispossible with a constant-size gadget. In this paper, we are able to use a gadget of decision-tree sizedepending only on the quantity we want to lift, namely d ( F ), and not depending on the numberof variables n of F . Our lifting theorem can be seen as a generalization of previous ones, whichhandled the case d ( F ) = n Ω(1) , and can also be viewed as a step towards proving a lifting theoremfor significantly smaller gadgets (eventually, constant-size).
Theorem 6 (Small gadget lifting) . For every m there exists a gadget g : { , } poly( m ) → { , } ofquery complexity O (log m ) such that for every unsatisfiable n -variate CNF formula F , m Θ(min( d ( F ) ,m )) ≤ cut-tree ( F ◦ g n ) ≤ res-tree ( F ◦ g n ) ≤ m O ( d ( F )) . Our main tree-like theorem (Theorem 2) now follows by combining Lemma 5 and Theorem 6.Indeed, choose m := log n and consider the algorithm A that on input an n -set system S outputsthe formula A ( S ) := B ( S ) ◦ g n where B ( S ) has n = n O (1) variables. We have γ ( S ) ≤ k = ⇒ cut-tree ( A ( S )) ≤ m O (log n ) = n O (log log n ) ≤ n o ( k ) ,γ ( S ) ≥ k = ⇒ cut-tree ( A ( S )) ≥ m Ω( k log n ) = n Ω( k log log n ) ≥ n ω ( k ) . B ( S ) ◦ g n can be constructed in time n o ( k ) . This will beevident from the formal definition (see Fact 11), but the intuition is as follows. Each O (log n )-widthclause of B ( S ) will turn into a whole family O (log m log n )-width clauses for B ( S ) ◦ g n . The familyfor a particular clause D is obtained by replacing each literal of D in all possible ways by an O (log m )-length root-to-leaf path (of which there are 2 O (log m ) many) in the decision tree for g .Altogether this will yield |B ( S ) | · (2 O (log m ) ) O (log n ) = n O (1) · n o ( k ) = n o ( k ) many clauses. Therefore,to prove Theorem 2 it remains to prove Theorem 6, which we do in Section 6. Relation to real protocols.
The lower bound in Theorem 6 holds not only for tree-like CuttingPlanes but also for a stronger model of computation, real communication protocols [Kra98]. Thisis not surprising: all existing lower bounds on tree-like CP length have been proved through realprotocols (or the even more powerful model of randomized protocols). In a nutshell, our proof ofTheorem 6 extends the techniques in a long line of work on tree-like lifting [RM99, BEGJ00, GPW15,dRNV16, GPW17, CFK + n . A detailed overview is given in Section 6. In this paper, we adopt the standard top-down view of proofs [Pud00, AD08]. Namely, we interpreta refutation of an n -variate CNF formula F := ∧ i ∈ [ m ] D i as a way of solving the associated falsified-clause search problem S F ⊆ { , } n × [ m ]. The problem S F is, on input a truth assignment x ∈ { , } n , to find a clause D j , j ∈ [ m ], falsified by x , that is, D j ( x ) = 0. For example, tree-likeResolution refutations of F are equivalent to decision trees solving S F [LNNW95]. We proceed toformalize this for dag-like models. The material in Section 3.1 is standard. Section 3.2 introduces anovel model, simplex-dags , for which we develop a lifting theorem in Section 4. Abstract dags.
Fix an abstract search problem S ⊆ I × O , that is, on input x ∈ I the goal isto find some o ∈ S ( x ) := { o ∈ O : ( x, o ) ∈ S } . We always work with total search problems where S ( x ) = ∅ for all x ∈ I . Fix also a family F of functions I → { , } . An F -dag solving S is adirected acyclic graph of out-degree ≤ v is associated with a function f v ∈ F (here f − (1) is sometimes called the feasible set for v ) satisfying the following. − Root.
There is a designated root vertex v (in-degree 0) that satisfies f v ≡ − Non-leaf.
Every non-leaf v with children u, u (perhaps u = u ) has f − v (1) ⊆ f − u (1) ∪ f − u (1). − Leaves.
For every leaf v there is some output o ∈ O such that f − v (1) ⊆ S − ( o ).The size of an F -dag is its number of vertices. Decision-dags and Resolution.
Consider instantiating the above template with the n -bit inputdomain I := { , } n and taking F to be the set of all conjunctions over the literals x , ¯ x , . . . , x n , ¯ x n .We call such F -dags simply decision-dags . Apart from the size of a decision-dag another importantmeasure is its width : the maximum width of a conjunction used. We define dec-dag ( S ) := least size of a decision-dag solving S, w ( S ) := least width of a decision-dag solving S. S = S F , we recover the usual Resolutionproof system. Indeed, dec-dag ( S F ) equals res ( F ), the length required to refute F in Resolution, and w ( S F ) equals the Resolution width complexity of F (famously studied in [BW01]). LTF-dags and Cutting Planes.
Consider instantiating I := { , } n and taking F to be the setof all n -bit linear threshold functions (LTFs). Recall that an f ∈ F is defined by a vector a ∈ R n +1 such that f ( x ) = 1 iff P i ∈ [ n ] a i x i ≥ a n +1 . We call such F -dags simply LTF-dags , and define ltf-dag ( S ) := least size of an LTF-dag solving S. When specialized to S = S F , we recover the semantic Cutting Planes proof system. Indeed, ltf-dag ( S F ) equals cut ( F ), the length required to refute F in semantic Cutting Planes. We now introduce a new type of dag, for which our dag-like lifting theorem is formulated (Section 4).Let k ≥ k -partite input domain I := I × · · · × I k . We say that a function f : I × · · · × I k → { , } is monotone (up to an ordering of the parts I i ; aka unate ) iff each set I i admits a total order (cid:22) i such that f ( x ) ≤ f ( y ) for every pair x (cid:22) y (meaning x i (cid:22) i y i for all i ∈ [ k ]).For example, every n -bit LTF is monotone as an n -partite function: the orderings are determinedby the signs of the coefficients appearing in the linear form defining f . We also say that a subset A ⊆ I × · · · × I k is a (combinatorial) k -simplex if its indicator function is monotone. Let F be theset of monotone functions over I × · · · × I k ; we emphasize that any two f, f ∈ F may not agreeon the ordering of any part I i . We call such F -dags simply simplex-dags , and define sim-dag ( S ) := least size of a simplex-dag solving S. Relation to other models.
Simplex-dags are a natural k -party generalization of the bipartitecase k = 2, which was called triangle-dags in [GGKS18]. Triangle-dags in turn are equivalent to realcircuits and real dag-like protocols [HC99, Pud97, HP18]. Our motivation to consider multi-partymodels is that they can be vastly weaker than two-party models. Hence one expects it to be easierto prove lower bounds for k -simplex-dags when k is large. For a toy example, consider the n -bit Xor n function. It is easy to compute for traditional two-party communication protocols regardlessof how the n bits are split between the two players. By contrast, for n parties, each holding oneinput bit, Xor n is hard to compute. The complexity measures introduced so far are related as follows: sim-dag ( S k ) ≤ ltf-dag ( S n ) ≤ dec-dag ( S n ) ≤ n O ( w ( S n )) . Here S n ⊆ { , } n × O is any n -bit search problem, and S k ⊆ { , } I × · · · × { , } I k × O is a k -partite version of S n obtained from an arbitrary partition I t · · · t I k = [ n ]. The first inequalityfollows by noting that each LTF f , defined by P i a i x i ≥ a n +1 , is a monotone k -partite function whenthe i -th part { , } I i is ordered according to the partial sum P i ∈ I i a i x i (breaking ties arbitrarily).The second inequality follows since every conjunction is an LTF. The last inequality is standard:the length of any width- w Resolution refutation can be made n O ( w ) by eliminating repeated clauses(and the same construction works for arbitrary search problems).7 .4 Blocks Block width.
Let S ⊆ ( { , } ‘ ) n × O be any search problem whose n‘ input bits are partitionedinto n blocks of ‘ bits each. For every conjunction C over the variables of S , we define the block-width of C as the maximum number of blocks that C touches , that is, contains a variable (or its negation)from a block. We define the block-width of a decision-dag solving S as the maximum block-widthover all conjunctions in the dag. Finally, we define bw ( S ) := least block-width of a decision-dag solving S. Block composition.
The column-index gadget
Ind ‘ × m : [ m ] × { , } ‘ × m → { , } ‘ is defined by Ind ‘ × m ( x, y ) := “ x -th column of y ”. We call y ∈ { , } ‘ × m the matrix and x ∈ [ m ] the pointer (for decision-dags, we tacitly encode the elements of [ m ] in binary as log m -bit strings.). Letting S ⊆ ( { , } ‘ ) n × O be as above, we define a composed search problem S ◦ Ind n‘ × m ⊆ [ m ] n × ( { , } ‘ × m ) n × O . (2)Namely, on input ( x, y ) ∈ [ m ] n × ( { , } ‘ × m ) n the goal is to find an output o ∈ S ( z ) for z :=( Ind ‘ × m ( x , y ) , . . . , Ind ‘ × m ( x n , y n )) ∈ ( { , } ‘ ) n . We shall view the composition (2) as an (1 + n‘ )-partite search problem by repartitioning the input domain as[ m ] n × ( { , } ‘ × m ) n = X × Q ( i,j ) ∈ [ n ] × [ ‘ ] Y ij where ( X := [ m ] n Y ij := { , } m .Here we think of player Alice as holding x ∈ X , and for ( i, j ) ∈ [ n ] × [ ‘ ], player Bob ij as holding( y i ) j ∈ Y ij , that is, the j -th row of the i -th matrix y i . x i ( Alice ) i -th gadget: ‘ m = ( y i ) ∈ Y i ( Bob i )= ( y i ) ∈ Y i ( Bob i )= ( y i ) ∈ Y i ( Bob i )011 100 101 011 001 We just defined block-composed search problems S ◦ Ind n‘ × m , but how can we translate such objectsback to CNF formulas? The standard recipe is as follows. Fix any search problem S ⊆ { , } n × O (not necessarily of a composed form). A certificate for ( x, o ) ∈ S is a partial assignment ρ ∈ { , , ∗} n consistent with x such that for any y consistent with ρ we have ( y, o ) ∈ S . The size of ρ is thenumber of its fixed (non- ∗ ) coordinates. The certificate complexity of S is the maximum over allinputs x ∈ { , } n of the minimum over all o ∈ S ( x ) of the least size of a certificate for ( x, o ). Forexample, if F is an unsatisfiable k -CNF formula, then S F has certificate complexity at most k .Conversely, any total search problem S of certificate complexity k contains the search problem S F associated with some unsatisfiable k -CNF formula F as a subproblem ( S is at least as hard as S F ).Namely, consider F := V x ¬ C x where C x is the conjunction that checks if the input is consistentwith some fixed size- k certificate for x . Note that F is unsatisfiable because S is total.8or unbounded-width CNF formulas (such as Atserias–M¨uller’s Ref( F )), we need to interpret theabove recipe with care. Indeed, fix any unsatisfiable (unbounded-width) CNF formula F with | F | many clauses and such that its n‘ variables are partitioned into n blocks of ‘ variables each. Denoteby b the maximum block-width of a clause of F . Then every clause D of F gives rise to a family ofcertificates for S F ◦ Ind n‘ × m . Namely, a certificate in the family for D consists of at most b log m bits (reading b many pointer values associated with the blocks of D ) together with | D | many bitsread from the pointed-to columns. Thus, altogether, we get at most | F | m b many certificates, atleast one for each input to S F ◦ Ind n‘ × m . We define F ◦ Ind n‘ × m as the formula obtained by listingall these certificates (more precisely, the disjunctions that are the negations of the certificates).The formula Ref( F ) of Atserias and M¨uller is such that its clauses have block-width 3 [AM19,Appendix A]. Hence Ref( F ) ◦ Ind n‘ × m has size n O (1) and moreover it is polynomial-time constructible. Fact 7.
Given an n -variate -CNF F , we can construct Ref( F ) ◦ Ind n‘ × m in polynomial time. The purpose of this section is to prove our block-lifting theorem (Theorem 4), which would completethe proof of our main dag-like result (Theorem 1). We restate the block-lifting theorem using thesearch-problem-centric language of Section 3. Then Theorem 4 is the special case S := S F . Theorem 8 (Block lifting) . Let S ⊆ ( { , } ‘ ) n × O be any search problem. For m := ( n‘ ) we have m Ω( bw ( S )) ≤ sim-dag ( S ◦ Ind n‘ × m ) ≤ dec-dag ( S ◦ Ind n‘ × m ) ≤ m O ( bw (Π)) · | Π | , where Π is any decision-dag solving S of size | Π | and block-width bw (Π) . Upper bound.
The last inequality is the trivial part of Theorem 8. We only sketch it here. Givena decision-dag Π for S , we construct a decision-dag Π for S ◦ Ind n‘ × m . For every block-width- b conjunction C in Π, there corresponds a family of exactly m b many conjunctions in Π . Namely,the family is constructed by replacing each positive literal x ij (resp. negative literal ¯ x ij ) of C witha sequence of log m + 1 many literals that witness the j -th output bit of the i -th gadget being 1(resp. 0). If C has children C , C that only touch blocks touched by C , then every conjunction inthe family for C can be directly connected to the families of C , C . However, if C , C touch someblock i (there can be at most one) that is untouched by C , then the family for C is connected tothe families of C , C via decision trees that query the pointer value of the i -th gadget. We have | Π | ≤ m O ( bw (Π)) · | Π | , as desired. Lower bound.
The first inequality is the nontrivial part of Theorem 8. Our proof follows closelythe plan from [GGKS18]. However, the proof here is in many ways simpler than the original one.The reason is that we work with multi-party objects (high-dimensional boxes and simplices) ratherthan two-party objects (rectangles and triangles). For example, one of the key technical lemmas,Lemma 9 (“ ρ -structured boxes are ρ -like”), admits a short proof in our multi-party setting, whereasthe original lemma for two parties required a long proof involving Fourier analysis. The rest of thissection is concerned with proving the simplex-dag lower bound. Let ρ ∈ ( { , } ‘ ∪ {∗} ) n be a partial assignment that assigns each of the n blocks either an ‘ -bitstring or the star symbol. We denote by free( ρ ) ⊆ [ n ] the subset of blocks assigned a star, and9efine fix( ρ ) := [ n ] (cid:114) free( ρ ). The subcube of strings consistent with ρ is Cube( ρ ) := { z ∈ ( { , } ‘ ) n : z i = ρ i , ∀ i ∈ fix( ρ ) } . For any set R ⊆ X × Q Y ij we say that “ R is ρ -like” iff Ind n‘ × m ( R ) = Cube( ρ ) . We formulate a sufficient condition for R to be ρ -like in case R is a box , that is a product set. Definition 1 (Random variables) . For a random variable x ∈ X we define its min-entropy by H ∞ ( x ) := min x log(1 / Pr [ x = x ]). When x is chosen from a set X k that is partitioned into k blocks,we define its blockwise min-entropy by min ∅6 = S ⊆ [ k ] 1 | S | H ∞ ( x S ) where x S is the marginal distributionof x over blocks S . We also define the deficiency of x ∈ X by D ∞ ( x ) := log |X | − H ∞ ( x ) ≥ X is a set, we denote by X ∈ X the random variable that is uniform over X .In particular, for X ⊆ X n the notation X I for I ⊆ [ n ] means “the marginal distribution overcoordinates I of the uniform distribution over X ”. We use X I := { x I : x ∈ X } to mean the set thatis the projection of X onto coordinates I ; thus X I is the support of X I . Definition 2 (Structured boxes) . Let R := X × Q ij Y ij ⊆ X × Q ij Y ij be a box and ρ ∈ ( { , } ‘ ∪{∗} ) n a partial assignment. We say R is ρ -structured if1. Gadgets are fixed according to ρ : Ind fix( ρ ) ‘ × m ( R fix( ρ ) ) = { ρ fix( ρ ) } .2. X has entropy on the free blocks: X free( ρ ) has blockwise min-entropy ≥ . · log m .3. Y ij are large: D ∞ ( Y ij ) ≤ m / for i ∈ free( ρ ), j ∈ [ ‘ ].The following key lemma is the reason our dag-lifting result is formulated for k -simplex-dags forlarge k —we do not know how to prove a multi-output gadget lemma like this for k = 2. (The paper[GGKS18] did it for k = 2 and single-output gadgets.) Lemma 9.
Let R := X × Q ij Y ij be ρ -structured. There is an x ∈ X so that { x } × Q ij Y ij is ρ -like.Proof. Assume for simplicity that ρ = ∗ n . Thus our goal is to find an x ∈ X such that Ind n‘ × m ( { x } × Q ij Y ij ) = ( { , } ‘ ) n . The key observation is that since each of the n‘ output bits is determined by adifferent Bob ij , the output bits are independent: Ind n‘ × m ( { x } × Q ij Y ij ) = Q ij Ind × m ( { x i } × Y ij ).Therefore it suffices to find an x ∈ X such that for all i ∈ [ n ], j ∈ [ ‘ ], x is “good” for Y ij : Ind × m ( { x i } × Y ij ) = { , } . (3)We claim that a uniform random choice x ∈ X satisfies all conditions (3) with positive probability.Indeed, for a fixed ij , how many “bad” values x i ∈ [ m ] are there that fail to satisfy (3)? Each badvalue x i implies that the x i -th bit is fixed in Y ij . But there can be at most D ∞ ( Y ij ) ≤ m / fixedsuch bits. Using H ∞ ( x i ) ≥ . · log m for i ∈ [ n ] and recalling that m = ( n‘ ) we have Pr [ x i is “bad” for Y ij ] ≤ m / · − . m < / ( n‘ ) . A union bound over all the n‘ many conditions (3) completes the proof.The following lemma is the culmination of this subsection: Every simplex can be partitionedinto ρ -like pieces (and some error sets); see Figure 1. The lemma is a high-dimensional analogue ofthe Triangle Lemma from [GGKS18]. We defer the proof to Appendix B.
Simplex Lemma.
Let T ⊆ X × Q ij Y ij be a simplex and k ≥ an error parameter. There existsa disjoint box covering F r R r ⊇ T and error sets X err ⊆ X , Y err ,ij ⊆ Y ij , each of density ≤ − k ,such that for each r one of the following holds: ◦ ,r T ∩ R r R r Figure 1:
Structured case of Simplex Lemma. The simplex T is partitioned as T = F r T ∩ R r where each structured part is sandwiched between two ρ r -structured boxes, R ◦ ,r ⊆ T ∩ R r ⊆ R r . • Structured case: R r is ρ r -structured for some ρ r that fixes O ( k/ log m ) blocks. Moreoverthere exists an “inner” box R ◦ ,r ⊆ T ∩ R r , which is also ρ r -structured. • Error case: R r is covered by error boxes: R r ⊆ X err × Q ij Y ij ∪ S ij X × Y err ,ij × Q i j = ij Y i j .Finally, a query alignment property holds: for every x ∈ X (cid:114) X err , there exists a subset I x ⊆ [ n ] with | I x | ≤ O ( k/ log m ) such that every “structured” R r intersecting { x } × Q ij Y ij has fix( ρ r ) ⊆ I x . To prove (the first inequality of) Theorem 8, fix a simplex-dag Π solving S ◦ Ind n‘ × m of size m d .Our goal is to construct a decision-dag Π solving S that has block-width O ( d ). We first present theproof under a simplifying assumption and then remove that assumption in Section 4.3.( ∗ ) Assumption:
If we apply Simplex Lemma for k := 2 d log m to any simplex T in Π, then eachpart in the produced partition T = F r T ∩ R r satisfies the “structured case”.Using ( ∗ ), apply Simplex Lemma (for the above choice of k ) to partition all simplicies T in Π.Each resulting structured part T ∩ R r will correspond to a vertex in Π associated with the partialassignment (or conjunction) ρ r , that is, with feasible set Cube( ρ r ). Moreover, we will let the type(root/internal/leaf) of a vertex T in Π dictate the type of the resulting vertices T ∩ R r in Π . Wewill add more vertices to Π shortly in order to connect all the internal vertices, but so far Π alreadymeets the root and leaf conditions of a decision-dag solving S , as we note next. Step 1: Root and leaves.
We may assume that for the root of Π, which is associated with thesimplex T := X × Q ij ×Y ij , the Simplex Lemma produces the trivial partition consisting of justone ∗ n -structured part, T itself. Hence, the designated root of Π is defined as the sole part T withan associated feasible set Cube( ∗ n ) = ( { , } ‘ ) n . This meets the root condition of a decision-dag.Consider any part R ◦ ,r ⊆ T ∩ R r ⊆ R r with an associated assignment ρ r , arising from a leaf T of Π. Suppose o ∈ O is a valid solution for T in Π, that is, T ⊆ ( S ◦ Ind n‘ × m ) − ( o ), or equivalently, Ind n‘ × m ( T ) ⊆ S − ( o ). We claim that o is also a valid solution for the leaf T ∩ R r in Π :Cube( ρ r ) = Ind n‘ × m ( T ∩ R r ) ⊆ Ind n‘ × m ( T ) ⊆ S − ( o ) . Here the equality uses the fact that T ∩ R r is ρ r -like (it is sandwiched between two sets that are ρ r -structured, and hence ρ r -like by Lemma 9). This meets the leaf condition of a decision-dag.11 tep 2: Internal. To complete the definition of Π , consider a vertex associated with some part R ◦ ⊆ T ∩ R ⊆ R , where R ◦ and R are ρ -structured, that arises from a non-leaf simplex T of Π.We connect this vertex to the vertices arising from T ’s two children, L and L . The connectionsare made via a decision tree T , which we include in Π . At a high level, the tree will satisfy thefollowing.(1) Root:
The root of the tree T is identified with the vertex T ∩ R associated with ρ . That is, T starts out with the bits in blocks fix( ρ ) ⊆ [ n ] already queried.(2) Non-leaf:
The non-leaf vertices of T query more bits, one block at a time.(3) Leaf:
Every leaf ρ ∗ of T extends some assignment τ that arises from the partitions of thechildren L , L . Therefore, in Π , we define ρ ∗ to have τ as its unique child. (This way, thefeasible sets satisfy Cube( ρ ∗ ) ⊆ Cube( τ ) as required in a decision-dag.) (cid:59) T TL L Simplex-dag Π decision-dag Π F r T ∩ R r : ρ ρ ∗ τ The tree T is defined precisely as follows. Since R ◦ =: X × Q ij Y ij is ρ -structured, Lemma 9produces an x ∗ ∈ X such that { x ∗ } × Q ij Y ij is ρ -like. Using the query alignment property for L and L , there are subsets I, I ⊆ [ n ], | I ∪ I | ≤ O ( k/ log m ) ≤ O ( d ), such that any structured part inthe partitions of L and L that intersects the slice { x ∗ } × Q ij Y ij has their fixed blocks containedin I ∪ I . We let T query all bits in the blocks ( I ∪ I ) (cid:114) fix( ρ ) in some order, and make the resultingvertices (having queried all bits in blocks I ∪ I ∪ fix( ρ )) the leaves of T . Claim 10.
Every leaf ρ ∗ of T satisfies item (3).Proof. Since ρ ∗ extends ρ , and { x ∗ } × Q ij Y ij is ρ -like, there is some y ∗ ∈ Q ij Y ij such that Ind n‘ × m ( x ∗ , y ∗ ) ∈ Cube( ρ ∗ ). Since ( x ∗ , y ∗ ) ∈ R ◦ ⊆ L ∪ L , we have ( x ∗ , y ∗ ) ∈ L or ( x ∗ , y ∗ ) ∈ L .Suppose wlog that ( x ∗ , y ∗ ) ∈ L . Let L ∩ R , where R is τ -structured, be the unique part of L containing ( x ∗ , y ∗ ). But since fix( τ ) ⊆ I ⊆ fix( ρ ∗ ) and both τ and ρ ∗ agree with Ind n‘ × m ( x ∗ , y ∗ ), weconclude that ρ ∗ extends τ , as required. Efficiency.
We remark that all the assignments appearing in Π have block-width O ( d ). This holdsfor the vertices coming from partitioning of the simplicies in Π due to our choice of k ≤ O ( d log m ),and it holds for the vertices in the decision trees as they query at most | I ∪ I | ≤ O ( d ) additionalblocks. This concludes the (simplified) proof of Theorem 8. Removing the assumption ( ∗ ) is done virtually in the same way as in [GGKS18]. We briefly recallthe outline (and refer to [GGKS18, § T , . . . , T m d (i.e., if T i is a descendant of T j then i < j ), and before partitioning T i we first remove12ll error sets resulting from partitioning of its descendants. More precisely, we initialize an “errorless”box B := X × Q ij Y ij and then process the simplicies as follows. Iterate for i = 1 , . . . , m d : (1) Update T i by removing all the errors accumulated so far: T i ← T i ∩ B . Note that T i continuesto be a simplex.(2) Apply Simplex Lemma to obtain a box covering F r R r ⊇ T i with error sets X err ⊆ X , Y err ,ij ⊆ Y ij . Output all the structured parts R r ∩ T i and discard the error parts.(3) Update B by removing all the error sets: B ← B (cid:114) ( X err × Q ij Y ij ∪ S ij X × Y err ,ij × Q i j = ij Y i j ). Note that B continues to be a box.We can now repeat the simplified proof of Section 4.2 nearly verbatim using only the structuredsimplices output by the above process . When processing Π’s root T m d ∩ B = B , where B =: X × Q ij Y ij is the errorless box at the end of the process, we have that each of X , Y ij has density at least1 − m d · − k = 1 − m − d ≥
99% by our choice of k . Hence B is ∗ n -structured and we may assumethat Simplex Lemma produces the trivial partition for B . This yields the unique root for Π asbefore. Another key observation is that the associated errorless box B grows when we step from asimplex T i in Π to either one of its children. Thus every structured part R r ∩ T i that is output bythe above process is wholly covered by the structured parts of T i ’s children. This means that ourdiscarding of error sets does not interfere with the construction of the internal trees in Step 2. As in the dag-like case, we use the search-problem-centric view of proofs. Namely, recall fromSection 3 that with any unsatisfiable n -variate CNF formula F := ∧ i ∈ [ m ] D i we associate a falsified-clause search problem S F ⊆ { , } n × [ m ] where, on input a truth assignment z ∈ { , } n , the goalis to find a clause D i , i ∈ [ m ], falsified by z , that is, D i ( z ) = 0.Given a CNF search problem S F ⊆ { , } n × O , we consider compositions with the (single-output) index gadget Ind m : [ m ] × { , } m → { , } defined by Ind m ( x, y ) := y x ; this is simply thecolumn-index gadget of Section 3.4 specialized to ‘ = 1. The discussion in Section 3.5 implies that S F ◦ Ind nm is at least as hard as S F where F := F ◦ Ind nm admits an efficient encoding: Fact 11.
For any n -variate k -CNF F with | F | clauses, F ◦ Ind nm is constructible in time | F | m k . The definitions of decision-dags and LTF-dags from Section 3 can be straightforwardly specializedto decision-trees and LTF-trees (underlying dag is a tree). We define for any S ⊆ { , } n × O , dec-tree ( S ) := least size of a decision-tree solving S, ltf-tree ( S ) := least size of an LTF-tree solving S, d ( S ) := least depth of a decision-tree solving S. We recover the usual proof systems by further specializing to S = S F , res-tree ( F ) = dec-tree ( S F ) = least length of a tree-like Resolution refutation of F , cut-tree ( F ) = ltf-tree ( S F ) = least length of a tree-like Cutting Planes refutation of F , d ( F ) = d ( S F ) = least depth of a tree-like Resolution refutation of F .13 .2 Real protocols Consider a bipartite search problem S ⊆ X × Y × O . A real protocol Π (introduced in [Kra98]) is abinary tree satisfying the following. Each non-leaf node v is labeled with a (combinatorial) triangle T v ⊆ X × Y , that is, a two-dimensional simplex (equivalently, T is a triangle if it can be writtenas T = { ( x, y ) ∈ X × Y : a T ( x ) < b T ( y ) } for some labelings of the rows a T : X → R and columns b T : Y → R by real numbers). Each leaf u of Π is labeled with a solution o u ∈ O . The protocol Πsolves S if, for any input ( x, y ) ∈ X × Y the unique root-to-leaf path, generated by walking left atnode v if ( x, y ) ∈ T v (and right otherwise), terminates at a leaf u with o u ∈ S ( x, y ). We define rCC ( S ) := least depth of a real protocol solving S .Real protocols are an established method for proving length lower bounds for tree-like CP: Lemma 12 (Kraj´ıˇcek [Kra98]) . Let S F ⊆ { , } n × { , } n × O be the search problem S F for anunsatisfiable CNF formula F together with an arbitrary bipartition of its n + n variables. Then rCC ( S F ) ≤ O (log cut-tree ( F )) . The purpose of this section is to prove our small gadget lifting theorem (Theorem 6), which wouldcomplete the proof of our main tree-like result (Theorem 2). We restate this lifting theorem usingthe search-problem-centric language. Theorem 6 is an immediate corollary (replace m by m ). Theorem 13 (Small gadget lifting) . Let F be an unsatisfiable CNF formula. For every m , m Θ(min( d ( F ) ,m / )) ≤ ltf-tree ( S F ◦ Ind nm ) ≤ res-tree ( S F ◦ Ind nm ) ≤ m O ( d ( F )) . Upper bound.
The last inequality is the trivial part of Theorem 13. Indeed, since S F admitsa decision-tree of depth d ( F ), we have that S F ◦ Ind nm admits one of depth d ( F ) d ( Ind m ) = d ( F )(log m + 1). Therefore res-tree ( F ◦ Ind nm ) ≤ exp( O ( d ( F ◦ Ind nm ))) = m O ( d ( F )) . Lower bound.
The first inequality is the nontrivial part of Theorem 13. We formulate a liftingtheorem for real protocols, which implies the first inequality by virtue of Lemma 12.
Theorem 14 (Real lifting) . Let F be an unsatisfiable CNF formula. For every m , rCC ( S F ◦ Ind m ) ≥ min( d ( F ) , m / ) · Ω(log m ) . The rest of this section is dedicated to proving Theorem 14, which would conclude the proof ofTheorem 13 and thereby the proof of our main tree-like result. Our proof follows the general planfamiliar from previous tree-like lifting theorems, especially the exposition in [GPW15, GPW17].
To prove Theorem 14, we start with a given real protocol Π of depth d ≤ o ( m / log m ) for thecomposed problem S F ◦ Ind nm and construct a decision-tree of depth O ( d/ log m ) for S F .The decision-tree is naturally constructed by starting at the root of Π and taking a walk downthe protocol tree guided by occasional queries to the variables z = ( z , . . . , z n ) of S F . During the14alk, we maintain a rectangle R ⊆ [ m ] n × ( { , } m ) n consisting of inputs that reach the currentnode in the protocol tree. Our goal is to ensure that the image Ind nm ( R ) has some of its bits fixedaccording to the queries to z made so far, and the remaining bits sufficiently unrestricted. We startby formulating our main technical lemma, which handles a single step (aka round ) in this walk:How to update R while controlling the gadget outputs.For terminology, recall from Definition 1 the notions of min-entropy H ∞ , blockwise min-entropy , deficiency D ∞ , the notation X ∈ X for a set X , and the marginal distribution X S supportedon X S .The purpose of the following Round Lemma is to start with an X of moderate blockwisemin-entropy ( ≥ . m ) and, through fixing some more gadget output bits (namely, I ), bump theblockwise min-entropy back up ( ≥ .
95 log m ). Round Lemma.
Let R := X × Y ⊆ [ m ] N × ( { , } m ) N be a rectangle for some set N . Suppose X has blockwise min-entropy at least . m and H ∞ ( Y ) ≤ d log m . Then there exists I ⊆ N (wewrite ¯ I := N (cid:114) I ) such that for all z I ∈ { , } I there exists a subrectangle R := X × Y ⊆ R s.t.(a) X I and Y I are fixed (singletons) to produce a gadget output Ind Im ( X I , Y I ) = { z I } .(b) X ¯ I has blockwise min-entropy at least .
95 log m .(c) D ∞ ( X ¯ I ) ≤ D ∞ ( X ) − Ω( | I | log m ) + O (1) .(d) D ∞ ( Y ¯ I ) ≤ D ∞ ( Y ) + O ( | I | ) . Decision-tree describes our query simulation of the real protocol Π. It repeatedly invokes theRound Lemma in each step down the protocol tree. Below, we analyze its correctness and efficiency.
Decision-tree
Input: z ∈ { , } n Output: solution to S F initialize v = root of Π, ρ = ∗ n , R := [ m ] n × ( { , } m ) n while v is not a leaf do let T v be the triangle associated with v let R := X × Y ⊆ R , | R | ≥ | R | /
4, be such that R ⊆ T v or R ∩ T v = ∅ ; see Figure 2 apply Round Lemma to R free( ρ ) = X free( ρ ) × Y free( ρ ) to obtain an I ⊆ free( ρ ) Query the variables z I ∈ { , } I let R ⊆ R be such that R free( ρ ) is the subrectangle given by Round Lemma for outputs z I update R ← R and ρ I ← z I update v to its left child if R ⊆ T v and right child otherwise Output the same value as v does Invariants and efficiency.
We claim that R = X × Y and ρ maintained by the decision-treesatisfy the following invariants at the start of the i -th iteration: ( (cid:15) ’) Write I := fix( ρ ) and ¯ I := free( ρ ) = [ n ] (cid:114) I for short. Then | I | ≤ O ( i/ log m ). (a’) X I and Y I are fixed to produce a gadget output Ind Im ( X I , Y I ) = { z I } (where z I = ρ I ). (b’) X ¯ I has blockwise min-entropy at least 0 .
95 log m . (c’) D ∞ ( X ¯ I ) ≤ O ( i ) − Ω( | I | log m ). (d’) D ∞ ( Y ¯ I ) ≤ O ( i ) + O ( | I | ) ≤ O ( i ). 15 = R R R R T T
Case 1 Case 2
Figure 2:
Simple fact: for every rectangle R and triangle T there is a subrectangle R ⊆ R with | R | ≥ | R | / T or disjoint from it. Namely, after permuting the rows andcolumns of R according to T ’s orderings, take either the first quadrant R or the fourth R . R R T v R Figure 3:
A single iteration of Decision-tree. The current rectangle R is split by the triangle T v .We choose R ⊆ R as a large rectangle either contained in T v or disjoint from it. Then we applyRound Lemma to R , query relevant bits, and finally obtain R ⊆ R .The first item follows from (c’) and the nonnegativity of deficiency. This shows that our decision-treeis efficient: it has depth O ( d/ log m ), as desired. All the other properties are straightforwardconsequences of (a) – (d) in Round Lemma. We only need to check that the assumptions of RoundLemma are met every time it is invoked on line 5. The shrinking of R down to R on line 4 canonly lose at most 2 bits of min-entropy for the relevant random variables. Thus, if the blockwisemin-entropy of X free( ρ ) is ≥ .
95 log m at the start of the iteration, then the blockwise min-entropy of X free( ρ ) is at least ≥ .
95 log m − ≥ . m . Moreover, Π has depth d , so (d’) implies inductivelythat the precondition H ∞ ( Y ¯ I ) ≤ d log m of Round Lemma is met. Correctness of output.
We finally have to argue that if we reach a leaf v of Π, while maintaining R , ρ , then the solution output by Π is also valid solution to z , of which the decision-tree knows that z fix( ρ ) = ρ fix( ρ ) . We need the following simple lemma (in fact, the Round Lemma will use a muchstronger property of the gadgets, but we still give a short proof of the following). Lemma 15.
Consider any R = X × Y and associated ρ during the execution of Decision-tree. Then Z := Ind nm ( R ) is such that Z fix( ρ ) = { z fix( ρ ) } and Z i = { , } for every i ∈ free( ρ ) .Proof. The claim about the coordinates fix( ρ ) is (a’) . Consider any i ∈ free( ρ ). Then H ∞ ( X i ) ≥ .
95 log m by (b’) , and D ∞ ( Y i ) ≤ O ( d ) by (d’) . Suppose for contradiction that Ind m ( X i , Y i ) = 0,16ay. Hence all the ≥ m . different values that X i ∈ [ m ] can take are fixed to 0 in Y i ∈ { , } m .This implies D ∞ ( Y i ) ≥ m . . But this contradicts D ∞ ( Y i ) ≤ O ( d ) ≤ m / log m .Suppose Π outputs a clause C of F at the leaf v . Our goal is to show that C ( z ) = 0, thatis, that C is a valid solution for z . By definition of S F ◦ Ind nm this means that C ( z ) = 0 for all z ∈ Ind nm ( R ), that is, all variables appearing in C are fixed in the set Ind nm ( R ). By Lemma 15 wemust have that the variables of C are contained in fix( ρ ). Thus C ( z ) = C ( z fix( ρ ) ) = 0, as desired.This completes the proof of the real lifting theorem, assuming the Round Lemma. To prove the Round Lemma we follow the general approach of [GPW17, GGKS18], which we recapnow along with what is needed to make it work for small gadgets where m (cid:28) N .Since the goal is to bump up the blockwise min-entropy from 0 . m to 0 .
95 log m , we startby computing a blockwise min-entropy restoring partition of X , which simply takes a maximalassignment that violates 0 .
95 log m blockwise min-entropy, makes a part with all x ’s that have thatassignment, and then repeats on the rest of X until all x ’s are covered. The construction willguarantee each part in the partition will fulfill all requirements for X , and so then we turn ourattention to finding a part with a fixed assignment ( I, α ) such that Y is roughly uniform on thelocations pointed to by ( I, α ).In [GGKS18], the simplest way to prove this is to show that there is some x ∈ X such that Y is roughly uniform on all locations pointed to by x , and then simply take the rectangle partcontaining x . Because X has high blockwise min-entropy and Y has very low deficiency, a Fourierargument directly shows that for every set I , the expected parity of PMInd Im ( x , y ) is close to 0,where PMInd m is the parity analogue of Ind m . Taking a union bound over all such sets I , withhigh probability over x ∈ X the expected parity of PMInd Im ( x, y ) is close to 0 for all sets I , whichis equivalent (see e.g. [GPW17]) to Ind Im ( x, y ) being close to uniform with high probability over x ,and choosing any such x completes the lemma as stated before.However, this union bound over all sets I ⊆ [ N ] only works when “close to 0” is N − Ω( | I | ) , sincethere will be N | I | sets of that size. In reality the argument only shows E [ PMInd Im ( x , y )] ≤ m − Ω( | I | ) ,which fails in our case where m (cid:28) N . Thus instead of disregarding the fixed ( I, α ) assignments of therectangle partition when looking at x , we will use the fact that the ( I, α )’s are the only coordinatesof y we care. While we have no control over the number of parts in the rectangle partition, we can say that each individual part corresponds to an assignment of at most O ( d ) coordinates.We group [ N ] into poly( d ) “megacoordinates” of size N/ poly( d ) such that most ( I, α ) assignmentsin the rectangle partition each only point to one value per megacoordinate (see Figure 4 for anillustration). We use the (
I, α )’s to replace the x s with shorter x vectors which only point toone value per megacoordinate, and repeat the argument in [GGKS18] but only using sets ofmegacoordinates I ⊆ [poly( d )]. Since m = poly( d ), m − Ω( | I | ) is enough to cancel out (poly( d )) | I | ,and so the union bound goes through, giving an x that makes Ind Im · N/ poly( d ) ( x , y ) close to uniform.Using the way we constructed the x s out of the rectangle partition, this will give us an assignment( I, α ) which is equally close to uniform from the partition, which completes the lemma.
We begin by performing a blockwise min-entropy restoring partition [GPW17] on X . − Initialize F = ∅ . Iterate the following for j = 1 , , . . . until X = ∅ :17 X X ... h h h . . . Figure 4:
After partitioning X into { X j } (purple regions are the coordinates of I j , the restriction α j to I j not pictured), we randomly block up the coordinate space [ N ] into poly( d ) megacoordinates(labeled h i here). With high probability only a small fraction of X will be lost due to collisions. − Let I j be a maximal (possibly empty) subset of [ N ] such that X violates 0 .
95 log m -blockwise min-entropy on I j , and let α j ∈ [ m ] I j be an outcome witnessing this: Pr [ X I j = α j ] > − .
95 log m . − Update
F ← F ∪ { ( I j , α j ) } . − Define X j := { x ∈ X : x I j = α j } and update X ← X (cid:114) X j . − Return X = F j X j and F Suppose the procedure returns X = F j X j with associated F = { ( I , α ) . . . ( I t , α t ) } . Forevery x ∈ X let j ( x ) be the j ∈ [ t ] such that x ∈ X j . By Lemma 5 of [GPW17] it holds that D ∞ ( X jI j ) ≤ D ∞ ( X ) − . | I j | log m + O (1) for all parts X j (except for some tiny parts, output latein the partitioning process, whose union covers at most 1% of X ; we tacitly ignore these parts).For convenience, we assume that N ≥ d . (Indeed, real lifting theorems already exist for largeenough gadgets as discussed in Section 2.2; moreover, Round Lemma is only easier to prove in theregime of large d and m .) We group the coordinates in [ N ] into d mega-coordinates. Let h be arandom variable which is uniform over all functions h mapping [ N ] → [ d ] where | h − ( i h ) | = Nd forall i h ∈ [ d ]. Consider the subset of F consisting only of pairs ( I j , α j ) such that all coordinates in I j are mapped to different mega-coordinates by h , or formally F h = { ( I j , α j ) ∈ F : ∀ i = i ∈ I j , h ( i ) = h ( i ) } Let X h ⊆ X be the union of all X j sets of the rectangle partition such that ( I j , α j ) ∈ F h . Claim 16.
With high probability over h ∼ h , we have | X h | ≥ . | X | .Proof. We show that for a uniform choice of x from X , with high probability the unique part X j ( x ) which contains x survives into X h . See Figure 4 for an illustration. Formally, Pr h ∼ h [ Pr x ∼ x ( X j ( x ) X h )] < .
01. First we consider the case of a fixed x . We will switch the calculation by treating h asa fixed partition from h and treating I j ( x ) as a random set of size at most 10 d . To see that these areequivalent, we can treat h ∼ h as simply being a uniformly random permutation on [ N ] with a fixedpartition into d equal sized megacoordinates, and so we can view I j ( x ) as a random set over h ([ N ]).18ecalling that N ≥ d , a straightforward calculation shows that Pr I j ( x ) ( ∀ i = i ∈ I j ( x ) : h ( i ) = h ( i )) = d Y i =0 − i · ( N/d − N − i ≥ (1 − d · N/d N/ d ≥ (1 − d ) d ≥ e − /d ≥ . Pr h ∼ h ( ∀ i = i ∈ I j ( x ) : h ( i ) = h ( i )) by our previous argument. Therefore Pr h ∼ h [ Pr x ∼ x ( X j ( x ) X h )] = Pr h ∼ h [ Pr x ∼ x ( ∃ i = i ∈ I j ( x ) : h ( i ) = h ( i ))]= Pr x ∼ x [ Pr h ∼ h ( ∃ i = i ∈ I j ( x ) : h ( i ) = h ( i ))] ≤ X x ∈ X Pr x ∼ x ( x = x ) Pr h ∼ h ( ∃ i = i ∈ I j ( x ) : h ( i ) = h ( i )) < X x ∈ X Pr x ∼ x ( x = x ) · .
01= 0 . X x ∈ X Pr x ∼ x ( x = x ) = 0 . h satisfying | X h | ≥ . | X | . We shift to viewing each y ∈ Y as a matrix y h ∈ Y h with m · N/d rows and d columns in the canonical way, where each entry (( α, i ) , i h )in y h corresponds to the entry ( α, i ) in the original matrix y , where i is the i th element of themegacoordinate i h . Following our usual conventions let x h be the uniform random variable forselecting x from X h and let and y h be the uniform random variable for selecting y from Y andviewing it as y h as described above.Recall that X satisfied 0 . m -blockwise min-entropy, and so for any I ⊆ [ N ], H ∞ ( X I ) ≥ . · | I | log m . Thus for all assignments α I , Pr x ∼ x h ( x I = α I ) ≤ | X || X h | Pr x ∼ x ( x I = α I ) ≤ . · − . | I | log m ≤ − . | I | log m and so X h satisfies 0 .
89 log m -blockwise min-entropy.Now we define the random variable α h on ([ m ] × [ Nd ]) d to be a random restriction on x thatpicks one location in each mega-coordinate and assigns it a restriction α . Note that this can alsobe viewed as choosing a location in each column of y h . The restriction will be sampled accordingto F h , by first sampling x ∼ x h and taking all assignments in the corresponding pair ( I j , α j ) h ( I j ) where j = j ( x ), and then choosing a random assignment ( i, α i ) i h for all mega-coordinates i h leftunassigned by α j . 19 (8 , (91 , (15 , (2 , (91 , x = α h = Figure 5:
Example of sampling α h for d = 5 megacoordinates of size mN/d = 4. Here ( I j , α j )for I j = { , , } and α j = { (8) , (91) , (2) } is sampled. (8) goes to (8 ,
3) in the first coordinate,(91) goes to (91 ,
1) in the second coordinate, and (2) goes to (2 ,
4) in the fourth coordinate. Forthe third and fifth coordinate a pair in [ m ] × [5] is chosen uniformly, choosing (15 ,
2) for the thirdand (91 ,
4) for the fifth.Formally we define α h by the following procedure: − sample x ∼ x h and let j = j ( x ) − for each i h ∈ h ( I j ) let i be the coordinate in I j mapping to i h and set α h ← α h ∪ (( α j ) i , i ) i h − for each i h / ∈ h ( I j ) choose i uniformly from h − ( i h ), choose α i uniformly from [ m ], and set α h ← α h ∪ ( α i , i ) i h − return α h Note that extending α j uniformly to α h does not change the min-entropy. Thus because X h hasblockwise min-entropy at least 0 .
89 log m , α h has blockwise min-entropy at least 0 .
89 log m as well,and the coordinates of every α h are exactly [ d ].To proceed we now state a key lemma which is a generalized version of the Uniform MarginalsLemma of [GPW17]. For completeness, we prove it in Appendix A. Definition 3 (Multiplicative uniformity) . We say a random variable x ∈ S is (cid:15) -multiplicativelyuniform if Pr [ x = x ] = (1 ± (cid:15) ) · | S | for all outcomes x ∈ S . Large Index Lemma.
Let x ⊆ [ ‘ ] k and y ∈ ( { , } ‘ ) k be random variables such that x hasblockwise min-entropy ≥
50 log k and D ∞ ( y ) ≤ k . Then there exists x ∈ supp( x ) such that Ind k‘ ( x, y ) is o (1) -multiplicatively uniform. We apply Large Index Lemma with x := α h , y := Y h , ‘ := mN/d , k := d . Note that D ∞ ( y ) ≤ O ( d ) ≤ k and that x has blockwise min-entropy ≥ .
89 log m ≥ .
89 log d ≥
50 log d = 50 log k .We conclude that there is an α h ∈ supp α h such that Ind mN/d ( α h , y h ) is o (1)-multiplicativelyuniform. Fix such an α h and let ( I j , α j ) be any pair from which α h can be sampled in our previousprocedure.We can now undo our grouping into mega-coordinates: Because Ind mN/d ( α h , y h ) is o (1)-multiplicatively uniform, by marginalizing to I j we have that for all x ∈ X j , Ind I j m ( x, y ) = Ind I j mN/d ( α j , y h ) is also o (1)-multiplicatively-close to uniform.We now proceed to prove the lemma for I := I j . Hence let z I ∈ { , } I . We first take X = X j .For Y we first define Y I,z I = { y ∈ Y : Ind Im ( α j , y ) = { z I }} . We need to fix the rest of Y I,z I I inorder for Y I to be fixed, and so for a ∈ { , } m | I | we take Y a = { y ∈ Y I,z I : y I = a } . Finally we let Y = Y arg max a | Y a | , or in other words we choose the largest Y a (obviously Y a is empty if a is notconsistent with z I in α I so we can assume otherwise). We verify the properties (a) – (d) .20a) X I and Y I are fixed and Ind Im ( α j , y ) = { z I } for all ( x, y ) ∈ R By definition of X j , x I j = α j for all x ∈ X I , and for a such that Y = Y a we have that y I = a for all y ∈ Y = Y a . Note that Y a ⊆ Y I,z I , and so by definition of Y I,z I we know y is fixed to { z I } on α j .(b) X I has blockwise min-entropy at least .
95 log m By the fact that all I j are maximally chosen in the rectangle partition, all rectangles X j haveblockwise min-entropy 0 .
95 log m on the coordinates [ N ] − I j .(c) D ∞ ( X ¯ I ) ≤ D ∞ ( X ) − Ω( | I | log m ) + O (1)By Lemma 5 of [GPW17], each X j in the rectangle partition has deficiency D ∞ ( X ) − . | I | log m + O (1).(d) D ∞ ( Y ¯ I ) ≤ D ∞ ( Y ) + O ( | I | )By the fact that X j × Y is o (1)-multiplicatively-close to uniform and by our definition ofmultiplicative uniformity, Pr y ∼ y ( y ∈ Y I,z I ) ≥ (1 ± o (1))2 −| I | ≥ · −| I | and so D ∞ ( Y I,z I I ) ≤ D ∞ ( Y ) + | I | + 1. To move to Y I we simply note that we chose theassignment a that maximizes Pr ( Y I,z I I = a ), which cannot increase D ∞ ( Y I,z I I ). A Proof of Large Index Lemma
We state two key lemmas before proving Large Index Lemma. For convenience we shorten the baseof the expectation when the variable in the inner expression is clear. The first lemma is a standardapplication of Fourier analysis which appears in different forms in many papers; we state the versionneeded to prove Large Index Lemma and prove it at the end of this subsection, following the proofof [LMV].
Lemma 17.
Let Λ and Γ be random variables on X := [ ‘ ] k and Y := ( {± } ‘ ) k respectively. Assumethat Λ has blockwise min-entropy β > / and Γ has deficiency s . Then for every I ⊆ [ k ] , | E Λ , Γ [ χ I ( y x )] | ≤ (2 − β/ − ( k + s )) | I | where χ I ( y x ) = Q i ∈ I y i ( x i )The second lemma appeared in a different form in [GPW17] as Lemma 9. We omit the proofand defer interested readers to [GPW17]. Lemma 18.
Let x ∈ [ ‘ ] k and Y ⊆ {± } ‘ × k be such that | E y [ χ I ( y x )] | ≤ − | I | log k for all I ⊆ [ k ] . Then y x is /k -multiplicatively-close to uniform.Proof of Large Index Lemma. We map all y from elements of { , } ‘ × k to ( {± } ‘ ) k in the naturalway. Applying Lemma 17 we get that for all I ⊆ [ k ] | E Λ , y [ χ I ( y x )] | ≤ (2 −
25 log k − ( k + k )) | I | ≤ − | I | log k I ⊆ [ k ] Pr x ∼ Λ ( | E y [ χ I ( y x )] | > − | I | log k ) ≤ − | I | log k We say x is good if | E y [ χ I ( y x )] | ≤ − | I | log k for all I ⊆ [ k ]. Taking a union bound over all such I we get Pr x ∼ Λ ( x is not good) ≤ X I ⊆ [ k ] Pr x ∼ Λ ( | E y [ χ I ( y x )] | > − | I | log k ) ≤ X I ⊆ [ k ] − | I | log k ≤ P kt =1 (cid:0) kt (cid:1) − t log k ≤ k X t =1 − t log k ≤ /k Hence most x are good, and by Lemma 18 for any good x we have that Ind k ( x, y ) is 1 /k -multiplicatively-close to uniform. Proof of Lemma 17.
Because marginalizing Γ to any S ⊆ ‘ × k cannot increase the deficiency of Γ S in Y S , it is enough to show that | E Λ , Γ [ χ ( y x )] | ≤ (2 − β/ − ( k + s )) k Let Λ( x ) = Pr (Λ = x ). Because Λ has blockwise min-entropy β , it has Renyi entropy at least β · k ,meaning P x Λ( x ) ≤ − β · k . By Cauchy-Schwarz | E Λ , Γ [ χ ( y x )] | = X x Λ( x ) | E Γ [ χ ( y x )] |≤ ( X x Λ( x ) ) / ( X x | E Γ [ χ ( y x )] | ) / ≤ − ( β/ k · ( X x | E Γ [ χ ( y x )] | ) / = 2 − ( β/ k · ( X x | E Γ [ χ ( y x )] | ) / We thus turn our attention to proving a bound on P x | E Γ [ χ ( y x )] | . Let χ ≥ i ( y x ) = χ { i...k } ( y x ).Again by Cauchy-Schwarz X x | E Γ [ χ ( y x )] | = X x | Y i E Γ [ χ ≥ i ( y x )] | ≤ X x Y i E Γ [ χ ≥ i ( y x )] = X x ...x k Y i ≥ E Γ [ χ ≥ i ( y x )] · X x E Γ [ χ ≥ ( y x )] Since H ∞ (Γ) ≥ ‘k − s , for a fixed x . . . x k H ( χ ≥ ( y x )) = H (Γ | Γ( x ) . . . Γ( x k )) ≥ ‘ − ( k + s )By Pinsker’s inequality E Γ [ χ ≥ ( y x )] ≤ (1 − H ( χ ≥ ( y x ))) /
2, and so by sub-additivity of theexpectation X x E Γ [ χ ≥ ( y x )] ≤ ( ‘ − ( ‘ − ( k + s )) / k + s ) / X x ...x k Y i ≥ E Γ [ χ ≥ i ( y x )] · X x E Γ [ χ ≥ ( y x )] ≤ k + s X x ...x k Y i ≥ E Γ [ χ ≥ i ( y x )] Finally we repeat for all i = 2 . . . k , and in the end we get X x | E Γ [ χ ( y x )] | ≤ X x Y i E Γ [ χ ≥ i ( y x )] ≤ k + s X x ...x k Y i ≥ E Γ [ χ ≥ i ( y x )] . . . ≤ ( k + s ) k Y i>k E Γ [ χ ≥ i ( y x )] = ( k + s k Putting this bound on P x | E Γ [ χ ( y x )] | together with the earlier proof completes the lemma. B Proof of Simplex Lemma
The proof of Simplex Lemma is a small modification of the proof of the Triangle Lemma (the case of2-dimensional simplices) in [GGKS18]. Since the proof for the latter is somewhat long, we describehere only the required modifications. Our discussion naturally assumes familiarity with the originalproof [GGKS18], which analyzed a partitioning procedure called Triangle Scheme (with subroutinesRectangle Scheme and Column Cleanup). The basic difference between the two settings is thatinstead of partitioning a 2-dimensional simplex over
X × Y , Bob’s input in Y is further shared over n‘ many Bobs, that is, Y is replaced with Q ij Y ij . In this appendix, we explain how to replaceall parts involving Bob with multi-party analogs. There are two: (1) Rectangle Scheme, and (2)Column Cleanup. (1) Rectangle Scheme. Our first observation is that the Rectangle Scheme, which partitionsrectangles R ⊆ X × Y , works equally well to partition boxes B ⊆ X × Q ij Y . Indeed, each partoutput by Rectangle Scheme is obtained from R := X × Y by restricting the set X arbitrarily and,crucially, restricting Y only via bit-wise restrictions (Round 2 of Rectangle Scheme fixes pointed-tobits in all possible ways). But such bit-wise restrictions when applied to a box B := X × Q ij Y ij still result in a box. With this understanding, we may apply Rectangle Scheme to a box. (2) Column Cleanup. Our biggest modification is to replace the Column Cleanup procedurewith a natural multi-party analog. We start with a lemma saying that either a simplex over Bobs’domains contains a box that satisfies the largeness condition of ρ -structuredness (Definition 2), orthe simplex can be covered with a small error set. Claim 19.
Let T ⊆ Q ij Y ij be a simplex. Then one of the following holds.(i) T contains a box B := Q ij Y ij where each Y ij has density ≥ − m / (i.e., D ∞ ( Y ij ) ≤ m / ).(ii) T is covered by S ij Y ij, err × Q i j = ij Y i j where each Y ij, err has density ≤ − m / .Proof. Consider the largest cube B := Q ij Y ij contained in T , that is, where all the sets Y ij ⊆ Y ij have the same size. The largest cube can be obtained by the following process: Identify each Y ij = { , } m with [ N ] according to the reverse of the ordering given to Y ij by T . (Thus if23 ∈ T ⊆ [ N ] n‘ and x ≤ x coordinate-wise then x ∈ T .) Then B equals [ M ] n‘ where M is thelargest number such that ( M, . . . , M ) ∈ T . If some (and hence every) Y ij has density ≥ − m / we are in case (i) . Otherwise we claim we are in case (ii) with Y ij, err := Y ij . Indeed, considerany x := ( M , . . . , M n‘ ) ∈ T . We must have M i ∗ j ∗ ≤ M for some ( i ∗ , j ∗ ) ∈ [ n ] × [ ‘ ] sinceotherwise by monotonicity ( M + 1 , . . . , M + 1) ∈ T contradicting our choice of M . But then x ∈ Y i ∗ ,j ∗ × Q i j = i ∗ j ∗ Y i j , as required.We say that a simplex T ⊆ Q ij Y ij is empty-or-heavy iff T = ∅ or T satisfies case (i) above. Bob Cleanup
Input: Simplex T ⊆ X × Q ij Y ij Output: Error sets Y ij, err ⊆ Y ij and their combination Y err initialize Y ij, err ← ∅ and write Y err := S ij Y ij, err × Q i j = ij Y i j as a function of the Y ij, err For I ⊆ [ n ], α ∈ [ m ] I , γ ∈ ( { , } ‘ ) I , define Y I,α,γ := (cid:8) y ∈ Q ij Y ij : g I ( α, y I ) = γ (cid:9) while there are I, α, γ, x ∈ X s.t. T := T ∩ ( { x } × ( Y I,α,γ (cid:114) Y err )) is not empty-or-heavy do Add to the Y ij, err all error sets from case (ii) for T Output Y ij, err and Y err The below claim is the multi-party analog of Claim 10 in [GGKS18]. This completes themodifications needed to the proof of the Triangle Lemma to handle multiple Bobs.
Claim 20.
For a simplex T ⊆ X × Q ij Y ij , let Y ij, err , Y err be the outputs of Bob Cleanup. Then: − Empty-or-heavy:
For every triple ( I ⊆ [ n ] , α ∈ [ m ] I , γ ∈ ( { , } ‘ ) I ) , and every x ∈ X , itholds that T ∩ ( { x } × ( Y I,α,γ (cid:114) Y err )) is empty-or-heavy. − Size bound: | Y ij, err | ≤ m − Ω( m / ) for every i, j .Proof. The first property is immediate by definition of Bob Cleanup. For the second property, ineach while-iteration, at most 2 m − m / elements get added to each Y ij, err . Moreover, there are nomore than 2 n · m n · n‘ · m n = (2 m ) n‘ choices of I , α , γ , x , and the loop executes at most once foreach choice. Thus, | Y ij, err | ≤ (2 m ) n‘ · m − m / ≤ m − Ω( m / ) . Acknowledgements
We thank Robert Robere for discussions and anonymous STOC reviewers for comments. Thefirst author was supported in part by the NSF grant No. CCF-1412958. The third and fourthauthors were supported by NSERC, and the fourth author was supported in part by NSF grant No.CCF-1900460. 24 eferences [ABMP01] Michael Alekhnovich, Sam Buss, Shlomo Moran, and Toniann Pitassi. Minimumpropositional proof length is NP-hard to linearly approximate.
Journal of SymbolicLogic , 66(1):171–191, 2001. doi:10.2307/2694916 .[AD08] Albert Atserias and V´ıctor Dalmau. A combinatorial characterization of resolutionwidth.
Journal of Computer and System Sciences , 74(3):323–334, 2008. doi:10.1016/j.jcss.2007.06.025 .[AM19] Albert Atserias and Moritz M¨uller. Automating resolution is NP-hard. In
Proceedingsof the 60th Symposium on Foundations of Computer Science (FOCS) , pages 498–509,2019. doi:10.1109/FOCS.2019.00038 .[AR08] Michael Alekhnovich and Alexander Razborov. Resolution is not automatizableunless W[P] is tractable.
SIAM Journal on Computing , 38(4):1347–1363, 2008. doi:10.1137/06066850X .[BCC93] Egon Balas, Sebasti´an Ceria, and G´erard Cornu´ejols. A lift-and-project cutting planealgorithm for mixed 0–1 programs.
Mathematical Programming , 58(1):295–324, 1993. doi:10.1007/BF01581273 .[BDG +
04] Maria Luisa Bonet, Carlos Domingo, Ricard Gavald`a, Alexis Maciel, and ToniannPitassi. Non-automatizability of bounded-depth Frege proofs.
Computational Com-plexity , 13(1-2):47–68, 2004. doi:10.1007/s00037-004-0183-5 .[BEGJ00] Maria Luisa Bonet, Juan Luis Esteban, Nicola Galesi, and Jan Johannsen. On therelative complexity of resolution refinements and cutting planes proof systems.
SIAMJournal on Computing , 30(5):1462–1484, 2000. doi:10.1137/S0097539799352474 .[BPR97a] Maria Bonet, Toniann Pitassi, and Ran Raz. Lower bounds for cutting planes proofswith small coefficients.
The Journal of Symbolic Logic , 62(3):708–728, 1997. doi:10.2307/2275569 .[BPR97b] Maria Luisa Bonet, Toniann Pitassi, and Ran Raz. No feasible interpolation forTC -frege proofs. In Proceedings of the 38th Symposium on Foundations of ComputerScience (FOCS) , pages 254–263, 1997. doi:10.1109/SFCS.1997.646114 .[BPR00] Maria Luisa Bonet, Toniann Pitassi, and Ran Raz. On interpolation and automatizationfor Frege systems.
SIAM Journal on Computing , 29(6):1939–1967, 2000. doi:10.1137/S0097539798353230 .[BW01] Eli Ben-Sasson and Avi Wigderson. Short proofs are narrow—resolution made simple.
Journal of the ACM , 48(2):149–169, 2001. doi:10.1145/375827.375835 .[CCT87] William Cook, Collette Coullard, and Gy¨orgy Tur´an. On the complexity of cutting-plane proofs.
Discrete Applied Mathematics , 18(1):25–38, 1987. doi:10.1016/0166-218X(87)90039-4 .[CEI96] Matthew Clegg, Jeff Edmonds, and Russell Impagliazzo. Using the groebner basisalgorithm to find proofs of unsatisfiability. In
Proceedings of the 28th Symposium onTheory of Computing (STOC) , pages 174–183, 1996. doi:10.1145/237814.237860 .25CFK +
19] Arkadev Chattopadhyay, Yuval Filmus, Sajin Koroth, Or Meir, and Toniann Pitassi.Query-to-communication lifting using low-discrepancy gadgets. Technical ReportTR19-103, Electronic Colloquium on Computational Complexity (ECCC), 2019. URL: https://eccc.weizmann.ac.il/report/2019/103/ .[CKS90] William Cook, Ravi Kannan, and Alexander Schrijver. Chv´atal closures for mixedinteger programming problems.
Mathematical Programming , 47(1):155–174, May 1990. doi:10.1007/BF01580858 .[DR03] Stefan Dantchev and Søren Riis. On relativisation and complexity gap for resolution-based proof systems. In
Proceedings of the 17th International Workshop on ComputerScience Logic (CSL) , pages 142–154. Springer, 2003. doi:10.1007/978-3-540-45220-1 14 .[dRMN +
19] Susanna de Rezende, Or Meir, Jakob Nordstr¨om, Toniann Pitassi, Robert Robere,and Marc Vinyals. Lifting with simple gadgets and applications to circuit and proofcomplexity. Technical Report TR19-186, Electronic Colloquium on ComputationalComplexity (ECCC), 2019. URL: https://eccc.weizmann.ac.il/report/2019/186/ .[dRNV16] Susanna de Rezende, Jakob Nordstr¨om, and Marc Vinyals. How limited interactionhinders real communication (and what it means for proof and circuit complexity).In
Proceedings of the 57th Symposium on Foundations of Computer Science (FOCS) ,pages 295–304. IEEE, 2016. doi:10.1109/FOCS.2016.40 .[FKP19] Noah Fleming, Pravesh Kothari, and Toniann Pitassi. Semialgebraic proofs andefficient algorithm design.
Foundations and Trends in Theoretical Computer Science ,14(1-2):1–221, 2019. doi:10.1561/0400000086 .[FPPR17] Noah Fleming, Denis Pankratov, Toniann Pitassi, and Robert Robere. Random CNFsare hard for cutting planes. In
Proceedings of the 58th Symposium on Foundations ofComputer Science (FOCS) , 2017. doi:10.2307/2275569 .[Gar19] Michal Garl´ık. Resolution lower bounds for refutation statements. In
Proceedings ofthe 44th Mathematical Foundations of Computer Science (MFCS) , volume 138, pages37:1–37:13, 2019. doi:10.4230/LIPIcs.MFCS.2019.37 .[GGKS18] Ankit Garg, Mika G¨o¨os, Pritish Kamath, and Dmitry Sokolov. Monotone circuit lowerbounds from resolution. In
Proceedings of the 50th Symposium on Theory of Computing(STOC) , pages 902–911. ACM, 2018. doi:10.1145/3188745.3188838 .[GKRS19] Mika G¨o¨os, Pritish Kamath, Robert Robere, and Dmitry Sokolov. Adventures inmonotone complexity and TFNP. In
Proceedings of the 10th Innovations in TheoreticalComputer Science Conference (ITCS) , pages 38:1–38:19, 2019. doi:10.4230/LIPIcs.ITCS.2019.38 .[GL10] Nicola Galesi and Massimo Lauria. On the automatizability of polynomial calculus.
Theory of Computing Systems , 47(2):491–506, 2010. doi:10.1007/s00224-009-9195-5 .[GP18] Mika G¨o¨os and Toniann Pitassi. Communication lower bounds via critical blocksensitivity.
SIAM Journal on Computing , 47(5):1778–1806, 2018. doi:doi.org/10.1137/16M1082007 . 26GPW15] Mika G¨o¨os, Toniann Pitassi, and Thomas Watson. Deterministic communication vs.partition number. In
Proceedings of the 56th Symposium on Foundations of ComputerScience (FOCS) , pages 1077–1088. IEEE, 2015. doi:10.1109/FOCS.2015.70 .[GPW17] Mika G¨o¨os, Toniann Pitassi, and Thomas Watson. Query-to-communication liftingfor BPP. In
Proceedings of the 58th Symposium on Foundations of Computer Science(FOCS) , pages 132–143, 2017. doi:10.1109/FOCS.2017.21 .[HC99] Armin Haken and Stephen Cook. An exponential lower bound for the size of monotonereal circuits.
Journal of Computer and System Sciences , 58(2):326–335, 1999. doi:10.1006/jcss.1998.1617 .[HN12] Trinh Huynh and Jakob Nordstr¨om. On the virtue of succinct proofs: Amplifyingcommunication complexity hardness to time–space trade-offs in proof complexity. In
Proceedings of the 44th Symposium on Theory of Computing (STOC) , pages 233–248.ACM, 2012. doi:10.1145/2213977.2214000 .[HP17] Pavel Hrubes and Pavel Pudl´ak. Random formulas, monotone circuits, and interpolation.In
Proceedings of the 58th Symposium on Foundations of Computer Science (FOCS) ,pages 121–131, 2017. doi:10.1109/FOCS.2017.20 .[HP18] Pavel Hrubeˇs and Pavel Pudl´ak. A note on monotone real circuits.
InformationProcessing Letters , 131:15–19, 2018. doi:10.1016/j.ipl.2017.11.002 .[IP01] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k -SAT. Journal ofComputer and System Sciences , 62(2):367–375, 2001. doi:10.1006/jcss.2000.1727 .[Iwa97] Kazuo Iwama. Complexity of finding short resolution proofs. In
MathematicalFoundations of Computer Science (MFCS) , pages 309–318. Springer, 1997. doi:10.1007/BFb0029974 .[KP98] Jan Kraj´ıcek and Pavel Pudl´ak. Some consequences of cryptographical conjectures for s and EF. Information and Computation , 140(1):82–94, 1998. doi:10.1006/inco.1997.2674 .[Kra97] Jan Kraj´ıˇcek. Interpolation theorems, lower bounds for proof systems, and independenceresults for bounded arithmetic.
Journal of Symbolic Logic , 62(2):457–486, 1997. doi:10.2307/2275541 .[Kra98] Jan Kraj´ıˇcek. Interpolation by a game.
Mathematical Logic Quarterly , 44:450–458,1998. doi:10.1002/malq.19980440403 .[Lin19] Bingkai Lin. A simple gap-producing reduction for the parameterized set cover problem.In
Proceedings of the 46th International Colloquium on Automata, Languages, andProgramming (ICALP) , volume 132, pages 81:1–81:15, 2019. doi:10.4230/LIPIcs.ICALP.2019.81 .[LMV] James Lee, Raghu Meka, and Thomas Vidick. Private correspondence.[LNNW95] L´aszl´o Lov´asz, Moni Naor, Ilan Newman, and Avi Wigderson. Search problems inthe decision tree model.
SIAM Journal on Discrete Mathematics , 8(1):119–132, 1995. doi:10.1137/S0895480192233867 . 27MPW19] Ian Mertz, Toniann Pitassi, and Yuanhao Wei. Short proofs are hard to find. In
Proceedings of the 46th International Colloquium on Automata, Languages, and Pro-gramming (ICALP) , volume 132, pages 84:1–84:16. Schloss Dagstuhl, 2019. doi:10.4230/LIPIcs.ICALP.2019.84 .[O’D17] Ryan O’Donnell. SOS is not obviously automatizable, even approximately. In
Pro-ceedings of the 8th Innovations in Theoretical Computer Science Conference (ITCS) ,volume 67, pages 59:1–59:10. Schloss Dagstuhl, 2017. doi:10.4230/LIPIcs.ITCS.2017.59 .[Pud97] Pavel Pudl´ak. Lower bounds for resolution and cutting plane proofs and monotonecomputations.
The Journal of Symbolic Logic , 62(3):981–998, 1997. doi:10.2307/2275583 .[Pud00] Pavel Pudl´ak. Proofs as games.
The American Mathematical Monthly , 107(6):541–550,2000. doi:10.2307/2589349 .[Pud10] Pavel Pudl´ak. On extracting computations from propositional proofs (a survey). In
Proceedings of the 30th Foundations of Software Technology and Theoretical ComputerScience (FSTTCS) , volume 8, pages 30–41. Schloss Dagstuhl, 2010. doi:10.4230/LIPIcs.FSTTCS.2010.30 .[Raz95] Alexander Razborov. Unprovability of lower bounds on circuit size in certain fragmentsof bounded arithmetic.
Izvestiya: Mathematics , 59(1):205–227, 1995. doi:10.1070/IM1995v059n01ABEH000009 .[RM99] Ran Raz and Pierre McKenzie. Separation of the monotone NC hierarchy.
Combina-torica , 19(3):403–435, 1999. doi:10.1007/s004930050062 .[RW17] Prasad Raghavendra and Benjamin Weitz. On the bit complexity of sum-of-squaresproofs. In
Proceedings of the 44th International Colloquium on Automata, Languages,and Programming (ICALP) , volume 80, pages 80:1–80:13, 2017. doi:10.4230/LIPIcs.ICALP.2017.80 .[Sok17] Dmitry Sokolov. Dag-like communication and its applications. In
Proceedings of the12th Computer Science Symposium in Russia (CSR) , pages 294–307. Springer, 2017. doi:10.1007/978-3-319-58747-9 26 .[Urq87] Alasdair Urquhart. Hard examples for resolution.
Journal of the ACM , 34(1):209–219,1987. doi:10.1145/7531.8928doi:10.1145/7531.8928