Abstract 1 Introduction 2 Tree-like Proofs and Decision Trees 3 Lifting of Relations and Formulas 4 Notation 5 Stifling 6 Linear Algebraic Tools 7 Simulation 8 Application References Appendix A Appendix

Super-Critical Trade-Offs in Resolution over Parities via Lifting

Arkadev Chattopadhyay ORCID Tata Institute of Fundamental Research, Mumbai, India Pavel Dvořák ORCID Charles University, Prague, Czech Republic
Abstract

Razborov [24] exhibited the following surprisingly strong trade-off phenomenon in propositional proof complexity: for a parameter k=k(n), there exists k-CNF formulas over n variables, having resolution refutations of O(k) width, but every tree-like refutation of width n1ϵ/k needs size exp(nΩ(k)). We extend this result to tree-like Resolution over parities, commonly denoted by Res(), with parameters essentially unchanged.

To obtain our result, we extend the lifting theorem of Chattopadhyay, Mande, Sanyal and Sherif [11] to handle tree-like affine DAGs. We introduce additional ideas from linear algebra to handle forget nodes along long paths.

Keywords and phrases:
Proof complexity, Lifting, Resolution over parities
Funding:
Arkadev Chattopadhyay: Funded by the Department of Atomic Energy, Government of India, under project no. RTI4001, and a Google India Research Award.
Pavel Dvořák: Major portion of work done as a visiting fellow at TIFR. Supported by Czech Science Foundation GAČR grant #22-14872O.
Copyright and License:
[Uncaptioned image] © Arkadev Chattopadhyay and Pavel Dvořák; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Proof complexity
Acknowledgements:
We would like to thank an anonymous reviewer for pointing out the short and elegant proof of Theorem 10 that we include here. Our original proof was complicated.
Editors:
Srikanth Srinivasan

1 Introduction

Understanding trade-offs among complexity measures in a computational model is a well known interesting theme, with many published results (for example, time-space trade-offs [15, 16, 26], rounds-communication trade-offs [21, 10, 2] and space-size trade-offs in propositional proof complexity [6, 3, 5]). Typically, in these trade-offs, one showed that in various models of computation, simultaneous optimization of two complexity measures, like space and time, or rounds and total communication, or space and width (in refuting CNF formulas) is not always possible. In particular trying to optimize one complexity measure, necessarily leads to a huge blow-up in the other measure. For instance, in Yao’s 2-party model of communication, the Greater-Than function can be computed in 1 round. It can also be computed using randomized protocols of communication cost O(logn). But every O(1)-round protocol, requires Ω(n) communication cost. On the other hand, every function has a protocol of cost O(n). In all of the trade-off results cited above, the general story was that trying to optimize the use of one resource, led to the cost with respect to to the other resource shooting up to the cost needed by a naive/generic algorithm.

In 2016, Razborov [24] exhibited formulas for which very different and extreme kind of trade-offs hold in the propositional proof system of resolution. Although these unsatisfiable k-CNF formulas on n variables have refutations of O(k) width, every one of their tree-like refutation of width less than n1ϵ/k has size exp(nΩ(k)). That is, despite the fact that every n-variable formula has a generic tree-like refutation of size 2n, these exhibited formulas that do have refutation of small width require super-critical tree-like refutation size whenever width is mildly restricted. Moreover, the super-critical size is in fact exponentially larger than the generic upper bound. Razborov remarked that such a phenomenon seemed extremely rare in the known body of tradeoff results in the computational complexity literature. In concluding his work, he urged finding more instances of such trade-offs. In response to that, follow-up works have appeared. They can be classified into two types. Ones which continue to focus on resolution and, others on more powerful proof systems. Examples of the former include work by Berkholz and Nordstrom [8], who showed super-critical trade-offs between width and space. A recent work of Berkholz, Lichter and Vinall-Smeeth [7] proves super-critical trade-offs for narrow resolution width and narrow tree-like size for refuting the isomorphism of two graphs.

The second type of work answers Razborov’s call by finding such trade-offs in stronger proof systems. This includes the recent work of Fleming, Pitassi and Robere [14] who first showed that the argument of Razborov extends to general resolution DAGs. They then use it along with appropriate lifting theorems to prove trade-offs between size and depth for DAG like Resolution, Res(k), and cutting planes. In very recent progress in the area, De Rezende, Fleming, Jannet, Nordström, and Pang [12], and Göös, Maystre, Risse, Sokolov [18] independently showed super-critical trade-offs not only for various proof systems but also the first super-critical depth-size tradeoffs for monotone circuits. Our work also falls in this second type as we study tree-like resolution over parities, that generalizes tree-like resolution.

We exhibit super-critical trade-offs for width and tree-like size/depth in the style of Razborov for resolution over parities, denoted by Res(). This system, introduced by Itsykson and Sokolov [19, 20], is one of the simplest generalizations of resolution for which obtaining super-polynomial lower bounds on size of refutations is a current, well known, challenge. Very recent works (see [13, 9]) managed to obtain exponential lower bounds on the size of regular proofs in this system.

Our work here will concern tree-like Res() proofs. Lower bounds for them were obtained by Itsykson and Sokolov [20] themselves. More recently, two independent works, one by Beame and Koroth [4] and the other by Chattopadhyay, Mande, Sanyal and Sherif [11], proved lifting theorems that yielded a systematic way of lifting tree-like resolution width complexity to strong lower bounds on size of tree-like Res() proofs for formulas lifted with constant-size gadgets. In this paper, we extend the lifting theorem by Chattopadhyay et al. [11] in the following manner. Their result was applicable to parity decision trees (duals of tree-like Res() proofs) that only had usual nodes where the algorithm queried (correspondingly the proof resolved on) an 𝔽2 linear form. We call such nodes query nodes. On the other hand, we want to deal here with width-bounded proofs that could be much deeper than n, the total number of variables of the formula. This would correspond to parity decision trees where the height is much larger than n, and therefore, necessarily there are nodes that forget. The affine space corresponding to such a forget node u is strictly contained in the affine space corresponding to u’s only child node v. Alternatively, in the bottom-up view of the corresponding proof, the linear clause at v is strictly weakened to get the linear clause at u. Dealing with such nodes, so that the width of the (ordinary) clauses in the extracted resolution proof never exceed the corresponding width of the linear clauses, is the main technical contribution of this work. Thus, we establish a depth-to-size lifting result from tree-like Res() of arbitrary depth to tree-like resolution, which also preserves the width of the refutation.

Theorem 1.

Let Φg be a lift of a contradiction Φ by an appropriate gadget g:{0,1}{0,1}. Suppose there is a tree-like Res() refutation for Φg with size s and width w. Then, there is a tree-like resolution refutation for Φ with depth at most logs and width at most w.

 Remark 2.

We point out the precise difference between our Theorem 1 and the earlier lifitng theorem of Chattopadhyay et al [11]. The earlier theorem, given a tree-like refutation of Φg in Res() of size s and width w, would have extracted a tree-like refutation of Φ in ordinary resolution of depth logs, with no guarantees on the width of this refutation. In fact, the width could get as large as the depth of the extracted refutation, i.e. logs. In super-critical trade-offs, which is our chief interest here, the width w of the given Res() refutation of Φg could be exponentially smaller than logs. This renders the earlier lifting theorem unusable for demonstrating such trade-offs.

Applying Theorem 1 to the trade-off by Razborov [24], we immediately obtain an analogous trade-off in the Res() proof system.

Theorem 3.

Let k=k(n)12 be any parameter and let ε>0 be an arbitrary constant. Then, there exists a k-CNF contradiction τ over n variables such that there is a resolution refutation for τ with width at most O(k), but for every tree-like Res() refutation Π for τ with w(Π)n1ε/k, we have the bound |Π|exp(nΩ(k)).

The contradiction τ from the previous theorem is a lift of the contradiction τ constructed by Razborov [24] by an appropriate gadget g:{0,1}{0,1} with a constant size. A caveat of τ (as Razborov also noted) is that the number of clauses of τ is nΘ(k). Naturally, this caveat is inherited by our contradiction τ. This issue was addressed in very recent work of de Rezende et al. [12]. They provided a contradiction χ such that the size of its tree-like resolution with bounded width is super-exponential in not just in the number of variables but also in the size of the formula. However, the bound on width of the tree-like resolution for which super-critical size is needed is much more strict than in Razborov’s result. They showed the super-critical trade-off only for tree-like resolution of width smaller than 2w, where w is the width of the resolution refutation of χ. Since our gadget has size 3, we can guarantee only resolution refutation with width at most 3w for the lifted formula χg. Thus, we can not lift their super-critical trade-off to Res() as it is extremely sensitive to width. Razborov’s result [24], on the other hand, is more robust making it possible to be lifted by our Theorem 1.

If one were able to construct another formula τ~ improving state-of-the-art in supercritical trade-off between width and size of tree-like resolution that is not so sensitive to the width of the refutations, this improvement could be used with our simulation theorem (Theorem 1) and be lifted to tree-like Res().

Relation to Other Recent Works

The Res() proof system has been an active area of research. Recently, Efremenko, Garlík, and Itsykson [13] showed that the binary pigeonhole principle formula requires an exponential-size refutation within the so-called bottom-regular Res(). The bottom-regular Res() is a fragment of Res() that contains both tree-like Res() and regular resolution proof systems. Furthermore, Bhattacharya, Chattopadhyay, and Dvořák [9] showed that bottom-regular Res() can not polynomially simulate even ordinary, but DAG-like resolution. This separation was very recently improved quantitatively by Alekseev and Itsykson [1].

Furthermore, Alekseev and Itsykson [1] established a width-to-width lifting from resolution to Res(). They proved this in a contra-positive way – if there is no resolution refutation of a contradiction Φ with width w, then there is no width-w Res() refutation of a lift of Φ by an appropriate gadget g. They utilized a game interpretation of resolution and Res() to prove their lifting theorem. While their proof is quite short, it is unclear whether their technique can be adapted to prove the depth-to-size lifting theorem as we need in order to show the trade-off in Res() (our Theorem 3). In particular, their theorem seems incomparable to the depth-to-size lifting of Chattopadhyay et al. [11]. On the other hand, since any refutation can be expanded into a tree-like refutation (with a possible exponential blow-up in size), our lifting theorem (Theorem 1) immediately implies the width-to-width lifting theorem of Alekseev and Itsykson (however our proof seems more involved). Hence, our Theorem 1 effectively contains a common generalization of the width-to-width lifting of Alekseev and Itsykson [1] and depth-to-size lifting of Chattopadhyay et al. [11]. Moreover, we use a completely different technique than Alekseev and Itsykson [1]. Specifically, we establish our lifting theorem directly by constructing a tree-like resolution refutation for a contradiction Φ simulating a tree-like Res() refutation for Φg. To achieve this, we use some ideas from linear algebra that, to our knowledge, have not been previously utilized in the context of lifting.

Overview of Our Ideas

Overall, the ideas behind the proof of Theorem 1 are inspired by the work of Chattopadhyay et al. [11]. However, they did not consider Res() refutation with a limited width. Thus, they only needed to process query nodes to prove their lifting theorem. In contrast, our setting also involves forget nodes, where a linear equation from the span of previously queried equations is forgotten. It turns out that processing forget nodes is non-trivial. In particular, an affine space can be viewed in two ways: the first is by the (linear) space of constraints that could be thought of as the dual view. The primal view is that of the set of vectors lying in space represented by a basis of the underlying vector space and a shift vector. Previously, in [11], the dual view was very effectively used for depth-to-size lifting in the absence of forget nodes. This is because a query node naturally adds a constraint to the dual space. On the other hand, a forget node increases the dimension of the affine space. This new space is not conveniently representable with respect to the basis maintained for the dual space of constraints just before “forgetting” happens. Here it seems the primal view is more helpful as any basis of a space A1 can be extended to a basis of a space A2 whenever A1A2. The main tool we use is a a characterization, via Theorem 10, of the constraint space of A2 in terms of the constraint space of A1, where A1A2𝔽2n. The proof of this turns out to be simple111Our original proof was complicated. The much simpler proof we present here has been pointed out to us by an anonymous referee.. With more ideas, including a new notion of strongly stifled gadgets that extends the earlier notion of stifling introduced by [11], Section 7 yields the process of dealing with forget nodes.

2 Tree-like Proofs and Decision Trees

A proof in a propositional proof system starts from a set of clauses Φ, called axioms, that is purportedly unsatisfiable. It generates a proof by deriving the empty clause from the axioms, using inference rules. The main inference rule in the standard resolution, called the resolution rule, derives a clause AB from clauses Ax and B¬x (i.e., we resolve the variable x). If we can derive the empty clause from the original set Φ, then it proves that the set Φ is unsatisfiable.

Resolution over parities (Res()) is a generalization of the standard resolution, using linear clauses (disjunction of linear equations in 𝔽2) to express lines of a proof. It consists of two rules:

Resolution Rule:

From linear clauses A(=0) and B(=1) derive a linear clause AB.

Weakening Rule:

From a linear clause A derive a linear clause B that is semantically implied by A (i.e., any assignment satisfying A also satisfies B).

The length |Π| of a resolution (or Res()) refutation Π of a formula Φ is the number of applications of the rules above in order to refute the formula Φ. The width w(Π) of a resolution (or Res()) refutation Π is the maximum width of any (linear) clause that is used in the resolution proof. A (linear) resolution proof is tree-like if the resolution rule is applied in a tree-like fashion. The depth d(Π) of the tree-like proof Π is the depth of the underlying tree (i.e., the length of the longest path from the root to a leaf).

We can replace the general resolution rule with a canonical one:

Canonical Resolution Rule:

From linear clauses C(=0) and C(=1) derive a linear clause C.

Using the canonical resolution rule instead of the general one will not make the proof system substantially weaker. If we want to apply the resolution rule on the clauses A(=0) and B(=1), we can apply the weakening rule to both of them to get linear clauses AB(=0) and AB(=1) and then apply the canonical resolution rule to derive the clause AB. Thus, from a tree-like Res() refutation Π of a contradiction Φ, we can derive an equivalent tree-like Res() refutation Π that uses only canonical resolution rule (and the weakening rule) with |Π|3|Π|, d(Π)2d(Π), and w(Π)w(Π)+1 as for each application of the resolution rule in Π we add 2 applications of the weakening rule in Π, and the width might increase by 1 as we introduce clause AB(=0) and AB(=1) but only the clause AB was present in Π.

It is known that a tree-like resolution (or Res()) proof, for an unsatisfiable set of clauses Φ, corresponds to a (parity) decision tree for a search problem Search(Φ) that is defined as follows. For a given assignment α of the n variables of Φ, one needs to find a clause in Φ that is not satisfied by α (at least one exists as the set Φ is unsatisfiable). The correspondence holds even for general (not only tree-like) proofs (see for example Garg et al. [17], who credit it to earlier work of Razborov [23] that was simplified by Pudlák [22] and Sokolov[25]), but in this paper, we are interested only in tree-like proofs.

Let R{0,1}m×O, where O is a set of possible outputs. A forgetting parity decision tree (FPDT) computing R is a tree 𝒯 such that each node has at most two children and the following conditions hold:

  • Each node v is associated with an affine space Av𝔽2m.

  • For every node v with two children u and w is called a query nodes. There is a linear query fv such that Au={xAv|fv,x=0} and Aw={xAv|fv,x=1}, or vice versa. We say that fv is the query at v.

  • Every node v with exactly one child u is called a forget node. It holds that AvAu.

  • Each leaf is labeled by oO such that for all xA, it holds that (x,o)R.

  • For the root r, Ar=𝔽2m.

The size |𝒯| of an FPDT 𝒯 is the number of nodes of 𝒯 and the width w(𝒯) of FPDT 𝒯 is the largest integer w such that there exists an affine space of co-dimension at least w associated with some node of 𝒯. The depth of 𝒯 is denoted d(𝒯). Note that there are no forget nodes in a standard parity decision tree. Thus, for such trees, the width is exactly the depth of the tree. It no longer holds for this model, because we may “forget” some linear queries that have been made earlier.

A forgetting decision tree (FDT) is defined similarly to FPDT but instead of affine spaces, cubes are associated with each node. Consequently, the width w(𝒯) of FDT is the maximum number w such that there exists a cube of width at least w associated with some node of 𝒯 and queries of single variables replace the linear queries at nodes.

The correspondence between an F(P)DT’s and tree-like resolution (or Res()) proofs using only canonical resolution rule is the following: We represent a (linear) resolution proof as a tree where nodes are associated with (linear) clauses. The leaves are associated with clauses of Φ and the root is associated with the empty clause. Each node with two children corresponds to an application of the canonical resolution rule and each node with exactly one child corresponds to an application of the weakening rule. To get an F(P)DT for Search(Φ) we just negate the clauses that are associated with the nodes. Thus, each node is associated with a cube (or an affine space in the case of Res()/FPDT). Moreover, a cube Cv (or an affine space Av) associated with the node v of an F(P)DT 𝒯 contains exactly the falsifying assignments of the (linear) clause that is associated with the corresponding node in the tree-like refutation Π that corresponds to 𝒯. It is clear that the width and the depth of such decision tree 𝒯 are exactly the same as the width and the depth of the corresponding tree-like refutation Π and the length |Π| equals the number of inner nodes of 𝒯 (as the inner nodes of 𝒯 correspond to the applications of the resolution rule).

We say an FPDT 𝒯 is canonical if for each forget node v of 𝒯 and its only child u, it holds that co-dim(Av)=co-dim(Au)+1. We say an FPDT 𝒯 is succinct if the parent of each forget node is a query node. Note that any FPDT can be transformed into an equivalent canonical (or succinct) FPDT by expanding forget nodes into paths of forget nodes (or contracting paths of forget nodes to single vertices).

Consider an FPDT 𝒯 and its succinct form 𝒯¯. Note that the number of query nodes of 𝒯¯ and 𝒯 is the same, and analogously the number of query nodes on a root-leaf path in 𝒯¯ equals the number of query nodes of the corresponding path in 𝒯. Thus, for an FPDT 𝒯 we define query size |𝒯|𝗊 and query depth d𝗊(𝒯) to be the number of query nodes of 𝒯 and the maximum number of query nodes on a root-leaf path of 𝒯.

Observation 4.

Let Π be a Res() refutation of a contradiction Φ. Then, there is a canonical FPDT 𝒯 computing Search(Φ) with |𝒯|𝗊|Π| and w(𝒯)w(Π)+1.

Proof.

As discussed above, first we modify Π to a Res() refutation Π that uses only canonical resolution rule (and weakening rule). By this modification, we have w(Π)w(Π)+1 and the number of applications of the resolution rule in Π is exactly the number of applications of the canonical resolution rule in Π. From Π, we derive an FPDT 𝒯 computing Search(Φ) that we finally modify to an equivalent canonical FPDT 𝒯. The width of Π and 𝒯 is the same, and the query size of 𝒯 is exactly the number of applications of the canonical resolution rule in Π. The modification of 𝒯 to the canonical FPDT 𝒯 does not change the width and the query size of the tree. Thus, we have w(𝒯)w(Π)+1 and |𝒯|𝗊|Π|.

Observation 5.

Let 𝒯 be a succinct FPDT computing Search(Φ) and Π be the tree-like Res() refutation of Φ corresponding to 𝒯. Then, |Π|32d𝗊(𝒯).

Proof.

As mentioned above, the length of Π equals the number of inner nodes of 𝒯. The tree 𝒯 has at most 2d𝗊(𝒯)1 query nodes. Since 𝒯 is succinct, the number of forget nodes is at most twice the number of query nodes as each query node might have at most two forget nodes as its children. Further, any child of a forget node is not a forget node. Thus, |Π|32d𝗊(𝒯).

3 Lifting of Relations and Formulas

Let g:{0,1}{0,1} be a boolean function. For a relation R{0,1}n×O we define its lift Rg{0,1}n×O as

Rg={(y,o){0,1}n×O(g(y),o)R},

where g(y11,,y1,,y1n,,yn)=(g(y11,,y1),,g(y1n,,yn)).

For CNF Φ over n variables {x1,,xn}, let Φg be the following lift of Φ over the variables {yjii[n],j[]}. For any clause D of Φ, let Vars(D) be the set of variables of D, and let ηD{0,1}Vars(D) be the only falsifying assignment of D. Then,

Dg={xiVars(D),j[]yjiκji|κg1(ηD)},

where yjiκji is the following literal:

yjiκji={yji if κji=0,¬yji if κji=1.

Now, the clauses of Φg are {DgD clause of Φ}.

Observation 6.

For a clause D, an assignment δ of Vars(Dg) falsifies Dg if and only if g(δ)=ηD, i.e., g(δ) falsifies D.

4 Notation

We use the following notation. For a vector u we use both ui and u[i] to denote the i-th entry of u, similarly for a matrix M we use Mi,j and M[i;j] to denote the entry in the i-th row and j-th column. For an ordered set of indices D we denote by u[D] the subvector of u given by D, i.e., u[D]=(ui)iD. For an abbreviation, we use u[i] to denote the vector u without the i-th entry, i.e., u[i]=(u1,,ui1,ui+1,,un).

5 Stifling

In this section, we extend the notion of stifling introduced by Chattopadhyay et al. [11]. Let g:{0,1}{0,1} be a Boolean function. For i[] and b{0,1}, we say a partial assignment δ{0,1,} is an (i,b)-stifling pattern for g if δj= if and only if j=i, and for any γ{0,1} such that γ[i]=δ[i], we have g(γ)=b. In words, δ assigns a value to all but the i-th bit and when we extend δ to a full assignment γ, it holds that g(γ)=b no matter how we set the value of the i-th bit.

Definition 7.

A Boolean function g:{0,1}{0,1} is strongly stifled if there is a collection P:={δi,b|i[],b{0,1}} where each δi,b is an (i,b)-stifling pattern for g and

i[],b{0,1},and D[]{i}
jD such that δj,b[D{j}]=δi,b[D{j}].

The collection P is called a converting collection of stifling patterns of g.

Chattopadhyay et al. [11] defined a stifled function (namely 1-stifled) as a function g:{0,1}{0,1} such that for each i[] and b{0,1} there is an (i,b)-stifling pattern for g. In this work, we require not only the existence of the stifling patterns but a stronger property that we can convert the stifling patterns to each other. More formally, consider an (i,b)-stifling pattern δi,b from the collection P (from the definition above). Let an adversary give us a set of coordinates D[]{i}. Then, we are able to pick a coordinate jD such that the stifling pattern δj,b is equal to δi,b on all coordinates in D{j}.

By a simple verification we can show that indexing of two bits 𝖨𝖭𝖣1:{0,1}3{0,1} and majority of 3 bits 𝖬𝖠𝖩3:{0,1}3{0,1} are strongly stifled functions, where 𝖨𝖭𝖣1(a,d0,d1)=da and 𝖬𝖠𝖩3(x)=1 if and only if |{i[3]|xi=1}|2.

Observation 8.

The functions 𝖨𝖭𝖣1 and 𝖬𝖠𝖩3 are strongly stifled.

Further, the strongly stifled notion is actually stronger than the original stifled notion, because the inner product function of 2-bit vectors 𝖨𝖯2:{0,1}4{0,1} is stifled [11] but not strongly stifled, where 𝖨𝖯2(x1,x2,y1,y2)=x1x2+y1y2mod2.

Observation 9.

The function 𝖨𝖯2 is not strongly stifled.

For more details, see the appendix.

6 Linear Algebraic Tools

Let A𝔽2m be an affine space over a field 𝔽2. A constraint representation of A is a system of linear equations (M|z) where M𝔽2q×m and z𝔽2q for some qm such that A={yMy=z}. The columns of M correspond to the variables of the system (M|z) and rows of M correspond to the constraints. We say a constraint i contains a variable a if Mi,a=1. A matrix M𝔽2q×m is in an echelon form if there are q columns c1<c2<<cq[m] such that for all i[q] it holds that

M[i;cj]={1if i=j,0otherwise.

Thus, the submatrix of M induced by the columns c1,,cq is the identity matrix Iq𝔽2q×q. The variables corresponding to the columns c1,,cq are dependent variables of the system (M|z) and the remaining variables are independent. The ci-th entry of the i-th row of M is called the pivot of the i-th row. We say a constraint representation (M|z) is in an echelon form if the matrix M is in an echelon form.

Let C𝔽2q×m be a matrix and t𝔽2q be a non-zero vector. We define a matrix C=𝖣𝖾𝗅(C,t,i)𝔽2q1×m where C arises from C by adding the i-th row to all rows j such that tj=1 and then deleting the row i. Analogously, we define the 𝖣𝖾𝗅 operation for a constraint representation (M|z) of an affine space A𝔽2m, where we treat the vector z as the last column of the matrix C. It turns out that the 𝖣𝖾𝗅 operation is the only operation needed to get a constraint representation for a super-space as shown in the following theorem that will be the key technical tool for us to process forget nodes while proving our main lifting theorem.

Theorem 10.

Let A1A2𝔽2m be two affine spaces such that dim(A2)=dim(A1)+1. Let (M1|z1) be a constraint representation in the echelon form of A1 such that M1𝔽2q×m. Then, there is a non-zero vector t𝔽2q such that the following is true: for every i[q] with ti=1, 𝖣𝖾𝗅((M1|z1),t,i) is a constraint representation of A2 in echelon form.

We call the vector t given by Theorem 10 as forgetting vector because it allows us to forget one constraint in the representation of A1 to get a representation of A2. Note that the dimension of t equals the number of equations in the system (M1|z1). We say t contains a constraint i if ti=1.

Theorem 10 follows from the following well-known lemma, which we will prove for completeness. Let V2V1𝔽2n be two vector spaces such that dim(V2)=dim(V1)1.

Lemma 11.

For any u,vV1V2 holds that u+vV2.

Proof.

Since u is in V1 but not in V2, we have that Span(V2,u)=V1 by the dimensions of V1 and V2. Since vV1V2 as well, we have that v=w+u for an appropriate vector wV2. It follows that u+v=wV2.

Corollary 12.

Let v1,,vd be a basis of V1. Let T={i[d]viV2}. Let jT, and for i[d]j let

ui={vi+vjif iT,viotherwise.

Then, (ui)i[d]j is a basis of V2.

Proof.

Vectors ui’s are linearly independent as vi’s are linearly independent. By definition and Lemma 11, all ui’s are in V2. Since dim(V2)=d1, the vectors ui’s has to form a basis of V2.

Theorem 10 follows from the previous corollary by setting V1 and V2 to be the constraints spaces of A1, and A2, respectively (i.e., row spaces of matrices (M1|z1) and (M2|z2)). Further, the forgetting vector of Theorem 10 is the characteristic vector of the set T given by Corollary 12.

7 Simulation

In this section, we prove our lifting theorem.

Theorem 13 (Theorem 1 stated for F(P)DT).

Let R{0,1}n×O be a relation and 𝒯 be a canonical FPDT computing Rg where g:{0,1}{0,1} is a strongly stifled gadget. Then, there is an FDT 𝒯 computing R such that d𝗊(𝒯)log|𝒯|𝗊 and w(𝒯)w(𝒯).

Algorithm

We prove Theorem 13 by simulation. On an input x{0,1}n, the constructed FDT 𝒯 simulates given FPDT 𝒯 on an input y{0,1}m (for m:=n) with x=g(y) by traversing a path from the root r of 𝒯 to a leaf. The main loop of the simulation is quite simple. We start in the root r of 𝒯 and in each iteration, we process the current node v of 𝒯 and pick a new node. Sometimes during the processing of a node of 𝒯, we query or forget a bit of x. When we reach a leaf s of 𝒯 we just output the value of s. The main loop is summarized in Algorithm 1.

Let v be a current node of 𝒯 we have just encountered. We maintain a constraint representation in echelon form (Mv|zv) of the affine space Av. We store queried (and not forgotten) bits of x in a partial assignment ρv{0,1,}n. Let C(ρv){0,1}n be a set of all possible extensions of ρv and w(ρv) be a number of fixed bits of ρv. Thus, C(ρv) is a cube and w(ρv) is its width. Our goal is that any x¯C(ρw) is represented in Av (i.e., there is yAv such that g(y)=x¯), and that w(ρv) is at most the co-dimension of Av.

An input y of 𝒯 is divided into n blocks B1,,Bn[m], each of size , and each such block corresponds to exactly one entry of x. Formally, Bi={(i1)+1,,i}. During the simulation of 𝒯, we divide the blocks into two groups – free and fixed. Fixed blocks correspond to the entries of x that were queried and were not forgotten – i.e., the entries fixed by ρv. The other blocks are free.

For each fixed bit i[n] of ρv, we have a unique constraint ji of (Mv|zv) such that the pivot of the constraint ji is in the block Bi. The constraint ji is called the primary constraint of Bi. The dependent variables of primary constraints are called marked variables. We will keep an invariant that each marked variable is in a different block, i.e., each fixed block contains a unique marked variable. The other (non-marked) variables of the fixed blocks are called stifling variables. We will assign values to the stifling variables according to appropriate stifling patterns, in such a way that a fixed block Bi is always mapped to xi, independently on the value of the marked variable of Bi. Further, we will assign a value to the marked variable in a block Bi in such a way that the assignment will satisfy the corresponding primary constraint. Since each marked variable is in a unique primary constraint, we will show that such an assignment of all marked variables always exists.

The constraints that are not primary for any block are called secondary. It will turn out that all secondary constraints contain variables only from fixed blocks. All variables of free blocks are called free. Thus, the matrix Mv has the following form (after rearranging columns):

Let P:={δi,bi[],b{0,1}} be a converting collection of stifling patterns of g, given by the assumption. Let αv{0,1,}m be the following partial assignment:

αv[Bi]={δj,xiif Bi is a fixed block and j is the index of the marked variable of Biif Bi is a free block

Note that the partial assignments αv assigns values exactly to the stifling variables of Mv. We will keep an invariant that if we set all stifling variables according to αv all secondary constraints of (Mv|zv) will be satisfied. This will help us to ensure that each x¯C(ρv) is represented in Av.

At the beginning of our simulation, we are at the root r of 𝒯. Since Ar={0,1}m, the matrix Mr is an empty matrix and all variables are free because we have not queried any entry of x yet. Also, the patterns ρr and αr do not contain any fixed bit, i.e. they are equal to n, or m, respectively.

Algorithm 1 Simulation.

Input: x{0,1}n Input for FDT 𝒯

FPDT 𝒯 with the root r computing Rg

 

Initialization:

 

Simulation:

During the simulation, we will maintain the following invariants. This will help us to ensure that each x¯C(ρv) is represented in Av.

Invariant 1:

The system of equations (Mv|zv) is a constraint representation of Av in the echelon form.

Invariant 3:

All variables of all free blocks are independent.

Invariant 5:

For each fixed bit i[n] of ρv, there is a unique constraint ji of (Mv|zv) such that the pivot (i.e., the marked variable) of the constraint ji is in the block Bi.

Invariant 7:

The partial assignment αv assigns values to all stifling variables and any extension of αv to a full assignment satisfies all secondary constraints.

Note that Invariant  Invariant 7: implies that secondary constraints of (Mv|zv) contain only variables of fixed blocks. We will show these invariants hold for any node v of 𝒯 at the moment, when v is checked whether v is a leaf – i.e., at Line 4 of Algorithm 1. Clearly, the invariants hold for the root r of 𝒯. Now, we describe how we process a node v (depending on whether v is a query node or forget node). We suppose the invariants hold for v. During the processing, we pick an appropriate child u of v and make u the new current node. Subsequently, we argue why the invariants hold for u.

We remark that the query node processing is a careful adaptation of the node processing given by Chattopadhyay et al. [11]. All new machinery (strongly stifled function and obtaining a constraint representation of a super-space by Theorem 10) is used only for the processing of forget nodes.

Query Nodes

When v is a query node, then v introduces a new parity query fv, and if fv,y=0 the computation of 𝒯 proceeds to the left child u0 of v, otherwise to the right child u1. Our goal is to pick an appropriate child u of v and create the system (Mu|zu) representing Au satisfying all our requirements. Let us start with a system (M|z(b)), where

M=(Mvfv),z(b)=(zvb),

with b being a parameter equal to 0 or 1. We fix the value of b when we pick the appropriate child u of v as the new node. Surely, the system (M|z(b)) represents the space Aub, however, it might not satisfy our requirements (for example the matrix M might not be in the echelon form). Note that the matrix M does not depend on the value of b. We do another pivoting step of the Gaussian elimination to get the system (M|z(b)) into the echelon form, i.e.,

  1. 1.

    We zero out all coefficients in fv corresponding the dependent variables in (Mv|zv), to get a new constraint (f|b), where b is a function of b. We call the new constraint (f|b) the reduced form of the constraint (fv|b).

  2. 2.

    We pick one of the remaining variables a contained in f as a new dependent variable, we pick an appropriate child u of v and we set the value of b (and b), accordingly.

  3. 3.

    We zero out all coefficients corresponding to a in all original constraints from the system (Mv|zv) to get the new system (Mu|zu).

It is clear the new system (Mu|zu) is a constraint representation of Au (i.e., Invariant  Invariant 1: will hold for u). The crucial part is to pick a new dependent variable a in Step 2 of the executed Gaussian elimination. Note that the reduced constraint (f|b) does not contain any marked variable as all marked variables are dependant and, thus, they are zeroed out from (f|b) in Step 1 of the executed pivoting step. There are two cases to consider as follows.

Case 1.

The new constraint (f|b) contains only variables of the fixed blocks. Then, the new constraint becomes a secondary constraint, and the new dependent variable a can be any variable of f. Since the constraint (f|b) contains only variables of fixed blocks (but no marked variable), we can assign a value to all variables of (f|b) given by αv. Thus, there is b¯{0,1} such that for any extension y of αv, it holds that f,y=b¯. Then, we pick the appropriate child u of v, that gives us the right value of b (and b) such that the new constraint (f|b) holds for any extension of αv. This ensures that Invariant  Invariant 7: holds for u.

We did not query any new bit of x in this case. It follows that the partial assignment ρv and the set of fixed and free blocks are not changed. The set of primary constraints is unchanged as well. Further, the set of pivots of (Mv|zv) is not changed by the pivoting step of the Gaussian elimination. Thus, Invariant  Invariant 5: holds for u. Invariant  Invariant 3: holds because the constraint (f|b) does not contain any free variable of (Mv|zv) and thus the new dependent variable a can not be from a free block.

Case 2.

The new constraint (f|b) contains at least one variable a of a free block Bi. In this case, we can pick the new vertex u as an arbitrary child of v. Let 𝒯w be a subtree of 𝒯 rooted in a node w of 𝒯. We compare the query size of subtrees 𝒯u0 and 𝒯u1 and we pick u to be the root of the subtree with the smaller query size, i.e., |𝒯u|𝗊|𝒯w|𝗊, where w is the other children of v.

We query xi and update the partial assignment ρv by the value of xi to get ρu. The block Bi becomes a fixed block. The new constraint (f|b) becomes the primary constraint of Bi and the variable aBi becomes the pivot of (f|b), i.e., a becomes a marked variable. Since the set of pivots of (Mv|zv) is not changed, Invariant  Invariant 5: holds for u. Since the only new dependant variable is aBi, Invariant  Invariant 3: holds as well.

The partial assignment αu differs only at the block Bi from αv (αv[Bi]=, and αu[Bi]=δj,xi). Since the block Bi was free in (Mv|zv), no secondary constraint of (Mv|zv) contains any variable of the block Bi. Thus, no secondary constraints of (Mv|zv) were changed by the pivoting step in this case. The new constraint (f|b) is primary. Thus, no secondary constraint of (Mu|zu) contains any variable of the block Bi as well. Therefore, any extension of αu still satisfies all secondary constraints of (Mu|zu) and Invariant  Invariant 7: holds for αu.

See Algorithm 2 for a summary of the query node processing.

Algorithm 2 Process Query Node (v: the current (query) node).

Forget Nodes

In the case when v is a forget node, the node v has the only child u and dim(Au)=dim(Av)+1. We have the constraint representation (Mv|zv) of Av maintained by our simulation for Mv𝔽2c×m and zv𝔽2c (where c is the co-dimension of Av). For processing the forget node, we introduce a classification of stifling variables. The variables of fixed blocks that are contained in the secondary constraints are called dangerous222Our notion of dangerous variables is not to be confused with the notion of dangerous constraints used by Efremenko et al. [13].. Note that the marked variables can not be dangerous. The remaining variables of fixed blocks (i.e., non-marked and non-dangerous) are called safe. Thus, with this new classification, the matrix Mv has the following form:

Let t𝔽2c be a forgetting vector given by an application of Theorem 10 to spaces Av and Au. The new system (Mu|zu) is obtained after applying 𝖣𝖾𝗅((Mv|zv),t,i) for a right choice of i (the function 𝖣𝖾𝗅 is defined in Section 6). By Theorem 10, the system (Mu|zu) is a constraint representation of Au in the echelon form, i.e. Invariant  Invariant 1: holds for u. Let p be the number of primary constraints in (Mv|zv), i.e. wlog, the constraints 1,,p are primary and the constraints p+1,,c are secondary. We consider two cases.

Case 1.

There is an i{p+1,,c} such that ti=1. Then, fix one such i and take a system (Mu|zu)=𝖣𝖾𝗅((Mv|zv),t,i). We do not query or forget any bit of x, thus ρu=ρv and αu=αv. To create (Mu|zu), we only added the secondary constraint i to some rows of (Mv|zv) and then we deleted it. Thus, the set of variables which appear in secondary constraints cannot grow in size and, therefore, secondary constraints are still satisfied by the assignment αu. Therefore, Invariant  Invariant 7: holds for αu.

The set of primary constraints is not changed. The 𝖣𝖾𝗅 operation does not change the set of marked variables as the secondary constraint i does not contain any pivot of the primary constraints. Thus, Invariants  Invariant 5: holds for u. The set of fixed blocks does not change and there is no new dependant variable. Thus, Invariant  Invariant 3: holds as well.

Case 2.

For all i{p+1,,c}, it holds that ti=0. Then, we fix some i{1,,p} such that ti=1. Note that such an i exists as t is a non-zero vector. Again, let (Mu|zu)=𝖣𝖾𝗅((Mv|zv),t,i)). Since t has only zeroes at the coordinates corresponding to the secondary constraints, the secondary constraints are not changed by the 𝖣𝖾𝗅 operation. As the constraint i is deleted and it was a primary one, one marked variable a (the pivot of the constraint i) becomes independent and safe. Let Bj be the block containing the variable a, i.e., the constraint i of (Mv|zv) is the primary constraint for Bj. We consider two sub-cases.

Sub-case 2.1.

The other variables of Bj are safe in (Mu|zu) as well, i.e., they are not in any secondary constraint. Thus, the whole block Bj contains only independent and safe variables of (Mu|zu). We forget the bit xj and make the block Bj free. The set of other primary constraints (different from i) may change their form, but their pivots are not changed. Hence, Invariant  Invariant 5: holds for u. There is no new dependant variable. Thus Invariant  Invariant 3: holds as well.

We get the partial assignment ρu by simply setting the variable xj free. The partial assignment αu differs from αv only at the block Bj (αu[Bj]=, and αv[Bj]=δj,xj). Further, the secondary constraints of (Mu|zu) do not contain any variable of the block Bj by the assumption. Thus, Invariant  Invariant 7: holds for αu.

Sub-case 2.2.

There is a dangerous variable in the block Bj, i.e., there is a secondary constraint of (Mu|zu) that contains a variable of Bj. In this case, we use the strong stifling property of g. Let D[] be the set of indices of all dangerous variables of (Mu|zu) in Bj. Let j1 be the index of the variable a in Bj (i.e., the previously marked variable in Bj). Note that j1D because the variable a is safe. Thus by definition of strongly stifling, there is a j2D such that δj2,xj[D{j2}]=δj1,xj[D{j2}] (note that αv[Bj]=δj1,xj). Let a be the j2-th variable in the block Bj and k be a secondary constraint that contains a (such constraint exists by the assumption).

We run again the pivoting step for a, i.e., we zero out all coefficients corresponding to a in all other constraints of (Mu|zu) by adding the constraints k to all other constraints containing a. We denote the final system of constraints as (Mu|zu). Note that (Mu|zu) is still a constraint representation of Au as it arises from (Mu|zu) only by row operations.

The constraint k is now the only constraint containing the variable a and a becomes a dependent variable. Thus, we make the constraint k a primary constraint for Bj and we mark the variable a. The primary constraint for Bj was changed from the constraint i of (Mv|zv) to the constraint k of (Mu|zu) and the marked variable in the block Bj was changed from a to a. The set of other primary constraints and their pivots were not changed. Thus, Invariant  Invariant 5: holds for u.

We do not change the assignment ρv, thus the sets of free and fixed blocks are the same. The only change in the set of dependent variables was done in the block Bj (that remains a fixed block), thus Invariant  Invariant 3: holds for u.

The secondary constraints of (Mv|zv) were not changed by the 𝖣𝖾𝗅((Mv|zv),t,i) executed at the beginning of this case (as ti=0 for all secondary constraints i). Since k is a secondary constraint of (Mu|zu), the secondary constraints of (Mu|zu) contains only variables of fixed blocks. However, we change the marked variable in the block Bj. Thus, the partial assignment αu differs from αv at the block Bj (αv=δj1,xi, and αu=δj2,xi, where j1 and j2 are indices of a and a in the block Bj). We need to be sure that αu still gives a solution to the secondary constraints of (Mu|zu). Note that the secondary constraints of (Mu|zu) might still contain variables from the block Bj.

By pivoting a and making the constraint k primary, the variable a is not in any secondary constraint of (Mu|zu). Since k was a secondary constraint of (Mu|zu), it can not happen that a safe variable in (Mu|zu) would become a dangerous one in (Mu|zu) (i.e., by the pivoting of a). In other words, the set of variables of the secondary constraints of (Mu|zu) is a subset of the set of variables of the secondary constraints of (Mu|zu). Thus, the set D{j2} still contains all dangerous variables of Bj in (Mu|zu). Since αv[D{j2}]=αu[D{j2}] by the assumption, any extension αu satisfy all secondary constraints of (Mu|zu) and Invariant  Invariant 7: holds for αu.

A summary of the forget node processing is in Algorithm 3.

Algorithm 3 Process Forget Node (v: the current (forget) node).

Proof of Theorem 13

Theorem 13 follows from the following lemma.

Lemma 14.

Suppose the simulation is at Line 4 of Algorithm 1, i.e., it checks whether the current node v is a leaf. Then,

  1. 1.

    w(C(ρv))co-dim(Av).

  2. 2.

    For any x¯C(ρv), there is yAv such that g(y)=x.

Proof of Item 1.

By Invariant  Invariant 1:, the co-dimension of Av is exactly the number of equations in the system (Mv|zv). By Invariant  Invariant 5:, the number of fixed bits by ρv is exactly the number of primary constraints in (Mv|zv). Thus, w(C(ρv))co-dim(Av).

Proof of Item 2.

Let x¯C(ρv). We will find a solution y to the system (Mv|zv) such that g(y)=x¯. Thus, by Invariant  Invariant 1:, yAv.

First, we set variables of free blocks. Let Bi be a free block. Thus, by Invariant Invariant 3:, all variables of Bi are independent. We set the variables of Bi in a way such that the block Bi is mapped to x¯i by the gadget g.

Now, we set the values of the stifling variables according to αv. By Invariant  Invariant 7:, all secondary constraints are satisfied by any extension of αv. Recall that for a fixed block Bi, αv[Bi]=δj,xi where j is the index of the marked variable of Bi and x¯i=ρv[i]. Since δj,xi is a (j,xi)-stifling pattern, it holds that the block Bi will be always mapped to x¯i by g, no matter how we set the marked variables. Thus, the constructed solution y will be mapped onto x¯. By Invariant  Invariant 5:, each primary constraint contains a unique marked variable. Thus, we can set a value to each marked variable a in such a way the primary constraint containing a is satisfied.

Proof of Theorem 13.

By Item 1 of Lemma 14, the width of a cube C(ρv) in a time of checking whether a vertex v is a leaf is at most co-dimension of Av. Thus, the width of the constructed FDT 𝒯 is at most the width of 𝒯.

Now, we bound the query depth of 𝒯. Consider a root-leaf path P of 𝒯 and let d be the number of queries made on P. Note that any time we query a bit of x (Line 9 of Algorithm 2) we also pick a subtree with a smaller query size (Line 8 of Algorithm 2). Thus, by each query of 𝒯 we halve the query size of 𝒯. Thus, 2d|𝒯|𝗊.

It remains to prove the constructed FDT 𝒯 is correct. Let s be a leaf of 𝒯 that is reached during the simulation and oO is the output of s. Since 𝒯 computes Rg, it holds that for all yAs we have (y,o)Rg. Note that the processing phase (Lines 5-8 of Algorithm 1) is not executed for any leaf. Thus, the assertion of Lemma 14 holds for the leaf s even at the time of output – Line 9 of Algorithm 1. Therefore at the end of the simulation, for any x¯C(ρs) there is yAs such that g(y)=x¯. Since (y,o)Rg, it holds that (x¯,o)R and the constructed FDT 𝒯 indeed outputs a correct answer.

8 Application

Razborov [24] showed the following trade-off between width and size of tree-like resolution.

Theorem 15 (Theorem 3.1, Razborov [24]).

Let k=k(n)4 be any parameter and let ε>0 be an arbitrary constant. Then, there exists a k-CNF contradiction τ over n variables such that there is a resolution refutation for τ with width at most O(k), but for any tree-like resolution refutation Π for τ with w(Π)n1ε/k, we have the bound |Π|exp(nΩ(k)).

By our simulation, given by Theorem 13, we can lift the trade-off (given by the previous theorem) to tree-like Res() and prove Theorem 3.

Theorem 3. [Restated, see original statement.]

Let k=k(n)12 be any parameter and let ε>0 be an arbitrary constant. Then, there exists a k-CNF contradiction τ over n variables such that there is a resolution refutation for τ with width at most O(k), but for every tree-like Res() refutation Π for τ with w(Π)n1ε/k, we have the bound |Π|exp(nΩ(k)).

Proof.

Let g:{0,1}3{0,1} be a strongly stifled gadget – such functions exist as observed in Section 5. Let k:=k/3, and τ be a k-CNF contradiction given by Theorem 15. We set τ:=τg that is a k-CNF contradiction. Since there is a resolution refutation for τ with width at most O(k), then there is a resolution refutation for τ with width at most O(k).

Now, let Π be a tree-like Res() refutation for τ with w(Π)n1ε/k. By Observation 4, let 𝒯 be a canonical FPDT corresponding to Π that computes Search(τ). Thus, we have w(𝒯)w(Π)+1 and |𝒯|q|Π|. We change 𝒯 to compute Search(τ)g. Let s be a leaf of 𝒯 outputting a clause D of τg. The clause D has to appear in a set of clauses Dg for a clause D of τ. We change the output of s to be the clause D instead of D. By Observation 6, the tree 𝒯 now computes Search(τ)g.

By Theorem 13, there is FDT 𝒯 computing Search(τ) with d𝗊(𝒯)log|𝒯|𝗊 and w(𝒯)w(𝒯). Let Π be the resolution refutation for τ corresponding to the succinct form of 𝒯. Thus, w(Π)=w(𝒯) and |Π|32d𝗊(𝒯) (by Observation 5). Since

w(𝒯)w(𝒯)n1ε/k+1n1ε/k, (1)

we have that |Π|exp(nΩ(k)) by Theorem 15. The last inequality in (1) holds if k2n1ε, which holds as we suppose that 1w(Π)n1ε/k. Putting everything together, we have

|Π||𝒯|𝗊2d𝗊(𝒯)13|Π|exp(nΩ(k))=exp(nΩ(k)).

References

  • [1] Yaroslav Alekseev and Dmitry Itsykson. Lifting to regular resolution over parities via games. Electron. Colloquium Comput. Complex., TR24-128, 2024. URL: https://eccc.weizmann.ac.il/report/2024/128.
  • [2] Sepehr Assadi, Gillat Kol, and Zhijun Zhang. Rounds vs communication tradeoffs for maximal independent sets. In 63rd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2022, Denver, CO, USA, October 31 - November 3, 2022, pages 1193–1204. IEEE, 2022. doi:10.1109/FOCS54457.2022.00115.
  • [3] Paul Beame, Christopher Beck, and Russell Impagliazzo. Time-space tradeoffs in resolution: superpolynomial lower bounds for superlinear space. In Howard J. Karloff and Toniann Pitassi, editors, Proceedings of the 44th Symposium on Theory of Computing Conference, STOC 2012, New York, NY, USA, May 19 - 22, 2012, pages 213–232. ACM, 2012. doi:10.1145/2213977.2213999.
  • [4] Paul Beame and Sajin Koroth. On disperser/lifting properties of the index and inner-product functions. In Yael Tauman Kalai, editor, 14th Innovations in Theoretical Computer Science Conference, ITCS 2023, January 10-13, 2023, MIT, Cambridge, Massachusetts, USA, volume 251 of LIPIcs, pages 14:1–14:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ITCS.2023.14.
  • [5] Chris Beck, Jakob Nordström, and Bangsheng Tang. Some trade-off results for polynomial calculus: extended abstract. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors, Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013, pages 813–822. ACM, 2013. doi:10.1145/2488608.2488711.
  • [6] Eli Ben-Sasson. Size space tradeoffs for resolution. In John H. Reif, editor, Proceedings on 34th Annual ACM Symposium on Theory of Computing, May 19-21, 2002, Montréal, Québec, Canada, pages 457–464. ACM, 2002. doi:10.1145/509907.509975.
  • [7] Christoph Berkholz, Moritz Lichter, and Harry Vinall-Smeeth. Supercritical size-width tree-like resolution trade-offs for graph isomorphism, 2024. doi:10.48550/arXiv.2407.17947.
  • [8] Christoph Berkholz and Jakob Nordström. Supercritical space-width trade-offs for resolution. SIAM J. Comput., 49(1):98–118, 2020. doi:10.1137/16M1109072.
  • [9] Sreejata Kishor Bhattacharya, Arkadev Chattopadhyay, and Pavel Dvořák. Exponential Separation Between Powers of Regular and General Resolution over Parities. In Rahul Santhanam, editor, 39th Computational Complexity Conference (CCC 2024), volume 300 of Leibniz International Proceedings in Informatics (LIPIcs), pages 23:1–23:32, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.CCC.2024.23.
  • [10] Mark Braverman and Rotem Oshman. A rounds vs. communication tradeoff for multi-party set disjointness. In Chris Umans, editor, 58th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October 15-17, 2017, pages 144–155. IEEE Computer Society, 2017. doi:10.1109/FOCS.2017.22.
  • [11] Arkadev Chattopadhyay, Nikhil S. Mande, Swagato Sanyal, and Suhail Sherif. Lifting to parity decision trees via stifling. In Yael Tauman Kalai, editor, 14th Innovations in Theoretical Computer Science Conference, ITCS 2023, January 10-13, 2023, MIT, Cambridge, Massachusetts, USA, volume 251 of LIPIcs, pages 33:1–33:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ITCS.2023.33.
  • [12] Susanna F. de Rezende, Noah Fleming, Duri Andrea Janett, Jakob Nordström, and Shuo Pang. Truly supercritical trade-offs for resolution, cutting planes, monotone circuits, and weisfeiler-leman, 2024. doi:10.48550/arXiv.2411.14267.
  • [13] Klim Efremenko, Michal Garlík, and Dmitry Itsykson. Lower bounds for regular resolution over parities. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 640–651. ACM, 2024. doi:10.1145/3618260.3649652.
  • [14] Noah Fleming, Toniann Pitassi, and Robert Robere. Extremely Deep Proofs. In Mark Braverman, editor, 13th Innovations in Theoretical Computer Science Conference (ITCS 2022), volume 215 of Leibniz International Proceedings in Informatics (LIPIcs), pages 70:1–70:23, Dagstuhl, Germany, 2022. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ITCS.2022.70.
  • [15] Lance Fortnow. Time-space tradeoffs for satisfiability. J. Comput. Syst. Sci., 60(2):337–353, 2000. doi:10.1006/jcss.1999.1671.
  • [16] Lance Fortnow, Richard J. Lipton, Dieter van Melkebeek, and Anastasios Viglas. Time-space lower bounds for satisfiability. J. ACM, 52(6):835–865, 2005. doi:10.1145/1101821.1101822.
  • [17] Ankit Garg, Mika Göös, Pritish Kamath, and Dmitry Sokolov. Monotone circuit lower bounds from resolution. Theory Comput., 16:1–30, 2020. Preliminary version in STOC 2018. doi:10.4086/TOC.2020.V016A013.
  • [18] Mika Göös, Gilbert Maystre, Kilian Risse, and Dmitry Sokolov. Supercritical tradeoffs for monotone circuits, 2024. doi:10.48550/arXiv.2411.14268.
  • [19] Dmitry Itsykson and Dmitry Sokolov. Lower bounds for splittings by linear combinations. In Erzsébet Csuhaj-Varjú, Martin Dietzfelbinger, and Zoltán Ésik, editors, Mathematical Foundations of Computer Science 2014 - 39th International Symposium, MFCS 2014, Budapest, Hungary, August 25-29, 2014. Proceedings, Part II, volume 8635 of Lecture Notes in Computer Science, pages 372–383. Springer, 2014. doi:10.1007/978-3-662-44465-8_32.
  • [20] Dmitry Itsykson and Dmitry Sokolov. Resolution over linear equations modulo two. Ann. Pure Appl. Log., 171(1), 2020. doi:10.1016/j.apal.2019.102722.
  • [21] Noam Nisan and Avi Wigderson. Rounds in communication complexity revisited. SIAM J. Comput., 22(1):211–219, 1993. doi:10.1137/0222016.
  • [22] Pavel Pudlák. On extracting computations from propositional proofs (a survey). In Kamal Lodaya and Meena Mahajan, editors, IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science, FSTTCS 2010, December 15-18, 2010, Chennai, India, volume 8 of LIPIcs, pages 30–41. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2010. doi:10.4230/LIPIcs.FSTTCS.2010.30.
  • [23] Alexander A. Razborov. Unprovability of lower bounds on circuit size in certain fragments of bounded-arithmetic. Izvestiya. Math., 59(1):205–227, 1995.
  • [24] Alexander A. Razborov. A new kind of tradeoffs in propositional proof complexity. J. ACM, 63(2):16:1–16:14, 2016. doi:10.1145/2858790.
  • [25] Dmitry Sokolov. Dag-like communication and its applications. In Pascal Weil, editor, Computer Science – Theory and Applications – 12th International Computer Science Symposium in Russia, CSR 2017, Kazan, Russia, June 8-12, 2017, Proceedings, volume 10304 of Lecture Notes in Computer Science, pages 294–307. Springer, 2017. doi:10.1007/978-3-319-58747-9_26.
  • [26] R. Ryan Williams. Time-space tradeoffs for counting NP solutions modulo integers. Comput. Complex., 17(2):179–219, 2008. doi:10.1007/s00037-008-0248-y.

Appendix A Appendix

In this section, we show that the functions 𝖨𝖭𝖣1 and 𝖬𝖠𝖩3 are strongly stifled and 𝖨𝖯2 is not strongly stifled.

Observation 8. [Restated, see original statement.]

The functions 𝖨𝖭𝖣1 and 𝖬𝖠𝖩3 are strongly stifled.

Proof.

We present collections of (i,b)-stifling patterns P(𝖨𝖭𝖣1) and P(𝖬𝖠𝖩3) for 𝖨𝖭𝖣1 and 𝖬𝖠𝖩3, respectively. It is straight-forward to verify that these collections are converting collections of stifling patterns for 𝖨𝖭𝖣1 and 𝖬𝖠𝖩3.

Table 1: P(𝖨𝖭𝖣1).
i b 0 1
1 (,0,0) (,1,1)
2 (1,,0) (1,,1)
3 (0,0,) (0,1,)
Table 2: P(𝖬𝖠𝖩3).
i b 0 1
1 (,0,0) (,1,1)
2 (0,,0) (1,,1)
3 (0,0,) (1,1,)

Observation 9. [Restated, see original statement.]

The function 𝖨𝖯2 is not strongly stifled.

Proof.

The only (1,1)-stifling pattern for 𝖨𝖯2:{0,1}4{0,1} is δ1:=(,1,0,1). Similarly, the only (2,1)- and (4,1)-stifling patterns for 𝖨𝖯2 are δ2:=(1,,1,0), and δ4:=(1,0,1,), respectively. Now, let D={2,4}. There is no jD such that δ1[D{j}]=δj[D{j}] as required to be a strongly stifled function.