On Obdd-Based Algorithms and Proof Systems that Dynamically Change Order of Variables

,


Introduction
An ordered binary decision diagram (OBDD) represents a Boolean function.A Boolean function is represented as a branching program with two sinks such that on every path from the source to a sink variables appear in the same order.This restriction on the order of variables allows handling the diagrams (compute binary Boolean operations on diagrams, compute projections, or test satisfiability) very efficiently.
Atserias, Kolaitis and Vardi [2] proposed an OBDD-based proof system.This system is meant to prove that a given CNF formula is unsatisfiable.For some order of variables π we represent clauses of the input 1 formula as a π-ordered BDD; we may derive a new OBDD applying either the conjunction rule or the weakening rule.(The authors of [2] supplied the system with one more rule -the projection, which derives ∃xD from D; we consider this rule as a special case of the weakening rule, so we do not need to allow it explicitly.)A proof in this system is a derivation of an OBDD that represents the constant false function.We refer to this proof system as the OBDD(∧, weakening) proof system.The OBDD(∧, weakening) proof system simulates Cutting Planes with unary coefficients and thus it is stronger than Resolution.This proof system provides also short refutations for the formulas that represent unsatisfiable systems of linear equations over F 2 [2], while linear systems are hard for Resolution.This observation motivates the study of the OBDDbased algorithms (notice that the popular DPLL and CDCL algorithms correspond to tree-like and DAG-like Resolutions).
Several strong lower bounds are known for different versions of OBDD proof systems.Segerlind [20] proved an exponential lower bound for the tree-like version of OBDD(∧, weakening) proof system using the communication complexity technique proposed in [3].Krajicek [14] proved an exponential lower bound for the DAG-like version of it using monotone feasible interpolation.Several papers study the OBDD-based proof system that has only one inference rule -the conjunction rule (we refer to this system as OBDD(∧) proof system).Groote and Zantema [11] showed that there is a formula φ (not in CNF) such that Tseitin transformation of this formula does not have a short resolution proof but φ has short OBDD(∧) proof.Tveretina, Sinz and Zantema [22] proved the lower bound 2 Ω(n) for the pigeonhole principle PHP n+1 n in the OBDD(∧) proof system.Friedman and Xu [9] proved an exponential lower bound for the complexity of random unsatisfiable 3CNF formulas in restricted versions of OBDD(∧) proof systems (with a fixed order of the variables) and an exponential lower bound for the running time on random unsatisfiable 3XOR formulas of restricted versions of OBDD(∧) proof systems (with fixed orders of application of rules).
An interesting approach to solving propositional satisfiability was suggested by Pan and Vardi [19].They proposed an algorithm that chooses some order π on the variables of the input CNF formula F and creates the current π-ordered BDD D that initially represents the constant true function, and a set of clauses S that initially consists of all clauses of the formula F .Then the algorithm applies the following operations in an arbitrary order: conjunction (or join): choose a clause C ∈ S, delete it from S and replace D by the π-ordered BDD representing C ∧ D; projection (or ∃-elimination): choose a variable x that has no occurrence in the clauses from S and replace D by the π-ordered BDD representing ∃xD.
When S becomes empty, the algorithm stops and reports "unsatisfiable" if D represents the constant false function and "satisfiable" otherwise.Every particular instance of this algorithm uses its own strategies to choose an order of variables π and an order of application of the operations.We refer to these algorithms as OBDD(∧, ∃) algorithms.Pan and Vardi [19] investigated some specific strategies and compared them with DPLL based SAT solvers and SAT solvers based on OBDDs without quantifier eliminations (we call them OBDD(∧) algorithms).Experiments showed in particular that OBDD(∧, ∃) algorithms are faster than OBDD(∧) algorithms [19].A result of [6] implies that an OBDD(∧, ∃) algorithm can solve PHP n+1 n in polynomial time.The lower bounds for the OBDD(∧, weakening) proof systems mentioned above imply the same lower bounds for the OBDD(∧, ∃) algorithms.

Statement of the problem
It is known that changing the order of the variables in an OBDD can be performed in time polynomial in the sizes of the input and the output [17].So it seems to be very restrictive to use the same order of variables in all OBDDs in the proof.Hence, we propose to strengthen the OBDD proof systems with a supplementary rule that dynamically reorders the variables in OBDDs.
In OBDD proofs, reordering rule may be applied to an arbitrary OBDD from the proof but the conjunction rule may be applied only to OBDDs with the same order since the verification of the application of the conjunction to OBDDs in different orders is hard (this problem is coNP-complete, see [18,Lemma 8.14]).
The first aim of this paper is to prove lower bounds for the OBDD-based algorithms and proof systems that use the reordering rule.The second aim is to show that reordering of the variables is really useful; we give examples of formulas that are hard for the OBDD-based proof systems without reordering and easy with reordering.

Our results
In Section 3, we consider the OBDD(∧, reordering) proof system.We prove two exponential lower bounds for size of OBDD(∧, reordering)-derivations of the pigeonhole principle PHP n+1 n and Tseitin formulas based on constant-degree algebraic expanders.The lower bound for pigeonhole principle extends the result of Tveretina et al. [22] from OBDD(∧) proofs to OBDD(∧, reordering) proofs.(Besides, we believe that our argument is simpler than the proof in [22].)The result for Tseitin formulas, to the best of our knowledge, was not known even for the more restrictive OBDD(∧) proofs.In both arguments we use the same strategy: • At first step, we prove an exponential lower bound on the size of the OBDD-representation for an appropriate satisfiable formula.Assume that the original unsatisfiable formula is minimally unsatisfiable.Roughly speaking, the satisfiable formula under consideration is equal to the original unsatisfiable formula with one canceled clause.For example, for the pigeonhole principle the appropriate satisfiable formula would be PHP n n ; for the Tseitin formulas such an appropriate formula is a satisfiable Tseitin formula.This part of the proof is quite cumbersome but it involves only rather elementary techniques of lower bounds for OBDD.
• Consider the last derivation step.It consists in the conjunction for F 1 and F 2 in the same order π.Our goal is to prove that at least one of F 1 and F 2 has an exponential size.Both F 1 and F 2 are satisfiable and they are conjunctions of different sets of clauses of the initial formulas.The idea is to construct partial substitutions ρ 1 and ρ 2 with the same support such that the formula F 1 | ρ1 ∧ F 2 | ρ2 is isomorphic to the satisfiable formula from the first step.Then any OBDD representation of F 1 | ρ1 ∧ F 2 | ρ2 has exponential size.Hence, the size of either F 1 | ρ1 or F 2 | ρ2 is large for the order π.Thus, the size of either F 1 or F 2 is large for the order π.
In Section 4, we construct an example of a family of formulas that are easy for the OBDD(∧, reordering) proof system but hard for the OBDD(∧) proof system.
In Section 5, we study OBDD(∧, ∃, reordering) algorithms.At first, we notice that there exists an OBDD(∧, ∃) algorithm that solves satisfiable and unsatisfiable Tseitin formulas in polynomial time.In contrast, we show that there exist formulas representing systems of linear equations over F 2 that are hard for OBDD(∧, ∃, reordering) algorithms.More specifically, we describe a construction of a family of satisfiable formulas F n on n variables in O(1)-CNF such that every OBDD(∧, ∃, reordering) algorithm runs at least 2 Ω(n) steps on F n .
The plan of the proof is as follows.
• We prove that if C ⊆ {0, 1} n is the set of codewords of a list-decodable code that allows to correct 2 3 n of erasures, then every OBDD that represents the characteristic function of C (χ C ) has a big size (this size proved to be close to the number of all codewords in the code).Moreover, this property holds even for the projections of χ C onto any 1  6 n coordinates.Notice that a similar result was known for error-correcting codes with large enough minimal distance (see for example the paper of Duris et al. [8]).Guruswami [12] showed that the codes with large enough minimal distance are erasure list-decodable but the opposite statement does not hold.
• In Section 6.1, we give a randomized construction of the required linear code.This construction is based on random checksum matrix.We use the codes of Gallager [10] that contain O(1) ones per row.
We prove that such a random code with a high probability enjoys the following expansion property: every 1  6 n columns of the matrix contain ones in almost all rows.And in Section 6.2 we give an explicit construction of the required linear code.
• We consider the execution of an OBDD(∧, ∃, reordering) algorithm on CNF formula that corresponds to the CNF representation of the checksum matrix of the code.We study two cases: 1. the algorithm applies the projection rule less than n 6 times; 2. the projection rule is applied at least n 6 times.In the first case, we focus on the OBDD at the end of the execution of the algorithm; its size should be exponential due to the properties of the code.In the second case, we consider the first moment in the computational process when we apply exactly n 6 projection operations.By the expansion property, OBDD D is a projection of almost the entire formula, thus its size should be close to the size of the OBDD of the characteristic function of the code.That is, the size of D should be large enough.
As we mentioned above, the previously known lower bounds for tree-like and DAG-like OBDD(∧, weakening) proofs imply lower bounds for OBDD(∧, ∃) algorithms.So, what is new in our results comparative to the lower bounds proven by Segerlind [21] and Krajíček [14]?First of all, our lower bound also works for the reordering operation.The second advantage of our construction is that we come up with quite a natural class of formulas (our formulas represent linear systems of equations that define some error correcting codes), while the constructions in [14,21] seem to be rather artificial.Further, we prove the lower bound 2 Ω(n) for a formula with n variables, whereas the previously known lower bounds are of the type 2 n ǫ (for some ǫ < 1/5).Besides, we proposed a new technique that might be applicable for other classes of formulas.

OBDD
An ordered binary decision diagram (OBDD) is a data structure that is used to represent Boolean functions.Let Γ = {x 1 , . . ., x n } be a set of propositional variables.A binary decision diagram is a directed acyclic graph with one source.Every vertex of the graph is labeled by a variable from Γ or by constants 0 or 1.If a vertex is labeled by a constant, then it is a sink (has out-degree 0).If a vertex is labeled by a variable, then it has exactly two outgoing edges: one edge is labeled by 0 and the other edge is labeled by 1.Every binary decision diagram defines a Boolean function {0, 1} n → {0, 1}.The value of the function for given values of x 1 , . . ., x n is computed as follows: we start a path at the source and on every step we go along the edge that corresponds to the value of the variable at the current vertex.Every such path reaches a sink labeled by the constant; this constant is the value of the function.The size of an OBDD is equal to the number of vertices in the graph.
Let π be a permutation of the set {1, . . ., n}.A π-ordered binary decision diagram (BDD) is a binary decision diagram such that on every path from the source to a sink every variable has at most one occurrence and variable x π(i) can not appear before x π(j) if i > j.An ordered binary decision diagram (OBDD) is a π-ordered binary decision diagram for some permutation π.Additionally, a binary decision diagram is called k-OBDD if every path from the source to a leaf can be split into at most k parts such that in each part the variables appears with respect to a fixed order π.
OBDDs have the following nice property: for every order of variables every Boolean function has a unique minimal OBDD.For a given order π, the minimal OBDD of a function f may be constructed in polynomial time from any π-ordered BDD for the same f .There are also known polynomial-time algorithms that efficiently perform the operations of conjunction, negation, disjunction, and projection (elimination of the existential quantifier) to π-ordered BDDs [17].There is an algorithm running in time polynomial in the size of the input and the output that gets as an input a π-ordered diagram A, a permutation ρ and returns the minimal ρ-ordered diagram that represents the same function as A [17].

Communication Complexity
In order to prove lower bounds on the size of an OBDD representation of a function we will use communication complexity.
Let f : {0, 1} n → {0, 1} be some function and Π = (Π 0 , Π 1 ) be a partition of [n] i.e.Π 0 ∪ Π 1 = [n] and Π 0 ∩ Π 1 = ∅.Two players Alice and Bob want to compute f (x) for some x.However, Alice knows only bits of x with indices from Π 0 and Bob knows bits of x with indices from Π 1 .In order to compute the value they can use a two-sided communication channel.They agreed in advance about a protocol; on each step of the protocol one of them send a bit string to another, at the end of the protocol both Alice and Bob should know f (x).The cost of the protocol is the maximal number of bits they sent to each other.The communication complexity of f with respect to the partition Π is equal to the minimal cost of the protocols for f (for the formal definition see [15]).
It is well-known that there is a connection between communication complexity and the minimal size of an OBDD representation.

Lemma 2.1 ([15]
).Let f : {0, 1} n → {0, 1} be a Boolean function, Π be a partition of [n].Then for any order π such that elements of Π 0 precedes elements of Π 1 in this order, any π-OBDD representation of f has size at least 2 C where C is equal to the communication complexity of f with respect to Π.
Moreover, the size of every π-k-OBDD representation of f is at least 2 C /2k.
Proof.Let us fix some π-k-OBDD representation D of f .Let us consider the path p in D from the source to a sink corresponding to the Alice and Bob's input x.
Since D is a k-OBDD, this path can be split into k parts so that in each part all variables appear according to the order π.This implies that the path can be split into 2k blocks so that in each block either all variables are known to Alice or all variables are known to Bob.
Let us show that Alice and Bob can find the sink of the path using 2k log |D| bits of communication.They do it in 2k rounds; starting from the source (which is known to both of them) they follow the path, and on each round one of the players sends to the other the name of the vertex where the current block ends; at the end, when one player reaches the sink, this player communicate the name of the sink to the other one.The value f (x) is determined by the sink vertex.Hence, the communication complexity of f is at most (2k + 1) log |D|.
In what follows, we will need to prove lower bounds on communication complexity.First of all we recall the technique of combinatorial rectangles.Let f : X × Y → {0, 1} be a function.We say that R = A × B is a 1-monochromatic rectangle for f iff A ⊆ X, B ⊆ Y , and for every a ∈ A and b ∈ B, f (a, b) = 1.We say that a sequence of rectangles R 1 , . . ., R ℓ is a partition of X × Y into 1-monochromatic rectangles iff • for every x ∈ X and y ∈ Y , f (x, y) = 1 iff (x, y) ∈ R i , for some i.Then the communication complexity of f with respect to Π is at least ⌊log ℓ⌋.
The Communication complexity of EQ n with respect to the partition Π is equal to n + 1.
Proof of Lemma 2.3.Let us assume that there is a communication protocol P for f of cost S.We are going to show that there is a protocol for EQ ⌊log ℓ⌋ of cost S and hence, by Lemma 2.4, S ≥ ⌊log ℓ⌋.
Let y be the binary representation of j and x be the binary representation of i.In order to check whether x = y, Bob finds a satisfying assignment τ for f | ρj .After that they run the protocol P for ρ i and τ .Note that if x = y, then ρ i = ρ j and τ satisfies f | ρi = f | ρj , i.e., f | ρiτ = 1; otherwise i = j and sets of satisfying assignments of f | ρi and f | ρj are disjoint, hence, f | ρiτ = 0.

OBDD proofs
If F is a formula in CNF, we say that the sequence D 1 , D 2 , . . ., D t is an OBDD-derivation of F if D t is an OBDD that represents the constant false function, and for all 1 ≤ i ≤ t, D i is an OBDD that represents a clause of F or can be obtained from the previous D j 's by one of the following inference rules: conjunction or join: D i is a π-ordered OBDD, that represents D k ∧ D l for 1 ≤ l, k < i, where D k , D l have the same order π; weakening: there exists a j < i such that D j and D i have the same order π, and D j semantically implies D i .The latter means that every assignment that satisfies D j also satisfies D i ; reordering: D i is an OBDD that is equivalent to an OBDD D j with j < i (note that D i and D j may have different orders).
We consider several different OBDD proof systems with different sets of allowed rules.When we need to denote some specific proof system, we indicate the rules specific for this system in brackets.For example, the OBDD(∧) proof system uses only conjunction rule and hence, we may assume that all OBDDs in a proof have the same order.We use the notation π-OBDD(∧) proof if all diagrams in this proof have order π.

OBDD algorithms for SAT
Pan and Vardi [19] proposed for the Boolean satisfiability problem the following family of algorithms based on OBDDs and the symbolic quantifier elimination.The algorithm gets as an input a CNF formula F , it chooses some order π on the variables and creates both a π-ordered OBDD D (which initially is equal to the constant true function) and a set of clauses S (which initially consists of all clauses of the formula F ).While S is not empty the algorithm applies one of the following three operations: join or conjunction delete some clause C from S and replace D by a π-ordered BDD that represents the conjunction D ∧ C; projection choose a variable x that has no occurrences in the clauses from S and replace D by a π-ordered BDD for the function ∃x D; reordering choose a new order on variables π ′ and replace D by the equivalent π ′ -ordered diagram.Assign π := π ′ .(Note that Pan and Vardi did not consider this rule in [19]).
After every step of the algorithm, the following invariant is maintained: F is satisfiable if and only if C∈S C∧D is satisfiable.After the termination of the algorithm the set S is empty; if the diagram D has a path from the source to a vertex labeled by 1, then the algorithm returns "Satisfiable" and returns "Unsatisfiable" otherwise.
We refer to the algorithms of this type as OBDD(∧, ∃, reordering) algorithms.Besides, we use a similar notation for algorithms that use some of the rules: we just enumerate the used rules in the brackets.For example, the OBDD(∧) algorithms use only the conjunction rule and the OBDD(∧, ∃) algorithms use only the conjunction and projection rules.
Since join and projection for OBDDs may be performed in polynomial time and reordering may be performed in time polynomial on the sizes of the input and the output, the running time of an OBDD(∧, ∃, reordering) algorithm are polynomially related with the total sum of the sizes of all values in the diagram D we ignore the time spent on choosing π and other operations with the permutation.

Error-correcting codes
By a code we mean a subset of binary strings with a fixed length.A code C ⊆ {0, 1} n has a relative distance δ if for any two codewords c 1 , c 2 ∈ C the Hamming distance between c 1 and c 2 is at least δn.
A linear code is a set of all n-bits vectors x = (x 1 . . .x n ) from some linear subspace in F n 2 .If k is the dimension of this space, then the ratio k/n is called the rate of the code.
A linear code can be specified by a system of linear equations.For a code of dimension k this system should consist of m ≥ n − k linear equations involving n variables.The set of all solutions of the system should give exactly our code, so the rank of the system must be equal to n − k.If we require in addition that the equations in the system are linearly independent, then the number of equations is equal to m = n − k.The matrix of this linear system is called a checksum matrix of the code.
For a checksum matrix (h ij ) over F 2 we say that a column i intersects a row j, if h ij = 1.Further, we say that a tuple of columns i 1 , . . ., i s intersects some row j if at least one of the columns i 1 , . . ., i s intersects row j.
We say that a code C recovers ρ fraction of erasures by a list of size L (or C is (ρ, L)-erasure list-decodable) if for any w ∈ {0, 1, ?} n such that the number of ? in w does not exceed ρn, there exist at most L elements in C that are consistent with w.A string s ∈ {0, 1} n is consistent with w if for all i, w i ∈ {0, 1} implies s i = w i .Theorem 2.5 ([12, Lemma 2]).If C is a code with relative distance δ, then for every ǫ > 0 the code C is ((2 − ǫ)δ, 2 ǫ )-erasure list-decodable.

Tseitin formulas
In this Section, we prove an exponential lower bound on the size of OBDD(∧, reordering) proofs of Tseitin formulas.
A Tseitin formula TS G,c is based on an undirected graph G = (V, E) with degree bounded by a constant d.Every edge e ∈ E has the corresponding propositional variable p e .There is a function c : V → {0, 1}, we call it the labelling function.For every vertex v ∈ V we write down a formula in CNF that encodes ).The conjunction of the formulas described above is called a Tseitin formula.If v∈U c(v) ≡ 1 (mod 2) for some connected component U ⊆ V , then the Tseitin formula is unsatisfiable.Indeed, if we sum up (modulo 2) all equalities stated in vertices from U we get 0 = 1 since every variable has exactly 2 occurrences.If In the following, we denote the number of connected components of a graph G by ♯G.
Theorem 3.1.Let graph G with vertices V and edges E have the following property: for some m ∈ [|E|] and k > 0 for all subsets E ′ ⊆ E of the size m the inequality ♯G ′ + ♯G ′′ ≤ k holds, where G ′ and G ′′ are graphs with vertices V and edges Proof.Let us fix an order π of the variables of TS G,c (i.e.π orders the edges of G).Let E ′ be the set of the first m edges in this order.We show that there are at least 2 |V |−k substitutions to the variables from E ′ such that applying each of these substitutions to TS G,c results in 2 |V |−k satisfiable functions with disjoint sets of satisfying assignments.Then due to Lemma 2.3, the communication complexity of TS G,c is at least , 1} be a labeling function that corresponds to a partial substitution with support E ′ : in every vertex v, c(v) is the sum modulo 2 of the values of all edges from E ′ that are incident to v. Note that making a partial substitution to a Tseitin formula TS G,c gives as the resulting formula again a Tseitin formula -some formula TS G ′′ ,c+c ′ , where G ′′ is a graph with vertices V and edges E \ E ′ , and c + c ′ is the sum of the functions c and c ′ modulo 2.
We will prove a lower bound for the number of different c ′ such that they can be obtained by a substitution and TS G ′′ ,c+c ′ is satisfiable.The required properties of c ′ can be described by a system of linear equations with variables c ′ (v) for v ∈ V : for every connected component U of graph G ′ with vertices V and edges E ′ we put down the equation: v∈U c ′ (v) = 0 (this subsystem states that c ′ can be obtained by a substitution or in other words that TS G ′ ,c ′ is satisfiable) and for each connected component W of G ′′ we put down the equation: v∈W c(v) + c ′ (v) = 0 (this subsystem corresponds to the satisfiability of TS G ′′ ,c+c ′ ).The system has a solution since TS G,c is satisfiable.There are |V | variables and at most ♯G ′ + ♯G ′′ ≤ k equations.Hence, there is at least 2 |V |−k solutions.Different solutions correspond to different satisfiable formulas TS G ′′ ,c+c ′ and thus their sets of satisfying assignments are disjoint.
We will apply Theorem 3.1 to algebraic expanders.Definition 3.2.A graph G with vertices V and edges E is an (n, d, α)-algebraic expander, if |V | = n, the degree of any vertex in V equals d and the absolute value of the second largest eigenvalue of the adjacency matrix of G is not greater than αd.
It is well known that for all α > 0 and all large enough constants d there exists a family G n of (n, d, α)algebraic expanders.There are explicit constructions such that G n can be constructed in poly(n) time [16].Also, it is known that a random d-regular graph is a good expander with high probability.

Lemma 3.3 ([1]
). (Expander mixing lemma) Let G(V, E) be an (n, d, α)-expander.For any two subsets S, T ⊆ V the following inequality holds: Proof.At first we prove the following proposition.
Proof.Assume for the sake of contradiction that there is a connected component C such that then the size of this component is greater than |V | 2 ; hence, there is at most one component with size at least 4|E ′ | d .Consider all other components.If the number of these components is at least 4|E ′ | d + 1, we choose several of them such that the total number of vertices in the chosen components is in the interval We denote the set of vertices in these components by T .Since T consists of several connected components in . Let S be a set of a vertices incident to E ′ .Note that if H is the graph with vertices S and edges E ′ then |V | − ♯G ′ = |S| − ♯H and the degree of each vertex of H is at least one.Hence, ♯H ≤ |S| 2 and Corollary 3.7.Let G be an (n, d, α)-algebraic expander with α < 1 32 and d ≥ 4. Assume that a Tseitin formula TS G,c is satisfiable.Then for every partition Π of the variables of TS G,c such that Proof.Follows from Theorems 3.1 and 3.5.
32 and d ≥ 4, and a Tseitin formula TS G,c is satisfiable, then every k-OBDD representing TS G,c has size at least 2 Ω(n) .
Proof.Follows from Corollary 3.7 and Lemma 2.1.Corollary 3.9.Let graph H n be obtained from an (n, d, α)-expander G(V, E) with α < 1 32 and d ≥ 4 by removing o(n) edges.If TS Hn,c is satisfiable, then every OBDD representation of TS Hn,c has size at least 2 Ω(n) .
Proof.Let M be a set of edges of 4d , and H ′ , G ′′ , H ′′ be graphs with vertices V and edges E ′ , M \ E ′ and E \ E ′ respectively.Obviously ♯H ′′ ≤ ♯G ′′ + o(n).By Corollary 3.8 size of an OBDD for TS Hn,c is at least 2
Lemma 3.11.Assume that all OBDDs representing a CNF formula φ have the size at least k.Assume that a CNF formula ψ can be obtained from φ by removing several clauses that are dependent on at most t variables in total.Then the size of any OBDD representing ψ is at least k2 −t−1 .
Proof.The conjunction of the removed clauses is a function of t variables, hence it can be represented as OBDD of size at most 2 t+1 for every order.Thus if ψ has OBDD representation of size less than k2 −t−1 by Lemma 3.10, then φ has OBDD representation of size k.
Lemma 3.12.Let G(V, E) be an (n, d, α)-algebraic expander with α < 1 20 and d ≥ 50.Then G is connected and it remains connected after removing of any vertex or any two vertices and the shortest path between them.
Proof.It is sufficient to prove that G is connected after removing any two vertices and the shortest path between them.Consider arbitrary two vertices x, y ∈ V and consider an arbitrary set S ⊆ V \ {x, y} such that |S| ≤ |V \ ({x, y} ∪ S)|.We will show that there is v ∈ S such that E({v}, V \ ({x, y} ∪ S)) ≥ 3.This will imply that after removing x and y and the shortest xy-path from G the resulting graph is connected.Indeed if it is not connected, then we get a contradiction for S that is equal to the smallest connected component.In this case the shortest xy-path may contain at most 2 edges incident to v, hence, there is an edge that goes from S to V \ ({x, y} ∪ S). 32 .Let Tseitin formula TS G,c be unsatisfiable and Φ denote the formula that can be obtained from TS G,c by removing one arbitrary clause.Then Φ is satisfiable and every OBDD representation of Φ has the size 2 Ω(n) .
Proof.Assume that TS G,c = Φ ∧ C, where C is a clause that corresponds to the equation in a vertex v. Let H be the result of removing the vertex v from G. By Lemma 3.12 the graph H is connected.Let us make a substitution to all variables of the clause C that falsifies C. Let Φ ′ denote the result of this substitution applied to Φ. Since the substitution falsifies the parity condition at the vertex v, Φ ′ corresponds to a satisfiable Tseitin formula based on H.By Corollary 3.9 the size of every OBDD for Φ ′ is at least 2 Ω(n) .(Formally we apply Corollary 3.9 to the graph H with one additional isolated vertex v.Note that a Tseitin formula does not change if we add isolated vertex to the graph).Φ ′ is the result of the substitution applied to Φ, hence, the size of every OBDD representing Φ is at least 2 Ω(n) .Theorem 3.14.Let G be an (n, d, α)-algebraic expander with d ≥ 50, α < 1 32 .
Then any OBDD(∧, reordering) proof of any unsatisfiable Tseitin formula TS G,c has the size at least 2 Ω(n) .
Before we present the formal proof of the theorem let us sketch the argument.We consider the last step of the OBDD proof: the conjunction of OBDDs F 1 and F 2 is the identically false function but both F 1 and F 2 are satisfiable.Both F 1 and F 2 are conjunctions of several clauses of TS G,c .We use the fact that a satisfiable Tseitin formula based on an expander has only exponential sized OBDDs.Moreover, if the underlying graph differs from some expander by o(n) edges, then any of its OBDD representations has also an exponential size, since the number of connected component of graphs G ′ and G ′′ in Theorem 3.5 changes by at most o(n).
Note that F 1 and F 2 together contain all clauses of TS G,c .The main case is the following: there are two nonadjacent vertices u and v such that F 1 does not contain a clause C u that corresponds to the vertex u and F 2 does not contain a clause C v that corresponds to v. We consider two partial substitutions ρ 1 and ρ 2 that are both defined on the edges adjacent to u and v and on the edges of a fixed shortest path p between u and v.The substitutions ρ 1 and ρ 2 assign opposite values to edges of the path p and are consistent on all other edges.The substitution ρ 1 satisfies C v and refutes C u and ρ 2 satisfies C u and refutes C v .
By the construction ρ2 is a satisfiable Tseitin formula based on the graph that is obtained from G by deletion of the vertices u and v and all edges from the path p (it is also possible that this formula does not contain some clauses for the vertices from p).The size of an OBDD representation of such a formula is exponential since the underlying graph is obtained from an expander by removing at most o(n) vertices.(Note that p is the shortest path in the expander, thus p contains at most O(log n) edges.)Hence, we get that either F 1 or F 2 has an exponential size in the given order.clause of TS G,c is either in F 1 or in F 2 since otherwise F 1 ∧ F 2 is satisfiable by Lemma 3.13.Our goal is to prove that either F 1 or F 2 has size 2 Ω(n) .
We consider two cases: 1.There exist two non-adjacent vertices u and v from G such that F 1 does not include some clause C v that corresponds to vertex v and F 2 does not include some clause C u for vertex u.
Consider a shortest path p from v to u.Let e v be the first edge of p and e u be the last edge (e v = e u since u and v are non-adjacent).Consider two substitutions ρ 1 and ρ 2 with the same support: all edges that are incident to u or v and all edges from p. Substitutions ρ 1 and ρ 2 are consistent on edges that are out of p: all edges that are adjacent to u or v but not in p have values that do not satisfy C u and C v (this is possible since u and v are non-adjacent).ρ 1 substitute zeros to all edges from p except e u and e v and substitute a value to e v that does not satisfy C v and a value to e u that satisfies C u .ρ 2 substitute ones to all edges from p except e u and e v and substitute a value to e v that satisfies C v and a value to e u that does not satisfy C u .So edges from p have different values in ρ 1 and ρ 2 ; ρ 1 satisfies u and refutes v and ρ 2 refutes u and satisfies v.
Consider the graph G ′ that can be obtained from G by removing u, v and all edges from the path p.
The graph G ′ is connected since by Lemma 3.12 after removing any two vertices with the shortest path between them the graph G remains connected.
Let c ′ be a labeling function of the result of the substitution ρ 1 applied to TS G,c and c ′′ be a restriction of c ′ on V \ {u, v}.Note that ρ 2 corresponds to the same c ′′ since ρ 1 and ρ 2 identically change the value of the labelling function for all vertices except u and v.We claim that TS G ′ ,c ′′ is satisfiable.Indeed if we make a substitution ρ 1 to TS G,c the vertex v would be refuted (it has no edges and it is labeled by 1), the vertex u would be satisfied (it has no edges and it is labeled by 0), all other vertices are marked according c ′ .Thus the sum of values of c ′′ is even and We consider the conjunction as a conjunction of clauses.For every vertex w that is not in p, the union of clauses of F 1 and F 2 contains all clauses that correspond to the equation at vertex w, substitutions ρ 1 and ρ 2 are consistent for all variables from this equation, hence, F 1 | ρ1 ∧ F 2 | ρ2 contains all clauses that correspond to the equation of vertex w in formula TS G ′ ,c ′′ .Consider a vertex w from p (w / ∈ {u, v}).Let ρ 1 and ρ 2 substitute some values to variables x and y that correspond to w.Note that by the construction ρ 1 (x) + ρ 1 (y) = ρ 2 (x) + ρ 2 (y).Hence, each of F 1 | ρ1 and F 2 | ρ2 contains several clauses from the equation that corresponds to w in TS G ′ ,c ′′ .And it is not necessary that F 1 | ρ1 ∧ F 2 | ρ2 contains all clauses from the equation that correspond to w.Finally, F 1 | ρ1 ∧ F 2 | ρ2 can be obtained from TS G ′ ,c ′′ by the removing of several clauses corresponding to the vertices from the path p.It is well known that the diameter of any (n, d, α)-expander is O(log n), hence, p contains at most O(log n) vertices.
The size of any OBDD representation of the formula TS G ′ ,c ′′ is at least 2 Ω(n) by Corollary 3.9, since G ′ can be obtained from an (n, d, α)-algebraic expander by the removing of O(log n) edges (formally we add two isolated vertices u and v to G ′ ; adding isolated vertices does not change Tseitin formulas).Then by Lemma 3.11, any OBDD representing F 1 | ρ1 ∧ F 2 | ρ2 has the size at least 2 Ω(n) .Thus, by Lemma 3.10, for every given order of variables π either F 1 | ρ1 or F 2 | ρ2 has the size of the minimal π-OBDD at least 2 Ω(n) .Hence, the minimal π-OBDD for F 1 or F 2 has the size of the at least 2 Ω(n) .
2. In the second case there are no such non-adjacent vertices.Since F 1 is not identically false, there exists a vertex u such that F 1 does not include a clause that corresponds to a vertex u and by the assumption F 2 does not include clauses only for the vertex v and its neighbors.In this case F 2 differs from a Tseitin formula without one clause by a constant number of clauses that depend on a constant number of variables.Thus any OBDD representation of F 2 by Lemmas 3.13 and 3.11 has size at least 2 Ω(n) .

Pigeonhole principle
In this section we consider formulas that encode the pigeonhole principle and prove an exponential lower bound on the size of OBDD(∧, reordering) proofs of them.Let m and n be integers and p i,j be different variables; p i,j states whether the ith pigeon is in the jth hole or not.The formula PHP m n has two types of clauses.The clauses of the first type (long clauses) state that every pigeon is in at least one hole: 96 , the communication complexity of PHP n n with respect to Π at is least Ω(n).
Proof.Let us fix some partition of variables Π such that |Π 0 | = n 2 96 .Consider a bipartite graph G(L, R, E) with two parts L and R associated with [n] and the set of edges E associated with Π 0 , i.e., (i, j) ∈ E iff p i,j ∈ Π 0 .Let G ′ (L, R, E ′ ) be the complement bipartite graph, i.e., . ., v n be the vertices of R ∪ L sorted by decreasing of their degrees in G: Note that every vertex from B is connected with at least 2k vertices outside of B.
Let M be the set of all matchings of size k that cover B and do not connect two vertices from B. Let us prove that |M| ≥ (2k)! k! .Note that the number of possibilities for the ith vertex from B to find a pair is at least 3k − |B| − (i − 1) = 2k − i.Hence, there are at least (2k)!k! matchings of this type.So there are at least k different sets that are sets of endpoints of matchings from M. For every M ∈ M we define a partial substitution ρ M with the support Π 0 such that ρ M (p i,j ) = 1 if (i, j) ∈ M and ρ M (p i,j ) = 0 if (i, j) ∈ E \ M .We claim that PHP n n | ρM is satisfiable for all M ∈ M. Let V (M ) denote the set of endpoints of edges from M .PHP n n | ρM is satisfiable if the graph G ′ − V (M ) (which is obtained from G ′ by removing of all vertices from M ) has a perfect matching.Since M is a matching, G ′ has the same number of vertices in its parts.We are going to use Hall's theorem to show that G ′ − V (M ) has a perfect matching.To this end we have to show that every set A ⊆ L \ V (M ) has at least |A| neighbors in G ′ .Consider two cases: in the first case |A| ≤ n 2 and every vertex from A has degree at least In the second case |A| > n 2 .We need to show that every vertex from R \ V (M ) has a neighbor in A and thus the number of neighbors of A is precisely Corollary 3.16.For every fixed constant k, every k-OBDD-representation of PHP n n has size at least 2 Ω(n) .
Proof.We consider the last step of the OBDD proof: the conjunction of OBDDs F 1 and F 2 is the identically false function but F 1 and F 2 are satisfiable.Both F 1 and F 2 represent conjunctions of several clauses of PHP n+1 n and have the same order π.Every clause of PHP n+1 n is either in F 1 or in F 2 since otherwise F 1 ∧ F 2 is satisfiable.Our goal is to prove that either F 1 or F 2 has size 2 Ω(n) .
We consider three cases and apply Corollary 3.16 in each of them: 1. Assume that there exist an i 1 ∈ [n + 1] and an i 2 ∈ [n + 1] (i 1 = i 2 ) such that F 1 does not contain a long clause that corresponds to i 1 and F 2 does not contain a long clause that corresponds to i 2 .Let us fix any j ∈ [n] and consider substitutions ρ 1 and ρ 2 with the support that substitute zero to all variables with two exceptions: ρ 1 (p i2,j ) = 1 and ρ 2 (p i1,j ) = 1.Note that the Boolean function n−1 and thus by Corollary 3.16 the π-OBDD representation of F 1 | ρ1 ∧ F 2 | ρ2 is of size at least 2 Ω(n) .Hence, either F 1 or F 2 has size of its minimal π-OBDD at least 2 Ω(n) .
2. Assume that there are i 1 , i 2 ∈ [n + 1], j ∈ [n] and i ∈ [n + 1] such that F 1 does not contain the short clause (¬p i1,j ∨ ¬p i2,j ) and F 2 does not contain a long clause that corresponds to i.
Let us consider two sub-cases.
• In the first case i ∈ {i 1 , i 2 }.Let us fix any j ′ ∈ [n] \ {j} and consider substitutions ρ 1 and ρ 2 with the support that substitute zero to all variables with five exceptions: . Hence, either for F 1 or for F 2 , the size of its minimal π-OBDD at least 2 Ω(n) .

OBDD(∧, reordering) is stronger than OBDD(∧)
In this section we give an example of a family of unsatisfiable formulas Φ n that have OBDD(∧, reordering) proofs of polynomial size while all OBDD(∧) proofs of it have size at least 2 Ω(n) .Theorem 4.1.Let Ψ n (x 1 , x 2 , . . ., x n ) be a family of unsatisfiable formulas of size poly(n) that satisfies the following conditions: • there exists an order τ such that Ψ n has τ -OBDD(∧) refutation of size poly(n); • there exists a polynomial p(n), an integer k ≤ log(p(n)) and permutations σ 1 , σ 2 , . . ., σ 2 k ∈ S n such that for any permutation π ∈ S n there exists i ∈ [2 k ] such that any πσ i -OBDD(∧) proof of Ψ n has size at least 2 Ω(n) .
Let us consider the following sketch of the proof, before we give a complete proof of this theorem.The lower bound.Consider an OBDD(∧) proof T of the formula Φ n , let τ be the order of the variables x 1 , x 2 , . . ., x n that is induced by the order from T .By the statement of the theorem, there exists 1 ≤ i ≤ 2 k such that all (τ σ i )-OBDD(∧) proofs of Ψ have at least the exponential size.We make a substitution w = i−1 to the proof T .This substitution converts the proof of Φ n into a proof of Ψ n with the order τ σ i .Hence, T has the exponential size.
The upper bound.Since there exists a polynomial sized OBDD(∧) proof of Ψ n , then for all i there is an order π i (we may assume after the permutation π the variables w get the leftmost positions) such that there is a π i -OBDD(∧) derivation of the diagram representing w = i − 1.From all such diagrams for different i we may construct a polynomial sized refutation of Φ n , since w contains only O(log n) variables.
In other words, µ i orders variables as follows: It is easy to see that this derivation may be transformed into a µ i -OBDD(∧) derivation of a diagram that represents w = i from the formula (w = i) → Ψ(x σi(1) , x σi(2) , . . ., x σi(n) ).Indeed, the variables w 1 , w 2 , . . ., w k in the order µ i appear in the beginning, hence, every diagram D from the original proof will be transformed to a diagram that represents D∨¬(w = i) and the latter diagram has size at most |D| + O(k), where |D| is size of the diagram D.
So we have all diagrams that represent w = i for all i ∈ [2 k ].Formally these diagrams use different orders µ i but in fact the diagrams depend essentially only on the variables w 1 , w 2 , . . ., w k , and all µ i order them in the same way.Thus, if we change orders in all of these diagrams to some "standard" one, the diagrams will be not changed.Then we apply the conjunction rule to these diagrams and get a constant false diagram since w 1 w 2 . . .w k is a binary representation of i − 1 for some i ∈ [2 k ].All intermediate diagrams have size at most 2 k poly(n).Hence, we get a proof of size poly(n).Now we construct a family of unsatisfiable formulas Ψ n that satisfies the conditions of Theorem 4.1.We use an argument similar to the proofs of the lower bounds for OBDD(∧, reordering) proofs.At first, we construct a function that has sizes of OBDD representations in different orders close to the required sizes of proofs for Ψ n .
The proof of the following lemma is similar to the proof of the Ω(n) lower bound on the best communication complexity of the shifted equality function [15,Example 7.9].Lemma 4.3.Let σ i for i ∈ [n] be a permutation such that σ i (j) = j for j ∈ [n] and σ i (n + j) = n + (i + j − 1 mod n) + 1 for j ∈ [n].Then for any balanced partition Π = (Π 0 , Π 1 ) of 2n variables x 1 , . . ., x 2n there exists i ∈ [n] such that communication complexity of EQ n with respect to σ i Π is at least Ω(n), where Claim 4.3.1.Communication complexity of EQ n with respect to a partition Γ is at least then EQ n (v 1 , . . ., v 2n ) = EQ(x 1 , . . ., x ℓ1+ℓ2 , . . ., x 2(ℓ1+ℓ2) ).Since Alice and Bob can independently compute v 1 , . . ., v n and v n+1 , . . ., v 2n , respectively, we prove that communication complexity of EQ n with respect to a partition Γ is at least If for some i ∈ [n] size |B Πσi | ≥ n 32 , then by Claim 4.3.1,communication complexity of EQ n with respect to Πσ i is at least n/32.Assume that for all i the following holds: we get Corollary 4.4.Let σ i for i ∈ [n] be a cyclic permutation of variables y that maps y j to y i+j mod n+1 for any j ∈ Then for any order π on 2n variables there exists i ∈ [n] such that every πσ i -OBDD representation of EQ n has size at least 2 Ω(n) .Now we are ready to construct a formula that may be used in Theorem 4.1.Consider a formula Ψ n (x, y, z) from 3n + 1 variables (here x, y are vectors of n variables and z is a vector of n + 1 variables) that is the conjunction of CNF representations of the following conditions: Note that Ψ n (x, y, z) is unsatisfiable since we have that x i = y i for all i; it implies that z i = 1 for all i, but z n should be zero.The following statement is straightforward.Proposition 4.5.Ψ n has a proof of polynomial size in the order z 0 , x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , . . ., x n , y n , z n .Proposition 4.6.Ψ n (x, y, z) is minimally unsatisfiable, i.e., it becomes satisfiable after removing any of its clauses.
Proof.We consider 3 cases.
1.If we remove the clause ¬z n (or z 0 ), then identically 1 (or identically 0) assignment satisfies all other clauses.
2. If we remove a clause that represents x i = y i (w.l.o.g.assume that this is the clause ¬x i ∨ y i ), then we assign x j = 1 for all j, y j = 1 for all j = i, y i = 0 and z j = 1 for j < i and z j = 0 for j ≥ i.
3. If we remove a clause that represents (x i = y i ) → (z i−1 → z i ) (w.l.o.g.assume that this is the clause x i ∨ y i ∨ ¬z i−1 ∨ z i ), then we assign x j = y j = 0 for all j ∈ [n] and z j = 1 for j < i and z j = 0 for j ≥ i.
Lemma 4.7.For any order π on the variables x, y, z size of a π-OBDD(∧) proof of Ψ n is at least 1 10 √ S, where S is the size of the shortest π ′ -OBDD representation of EQ n (x, y), where π ′ is the order induced by π on the variables x, y.
Proof.Assume that in the last step of the proof we apply the conjunction operation to F 1 and F 2 and get a contradiction.By Proposition 4.6, Ψ n is minimal unsatisfiable; hence, every clause of Ψ n was joined either to F 1 or to F 2 .F 1 and F 2 are not identically false functions.By the argument similar to the proof of Proposition 4.6 there exists a satisfying assignment τ 1 for F 1 and there exists a set I 1 ⊆ [n] of size at least (n − 1) such that for all i ∈ I 1 the values of variables τ 1 (x i ) = τ 1 (y i ).Moreover, if for arbitrary set J ⊆ I 1 we simultaneously change values of variables x j and y j for j ∈ J, then τ 1 remains satisfiable.Let ρ 1 be a partial substitution that does not substitute values for x i and y i for i ∈ I and for all other variables it is consistent with τ 1 .We define I 2 and ρ 2 analogously.Let us consider the function F 1 | ρ1 ∧ F 2 | ρ2 ; it contains all clauses of EQ n (x, y) that have occurrences of x i and y i for i ∈ I 1 ∩ I 2 and possibly several remaining clauses of EQ n (x, y).Hence, EQ n (x, y) can be obtained from F 1 | ρ1 ∧ F 2 | ρ2 by addition of at most four clauses, and each of them depends on two variables.Hence, S (recall that S is the shortest π ′ -OBDD representation of EQ n (x, y)) is at most 100 times the size of any π ′ -OBDD representation of F 1 | ρ1 ∧ F 2 | ρ2 .Therefore, an π-OBDD-representation of either F 1 or F 2 has size at least 1 Proof.By Lemma 4.7 for every order π a size of π-OBDD(∧) proof of Ψ n is at least 1 10 √ S, where S is the size of the shortest π ′ -OBDD representation of EQ n .By Lemma 4.4 there exists a family of permutations σ i of [2n] for i ∈ [n] such that for every order τ there exists an i ∈ [n] such that size of any τ σ i -OBDD(∧) proof of Ψ n is at least 2 Ω(n) .By Proposition 4.5 there exists a required order τ and a τ -OBDD(∧) proof of Ψ n of size poly(n).Theorem 4.1 gives a construction of the desired formula Φ n .
Informally the proof of this theorem is the following.Notice that the projection of two linear equations over the common variable is just the sum of these equations.Since every variable has exactly two occurrences in Tseitin formulas, we can sum up all equations in every connected component.
1.If S = ∅, choose C ∈ S and apply join operation; otherwise goto Step 5.
2. If D depends on some variable x, apply join operation to all clauses in S that depend on x.
3. Apply projection operation over variable x.We prove that this algorithm solves Tseitin formulas in polynomial-time.We note that after Step 2 the current diagram D represents the conjunction of two linear equations and after Step 3 the current diagram D represents one linear equation.Indeed every variable of Tseitin formula has occurrences in exactly two equations.And the projection of two linear equations over the common variable is just the sum of this equations.
It is easy to see that the algorithm chooses a connected component of the graph and sums up all equations from this component.If the component is unsatisfiable the algorithm stops and return 0; otherwise it goes to the next component.Finally if all components are satisfiable it returns 1.
Any OBDD that represents one linear equation have linear size.We need to check that if we join to D a subset of clauses representing linear equation we still have small diagram.Consider some equation from a Tseitin formula that depends on d variables, the maximum size of OBDD for the subset of clauses has size at most 2 d+1 − 1 (the size of a decision tree).The size of any CNF representation of a linear equation is at least 2 d−1 .Hence, the OBDD size of conjunction of the clauses is less than the size of the formula multiplied by 4. Now we show that every OBDD for a characteristic function of a good enough code has at least exponential size.
The case where the algorithm applies the projection operator less than n/6 times is analogous, we have to consider the last diagram D.
In what follows we show that there exist linear codes matching the requirements of Theorem 5.3.In Section 6.1 we prove the existence of suitable codes; in Section 6.2 we prove a stronger statement and show that the required codes can be constructed explicitly.These constructions of codes together with Theorem 5.3 imply the following result: Corollary 5.5.For all large enough n there exists a CNF formula with n Boolean variables, of size O(n) such that every OBDD(∧, ∃, reordering) algorithm runs on this formula at least 2 Ω(n) steps.Moreover, for a given n such a formula can be constructed by a deterministic algorithm in time poly(n).

Constructions of suitable linear codes 6.1 A randomized construction of suitable linear codes
We are going to combine Theorem 5.3 with some specific constructions of codes.In this section we describe a construction of low-density parity codes (LDPC) that can be combined with Theorem 5.3.The idea of low-density parity codes goes back to Gallager [10].The LDPC are linear codes whose checksum matrix are "sparse", i.e., contains few ones in each row and each column.We employ the standard properties of the LDPC -a randomly chosen matrix (with suitable parameters) with high probability defines a linear code with large enough distance.We also employ a somewhat less conventional property of LDPC: most of these codes share some property of "uniformity"; that is, even a rather small set of variables must be involved in almost all checksums of the code.
First of all we recall the classic construction of random LDPC from [10].Let us fix some integer parameters t, r, and n (assuming that t divides n).Define the "basic" matrix A of size (n/t) × n as a concatenation of t copies of the identity matrix (n/t) × (n/t): Notice that each column of A contains one non-zero element; in each row of A there are exactly t non-zero elements.Further, we consider the family of all matrices of size (rn/t)×n that consist of r horizontal "blocks" of size (n/t) × n, where each block is obtained as a permutation of columns of A, It is easy to see that in each column of this matrix there are r ones, and in each row there are exactly t ones.We introduce the uniform distribution on all matrices of this type.We can interpret these matrices as checksums matrices of some linear codes.Gallager proved that most of these codes have rather large minimal distance.
Proposition 6.1 (see [10]).Most (say, at least 90%) of matrices in Gallager's family define a linear code with parameters approaching Gilbert-Varshamov bound.More precisely, for every δ ∈ (0, 1 2 ) and for every t there exists r = r(t) such that for large enough n most matrices from the defined family have minimal distance ≥ δn.Moreover, the ratio r(t)/t approaches h(2δ) as t goes to infinity, where h(x) = −x log x − (1 − x) log(1 − x) (the binary entropy).This means that the rate of the code can be made arbitrarily close to 1 − h(2δ) (i.e., to the Gilbert-Varshamov bound).
A family of linear codes defined above can be specified by parameters r, t, n.However, it is more convenient to specify these codes by another triple of numbers -by (δ, t, n) (assuming that the value r = r(δ, t, n) is defined implicitly as the minimal integer such that most codes of the family have minimal distance greater than δn).Now we can state the main technical lemma of this section.Lemma 6.2.For all β ∈ (0, 1), γ < 1, and δ ∈ (0, 1  2 ), for all large enough t most (say, at least 90%) of linear codes from Gallager's family with parameters (δ, t, n) satisfy the following property: every βn columns in the checksum matrix of the code intersect at least a fraction γ of all rows of the matrix.
Proof.By construction, every checksum matrix from Gallager's codes family consists of r blocks of size (n/t) × n (where each if these blocks is a permutation of columns of the basic matrix A defined above).Let us fix some real ρ > 0. We say that some tuple of βn columns is poor for some block of the matrix, if these columns intersect with at most ρ • (n/t) rows of the block.We will proceed as follows.
Step 1.We estimate the probability of the event that one fixed tuple of βn columns is poor for a randomly chosen block (which is obtained as a random permutation of columns in A).
Step 2. We estimate the probability that one fixed tuple of βn columns is poor for more than ρr randomly chosen blocks.
Step 3. At last, we estimate the probability that at least one tuple of βn columns is poor for more than ρr (independently) randomly chosen blocks.
We are going to show that the probability estimated on Step 3 becomes very small for a suitable t.It follows that for most Gallager's codes, every tuple of βn columns intersects all but 2ρrn/t rows (one fraction of ρ rows comes from all blocks where these columns are poor, and another fraction of ρ rows comes from all other blocks).We can choose ρ so that 1 − 2ρ > γ, and the Lemma will follow.Thus, it remains to bound the probabilities in Steps 1-3.
Step 1: We fix some tuple of βn indices of columns, then take a random permutation of columns in a matrix A and count the total number of intersected rows.These random procedure can be equivalently explained in other words: we fix the original matrix A and choose at random a tuple of βn columns.By the construction of the matrix A, every column from the chosen tuple intersects with only one row.We need to estimate the number of rows that intersect with at least one of these βn columns.We have to show that for βn ≫ n/t a "typical" tuple of columns i 1 , . . ., i βn intersects with almost all rows.Let us estimate the probability of the "bad" event, when the randomly chosen columns intersect with only s ≤ (1 − ρ)(n/t) rows.This bad event means that we can select s positions in the sequence of indices 1, . . ., βn so that (i) the s columns with "selected" indices i l1 , . . ., i ls intersect pairwise different rows of the matrix A, and (ii) each of the other (βn−s) columns intersects once again the same row as one of the s "selected" columns.
Probability of this event is not greater than Indeed, for each s we have βn s ways to choose s indices in the list 1, . . ., βn.When the positions of the s "selected" columns are fixed, every next randomly chosen column intersects with with one of the previously counted rows with a probability less than [columns intersecting with given s rows] [total number of columns] = s • t n < 1 − ρ.
For a fixed ρ and (n/t) ≪ βn, the sum (1) is less than 2 −cβn , where c > 0 depends on ρ (and not on n).
Step 2: Let us fix some tuple of βn columns.At Step 1 we proved that the probability to get one poor block is p n < 2 −cβn .Since all r blocks in the checksum matrix are chosen independently, the probability that at least k = (1 − ρ)r of them are poor for the fixed columns is less than r k • (p n ) k ≤ 2 r • 2 −cβkn .As we increase t, the corresponding values of r = r(t) and k(t) = (1 − ρ)r(t) grow linearly.It follows that 2 r • 2 −cβkn decreases as 2 −Θ(βtn)+O(t) (the multiplicative constants hidden in the terms Θ(βtn) and O(t) depend on ρ but not on t).
Step 3: It remains to multiply the probability from Step 2 by the number of all tuples of βn columns.We get the bound n βn • 2 −Θ(βtn)+O(t) = 2 h(β)n+o(n) • 2 −Θ(βtn)+O(t) for the probability that at least one tuple of βn columns intersects too few rows.It remains to choose a suitable t = t(β) and make this probability less than 0.1.Corollary 6.3.For the distribution defined above, the system of linear equations Hx = 0 with probability close to 1 can be represented as a CNF of size O(n).
Thus, we obtain a weak version of Corollary 5.5 (without the moreover part) for CNF of size O(n) with n Boolean variables.In other words, for every N there exists a CNF formula of size N such that every OBDD(∧, ∃) algorithm runs on this formula at least 2 Ω(N ) steps.In the next section we prove a similar result for an explicitly constructed code.

An explicit construction of suitable linear codes
In this section we present an explicit construction of a linear code with the property of list decoding and a check-sum matrix that is sparse and strongly mixing.More technically, we construct explicitly a code that enjoys the properties from Proposition 6.1 and Lemma 6.2 (in the previous section we proved that this property holds with high probability for randomly chosen code from Gallager's family of linear codes).

The large-scale scheme of the construction
Our aim is to construct an explicit family of linear codes with the properties discussed in the previous section.To be more specific, we fix a triple of real parameters (α, β, γ) and define four properties of a linear code (more precisely, we define properties of a checksum matrix of a linear code).
(G) The number of codewords matching this matrix is equal to 2 Ω(n) (the code is asymptotically good).
(S) Sparseness: every row contains only O(1) ones (the other matrix elements are zeros) (L) List decoding: for every set of αn positions in a codeword and for every assignment of bits b j to these positions, there exist at most O(1) codewords x = (x 1 , . . ., x n ) corresponding to this checksum matrix such that x ij = b j for j = 1, . . ., αn.
(M) Mixing: For every set of βn columns (between the 1-st and the n-th) there exist ≥ γn rows of the matrix intersecting at least one of these columns with 1.
Now we can formulate the main result of this section.
Theorem 6.4.For any values of parameters α > 0, β > 0, and γ < 1 there exists a polynomial-time computable algorithm that finds for inputs n from a dense enough sequence of integers n (technically, for an arithmetic series of n) a (binary) checksum matrix M n of size n × k(n) (with n columns and k(n) linearly independent rows) that satisfies the conditions (G), (S), (L), and (M).
Together with Theorem 5.3 this statement implies Corollary 5.5.Indeed, to prove Corollary 5.5 it is enough to take the natural representation of the linear system constructed in Theorem 6.4.
In the proof of Theorem 6.4 we prefer to use instead of (L) another property that can be defined in terms of the code distance: (L ′ ) Code distance: the distance between every two codewords in the code is ≥ ( 1 2 − δ)n.Notice that (L ′ ) implies (L) due to Theorem 2.5.Thus, to prove the theorem it is enough to provide an explicit construction of codes that satisfy (G), (S), (L ′ ), and (M).Also for some technical reason we will need in the proof a stronger version of (M) with some suitable parameter q > 0: (M ′ ) Strong mixing: for every set of βn columns there exist ≥ γn rows of the matrix intersecting at least q of these columns with 1.
The rest of this section is organized as follows.In Section 6.2.2 we explain an explicit construction of a code that satisfies (L ′ ).In Section 6.2.3 we explain an explicit construction of a code that satisfies (M ′ ).In Section 6.2.4 we merge these two constructions.At last, in Section 6.2.5 we briefly discuss the explicit construction of algebraic expanders involved in the previous sections.

A code with a very high distance.
Our construction is iterative: we start with some asymptotically good explicitly constructed linear code and then amplify its parameters by iterating O(1) times some transformation of this code, as explained below.
The starting point of our construction is an asymptotically good linear code with the code length N and code distance ρN for some constant ρ > 0. For instance, we can take the explicit construction of expander codes suggested by Zémor, [25].So far we only assume that ρ > 0 (so the code distance can be much less than N/2).In what follows we apply (O(1) times) to this code some amplification procedure.Each iteration of this procedure • extends the length of codewords by some constant factor, • does not change the number of codewords, • makes the code distance closer to 1/2 of the code length.
The amplification procedure decreases the rate of the code by some constant factor.However, the code remains asymptotically good.After O(1) iteration of this procedure we will obtain a code that satisfies properties (G), (S), and (L ′ ).At this stage we cannot guarantee the property (M) (to achieve (M) we will need some more work, see the next section).To "amplify" a code with the length N and the distance ρN we will use an (explicitly constructed) expander graph G = (V, E) on N vertices, with the following property of strong ε-expansion: For every set of vertices S ⊂ V of size ≤ ( 1 2 − ε)n the number of neighbors of this set (i.e., the number if vertices w ∈ V that are connected by an edge with at least on vertex v ∈ S) is not less that (2 + ε)|S|.Remark: A graph with the property of strong ε-expansion can be easily constructed from any algebraic expander with parameters (N, d, 1/2).It is enough to add a loop to each vertex and then take a suitable degree r of this graph.In other words, the edges of the new graph are paths of length ≤ r in the initial algebraic expander.The less is the value of ε, the bigger length of the path r = r(ε) we need to take, and the bigger is the degree of the resulting graph.However, for every constant ε we obtain a graph with the property of strong ε-expansion and some degree D = D(ε), which does not depend on N .We may assume that ε is less than the value of δ from (L ′ ).In what follows we describe the amplification procedure.We assume that we are given a linear code C with the code length N and the code distance ρN .We fix some one-to-one correspondence between the bits of the codewords of C (i = 1, . . ., n) and the vertices of a graph G (with N vertices, of some degree D) with the property of strong ε-expansion defined above.In what follows we transform C into a code C ′ , and then into another code C ′′ .The last one will be the required "amplified" code.
The first stage of the amplification: from C to C ′ .We construct a new code C ′ where each codeword will consist of N ′ := DN bits, with the distance ρN ′ (i.e., the relative code distance in the new code C ′ is the same as in the original code C).The bits of the codeword in C ′ correspond to the ends of edges in the graph G (in a uniform graph of degree D with N ′ vertices we have DN/2 edges, and each edge has 2 ends).
The transformation from C to C ′ is quite trivial: we place the bits a codeword x = (x 1 , . . ., x N ) from C to the corresponding vertices (v 1 , . . ., v N ) of G, and then rewrite the value of each bit x i to the opposite ends of the edges (v i , v j ) incident to v i .In other words, for each edge (v i , v j ) of the graph we assign the bits x i and x j from the codeword x to the opposite ends of this edge (x i is assigned to the end incident to v j , and x j is incident to the end incident to v i , see an example in Fig. 1).
Thus, we essentially duplicate D times each bit of a codewords and then redistribute these values between the ends of the edges of G.
The second stage of the amplification: from C ′ to C ′′ .We construct another code C ′′ , where each codeword consists of N ′′ := 2 D N bits.To transform a codeword of C ′ in a codeword of C ′′ , we split the codeword in blocks of D bits corresponding to the ends of edges incident to one vertex.Then we separately encode each of these blocks by the Hadamard code.(In fact, instead of the Hadamard code with the relative code distance 1/2 we could take any other linear code with the relative code distance close enough to 1/2).
Let us estimate the distance of C ′′ .The distance of the initial code C is equal to ρN , so every non-zero codeword x in this code contains at least ρN ones.If ρ < 1 2 − ε, then in the corresponding codeword x′ in C ′ contains ≥ (2 + ε)ρN blocks (with D bits in each block) that involve at least one non-zero bit.By applying the Hadamard code we obtain a codeword x′′ in C ′′ with ≥ (2 + ε)ρN non-zero blocks of size 2 D , where each of these blocks contains exactly D/2 zeros and D/2 ones.Hence, the code distance of C ′′ is not less than Thus, we have "amplified" the relative code distance from ρ to 1 + ε 2 ρ.This described amplification procedure does not change the number of codewords in a code, and increases the code length by a constant factor.Hence, if the original family of codes C is asymptotically good, then the amplified codes C ′′ are also asymptotically good.
What is the structure of the checksum matrix of the new code?W.l.o.g.we may assume that the Hadamard code is systematic, so each bit of a codeword of C is just transferred to some position of the amplified C ′′ .Hence, for the amplified code we inherit all equations that define the original code C without any changes (up to renaming of the variables).If the checksum matrix of C is sparse, then each of these equations involve only O(1) variables.Besides the equation inherited from C, we add the equation that define the Hadamard code for each block of 2 D bits (one block for each vertex of G).Each of these equations contains at most 2 D = O(1) variables.Thus, the transformation preserves the property of sparsity of the checksum matrix.If the resulting family of linear constraints is not linearly independent, we can eliminate the redundant equations.
By repeating this amplification procedure O(1) times we obtain a linear code with the relative distance ≥ 1 2 − δ.This code satisfies condition (L ′ ), and therefore (L).The properties (G) and (S) are satisfied for this code, as explained above.It remains to achieve the property (M).We discuss in the next section.

A checksum matrix with the mixing property
In this section we focus on the properties of a checksum matrix that look more natural being formulated as properties of a system of linear equations.Given a real σ > 0 and an integer q > 0, we study the following problem of linear algebra: we need to construct a system of m ≤ σn linear equations with n variables, with the properties of sparsity (S) and mixing (M ′ ).This problem can be reformulated as follows: we need to construct a bipartite graph G = (V L , V R , E) with n vertices in the left part (the n vertices in V L correspond to the variables of the system) and m vertices in the right part (the m vertices in V R correspond to the linear equations of the system); an edge connects v i ∈ V L with w j ∈ V R (i.e., (v i , w j ) ∈ E), if and only if the i-th variable is involved in the j-th l equation of the linear system.In terms of this graph, the property of sparsity means that the degrees of all vertices in the right part are bounded by O(1), and the property of mixing means that for every set S of βn vertices on the left there exists a set T of γm vertices on the right such that every w ∈ T is connected with S by at least q edges.We construct the required bipartite graph using an algebraic expander.Let us fix an algebraic expander H with parameters (N, d, λ).In our construction the vertices in V R (the linear equations) will correspond to the vertices of this expander, and the vertices in V L (the variables of the linear system) correspond to the paths of length t in the expander.Thus, the number of variables in the system is n = N d t , and the number of equations is m = N .The i-th variable is involved in the j-th equation, if and only if the i-th path of length t in H contains the j-th vertex of H.If t is a constant (does not depend on n), then this construction gives a sparse linear system: every variable is involved in (t + 1) • d t = O(1) equations.By choosing t large enough, we can make the fraction m/n less than the given parameter σ.
With a large enough t we obtain a linear system with the strong property mixing.Indeed, let us fix in H some set of vertices S of size γN .Then the fraction of paths P of length t where all but q vertices belong to S, is not greater than (γ + λ) t−q • t q see [13, Theorem 3.10].We can choose t and λ so that this fraction is less than β.Thus, we can achieve the property of strong mixing for the required values of β, γ, q.

Merging two constructions
Let us summarize the constructions discussed in two previous sections.In Section 6. with n variables and ℓ = σn equations, with the property of strong mixing (M ′ ) from some β, γ, q.We are free to chose the parameters, so we may assume that q > c 2 .Moreover, we can achieve the property (M ′ ) with arbitrarily small positive σ.Now we joint together these two linear systems (we just take the union of linear equations from both systems).The resulting linear system is defined by the matrix This linear system defines a code which is still asymptotically good provided that σ < c 1 (we may choose the value of σ small enough).We refer to the m linear constraints that came to the joint system from the construction of Section 6.2.2 as primary equations, and to the ℓ linear constraints that came from the construction of Section 6.2.2 as auxiliary equations.
The new code has only a weak version of the mixing property: the property (M ′ ) holds only for the auxiliary equations.How to spread the property (M ′ ) to the entire linear system?To this end we xor the auxiliary equations with the primary equations.More precisely, we add (in the sense of linear algebra) each of the auxiliary equations to the fraction 1/ℓ of the primary equations.The same time, the auxiliary equations remain intact.Thus, we obtain a linear system with the matrix • On the first step, we prove exponential lower bounds on the OBDD complexity of a satisfiable formula Φ.Actually, in each case we prove a linear lower bound on the communication complexity of computing Φ with respect to every nearly balanced partition of the input.
• We focus on the last step of the derivation.This step is the conjunction of F 1 and F 2 in the same order π.We need to prove that at least one of F 1 and F 2 has exponential size.Both F 1 and F 2 are satisfiable, and they are conjunctions of different sets of clauses of the initial formula.We construct partial substitutions ρ 1 and ρ 2 with the same support such that the formula F 1 | ρ1 ∧ F 2 | ρ2 is isomorphic to Φ. Then the communication complexity of computing F 1 | ρ1 ∧ F 2 | ρ2 is linear with respect to any nearly balanced partition Π consistent with π.Hence, the communication complexity of F 1 | ρ1 or F 2 | ρ2 with respect to Π is linear.Thus, the communication complexity of either F 1 or F 2 with respect to π is linear.Therefore, by Property 4 of OBDDs it follows that for the order π either F 1 or F 2 has exponential size.
Thus, only Property 4 is needed to prove a lower bound for OBDDs.It is known that k-OBDDs enjoy Properties 1-3 and Property 4 as well (see for example [24]).Therefore, our lower bounds and separations proven (for OBDD(∧) and OBDD(∧, reordering)) in Section 3, equally apply to the proof systems based on k-OBDDs.
In Section 4, we constructed a family of formulas that have short OBDD(∧, reordering) proofs but all the OBDD(∧) proofs of them have exponential size.And again, to get the lower bound, we used only Property 4 of OBDDs.So this lower bound holds for k-OBDD(∧) as well.
Finally, in Section 5, we proved that while an OBDD(∧, ∃, reordering) algorithm processes a formula, at some moment it comes to a diagram D that computes a function with a linear communication complexity.By Property 4, this implies an exponential lower bound on the size of D. Therefore, the proven lower bound holds also for the k-OBDD(∧, ∃, reordering) algorithms.

Further research
The major open problem is to prove superpolynomial lower bounds for OBDD(∧, weakening, reordering) proofs.
Tseitin formulas based on expanders are easy for OBDD(∧, weakening), but by Theorem 3.14 they are hard for OBDD(∧, reordering).The paper [4] presented a family of formulas such that their shortest OBDD(∧, weakening) proof is superpolynomially larger than every OBDD(∧, reordering) proof of these formulas; it would be interesting to to strengthen this result and establish an exponential separation.
v∈U c(v) = 0 for every connected component U , then the Tseitin formula is satisfiable ([23, Lemma 4.1]).Note that if formulas TS G,c and TS G,c ′ are satisfiable and c = c ′ then TS G,c and TS G,c ′ are different functions; moreover, any satisfying assignment of TS G,c can not satisfy TS G,c ′ .

4 .
If D represents a constant then go to Step 1, otherwise goto Step 2. 5.If D is satisfiable then return 1, otherwise return 0.

3 Figure 1 :
Figure 1: The bits (x 1 x 2 x 3 ) assigned to the six ends of edges of the triangle graph.