Automating Tree-Like Resolution in Time n o (log n ) Is ETH -Hard

We show that tree-like resolution is not automatable in time n o (log n ) unless ETH is false. This implies that, under ETH , the algorithm given by Beame and Pitassi (FOCS 1996) that automates tree-like resolution in time n O (log n ) is optimal. We also provide a simpler proof of the result of Alekhnovich and Razborov (FOCS 2001) that unless the ﬁxed parameter hierarchy collapses, tree-like resolution is not automatable in polynomial time. The proof of our results builds on a joint work with G¨o¨os, Nordstr¨om, Pitassi, Robere and Sokolov (STOC 2021), which presents a simpliﬁcation of the recent breakthrough of Atserias and M¨uller (FOCS 2019)


Introduction
The P vs NP problem is equivalent to the question of whether there exists a polynomial-time algorithm that given a 3-CNF formula determines if it is satisfiable. If such an algorithm exists, then given an unsatisfiable formula the execution trace of the algorithm can be seen as a polynomial size proof-formalizable in some system-of unsatisfiability. Therefore, the P vs NP problem can be broken into two parts: (i) Do all unsatisfiable formulas F admit polynomial size proofs of unsatisfiability?
(ii) If an unsatisfiable formula F admits polynomial size proofs of unsatisfiability, can we find one in polynomial time?
Answering any of these questions negatively would prove that P = NP, and answering both of them positively would imply that P = NP. Proof complexity provides a natural framework for studying these questions and, moreover, studying specific proof systems allows us to perceive the potential and limits of the class of algorithms that are based on these systems. Traditionally, more attention has been given to the first question, but since the late 90's there has been a growing interest in the second [BP96, Iwa97, KP98, BPR00, ABMP01, BDG + 04, AB04, AR08, GL10] with a more recent revival [MPW19, AM20, GKMP20, Gar20, Bel20, dRGN + 21] mainly due to the breakthrough result of Atserias and Müller [AM20].
To formalize the proof search problem, Bonet, Pitassi and Raz [BPR00] introduced the notion of automatability. A proof system P is said to be automatable in time f (n) if there is an algorithm that given any unsatisfiable formula F outputs a P-refutation of F in time f (n), where n is the size of the smallest P-refutation of F plus the size of F .
In this paper, we focus on the (non-)automatability of tree-like resolution. Tree-like resolution stands out for being a natural non-trivial proof system that is known to be automatable in quasipolynomial time. This was observed by Beame and Pitassi in [BP96], where they presented a quite straightforward algorithm that automates tree-like resolution in time n O(log n) . Whether this simple algorithm is optimal was left open.
Alekhnovich and Razborov [AR08] provided the first evidence that tree-like resolution is not-automatable in polynomial time. Their result, together with a derandomization procedure from [EGG08], implies that if tree-like resolution is polynomial-time automatable then W[P] = FPT. More recently, Mertz, Pitassi and Wei [MPW19] proved that if tree-like resolution is automatable in time n O(log 1/7− log n) then ETH is false. We note that these two results are incomparable since W[P] = FPT implies ETH is false but the other direction is not known to hold.
In this work, we strengthen the latter result and, under ETH, settle the question of tree-like resolution's automatability. The proof builds on [dRGN + 21] which presents a simplification of the recent breakthrough result of Atserias and Müller [AM20]. By generalizing the approach slightly, we are also able to provide an alternative, arguably much simpler proof of the result of Alekhnovich and Razborov [AR08].
We note that Theorem 1.1 holds even if the automating algorithm is allowed to produce DAG-like resolution refutations, or even polynomial calculus refutations. In Section 2 we present an overview of the proof and also explain how the rest of the paper is structured.

Proof overview
Before we outline the proof of the main theorem, we introduce some notation. We denote by [n] the set of integers {0, 1, . . . , n − 1}. Given an integer σ ∈ 2 k , we denote by σ i the (i + 1)st least significant bit of σ, so that σ = i∈ [k] Let F be a CNF formula, that is, a conjunction of clauses, over variables x i for i ∈ [n]. A literal is either a variable or its negation. We denote the negation of a variable x i by x i and also use the notation x 1 i = x i and x 0 i = x i . We refer to the clauses of F as axioms of F , and sometimes view a clause as a set of literals. The width of a clause D, denoted |D|, is the number of literals in the clause, and the width of a CNF formula F is w(F ) = max D∈F |D|. A resolution refutation of F is a sequence of clauses P = (D 0 , D 1 , . . . , D s−1 = ⊥) such that, for each i ∈ [s], either D i is an axiom of F or it is derived from previous clauses by the resolution rule where x k ∈ D j , x k ∈ D j and j, j < i, or by weakening D i ⊇ D j , where j < i. The size of the refutation P is s and the width of P is the maximum width of any clause D i in P. We denote by w(F ⊥) the minimum width over all refutations of F . A refutation is said to be tree-like if every clause appearing in the refutation is used in at most one derivation step. The polynomial calculus proof system is defined in Section 6. For this overview it is enough to note that it polynomially simulates resolution.
A circuit with OR (∨), AND (∧), and NOT (¬) gates that receives as input n Boolean variables is referred to as an n-variate (Boolean) circuit. An n-variate circuit C is satisfiable if there is an assignment to the n input variables such that C outputs 1; otherwise C is unsatisfiable. The size of the circuit is the number of wires.
The exponential time hypothesis (ETH), which is a strengthening of the P = NP conjecture, states that 3-SAT cannot be solved in subexponential time, i.e., that there is no algorithm that, for any 3-CNF formula F over n variable, determines whether F is satisfiable in time 2 o(n) . The class of all fixed parameter tractable problems is denoted FPT and can be viewed as the "parameterized P". There is a whole hierarchy of classes that can be viewed as the "parameterized NP" and W[P] is placed at the top of this hierarchy. We note that the complexity assumption W[P] = FPT is in between ETH and P = NP, that is, ETH implies W[P] = FPT which implies P = NP. We refer the reader to the textbook [FG06] for an excellent survey on parameterized complexity. For our purposes, we only need the following classical result.
Theorem 2.1 (Theorem 6.3 in [ADF95], see also Theorem 3.25 in [FG06]). If there is an algorithm that given any n-variate circuit C of size m decides whether C is satisfiable in time poly(m) · 2 n/ι(n) , where ι : N → N is a nondecreasing, unbounded computable function, then W[P] = FPT.
We would like to stress that we only use N Γ for vertices in U and, therefore, we often view N Γ as a function N Γ : We sometime denote the set of edges E by E(Γ). We consider the following definition of expanders. There are many known explicit constructions of expanders. For our applications the following special case of the construction in [CRVW02] suffices.

Main theorem
Our main theorem, from which Theorem 1.1 follows almost immediately, says that given any circuit C, it is possible to construct a CNF formula that has moderately small tree-like resolution refutations when C is satisfiable but requires much larger refutations, even in the stronger polynomial calculus proof system, when C is unsatisfiable.
Theorem 2.4 (Main theorem). There is a poly(m)·2 O( √ n) -time algorithm A that given as input an n-variate Boolean circuit C of size m, where n ≤ m ≤ 2 n , outputs a CNF formula A(C) such that: (ii) If C is unsatisfiable, then A(C) requires polynomial calculus refutations of size at least 2 Ω(n) .
This theorem is in the same spirit as its counterparts in [AM20] and [dRGN + 21], which state that given a CNF formula F it is possible to construct in polynomial time a CNF formula A(F ) that has polynomial size resolution refutations when F is satisfiable and requires resolution refutations of size 2 Ω(n) when F is unsatisfiable. This implies that resolution is NP-hard to automate. The reason the previous versions of A(F ) do not give any non-automatability result for tree-like resolution is that the upper bound strategy, when F is satisfiable, essentially produces a DAG-like refutation. Moreover, we do not expect there to be a polynomial, or even exp(o(n/ log n)), size tree-like resolution refutation of the previous versions of A(F ) since-by analyzing the algorithm from [BP96] that automates tree-like resolution in quasi-polynomial time-the former would imply that NP is in quasi-polynomial time and the latter that ETH is false.
We would like, therefore, to define some variant of the A(F ) formula of [AM20, dRGN + 21] that has a small(-ish) tree-like refutation whenever F is satisfiable. We show that this is possible by blowing up the size of the formula. There is, in fact, a certain trade-off between the size of the formula A(F ) and the tree-like upper bound we can prove for A(F ), and the best results are obtained when these two values are approximately the same. We explain this in more detail in Section 4.
Another difference between our result and that of [AM20, dRGN + 21] is that we generalize the algorithm A to receive as input any circuit and not only CNF formulas. This generalization is not necessary for obtaining items (i) and (ii) of Theorem 1.1 but is important for item (iii).

Proof of Theorem 1.1 from Theorem 2.4
Let us see how Theorem 1.1 follows from the main theorem (Theorem 2.4).
Proof of Theorem 1.1. Suppose that tree-like resolution is automatable in time f (N ) (even if allowed to output a polynomial calculus refutation), that is, that there exist an algorithm A that given an unsatisfiable formula F finds a polynomial calculus refutation of F in time f (N ), where N is the size of the smallest tree-like resolution refutation of F plus the size of F . We will use A to decide whether a circuit is satisfiable.
Let C be an n-variate circuit of size m. Let p be the largest of the two poly(m) factors that appear in the statement of Theorem 2.4. By Theorem 2.4 we have that the size of the formula A(C), which we denote by R, is at most p · 2 O( √ n) and that: • if C is unsatisfiable, any polynomial calculus refutation of A(C) requires size L ≥ 2 Ω(n) .
For items (i) and (ii) we consider the case where C is a 3-CNF formula viewed as a depth-2 circuit of size m = O(n 3 ) (hence p is polynomial in n). For item (i) our assumption is that f (N ) = N o(log N ) . In order to decide whether C is satisfiable we simply run the algorithm A on A(C) for f (R + S) steps. If C is satisfiable we are guaranteed A will return a refutation, and if C is unsatisfiable A cannot return a refutation since f (R + S) = 2 o(n) < L for any large enough n. Therefore, we are solving 3-SAT in time f (R + S) = 2 o(n) , which implies that ETH is false. For item (ii) we consider f (N ) = N O(log 1− N ) and conclude that 3-SAT can be solved in time 2 O(n 1− /2 ) .
It remains to prove item (iii), where we start with the assumption that f (N ) = O(N k ) for some constant k. We show that, for n large enough, there is an algorithm that decides whether C is satisfiable in time poly(m) · exp(O( √ n)). By Theorem 2.1 this implies that W[P] = FPT. We first note that if p ≥ L 1/2k , then m = 2 Ω(n) and the trivial algorithm that evaluates C on each of the 2 n assignments runs in time poly(m) · 2 n = poly(m). We therefore assume that p < L 1/2k . We run algorithm A on the formula A(C) for f (R + S) steps. If C is satisfiable, A is guaranteed to return a refutation. Moreover, since f (R + S) ≤ O((2p) k ) · 2 O( √ n) , which (assuming n large enough) is less than L = 2 Ω(n) by our assumption p < L 1/2k , it follows that if A did return a refutation it cannot be the case that C is unsatisfiable. Therefore, we conclude that in time f (R + S) = poly(m) · 2 O( √ n) we can decide C's satisfiability.
The rest of the paper is dedicated to the proof of Theorem 2.4. Let C be an n-variate circuit with m gates. The formula output by the algorithm A of Theorem 2.4 when receiving C as input is the CNF formula ShallowRef(C) that is defined in Section 3. This definition is, perhaps, the most important technical contribution of this paper. The construction is based on the formula Ref(F ) of [AM20, dRGN + 21] but requires some non-trivial modifications. Once the correct definition is in place, proving Theorem 2.4 is a rather straightforward adaptation of previous works [AM20, dRGN + 21].
In Section 4, we exhibit a tree-like resolution refutation of ShallowRef(C), when C is satisfiable, in size poly(m) · 2 O( √ n) proving the upper bound in Theorem 2.4. Then, in Section 5, we prove the lower bound of Theorem 2.4 for DAG-like resolution by showing that, when C is unsatisfiable, ShallowRef(C) requires DAG-like resolution refutations of size at least 2 Ω(n) . This is done by first proving a width lower bound via a reduction to the pigeonhole principle (as was done in [dRGN + 21], although here we use a slightly different encoding based on expander graphs in order to get optimal parameters) and then applying the well-known size-width relation of Ben-Sasson and Wigderson [BW01]. Finally, in Section 6 we show that the lower bound holds even for the polynomial calculus proof system. We wrap-up in Section 7 with some open problems.

The formula ShallowRef (C)
Given a CNF formula F over n variables, the formula Ref(F ) of [AM20, dRGN + 21] encodes that there is a resolution refutation of F of some fixed polynomial size. It is convenient to view this purported refutation as being layered in such a way that every clause at a given layer is obtained from two clauses in the layer precisely below it and that there are a total of n layers, each with poly(n) clauses.
As mentioned earlier, it seems that the formula Ref(F ) cannot give non-automatability results for tree-like resolution. Indeed, it might well be the case that tree-like resolution requires size at least 2 Ω(n) to refute Ref(F ), regardless of F 's satisfiability. The problem is that the resolution refutation upper bound in [AM20, dRGN + 21], when F is satisfiable, is crucially DAG-like. It consists of following a root-to-leaf path in the purported refutation in order to reach a leaf that contains a clause falsified by a satisfying assignment of F (leading to a contradiction). If we transform this refutation into a tree-like refutation the size blows up to exp(Ω(n log n)) since it must contain a clause for each of the exp(Ω(n log n)) different root-to-leaf paths.
Thus, in order to obtain a shorter tree-like refutation, we adapt Ref(F ) to reduce the number of root-to-leaf paths. This can be done by considering a shallow variant, which we denote ShallowRef(F ), where instead of n layers we have h n layers. If each layer has poly(n) clauses, there can be at most exp(O(h log n)) root-to-leaf paths, hence there are tree-like resolution refutations of approximately this size (which for h small enough is much smaller than the lower bound of 2 Ω(n) ).
The catch is that, given a satisfying assignment of the formula F , we must be able to trace one of these root-to-leaf paths and this requires that each clause in the purported refutation be derived from 2 n/h clauses in the layer below. This is the reason we have the trade-off, mentioned earlier, between the size of the formula ShallowRef(F ) and the tree-like resolution upper bound we can obtain. In short, for every h ∈ {1, . . . , n} we can define a version of the formula ShallowRef(F ) of size poly(n) · 2 O(n/h) that, when F is satisfiable, has a tree-like resolution refutation of size poly(n) · 2 O(h log n) .
To get the tight non-automatability results, however, we need to reduce further the number root-to-leaf paths to obtain an upper bound of poly(n) · 2 O(h) . To this end, for any given clause in the purported refutation, we restrict the clauses from the layer below that can be used to obtain it. Figure 1: Structure of the blocks of ShallowRef(C), where h = √ n and s = m2 2n/h . Red blocks are internal blocks and each one has p = 2 n/h pointers (represented by blue circles). Green blocks are leaf blocks and each one is associated to a copy of the circuit C. This is done by considering a constant degree expander between layers and, for such an expander to exists, increasing the number of clauses per layer to 2 Θ(n/h) . Finally, we choose h = √ n so that both the size of the formula and that of the tree-like refutation are approximately the same.
Another difference from Ref(F ) is that ShallowRef(C) is defined for any circuit C while Ref(F ) is defined only for CNF formulas F . As noted before, this generalization is necessary in order to obtain item (iii) in Theorem 1.1. We point out that this requires that we encode 2 Θ(n/h) copies of the circuit C in ShallowRef(C) (one for every leaf of the purported refutation).
We now proceed to define the formula ShallowRef(C). Let C be a Boolean circuit-i.e., with OR (∨), AND (∧), and NOT (¬) gates and Boolean inputs-of size m and let x 0 , . . . , x n−1 be its input variables. For simplicity, we assume C has fan-in 2 (otherwise we can construct in time O(m) a circuit C of fan-in 2 that computes the same function as C and that has size at most 2m).

Variables of ShallowRef (C)
The variables of ShallowRef(C) are structured in sh + 1 blocks set up in h + 1 layers (see Figure 1): for α ∈ {1, . . . , h}, layer α contains blocks B α,0 , . . . , B α,s−1 . The first block B 0,0 is alone on layer 0 and is called the root. Blocks on layer h are called leaf blocks and all non-leaf blocks (including the root) are internal blocks.
The idea is for each block to contain a partial assignment, 1 each internal block to have p pointers, one for each of the different ways of extending the current assignment to the next log p variables, and each leaf block to have a copy of the circuit C. One caveat is that each pointer only has a constant number of blocks in the layer below that it can point to, and these options are given by the fixed expander graph Γ. Formally, for each block B we have the following Boolean variables: • Enabled variable. There is one variable enbl B encoding whether the block B is enabled or not.
• Literal set variables. There are 2n many indicator variables lit B , one for each of the literals ∈ {x 0 , x 0 , . . . , x n−1 , x n−1 }. This defines the set of literals corresponding to a partial assignment at B. The intended interpretation is that lit B = 1 if and only if the partial assignment in block B assigns to true. (Note that assignments are defined for literals and can be inconsistent if both lit B x = 1 and lit B x = 1. Moreover, lit B = 0 simply means that the partial assignment does not assign to true, and not that it assigns to false.) And if B is a leaf block we have: • Circuit variables. There is one copy of the circuit C per leaf block. This means that there are m = |C| variables gate B g for g ∈ [m] that encode the value of each gate (of this copy) of the circuit C. The intention is that these variables encode the evaluation of each gate on the assignment at the leaf block B.

Axioms of ShallowRef (C)
The axioms of ShallowRef(C) can be partitioned into three groups: root axioms, internal block axioms and circuit axioms.
Root axioms. Let B = B 0,0 be the root. This first group of axioms consists of the unit clause enbl B and the 2n unit clauses enforcing the root to be enabled and to contain the empty assignment.
Internal block axioms. For each of the s(h − 1) + 1 internal blocks, we have a set of axioms encoding that each of its children extends the partial assignment in the block to the next log p variables in a different way.
Let B = B α,i be an internal block. For σ ∈ p , we have the clause encoding that the σth child should exist. Now let L σ = {x σ 0 α log p , x σ 1 α log p+1 , . . . , x σ log p−1 α log p+log p−1 } be the set of literals that are not in B and that we expect the σth child of B to contain, and let L σ = {x 0 , x 0 , . . . , x n−1 , x n−1 } \ L σ . For succinctness, we denote by B j the block B α+1,j .
For every σ ∈ p , and every j ∈ N Γ (ip + σ) we have the following set of axioms encoding that if B is enabled and B j is the σth child of B, then B j must be enabled and contain exactly the literals in L σ union the literals contained in B. Note that, to make the semantics clearer, we use the notation C → D, for C being a conjunct and D a clause, to denote the clause ¬C ∨ D. This yields a total of (s(h − 1) + 1)p clauses of width at most ∆ If g is an input gate gate B g = lit B , where is the input variable of g.
If g is a NOT gate where g is the input gate of g.
If g is an AND gate gate B g = gate B g ∧ gate B g , where g and g are the input gates of g. (10) If g is an OR gate gate B g = gate B g ∨ gate B g , where g and g are the input gates of g. (11) Finally, we have one extra constraint gate B g = 0, where g is the sink gate of C, enforcing that the circuit output 0. Note that each of these m + 1 constraints can be encoded by at most 3 clauses, all of width at most 3.

Upper bound for ShallowRef (C)
In this section we prove the upper bound in Theorem 2.4, namely we show that, if C is a satisfiable n-variate circuit of size m, there is a tree-like resolution refutation of ShallowRef(C) of size at most poly(m) · 2 O( √ n) . We again consider the parameters h = √ n, p = 2 n/h and s = mp 2 , and fix the (r, ∆, ∆/2)-boundary expander Γ = Γ sp s given by Theorem 2.3, where we recall that r = Θ(s) and ∆ = Θ(1).
We prove the upper bound by considering the falsified clause search problem on the formula, that is, the problem of, given a total assignment to the variables of the formula, finding a falsified clause. A decision tree that solves the falsified clause search problem on an unsatisfiable formula F is a decision tree that queries the variables of F and, at each leaf, outputs a clause of F that is falsified by the partial assignment given by the queries that lead to this leaf.
We proceed to describe a decision tree solving the falsified clause search problem on ShallowRef(C) that is of size poly(m) · 2 O(h) , and, by the classical equivalence between decision trees solving the falsified clause search problem on F and tree-like resolution refutations of F (see, e.g., [BIW04, Lemma 7]), item (i) of Theorem 2.4 follows directly.
Intuition. The main idea is to fix a satisfying assignment x * of the circuit C and then walk down the blocks of ShallowRef(C) from the root block to a leaf block, keeping the invariant that the current block contains a partial assignment of x * . At each step, since the axioms of ShallowRef(C) guarantee that it is possible to extend the current partial assignment to the next log p variables in every possible way, we can either move to a child-block that contains a larger partial assignment of x * or we already find a falsified axiom of ShallowRef(C). If we reach a leaf block of ShallowRef(C), the partial assignment at this block is all of x * and we can therefore detect a falsified axiom of ShallowRef(C) with a decision tree of size O(m). Indeed, since x * satisfies C, we can evaluate each gate of C and either find a gate that computes its output incorrectly, or find that the circuit C outputs 1. Either way, we have found a falsified axiom of ShallowRef(C). The size of this tree is approximately the number of different root-to-leaf paths, that is,

multiplied by O(m).
Formal proof. Let x * be a satisfying assignment of C, and let L be the set of n literals satisfied by x * ordered according to the index (that is, the ith literal of L is either x i or x i ). We say a node of the decision tree is open if the partial assignment given by the queries leading to this node does not falsify any axiom of ShallowRef(C). Otherwise, we say the node is closed or is a leaf.
Let B = B 0,0 be the the root of ShallowRef(C). The decision tree starts by querying the enabledvariable enbl B (one query and leaves one open node since there is an axiom of ShallowRef(C) that says the root is enabled). Then it queries the indicator variables lit B for all 2n literals . The branches in which any of these queried literals are present falsifies the axiom of ShallowRef(C) that says that the root does not contain this literal. Therefore, so far we have a decision tree with 2n + 1 leaves and one open node. We label this open node with B.
The decision tree then repeats the following iterative process, keeping the invariant that at the beginning of each iteration the current open node is labeled with some internal block B = B α,i and the partial assignment leading to this node determines that B is enabled and that the literals present in B are exactly the α log p first literals of L.
Let σ ∈ p be such that x * assigns to the variable x α log p+j the value σ j for all j ∈ [log p]. The decision tree queries one by one the ≤ ∆ variables of the σth pointer of B, that is, variables pntr B,σ j for j ∈ N Γ (ip + σ), until it finds one that is 1 or finds that all are 0. The node corresponding to all pointer variables being 0 contradicts the axiom that states that the σth child should exist. For each j ∈ N Γ (ip + σ) let v j be the node reached if pntr B,σ j = 1. At each of these nodes, we repeat the queries done for the root. To be precise, fix an open node v j and let B = B α+1,j . The decision tree queries the enabled variable enbl B and the indicator variables lit B for the 2n literals. Observe that if B is not enabled or does not contain exactly the first (α + 1) log p first literals of L, then we immediately falsify one of the clauses of ShallowRef(C). Therefore, we are left with one open node, say v j , which we label with B . If B is not a leaf block, v j satisfies the invariant and we repeat the process. We note that the subtree constructed in each iteration has ≤ ∆(2n + 1) + 1 leaves and ≤ ∆ open nodes.
After h steps, we reach a leaf block B h,i . Here the decision tree queries all circuit variables c B g , starting from the input gates and only querying gates for which its input gate(s) have already been queried. In this way, we obtain a subtree with m + 1 leaves: m leaves correspond to a gate that did not correctly compute its output given its input(s) and one leaf corresponds to all gates computing correctly and, since x * satisfies C, the circuit outputting 1. For each of these leaves there is some clauses of ShallowRef(C) that is falsified.
This completes the decision tree since there are no more open nodes. The number of leaves of the tree is at most and, therefore, the size of the tree is at most . This concludes the proof of the upper bound in Theorem 2.4.

Lower bound for ShallowRef (C)
We now prove the lower bound in Theorem 2.4, which states that, if C is an unsatisfiable n-variate circuit, then any DAG-like resolution refutation of ShallowRef(C) requires size 2 Ω(n) . The main step in this proof is to show a resolution width lower bound and the size lower bound then follows by the size-width relation of Ben-Sasson and Wigderson.
where for the first inequality we use the fact that m ≤ 2 n and thus log s = O(n). We prove the width lower bound (13) via a reduction to a convenient version of the pigeonhole principle. The formula we use is a graph version of the retraction pigeonhole principle, rPHP [Jeř07,PT19]. The retraction pigeonhole principle was also used in [dRGN + 21] to prove a similar reduction. We note, however, that we require a weaker version (with more pigeons) and that we define it over a graph in order to match the definition of ShallowRef(C).
We assume the reader is familiar with standard notions of Boolean functions (see, e.g., [Juk12,§14]), in particular, that a depth d decision tree computing a Boolean function f naturally gives both a d-CNF and a d-DNF formula computing f .

Weak graph rPHP formula
In this variant of the pigeonhole principle, the pigeon-mapping is restricted to the edges of a given bipartite graph and, moreover, there is an efficient way to invert the mapping. Formally, given a bipartite graph Γ = (U The variables x i,j have the intended meaning that pigeon i is mapped to hole j, and the variables g j, for ∈ [log m] encode the pigeon that is mapped to hole j and can thus be seen as describing a function g : [n] → [m]. The formula rPHP(Γ) states that for each pigeon i ∈ U j∈N Γ (i) that is, it must be mapped to (at least) one of its neighbors, and that for every (i, j) ∈ E, or, equivalently, Note that (17) corresponds to log m clauses each of width 2. Therefore, if the left degree of Γ is at most ∆, rPHP(Γ) can be written as an O(∆)-width CNF formula with O(n∆ log m) clauses. It was shown in [BW01] that if Γ is a good enough expander, then the pigeonhole principle formula over Γ requires large width to be refuted in resolution. The proof presented in [BW01] is for the classical encoding of the graph pigeonhole principle, but it is straightforward to see that it also holds for rPHP(Γ).

Decision tree reductions
Our goal is to show, via a moderately small-depth reduction that the width required for refuting ShallowRef(C) is almost as large as the width required for refuting rPHP(Γ sp s ). For the definition of reduction, we view a clause as a function, that is, given a CNF formula G over m variables, we view a clause D ∈ G as a function from {0, 1} m to {0, 1}, which can be computed by a depth-|D| decision tree. In this way, given a function r : {0, 1} n → {0, 1} m , D • r is a function from {0, 1} n to {0, 1}. Moreover, if r i is computed by a depth-d decision tree, then D • r can be naturally written as a (d · |D|)-CNF formula over n variables. • for every axiom D ∈ G, each clause in the representation of D • r as a (d · |D|)-CNF formula (as discussed above) is a weakening of some axiom of F .
The important property of reductions that we use is that width bounds carry over.
For the rest of this section, let Γ = Γ sp s be the boundary expander given by Theorem 2.3. Combining Lemmas 5.2 and 5.4 implies that, in order to obtain (13), it is enough to show that

Overview of the reduction
The proof of the reduction is similar to that of [dRGN + 21]. The main difference is that in [dRGN + 21] the reduction is guided by a full binary tree of height n and our reduction is guided by a full tree T of height h = √ n and arity p = 2 n/h . Recall that we consider a fixed ordering x 0 , . . . , x n−1 of the variables of C. Each node of T contains a partial assignment, which, as before, we identify with the set of literals that are satisfied by the assignment. The root contains the empty assignment and each node at distance α from the root contains an assignment to the first α log p variables defined recursively as follows. If a non-leaf node at distance α from the root contains the partial assignment ρ to the first α log p variables, each of its p children contains one of the possible extensions of ρ to the next log p variables, that is, for σ ∈ [p], the σth child contains the assignment Thus, T has 2 n leaves each containing a different full assignments to the n variables of C (see Figure 2 for an example).
The formula ShallowRef(C) is, intuitively, saying that this tree T "fits" in a tree with s blocks per layer, that is, that there is a mapping from nodes of T to blocks of ShallowRef(C). At a high-level, the reduction defines an rPHP(Γ) instance between every two consecutive layers of ShallowRef(C) so that refuting ShallowRef(C) amounts to refuting one of the instances of rPHP(Γ).
We now prove the reduction formally. For each variable of ShallowRef(C), we describe a O(n)depth decision tree that computes its value by querying variables of rPHP(Γ). This defines the reduction function r and shows it satisfies the first condition of Definition 5.3. We then argue that r also satisfies the second condition.

The reduction function
We start by describing the decision trees that compute the variables of ShallowRef(C). For simplicity, we sometimes describe one decision tree that computes several variables at once. Recall that the variables of rPHP(Γ) are x i,j for (i, j) ∈ E(Γ) and g j, for j ∈ [s] and ∈ [log sp], and that the latter set of variables defines a function g : Pointer variables. The pointer variables are defined in terms of the variables of rPHP(Γ). Since each block has p pointers, each layer α ∈ {1, . . . , h − 1} has a total of sp pointers (layer 0 has only one block and thus only p pointers) that should be mapped to the s blocks at level α + 1. The idea is to define this mapping by "copying" the rPHP(Γ) mapping from the sp pigeons to the s holes. Formally, for α ∈ {0, 1, . . . , h − 1}, let B = B α,i be an internal block, let σ ∈ p and let k = ip + σ. For all j ∈ N Γ (k), we define the pointer variable pntr B,σ j = x k,j . This can clearly be done by a decision tree of depth 1.

Enabled and literal set variables.
We have now reached the most complicated part of the reduction. Consider the function g : ) and x g(j),j = 1 otherwise.
In order to determine whether a block B = B α,j is enabled or not and what literal set it contains, we recursively define a path of blocks and pointers starting from B, denoted path(B), in the following way. If B is the root or if g (j) = , then the path ends at B, that is, path(B) = B. Otherwise, let Note that j and σ are defined so that the σth pointer of the block B = B α−1,j is j, that is, pntr B ,σ j = x g(j),j = 1. We define path(B) to be (B, σ) concatenated with path(B ). We are now ready to define a decision tree that computes the enabled variable and the literal set variables of the block B. In order to do so, the decision tree must compute path(B), which can be done in depth O(h log s) = O( √ n log s). Indeed, the length of path(B) is at most h and to determine the next block in a path it is enough to compute g , which can be done with O(log sp) = O(log s) queries to the variables of rPHP(Γ).
Once path(B) is determined, the decision tree outputs the value of the variables as follows. If path(B) does not end at the root, the enabled variable enbl B and the literal variables lit B for ∈ {x 0 , x 0 , . . . , x n−1 , x n−1 } are all set to 0. If path(B) ends at the root, let π be the reverse of path(B). Note that π defines a unique path in the tree T starting from the root and following the pointers in π. This path in T ends in some block B at level α. The decision tree sets the enabled variable enbl B to 1 and sets the literal variables lit B for ∈ {x 0 , x 0 , . . . , x n−1 , x n−1 } to match the assignment of the block B .
Circuit variables. The circuit variables are computed "honestly" given the assignments contained at the leaf blocks. That is, in order to determine the circuit variables for the leaf block B = B h,i , the decision tree computes path(B) (in depth O( √ n log s)), in this way determining the literal variables of B, and then it outputs the value of each circuit variable gate B g to be consistent with the literal variables. We note that, if path(B) does not end at the root, then the literal variables of B are all set to 0 and the circuit variable gate B g are simply the value of the gate on the all zero input.
Therefore, we conclude that the reduction r satisfies the required condition that for each i there is a decision of depth O(n) that computes r i .

Correctness of the reduction
We now show that the reduction satisfies the second condition of Definition 5.3. Recall that r is the function defined by the decision trees described above. Let D be an axiom of ShallowRef(C). It is enough to show that for every partial assignment ρ to the variables of rPHP(Γ), if ρ falsifies D • r then ρ falsifies an axiom of rPHP(Γ).
We first note that, by definition of r, if D is a root axiom or a circuit axiom, then D • r is a tautology, that is, for any full assignment ρ to the variables of rPHP(Γ), the formula D • r is satisfied. It remains to consider the case when D is an internal block axiom. If D is one of the axioms (3) of ShallowRef(C), that is, the axiom j∈N Γ (ip+σ) pntr B,σ j for some block B = B α,i and some σ ∈ p , then we have found that ρ does not map pigeon ip + σ to any of its neighbors (falsifying axiom (15) of rPHP(Γ)). If D is one of the axioms (4)-(7) of ShallowRef(C) involving some block B = B α,i , some σ ∈ p and some block B j = B α+1,j , it must be the case that, under ρ, block B is enabled (i.e., enbl B = 1 and thus path(B) reaches the root), its σth child is block B j (i.e. pntr B,σ j = 1), and either B j is not enabled (falsifying axiom (4)) or it does not contain the right set of literals (falsifying one of the axioms (5)-(7)). Let k = ip + σ. Since pntr B,σ j = 1, by the definition of the reduction r, it follows that x k,j = 1. Now if g(j) = k, then path(B j ) would have been (B j , σ) concatenated with path(B). But by the definition of r, this would imply that B j reaches the root (hence is enabled) and that it contains the set of literals compatible with being the σth child of B. This contradicts the fact that one of the axioms (4)-(7) is falsified, so it must be the case that g(j) = k and thus one of the axioms (17) of rPHP(Γ) that encode that x k,j =⇒ g(j) = k must be falsified. This completes the proof of the reduction.

Generalization for polynomial calculus
We now prove that the lower bound of Theorem 2.4 holds for the polynomial calculus proof system [CEI96,ABRW02]. In this section, all polynomials are over the polynomial ring F[X], where F is a fixed field and X is a set of formal variables. We define the size of a polynomial p, denoted by p , to be the number of non-zero monomials of p when expanded as a linear combination of monomials.
Polynomial Calculus. A polynomial calculus (PC) derivation (over F) of a polynomial equation p = 0 from a set of polynomial equations F = {f 0 = 0, . . . , f m−1 = 0} is a sequence of polynomials P = (p 0 , . . . , p t−1 ) such that p t−1 = p and for each i ∈ [t] either: • Axiom: p i = 0 ∈ F ; or • Linear combination: p i = αp j + βp j for some α, β ∈ F and j, j < i; or • Multiplication: p i = xp j for some x ∈ X and j < i.
The size of the derivation is P := i∈[t] p i and its degree is deg(P) := max i∈[t] deg(p i ). A PC refutation of F is a PC derivation of 1 = 0 from F . We denote by deg(F ⊥) the minimum degree of any PC refutation of F . We sometimes refer to the equation in F as axioms.
Given a CNF formula F over variables var(F ) we consider the standard translation of F into a set of polynomial equations F * that has the same set of satisfying assignments. For every variable x ∈ var(F ), we include in F * Boolean axioms x 2 − x = 0 (enforcing x ∈ {0, 1}). For every clause i∈I in F , the set F * contains the equation where we interpret 1 as true and 0 as false. We also include twin variables, that is, formal variables x for every variable x ∈ var(F ), with the corresponding Boolean axioms x 2 − x = 0 and complementary axioms x + x − 1 = 0 (enforcing x and x take complementary values). Henceforth, we often do not distinguish between F and its translation F * . We note that using twin variable we could have the equation i∈I x i · j∈J x j = 0 instead of (22), but for our purposes the precise encoding is not relevant since the CNF formulas we consider have constant width and thus it is possible to derive one from the other in constant degree and size. It was shown in [ABRW02] that PC with twin variables-sometimes referred to as PCR-polynomially simulates resolution with respect to size.
The strategy for proving the PC size lower bound is the same as for resolution. We first prove a degree lower bound and then, by the size-degree relation of [IPS99], we obtain a size lower bound. Therefore, it is enough to prove a degree lower bound of where s = mp 2 and p = 2 √ n are defined as before. To do so, we can use the same reduction as defined in Section 5 since it was shown in [dRGN + 21] that decision tree reductions-and even the more general algebraic reductions-transfer polynomial calculus degree hardness.
However, in order to apply this lemma to ShallowRef(C), and complete the proof of the size lower bound, we need a lower bound on the degree of any PC refutation of rPHP(Γ sp s ). So for the rest of this section, we focus on showing that if Γ is an (r, ∆, c)-bipartite boundary expander, deg(rPHP(Γ) ⊥) ≥ rc/2.
We note that in terms of the degree required to refute a formula, it does not matter whether we include twin variables or not, since given a refutation with twin variables we can substitute every occurrence of a variable x by (1 − x) and this yields a valid refutation in the same degree. Therefore, when proving degree lower bounds we consider the encoding without twin variables.
First we consider the more classical encoding of the graph pigeonhole principle. Let Γ = (U . ∪V, E) be a bipartite graph. We define aPHP(Γ) to be the following system of polynomial equations over variables x i,j for (i, j) ∈ E(Γ): "each pigeon occupies a hole," "no hole houses two pigeons," We can define rPHP(Γ) in a similar way, where we write g (1) := g and g (0) := 1 − g for short: "no hole houses two pigeons," x Boolean axioms," We refer to the variables g j, as type-g variables and to the variable x i,j as type-x variables. Note that instead of translating the clauses j∈N Γ (i) x i,j of rPHP(Γ) into j∈N Γ (i) (1 − x i,j ) = 0, we included the equation j∈N Γ (i) x i,j = 1. The latter equation is a stronger constraint: it is enforcing that each pigeon be mapped to exactly one hole. Since the graphs we are interested in have constant left degree-and hence these equations are over a constant number of variables-by the implicational completeness of PC it is possible to derive the former from the latter in constant degree.
Alekhnovich and Razborov [AR03] (see also [MN15]) proved a PC degree lower bound for refuting aPHP(Γ) when Γ is a good enough expander. In [dRGN + 21] it was shown that (the standard, non-graph version of) aPHP can be reduced, via an algebraic reduction, to (the standard version of) rPHP. The same reduction also works for the graph versions and, therefore, by Lemma 6.3 PC requires large degree to refute rPHP(Γ) when Γ is a good enough expander. We include a self-contained proof that is essentially that of [dRGN + 21], except that in our setting it can be made even simpler so we avoid defining algebraic reductions and resorting to the generic "reduction preserves degree" lemma of [dRGN + 21]. ∪ V, E) be any bipartite graph (not necessarily an expander). We show that, given a PC refutation P = {p 0 , . . . , p t−1 } of rPHP(Γ) in degree d, we can construct a PC refutation P of aPHP(Γ) also in degree d. The lemma then follows from Lemma 6.3.
For each polynomial p i ∈ P, let p i be the polynomial obtained by substituting the g-variables by g j, := i∈I x i,j , where I := {i : (i, j) ∈ E(Γ), i = 1} are the pigeons that can be mapped to j and that have the th bit equal to 1. Each polynomial p i is now only on type-x variables and the degree has not increased, that is, deg(p i ) ≤ deg(p i ). We argue by induction over i that if p i is derived from rPHP in degree d, then p i can be derived from aPHP in degree d.
• Linear Combination. If p i is derived by linear combination from p k and p k for k, k < i, then p i can be derived by the same linear combination from p k and p k .
• Multiplication. If p i is derived by multiplying p k by a variable v for k < i then, if v is a type-x variable, p i can be derived by multiplying p k by the same variable v; if v = g j, is a type-g variable, p i can be derived by several applications of the multiplication rule to p k , each by one of the variables {x i ,j : i ∈ I }, and then adding these by repeatedly applying the linear combination rule.
In both cases degree of the derivation is preserved. It remains to argue that if p i is an axiom of rPHP(Γ), then p i can be derived in low degree from aPHP(Γ). We only need to consider the axioms that involve type-g variables. We first consider the Boolean axioms of rPHP(Γ) for variables g j, , which can be derived as follows: In order to derive x i,j · g (1−i ) j, (recall we write g (1) := g and g (0) := 1 − g) we consider two cases.
• Case i = 0 (where i / ∈ I ): • Case i = 1 (where i ∈ I ): Since all derivations are in degree 2, the lemma follows.

Concluding remarks
In this paper, we showed that automating tree-like resolution in time n o(log n) is ETH-hard, even if the automating algorithm is allowed to produce DAG-like resolution refutations, or even polynomial calculus refutations. The lower bound required for this result was obtained via a width/degree lower bound and then an application of the size-width [BW01] or size-degree [IPS99] relation. It would also have been possible to derive the lower bound by relativization/block-lifting, as was done in [AM20, dRGN + 21]. In this setting, we think of the variables as partitioned into blocks and define complexity measures (width, degree, depth) with respect to these blocks. While this would yield a somewhat more elaborate proof, it would slightly improve some parameters. The recent break-through result of Atserias and Müller [AM20] proved that resolution is NP-hard to automate. This result was extended to cutting planes [GKMP20], Res(k) (resolution over k-DNFs) for constant k [Gar20], ordered resolution [Bel20], and Nullstellensatz, polynomial calculus and Sherali-Adams [dRGN + 21]. There are many intriguing open problems regarding automatability; here we highlight only some of the most related to this work. What other proof systems, perhaps tree-like ones, are automatable in subexponential time? A generalization of the [BP96] algorithm that automates tree-like resolution in time n O(log n) implies that tree-like Res(k) can be automated in time n O(k log n) (see, e.g., [AB02]). Is this optimal? What can be said about tree-like Res(⊕) (resolution over linear equations mod 2) or tree-like cutting planes? (For tree-like cutting planes some partial results were obtained in [GKMP20].) Are they automatable in, even randomized, subexponential time? Are they NP-hard to automate?