Lower Bounds for Regular Resolution over Parities

The proof system resolution over parities (Res(⊕)) operates with disjunctions of linear equations (linear clauses) over GF(2); it extends the resolution proof system by incorporating linear algebra over GF(2). Over the years, several exponential lower bounds on the size of tree-like refutations have been established. However, proving a superpolynomial lower bound on the size of dag-like Res(⊕) refutations remains a highly challenging open question. We prove an exponential lower bound for regular Res(⊕). Regular Res(⊕) is a subsystem of dag-like Res(⊕) that naturally extends regular resolution. This is the first known superpolynomial lower bound for a fragment of dag-like Res(⊕) which is exponentially stronger than tree-like Res(⊕). In the regular regime, resolving linear clauses C1 and C2 on a linear form f is permitted only if, for both i∈ {1,2}, the linear form f does not lie within the linear span of all linear forms that were used in resolution rules during the derivation of Ci. Namely, we show that the size of any regular Res(⊕) refutation of the binary pigeonhole principle BPHPnn+1 is at least 2Ω(∛n/logn). A corollary of our result is an exponential lower bound on the size of a strongly read-once linear branching program solving a search problem. This resolves an open question raised by Gryaznov, Pudlak, and Talebanfard (CCC 2022). As a byproduct of our technique, we prove that the size of any tree-like Res(⊕) refutation of the weak binary pigeonhole principle BPHPnm is at least 2Ω(n) using Prover-Delayer games. We also give a direct proof of a width lower bound: we show that any dag-like Res(⊕) refutation of BPHPnm contains a linear clause C with Ω(n) linearly independent equations.


INTRODUCTION
Propositional proof complexity studies proof systems for the language of unsatis able CNF formulas (UNSAT).Complexity classes NP and coNP are di erent if and only if no proof system has polynomial size proofs for all formulas from UNSAT [12].The main direction in proof complexity is to prove superpolynomial lower bounds on proof sizes for particular proof systems; this direction is also known as Cook's program for separating NP and coNP.
Resolution is one of the most studied and simplest propositional proof systems.A resolution refutation of a CNF formula is a sequence of clauses 1 , 2 , . . ., such that (1) is the empty clause (i.e.identically false); (2) for every , is either a clause of or is obtained by the resolution rule from and , where , < .The resolution rule allows us to derive the clause ∨ from clauses ∨ and ∨ ¬ , where is a variable.Resolution is highly connected with contemporary SAT-solvers.The rst practical SAT solvers were based on splitting (so-called DPLL algorithms due to Davis, Putnam, Loveland, and Logeman [13,14]).Protocols of DPLL algorithms running on unsatis able formulas can be viewed as tree-like Resolution refutations.Current fastest SAT-solvers are based on the CDCL (Con ict-Driven Clause Learning) approach; the execution of such algorithms on unsatis able formulas actually contains a Resolution refutation [7].Thus, formulas that require very large resolution proofs are also hard instances for DPLL and CDCL solvers.
Nowadays we know many formulas that require exponential size resolution refutations, however, for Frege systems (which include the standard propositional proof systems from logic textbooks) we do not know any superpolynomial lower bounds, and there is even a lack of good candidates for hard formulas.A derivation in a Frege system is a sequence of Boolean formulas (and a sequence of Boolean circuits in Extended Frege).The question of proving lower bounds for Frege systems is usually compared to proving lower bounds on the size of Boolean formulas or circuits for explicit Boolean functions.In general, both questions seem to be intractable by currently known techniques.However, some progress has been made on restricted versions of both questions.An exponential lower bound on the size of constant depth circuits computing parity was proved in the 1980s [1,15].Later, using a similar technique combined with a forcing argument, Ajtai proved a superpolynomial lower bound for bounded depth Frege systems [2].Razborov and Smolenski in 1987 proved a lower bound for constant depth circuits built up from ¬, ∨, ∧ and MOD gates [36,37].However, the analogous question of proving a lower bound for bounded depth Frege operating with formulas using ¬, ∨, ∧ and MOD gates (denoted AC 0 [ ]-Frege) is open for all values of > 1.
In this paper, we study a subsystem of AC 0 [2]-Frege called resolution over parities, or Res(⊕) [25,26].The proof lines in this proof system are disjunctions of linear equations over F 2 , called linear clauses.Every linear clause ∈ ( = ) is the negation of the linear system ∈ ( = + 1).An ordinary clause (a disjunction of literals) is a special case of a linear clause since the literal ¬ is equivalent to = 0 and the literal is equivalent to = 1.A Res(⊕) refutation of an unsatis able CNF formula is a sequence of linear clauses 1 , 2 , . . ., such that (1) is the empty clause (i.e.identically false); (2) for every , is either a clause of or is obtained from and with , < by the resolution rule, or is obtained from with < by the weakening rule.The resolution rule allows to derive the clause ∨ from clauses ∨ ( = 0) and ∨ ( = 1), where is a linear form.The weakening rule allows to derive from if semantically implies , i.e., any assignment satisfying also satis es .For resolution refutations, the weakening rule is not necessary and can be eliminated without increasing the size of the refutation.However, in Res(⊕) the weakening rule is important since this is the only way to get equations depending on more than one variable.
Roughly speaking, Res(⊕) is a combination of resolution and linear algebra over F 2 .Unsatis able linear systems over F 2 encoded as a CNF are easy for tree-like Res(⊕) [26], however, it is known that unsatis able linear systems over F 2 based on expander graphs are hard for resolution [39].
Proving superpolynomial lower bounds on the size of Res(⊕) refutations is a frontier open problem on the way to obtaining lower bounds for AC 0 [2]-Frege.This question seems to be very challenging.There have been a few attempts to attack lower bounds for Res(⊕), below we summarize the main results achieved so far in this direction.

Review of Previous Results
1.1.1Tree-Like Lower Bounds.A Res(⊕) refutation is said to be tree-like if every linear clause appearing in the refutation is used at most once as a premise of a rule.There are many techniques for proving lower bounds for tree-like Res(⊕).We give a brief overview of the most important ones.
Prover-Delayer games.Initially, Prover-Delayer games were dened by Impagliazzo and Pudlak [34] for proving lower bounds for tree-like Resolution.Istykson and Sokolov [26] extended this game to tree-like Res(⊕).For a given unsatis able CNF formula , two players, Prover and Delayer, play the following game: the game starts with an empty board; in each step, Prover chooses a linear form and Delayer either chooses ∈ {0, 1} or allows Prover to choose herself.In the latter case, Delayer earns a coin.They write the equation = on the board.The game stops when the linear system on the board contradicts a clause of .It is known that if Delayer can earn at least coins with any behavior of Prover, then the size of any tree-like Res(⊕) refutation of is at least 2 [26].
Using Prover-Delayer games, one can prove exponential lower bounds on the size of tree-like Res(⊕) refutations of the (unary) pigeonhole principle [25,26] and various ordering principles [19].These games were also used for proving exponential lower bounds on the running time of drunken DPLL(⊕) algorithms on satis able formulas [22].Lower bound proofs using Prover-Delayer games are very explicit.However, such proofs are not known to work for CNFs consisting of clauses of small (e.g.constant) width.

Randomized communication complexity.
Every unsatis able CNF formula de nes a search problem Search( ): given an assignment of variables, nd a clause of falsi ed by this assignment.
Itsykson and Sokolov [25,26] noticed that any size-tree-like Res(⊕) refutation of a formula can be transformed into a randomized communication protocol for Search( ) of cost (log ), where variables of are distributed between two communicating parties.Examples of formulas with large randomized communication complexity of Search( ) can be found in [9,18,21]; all of them have a lifted structure: an essential formula (expressing some standard combinatorial principle) is lifted (i.e.composed) with some gadget.Itsykson and Ryazanov used slightly di erent communication complexity arguments to prove an exponential lower bound on the size of tree-like Res(⊕) refutations of the perfect matching principle for graphs with an even number of vertices (while for graphs with an odd number of vertices perfect matching has short tree-like Res(⊕) refutations [23]).Itsykson and Riazanov [23] also proved a lower bound on the randomized communication complexity of Search(BPHP +1 ), where BPHP +1 is the binary pigeonhole principle with + 1 pigeons and holes; Göös and Jain [17], using another approach, proved a lower bound on the randomized communication complexity for the search problem based on the slightly weak binary pigeonhole principle Search(BPHP 2 ).
Reduction from polynomial calculus degree.Garlik and Kołodziejczyk [16] noted that any tree-like Res(⊕) refutation of a -CNF formula of size can be converted to a dag-like Res(⊕) refutation of of width log + + (1), where the width of a refutation is the maximum number of linear equations that appear in a linear clause in the refutation.It is easy to see that a Res(⊕) refutation of width may be converted to a polynomial calculus (over F 2 ) refutation of degree + (1).This gives another method of proving lower bounds for tree-like Res(⊕) via polynomial calculus degree lower bounds.For example, degree lower bounds for random 3-CNFs [5] and the functional graph pigeonhole principle [32] imply exponential lower bounds on the size of tree-like Res(⊕) proofs of these formulas.
Lifting from resolution depth.Recently Chattopadhyay, Mande, Sanyal, and Sherif [10] and independently Beame and Kroth [8] developed a lifting technique from resolution depth/tree-like resolution size to tree-like Res(⊕) refutation size using sti ing gadgets.Namely, if requires resolution depth and is a -sti ing gadget, then • requires a tree-like Res(⊕) refutation of size at least 2 [10].
1.1.2What is Known for Dag-Like Res(⊕)?Itsykson and Sokolov [26] considered systems Res(⊕; ⩽ ) which are subsystems of Res(⊕) operating with linear clauses that contain at most equalities depending on more than one variable.Exponential lower bounds for Res(⊕; ⩽ ) (where < 1 is a constant and is the number of variables) can be obtained by monotone interpolation.Exponential lower bounds for Res(⊕; ⩽ ) (where < 1 is a constant) can be obtained by a simulation in Polynomial Calculus Resolution with a moderately exponential blowup [26].
Lauria [29] considered a system Res(⊕ ), which is a subsystem of Res(⊕) in which each equation in each linear clause uses at most variables.This system is weaker than Res( ), hence lower bounds follow from lower bounds for Res( ).
Krajíček [28] presented a randomized feasible interpolation that is based on randomized communication complexity of evaluating a proo ine.Krajíček reduced the question of a lower bound on Res(⊕) to lower bounds for monotone CLO circuits (circuits with local oracles) that separate two disjoint NP sets.However, lower bounds for monotone CLO circuits are still unknown.
Khaniki [27] proved a superlinear lower bound for the dag-like version of Res(⊕) (however, the proof system considered uses a di erent set of rules, and it is not clear whether the lower bound would remain non-trivial for the rules we use).
Several works have investigated proof systems Res( ) operating with disjunctions of linear equations over a ring for various rings.Raz and Tzameret studied the proof system Res( Z ) over integers [35].Part and Tzameret considered many other elds and rings [33].The eld F 2 di ers from other rings in that over F 2 the negation of an equality can also be represented as an equality; nevertheless Res( Z ) polynomially simulates Res(⊕) [26].Part and Tzameret proved that the binary value principle 1 + 1 + 2 2 + • • • + 2 −1 = 0 requires exponential size refutations in dag-like Res( Q ).Alekseev [6] proved that the binary value principle is hard even for a stronger proof system called extended polynomial calculus over Q.However, the binary value principle is not a CNF formula.
1.1.3Read-Once Linear Branching Programs.It is known that every tree-like resolution refutation of a formula can be viewed as a decision tree for the problem Search( ) and vice versa.The same equivalence exists between tree-like Res(⊕) refutations of and parity decision trees solving Search( ) [26].In the dag-like case, it is known that regular resolution refutations of are equivalent to read-once branching programs computing Search( ).Recall that regular resolution is a subsystem of resolution.For every clause we additionally have the list of variables that were resolved in the resolution rules in the derivation of .In the regular regime, it is allowed to resolve clauses and on a variable only if ∉ ∪ .Linear branching programs extend branching programs by allowing them to query F 2 -linear forms instead of just variables.Gryaznov, Pudlák, and Talebanfard [20] introduced two versions of the read-once property for linear branching programs: weak and strong.Gryaznov, Pudlák, and Talebanfard [20] gave an explicit construction of a Boolean function that requires strongly read-once linear branching programs of exponential size in the average case; recently Eshan Chattopadhyay and Liao [11], Li and Jong [31] and Li [30] have improved the lower bound.
As in the classical case, a weakly (and strongly) read-once linear branching program for Search( ) can be converted to a Res(⊕) refutation of of the same size [20].Gryaznov, Pudlák, and Talebanfard [20] raised the question of proving a lower bound for weakly and strongly read-once branching programs computing Search( ).In this paper, we resolve the question for strongly read-once linear branching programs by giving an exponential size lower bound.

Our Contributions
The main objective of this paper is to take a signi cant stride towards moving the frontier of currently known lower bounds for the tree-like Res(⊕) much closer to the dag-like Res(⊕).To achieve this, we consider a natural barrier, a speci c fragment within daglike Res(⊕) that possesses additional structural properties.This speci c fragment naturally extends regular resolution, which is an important subsystem of resolution.
We introduce the notion of regular Res(⊕) refutation.Analogously to ordinary resolution, with each linear clause forming a proof line of a Res(⊕) derivation we remember the set of all linear forms that were used in the resolution rules in the derivation of the clause .In regular Res(⊕) refutations, it is allowed to resolve linear clauses and on a linear form only if ∉ ⟨ ⟩ ∪ ⟨ ⟩, where ⟨. ..⟩ denotes span.
It is easy to see that regular resolution is a subsystem of regular Res(⊕).It is known that tree-like Res(⊕) and regular resolution do not polynomially simulate each other and, moreover, they can be exponentially separated from each other (see Sections 3.2 and 3.5 of [26]).Regular Res(⊕) simulates tree-like Res(⊕) (see Lemma 2.5).Thus regular Res(⊕) is exponentially stronger than both regular resolution and tree-like Res(⊕).
We prove an exponential lower bound on the size of regular Res(⊕) refutations.As a hard formula we use the binary pigeonhole principle BPHP 2 ℓ which encodes in CNF that there are pairwise distinct strings from {0, 1} ℓ .We usually say that there are 2 ℓ holes and pigeons and the th string is the binary number of the hole where the th pigeon sits.This formula is unsatis able if and only if > 2 ℓ .
Our main result is the following theorem: Theorem (Theorem 8.1).Any regular Res(⊕) refutation of has size at least 2 Corollary (Corollary 8.2).The size of any strongly readonce linear branching program solving Search(BPHP This corollary answers the question raised by Gryaznov, Pudlák and Talebanfard [20]. We develop tools to prove the theorem and use them to obtain additional results.Theorem 5.5 shows that any Res(⊕) refutation of BPHP contains a linear clause such that rk(¬ ) ≥ /4, where by the rank of a linear system we mean the rank of the matrix of its left-hand side.The attractive feature of this result is that it is proven very directly: we demonstrate a procedure for nding such a wide clause in every refutation.All previously known lower bounds on width/rank were based on polynomial calculus degree lower bounds, hence they were very indirect.Further, we show that the size of any tree-like Res(⊕) refutation of BPHP is at least 2 /4 (see Theorem 5.8).This proof is mostly interesting because of its explicitness.It is done by means of a Prover-Delayer game for tree-like Res(⊕), and this is the rst example of such a game for formulas that have only narrow clauses.

PRELIMINARIES 2.1 Linear Algebra
For a set of vectors from a vector space we denote by ⟨ ⟩ the linear span of .
In this paper, all scalars are from the eld F 2 .Let be a set of variables that take values in F 2 .A linear form in variables from is a homogeneous linear polynomial over F 2 in variables from or, in other words, a polynomial , where ∈ is a variable and ∈ F 2 for all ∈ [ ].A linear equation is an equality = , where is a linear form and ∈ F 2 .A linear system is a conjunction of linear equations.
We say that a linear equation = is implied by a linear system Φ (or = is a corollary of Φ) if any solution of Φ satis es = .
Lemma 2.1 (folklore).A linear equation = is implied by a satis able linear system Φ if and only if = can be obtained as a linear combination of equations from Φ.

Resolution over Parities
A linear clause is a disjunction of linear equations: =1 ( = ).Notice that over F 2 a linear clause =1 ( = ) may be represented as the negation of a linear system: ¬ =1 ( = + 1).
For a linear clause we denote by ( ) the set of linear forms that appear in ; i.e.
=1 ( = ) = { 1 , 2 , . . ., }.Let be an unsatis able CNF formula.A refutation of in the proof system Res(⊕) [26] is a sequence of linear clauses 1 , 2 , . . ., such that is the empty clause (i.e., identically false) and for every ∈ [ ] the clause is either a clause of or is obtained from previous clauses by one of the following inference rules: • Resolution rule allows us to derive from linear clauses ∨( = ) and ∨ ( = + 1) the linear clause ∨ .• Weakening rule allows us to derive from a linear clause an arbitrary linear clause in the variables of that semantically follows from (i.e., any assignment satisfying also satis es ).A resolution refutation of a formula is a special case of a Res(⊕) refutation, where all linear clauses are ordinary clauses.
Any Res(⊕) refutation Π of a CNF formula can be represented as a directed acyclic graph Π with one source.Each node of Π is labeled with a linear clause, the source is labeled with the empty clause, sinks are labeled with clauses of and every node except sinks has one or two outgoing edges such that (1) if a node labeled with 1 has two outgoing edges to nodes labeled with 2 and 3 , then 1 is the result of the resolution rule applied to 2 and 3 and (2) if a node labeled with 1 has only one outgoing edge to a node labeled with 2 , then 1 is the result of the weakening rule applied to 2 .
Actually, we will use another graph ˜ Π that is obtained from Π by contractions of all edges corresponding to weakening rules.For every node of ˜ Π : • Let be the result of merging the nodes 1 , 2 , . . ., ( > 1) forming a path in such that each of the edges ( 1 , 2 ), . . ., ( −1 , ) of the path corresponds to an application of the weakening rule.Assume that the nodes 1 , 2 , . . ., are labeled with 1 , 2 , . . ., , respectively; • We label with , the strongest of the clauses.We call the resulting graph ˜ Π the refutation graph.It has the following properties: • ˜ Π is a directed acyclic graph with one source and each of its sinks is labeled with a clause of ; • every node of ˜ Π except sinks has two outgoing edges, and if a node labeled with 1 has two outgoing edges to nodes labeled with 2 and 3 , then 1 is the result of the resolution rule applied to a weakening of 2 and a weakening of 3 .By the size of a Res(⊕) refutation Π we mean the number of vertices in its refutation graph ˜ Π .

Res(⊕) Refutations as Linear Branching Programs
Let be a set of variables.A linear branching program is a directed acyclic graph with one source; every node except sinks has two outgoing edges; for every non-sink node there is a linear form in variables from that is called a query at the node ; one edge leaving is labeled = 0 and the other edge is labeled = 1.Each sink of the graph is labeled with an element from a set (the set of answers).Every linear branching program computes a function from {0, 1} → : a full assignment of variables from determines the unique path from the source to a sink such that this assignment satis es all equations labeling the edges of this path.The label of the sink is the result of the function.
For every unsatis able CNF formula we de ne a relation Search( ) that consists of all pairs of ( , ), where is an assignment of the variables of and is a clause of falsi ed by .We may think of Search( ) as a search problem where, given an assignment , we have to nd such that ( , ) ∈ Search( ).
Consider a Res(⊕) refutation graph Π of a CNF formula .We now show that the graph Π can be relabeled such that it turns into a linear branching program with the set of answers equal to the set of clauses of .Sinks of Π are already labeled with clauses of .For every non-sink node of , there is a linear form that is used in the resolution rule at the node ; will be a query at the node of the linear branching program.Consider an arbitrary node be obtained from ( + = 0 ∨ = 1) and 3 by resolving on ; (2) ( + = 0 ∨ = 1) is a weakening of 3 , and 1 can be obtained from ( + = 0 ∨ = 1) and 2 by resolving on .
To avoid ambiguity in the construction of a linear branching program associated with a Res(⊕) refutation graph, we will assume that every Res(⊕) refutation graph also keeps a record of the resolved linear forms at all its nodes.Lemma 2.3.Consider a Res(⊕) refutation graph with its edges labeled as in the linear branching program associated with it.Let and be two of its nodes labeled with linear clauses and such that there is a path connecting to .Let Φ be the conjunction of the equations labeling the edges of .Then Φ ∧ ¬ implies ¬ .In particular, for any path from the source of a Res(⊕) refutation graph to a node labeled with , the system of linear equations written on the edges of this path implies ¬ .
Proof.We prove the lemma by induction on the length of .In the base of induction, has zero length and = ; the statement is trivial.Induction step.Let be the predecessor of on the path and let be labeled with .Assume that is the result of the resolution rule applied to 1 ∨ ( = ) and 2 ∨ ( = + 1), where 1 ∨ ( = ) is the weakening of .Let Ψ be the linear system written on the part of the path from to .By the construction, the edge ( , ) is labeled with , and ¬ 1 ∧ ( = + 1) implies ¬ , since semantically implies 1 ∨ ( = ).Thus ¬ ∧Φ implies ¬ and the inductive step is proved.□ Lemma 2.3 implies that every Res(⊕) refutation graph of a formula may be also considered as a linear branching program solving the search problem Search( ).
A Res(⊕) refutation is called tree-like if any non-sink node of the refutation graph has at most one incoming edge.A parity decision tree is a linear branching program such that any non-sink node has at most one incoming edge.So the last observation implies that a tree-like Res(⊕) refutation of can be thought of as a parity decision tree for Search( ).

Regular Refutations
For a node of a linear branching program, we denote by Pre( ) the linear span of all linear forms such that is a query at a node ≠ on a path from the source to .We denote by Post( ) the linear span of all linear forms such that is a query at a node on a path from to a sink.
A linear branching program is weakly read-once if for all nonsink nodes , ∉ Pre( ), where is a query at a node [20].A linear branching program is strongly read-once if for all nodes , Pre( ) ∩ Post( ) = {0} [20].
A Res(⊕) refutation is called top-regular if the associated linear branching program is weakly read-once.
We have already shown that any Res(⊕) refutation graph of can be considered as a linear branching program for Search( ).Gryaznov, Pudlák and Talebanfard [20] showed that any weakly read-once linear branching program for Search( ) can be viewed as a top-regular Res(⊕) refutation of .

Lemma 2.4 ([20]
).For any weakly read-once linear branching program solving Search( ), there is a labeling of its non-sink nodes with linear clauses that makes it a refutation graph of a top-regular Res(⊕) refutation of .Moreover, for every node, its query coincides with the linear form resolved at this node.
A Res(⊕) refutation is called bottom-regular, or just regular, if for every edge ( , ) in the associated linear branching program ∉ Post( ), where is the query at .

Lemma 2.5 ([20]
).Given a tree-like Res(⊕) refutation of , one can construct a tree-like Res(⊕) refutation of of no larger size that is top-regular and bottom-regular.
Lemma 2.6.Suppose that is an unsatis able CNF formula in variables, and Π is a regular Res(⊕) refutation of .Let Π be the refutation graph associated with Π.Then for every node in Π such that there is a path from the source to of length , the dimension of Post( ) is at most − .
Proof.Consider a path from the source to of length : gives the only consequence of regularity that we need for our proof of the lower bound on the size of regular Res(⊕) refutations.

Binary Pigeonhole Principle
The binary pigeonhole principle BPHP 2 ℓ states that pigeons can be placed in 2 ℓ holes such that every pigeon sits in a hole and no two pigeons sit in the same hole.The address of each hole can be represented as an ℓ-bit binary string, and so this principle can be expressed as the statement that there are pairwise di erent ℓ-bit binary strings 1 , 2 , . . ., , where is the binary number of the hole in which the th pigeon sits.BPHP 2 ℓ has ℓ variables corresponding to the bits of for ∈ [ ]; namely, for every ∈ [ ] and ∈ [ℓ], the variable , denotes the th bit of .Then BPHP 2 ℓ is ≠ ∈ [ ] ≠ , where the predicate ≠ is encoded as a 2ℓ-CNF formula with 2 ℓ many clauses as follows: ∈ {0,1} ℓ ( ≠ ∨ ≠ ), where ≠ ∨ ≠ is the following clause with with 2ℓ literals: where = 1 denotes , = 0 denotes ¬ , and 1 , 2 , . . ., are the bits of .
We usually denote the number of holes by = 2 ℓ .If > , then the formula BPHP is unsatis able.
Let be the set of variables of the formula BPHP 2 ℓ .Every Boolean assignment with domain naturally corresponds to a mapping ˜ : [ ] → [ ] as follows:

SAFE AND DANGEROUS SETS OF LINEAR FORMS
We consider the set of propositional variables = { , | ∈ [ ], ∈ [ℓ]}.The variables from are divided into blocks by the value of the rst index.The variables ,1 , ,2 , . . ., ,ℓ form the th block, for ∈ [ ]. Since is the set of variables of the binary pigeonhole principle BPHP 2 ℓ , when we start working with this principle later, we will use that blocks correspond to pigeons and the variables of a block encode a hole.
The point of departure for our lower bound results is to consider a system of linear equations in the variables and to formalize the notion of many independent linear consequences of this system talking about variables from a small number of blocks.It turns out that this notion is already determined by the set of linear forms forming the left-hand side of the system.
Consider sets of linear forms using variables from over the eld . ., } of blocks of variables that appear in with non-zero coe cients.We denote the support by supp( ).The support of a set of linear forms is the union of the supports of all linear forms in this set.We denote it by supp( ).We say that a linearly independent set of linear forms is dangerous if | | > |supp( )|.We say that a set of linear forms is safe if ⟨ ⟩ does not contain a dangerous set.If is linearly dependent but ⟨ ⟩ contains a dangerous set, instead of saying that is dangerous, we say it is not safe.
Every linear form corresponds to a vector of its coe cients indexed by the variables from the set .Given a list of linear forms 1 , 2 , . . ., one may consider their coe cient matrix of size × | | in which the -th row coincides with the coe cient vector of .Theorem 3.1.Let 1 , 2 , . . ., be linearly independent linear forms and let be their coe cient matrix.Then the following conditions are equivalent.
(2) For every set ⊆ [ ], the dimension of the span of the set of columns of corresponding to the variables with support in is at least | | − ( − ).(3) One can choose blocks and one variable from each of these blocks such that the columns of corresponding to the chosen variables are linearly independent.It follows from Theorem 3.1 that to solve a linear system that has a safe set of linear forms 1 , 2 , . . ., as left-hand sides, we can assign values to all variables except the chosen (which correspond to distinct blocks) arbitrarily, and the values of the remaining variables will be uniquely determined.Thus any linear system based on a safe set of forms actually restricts at most one bit for each block.
The main ingredient of the proof of this theorem is treated in the next subsection.

Extended Hall's Theorem
The following extension of the well-known Hall's matching theorem was proved by Welsh in 1971.
We need a slightly more general statement but it has virtually the same proof.For a set of linear forms we will use the notation A closure of a set of linear forms is any inclusion-wise minimal set is safe, and therefore a closure of exists.Our goal in this section is to prove the main properties of the closure.Lemma 4.1 (Uniqeness).For any its closure is unique.
We denote the closure of by Cl( ).

Lemma 4.2 (Monotonicity
The de nition of the closure is similar in spirit to the concept of the closure operator for expanders that was originally de ned in [3,5] under di erent names and further called closure i.e. in [4,24,38]; however, we do not know any formal connections between these two notions.Informally speaking, the closure of a set of linear forms is a set of blocks that may be highly restricted by a system of linear equations having this set of forms.

LOCALLY CONSISTENT LINEAR SYSTEMS
In this section we de ne the notion of locally consistent linear systems.We demonstrate how this notion is useful for proving rank and tree size lower bounds for Res(⊕) refutations of BPHP 2 ℓ .Now we take advantage of the fact that is not just a set of variables indexed by two parameters, but that is the set of variables of the formula BPHP , where = 2 ℓ .We will exploit the semantics of these variables, described in Section 2.5.
Let Φ be a linear system with variables from and be a set of linear forms from the left-hand sides of these equations.An assignment : → {0, 1} is called a locally injective solution of Φ if satis es Φ and ˜ is injective on Cl( ), where ˜ is de ned in Section 2.5.We say that Φ is locally consistent if it has a locally injective solution.
Consider some examples of locally consistent linear systems: (1) An empty linear system (i.e. the negation of the empty clause) is locally consistent.(2) The negation of any clause of BPHP is not locally consistent.Indeed, the system looks like ℓ So there is no locally injective solution.
Proposition 5.1.Let Φ and Ψ be linear systems and suppose that every equation in Φ is implied by Ψ.If Ψ is locally consistent, then Φ is also locally consistent.
Proof.Let and be the sets of linear forms of systems Φ and Ψ respectively.Then by Lemma 2.1, ⊆ ⟨ ⟩, hence by the properties of closure Cl( ) ⊆ Cl( ).Thus a locally injective solution of Ψ is also a locally injective solution of Φ. □ Corollary 5.2.If a linear clause is a weakening of a linear clause and ¬ is locally consistent, then ¬ is also locally consistent.
The next two lemmas tell us how to keep local consistency when a new equation is added to a system.Lemma 5.3.Let Φ be a locally consistent linear system with the set of linear forms and let be a linear form.Suppose that Cl( ∪{ }) = Cl( ) and [\ Cl( )] ∉ ⟨ [\ Cl( )]⟩.Then for every ∈ {0, 1} the system Φ ∧ ( = ) is locally consistent.
Proof.It is su cient to show that there exists a solution of Φ such that ˜ is injective on Cl( ∪ { }).Then, setting to the value of at , the lemma follows.
Let be a solution of Φ such that ˜ is injective on Cl( ).Let be the restriction of to the variables with support in Cl( ).It follows that the system Φ| is satis able.To satisfy Φ| it is su cient to satisfy a maximal linearly independent set of its equations.Note that the set of linear forms of Φ| is exactly [\ Cl( )], hence it is safe.Let be the matrix of the left-hand side of some maximal linearly independent part of Φ| and let be the number of rows of .By Theorem 3.1 the matrix contains linearly independent columns such that the set of variables corresponding to these columns does not contain two variables mentioning the same pigeon.So in order to satisfy Φ| we can arbitrarily x all variables except those in , and then the values of the variables in are uniquely determined.We are going to choose the variables outside of so that the resulting assignment is injective regardless of the assignment to the variables in .
Our goal is to show that there exists a solution of Φ extending such that ˜ is injective on Cl( ∪ { }).We will construct an assignment of the variables such that extends and for every assignment ′ that di ers from only on a subset of the variables from , ′ is injective on Cl( ∪ { }).By the above remark, there exists a solution of Φ that di ers from only on a subset of the variables from ; this satis es all the requirements.
We de ne such that it coincides with on the variables with support in Cl( ).We de ne arbitrarily on the variables with support in [ ]\Cl( ∪{ }).Let Cl( ∪{ })\Cl( ) = { 1 , 2 , . . ., }.By induction on we de ne on the variables with support in { 1 , 2 , . . ., } such that for every assignment ′ that di ers from only on a subset of the variables from , ′ is injective on Cl( ) ∪ { 1 , 2 , . . ., }.The base of induction is = 0 and there is nothing to prove.For the induction step from −1 to , we identify the holes for that can lead to a collision with Cl( ) ∪ { 1 , 2 , . . ., −1 } under a change of values to -variables: • There are | Cl( )| holes occupied by .A hole for the pigeon should be di erent from these holes even if the values of some variables from are ipped.Since there is at most one -variable corresponding to , forbids at most 2| Cl( )| holes to pigeon ; • There are − 1 holes occupied by pigeons 1 , . . ., −1 .A hole for the pigeon should be di erent from these holes even if the values of some variables from are ipped.Since there is at most one variable from for each pigeon in { 1 , . . ., −1 } ∪ { }, the pigeons 1 , . . ., −1 prohibit at most 4( − 1) holes to pigeon .So there are at most 2| Cl( )| + 4( − 1) ≤ 2| Cl( )| + 4( − 1) ≤ 4(Cl( ∪ { }) − 1) < 2 ℓ forbidden holes, hence there is at least one non-forbidden hole that we can use for pigeon .□

Rank Lower Bound
Theorem 5.5.Any Res(⊕) refutation of BPHP 2 ℓ contains a clause such that the rank of ¬ is at least 2 ℓ −2 .
Proof.Given a Res(⊕) refutation of BPHP 2 ℓ , we will construct a path in the refutation graph of BPHP 2 ℓ .We start the path at the source and we continue the path as long as it is possible to satisfy the following invariant: for every clause on our path, ¬ is locally consistent.The empty clause at the source satis es the invariant.
Consider a linear clause in the refutation graph of BPHP 2 ℓ .Let linear clauses and be direct successors of .We will show that if ¬ is locally consistent and rk(¬ ) < 2 ℓ −2 , then ¬ or ¬ is also locally consistent.Since the negations of the clauses of BPHP 2 ℓ are not locally consistent, the constructed path can nish only in a clause such that |rk(¬ )| ≥ 2 ℓ −2 .
By the de nition of the refutation graph, there are linear clauses ′ and ′ and a linear equation = such that ′ ∨ ( = ) is a weakening of and ′ ∨ ( = 1 − ) is a weakening of and = ′ ∨ ′ .Hence, the clause ∨ ( = ) is a weakening of ′ ∨ ( = ) and ∨ ( = 1 − ) is a weakening of ′ ∨ ( = 1 − ).So by Corollary 5.2 it is su cient to prove that at least one of the two systems ¬ ∧ ( = 1) and ¬ ∧ ( = 0) is locally consistent.
In the second case, Cl( ( )

Tree-Like Lower Bound
We consider a Prover-Delayer game with an unsatis able CNF .There are two players: Prover and Delayer.They have a board on which they write linear equations in the variables of .The game starts with an empty board.
The game consists of a sequence of moves, each of which has the following form.Prover writes a linear form on the board.Delayer responds in one of two ways.Either Delayer chooses ∈ {0, 1}, completing Prover's form the board to the equation = , and the move is complete; or Delayer asks Prover to choose herself, for which Delayer earns a coin, Prover chooses and completes the form on the board to the equation = , and the move is complete.The game ends when the system of equations on the board contradicts a clause of .Delayer's goal in this game is to earn as many coins as possible.The following is not di cult to prove.Lemma 5.6 ([26]).If for an unsatis able formula there is a strategy for Delayer that guarantees him to earn at least coins, then the size of any tree-like Res(⊕) refutation of is at least 2 .
In our strategy for BPHP 2 ℓ , Delayer will try to keep the linear system on the board locally consistent.The following lemma shows that as long as this is the case, the game cannot end.
Lemma 5.7.Let ℓ > 1.If Φ is locally consistent, then for any clause of BPHP 2 ℓ , Φ does not contradict (i.e.there is a solution of Φ that satis es ).
Proof.Consider some clause of the formula BPHP 2 ℓ ; it says that either pigeon is not in hole , or pigeon is not in hole .
Let us describe a strategy for Delayer.Let be a dynamic variable that equals the set of linear forms written on the board.Delayer will keep a locally consistent system on the board as long as possible.Note that the board is empty at the start and the empty system is locally consistent.By Lemma 5.7, the game cannot be over while the system on the board is locally consistent.
The strategy of Delayer is the following: then Delayer chooses a value ∈ {0, 1} such that = is satis ed by some locally injective solution of the system on the board.Trivially, the resulting system is locally consistent.
then Delayer earns a coin by letting Prover choose .By Lemma 5.3 the invariant will hold for the new system on the board.• In the last case, Cl( ∪ { }) \ Cl( ) = for some ≠ ∅.
We claim that at any time before Delayer gives up, the quantity | Cl( )| + dim⟨ [\ Cl( )]⟩ records the number of coins he has earned so far.We prove this by induction on the number of moves made.The base corresponds to the start of the game and the statement is trivial.
If Thus, at the time Delayer gives up, he has earned at least 2 ℓ −2 coins.Lemma 5.6 completes the proof of the theorem.□

RANDOM PATH IN A REFUTATION GRAPH
We consider a random process on a linear branching program associated with a refutation graph of the formula BPHP 2 ℓ .We take a uniformly random full assignment to the variables and take steps starting from the source.At each step, we go along the edge labeled with an equation satis ed by ; if we come to a sink earlier than in steps, we just remain there.Our goal is to prove that with signi cant probability in steps we reach a vertex labeled with a clause such that ¬ is locally consistent.Moreover, we will show that with signi cant probability is a locally injective solution of ¬ .
We will prove the following lemma in Subsection 6.1.
Lemma 6.1.Suppose that Φ is a system of linear equations in the variables and denote by the set of linear forms from the lefthand side of Φ.Let be a linear form, ∈ {0, 1}, and assume that | Cl( ∪ { })| ≤ .Consider a random full assignment .Then Lemma 6.2.Let be a uniformly random full assignment of variables of BPHP 2 ℓ .Consider the refutation graph of a Res(⊕) refutation of BPHP 2 ℓ and the linear branching program associated with it.Consider a path of length in the linear branching program corresponding to ; if the path reaches a sink, it stops there.Assume that the path ends in a node labeled with a clause .Then, the probability that ˜ is not injective on Cl( ( )) is at most 6 3 .
Proof.Let denote the conjunction of the linear equations labeling the edges of the path of length in the linear branching program corresponding to (if the path reaches a sink earlier than in steps, it stops there).Let us denote by the set of linear forms of .

Pr[ is not injective on
Let denote the set of paths from the source of the linear branching program of length (or shorter if they end in a sink earlier).For a path from the source, we denote by Φ ( ) the system of equations corresponding to (i.e. the conjunction of the equations labeling the edges of ).
Pr[ is not injective on Cl( +1 ) but injective on Cl( )] In the inequality we used Lemma 6. Proof of Lemma 6.1.If 6 ≥ , then the statement of the lemma is trivial; so we assume that 6 < .
Consider a partial assignment such that ˜ injectively maps its domain Cl( ) to [2 ℓ ] and can be extended to a solution of Φ ∧ ( = ).We are going to estimate the probability conditioned on : The system Φ| is satis able, so to solve Φ| it is su cient to consider a maximal linearly independent set of its equations.The set of linear forms from the left-hand side of the equations of Φ| is [\ Cl( )], hence it is safe.Let be the matrix of some maximal linearly independent part of Φ| and let contain rows.By Theorem 3.1 the matrix contains linearly independent columns corresponding to a set of variables such that does not contain two variables mentioning the same pigeon.However, we have the system (Φ ∧ ( = ))| and to satisfy it we have to satisfy both Φ| and ( = )| .
Let us de ne a matrix ′ corresponding to a maximal linear independent part of the system (Φ ∧ ( = ))| as follows.Note that ⟩ is safe and therefore Cl( ) = Cl( ∪ { }).Hence ( = )| does not follow from Φ| .Let ′ be obtained from by adding to one row corresponding to the equality ( = )| .The rank of ′ equals + 1, so in ′ we can take the linearly independent columns corresponding to the variables in and add to this set a ( +1)th column from ′ such that all these columns are linearly independent.Let ′ be the set of variables corresponding to these + 1 columns.While no two di erent variables in mention the same pigeon, the variable corresponding to the ( +1)th column may mention the same pigeon as some variable in .To satisfy (Φ ∧ ( = ))| we can assign values to all variables outside ′ arbitrarily and then the values of the variables from ′ are uniquely determined.
The probability we are interested in is over a random solution of the system (Φ ∧ ( = ))| .Let us assume that we rst randomly assign values to all variables with support in [ ] \ Cl( ) (including values of the variables in ′ , which are not under our control) and then possibly change the values of the variables in ′ to satisfy (Φ ∧ ( = ))| .We stress that we will change at most one bit for − 1 pigeons and at most two bits for one pigeon (or, if no two variables in ′ share a pigeon, we will change at most one bit for + 1 pigeons).By the assumptions of the lemma, | Cl( Let us order the set such that the pigeon with two variables from ′ (if there is such a pigeon in ) comes rst.Considering the pigeons from in this order, for the rst pigeon in we have at most 4 forbidden holes: at most holes are occupied by and we might need to ip two bits corresponding to the two variables in ′ mentioning this pigeon.For the second pigeon, we have at most 2( + 4) forbidden holes: holes are occupied by and at most four holes are reserved for the rst pigeon; the factor 2 corresponds to one bit of the second pigeon that may be ipped in case a variable in ′ mentions the second pigeon.For the third pigeon we have at most 2( + 6) forbidden holes, etc.
Thus, the probability that all pigeons from in a random solution of (Φ ∧ ( = ))| are in di erent holes that are not used by is at least In the last inequality, we use Bernoulli's inequality (1 + ) ≥ 1 + , which holds for every integer ≥ 1 and real number ≥ −1.
So we have proved an upper bound on the probability conditioned on : Pr[ ˜ is not injective on Cl( ∪ { }) but injective on Cl( ) | satis es Φ ∧ ( = ) and extends ] ≤ 6 2  .
Since the condition event we need is partitioned according to into the condition events as in the last inequality (including 's with non-injective ˜ , for which the estimated probability is 0), the lemma follows.□

RANK LOWER BOUND FOR REGULAR Res(⊕) REFUTATIONS
In this section we assume that is the set of variables of BPHP 2 ℓ +1 2 ℓ .That is, the number of pigeons exceeds the number of holes exactly by one.In Section 5.1 we have showed that any Res(⊕) refutation of BPHP 2 ℓ +1 2 ℓ contains at least one clause such that rk¬ is large.In contrast in this Section, we show that regular Res(⊕) refutation of BPHP 2 ℓ +1 2 ℓ contains many such clauses.Lemma 7.1.Let a linear system Φ in variables from be locally consistent and contain linearly independent equations, where < 2 ℓ −2 .Let ⊆ [ + 1] and | | ≥ + 1.Then there is a solution of Φ such that ˜ is injective on [ + 1] \ .
Proof.Since Φ is locally consistent, there exists a locally injective assignment, and let be its restriction to the variables with support in Cl( ).Note that ˜ is injective on its domain and Φ| is satis able.
The set of linear forms [\ Cl( )] is safe by the de nition of the closure.Let ℎ = dim⟨ [\ Cl( )]⟩.Consider ℎ linearly independent forms from [\ Cl( )]: 1 , 2 , . . .ℎ .Note that Φ| contains equations with linear forms 1 , 2 , . . .ℎ and all other equations of Φ| follow from these equations.Let be the coe cient matrix of 1 , 2 , . . ., ℎ .By the de nition of Cl( ), the set 1 , 2 , . . ., ℎ is safe, so by Theorem 3.1, there are ℎ linear independent columns in that correspond to ℎ di erent pigeons.Let us denote by the set of variables corresponding to these ℎ columns.To satisfy the system Φ| , one can arbitrarily choose values for all variables except those in , and then the values of the variables in are uniquely determined.We are going to describe a solution of Φ such that ˜ is injective on [ + 1] \ and extends .
Pigeons from Cl( ) are already in distinct holes, and we assume that their holes are reserved.First, we will reserve holes for the ℎ pigeons that have a corresponding variable in .For each such pigeon, we will reserve two holes that di er only in the th bit, where is the second index of the variable in mentioning the pigeon.We do it inductively.Assume that we have already reserved pairs of holes for the rst pigeons.Let us treat the ( + 1)th pigeon.Let ∈ [ℓ] be the second index of the variable in mentioning this pigeon.There are 2 ℓ −1 pairs of strings of length ℓ such that the strings in each pair di er exactly in the th bit.Some elements of some pairs may have been reserved earlier; we will call such pairs touched Finally, assume that the third condition holds and there are chosen columns of corresponding to di erent blocks.Let ⊆ [ ].At most − | | of the chosen columns have their corresponding block in [ ] \ , hence there are at least − + | | of the chosen columns with their corresponding block in .Therefore, the dimension of the span of the set of columns of corresponding to variables with support in is at least | | − ( − ).I.e., the second condition holds.□ 4 CLOSURE OF A SET OF LINEAR FORMS Let ⊆ [ ] be a set of blocks; for a linear form we denote by [\ ] a linear form obtained from by substituting 0 for all variables with support in .In other words, [\ ] is the projection of to the linear space of all forms with support in [ ] \ .Being a projection, [\ ] is a linear operator for every ⊆ [ ].