On CDCL-based proof systems with the ordered decision strategy

09/09/2019 ∙ by Nathan Mull, et al. ∙ The University of Chicago 0

We prove that conflict-driven clause learning SAT-solvers with the ordered decision strategy and the DECISION learning scheme are equivalent to ordered resolution. We also prove that, by replacing this learning scheme with its opposite that stops after the first new clause when backtracking, they become equivalent to general resolution. To the best of our knowledge, this is the first theoretical study of the interplay between specific decision strategies and clause learning. For both results, we allow nondeterminism in the solver's ability to perform unit propagation, conflict analysis, and restarts, in a way that is similar to previous works in the literature. To aid the presentation of our results, and possibly future research, we define a model and language for discussing CDCL-based proof systems that allows for succinct and precise theorem statements.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

SAT-solvers have become standard tools in many application domains such as hardware verification, software verification, automated theorem proving, scheduling and computational biology (see [24, 26, 16, 31, 19] among the others). Since their conception in the early 1960s, SAT-solvers have become significantly more efficient, but they have also become significantly more complex. Consequently, there has been increasing interest in understanding the theoretical limitations and strengths of contemporary SAT-solvers. Much of the recent literature has focused on the connections between SAT-solvers and subsystems of the resolution proof system originally introduced in [12, 36].

This connection essentially started with the Davis-Putnam-Logemann-Loveland procedure (DPLL) [21], a backtracking search algorithm that builds partial assignments one literal at a time until a satisfying assignment is found or all assignments have been exhausted. Since DPLL is sound and complete, its computational trace when applied to an unsatisfiable formula is a proof of unsatisfiability. It is generally accepted as a folklore result that the computational trace of DPLL on an unsatisfiable formula can be converted into a tree-like resolution refutation. Thus, tree-like resolution lower bounds imply DPLL running time lower bounds. And in some sense, these lower bounds are tight: DPLL, given oracle access to a tree-like resolution refutation of the input formula, can run in time that is polynomial in the length of . That is, DPLL is essentially equivalent to tree-like resolution and thus can be viewed as a propositional proof system in the Cook-Reckhow sense [20].

Nearly all contemporary SAT-solvers are variants of DPLL augmented with modern algorithmic techniques and heuristics. The technique most often credited for their success is

conflict-driven clause learning (CDCL) [27, 30], so these solvers are interchangeably called CDCL SAT-solvers, CDCL solvers, or simply CDCL (for further information regarding the design of SAT-solvers, see the 2009 Handbook of Satisfiability [11]). Just as with DPLL, the computational trace of CDCL can be converted into a resolution refutation, but may no longer be tree-like or even regular. Thus, general resolution lower bounds imply CDCL running time lower bounds, but it is unclear a priori whether these bounds are tight in the same sense as above.

The line of work on the question of whether CDCL solvers simulate general resolution was initiated by Beame et al. [6] and continued by many others [23, 33, 25, 17, 8, 35, 3, 22]. The primary difference between all these papers is in the details of the model, the models considered by Pipatsrisawat and Darwich [35] and Atserias et al. [3] being perhaps the most faithful to actual implementations of CDCL SAT-solvers. But almost all models appearing in the literature make a few nonstandard assumptions.

  1. Very frequent restarts. The solver restarts roughly times for every clause in the given resolution refutation . Though many solvers do restart frequently in practice [10], it is unclear if this is really necessary for the strength of CDCL.

  2. No clause deletion policy. The solver has to keep every learned clause. In practice, some solvers periodically remove half of all learned clauses [4].

  3. Nondeterministic decision strategy. The solver uses oracle access to to construct a very particular decision strategy. In practice, solvers use heuristics [29, 32, 28].

It is natural to ask whether these assumptions can be weakened or removed entirely. In this respect, the first two assumptions have become topics of recent interest. With regards to the first, much research has been dedicated to the study of nonrestarting SAT-solvers [23, 17, 18, 14, 7]. The exact strength of CDCL without restarts is still unknown and, arguably, makes for the most interesting open problem in the area. With regards to the second, Elffers et. al. [22] proved size-space tradeoffs in a very tight model of CDCL, which may be interpreted as results about aggressive clause deletion policies.

In this paper we are primarily concerned with the third assumption, i.e. how much does the efficiency of CDCL-solvers depend on the nondeterminism in the decision strategy? To the best of our knowledge, this has not yet been considered in the literature, perhaps due to the complexity of decision strategies in contemporary SAT-solvers. We study a simple decision strategy that we call the ordered decision strategy and, as a historical motivation, we remark that it is identical to the strategy studied by Beame et. al. [5] in the context of DPLL without clause learning. It is defined naturally: when the solver has to choose a variable to assign, the ordered decision strategy dictates that it chooses the smallest unassigned variable according to some fixed order. There is still a choice in whether to fix the variable to (false) or (true), and we allow the solver to make this choice nondeterministically. If unit propagation is used, the solver may assign variables out of order; a unit clause does not necessarily correspond to the smallest unassigned variable. This possibility to “cut the line” is precisely what makes the situation much more subtle and nontrivial.

Thus, our motivating question is the following:

Is there a family of contradictory CNFs that possess polynomial size resolution refutations but require superpolynomial time for CDCL using the ordered decision scheme, for any order?

Before describing our contributions towards this question, let us briefly review analogous separations in the context of proof and computational complexities. Bonet et. al. [15] proved that a certain family of formulas requires exponential-sized ordered resolution refutations but have polynomial-sized regular resolution refutations. Bollig et. al. [13] proved that a certain boolean function requires exponential-sized ordered binary decision diagrams (OBDDs) but have polynomial-sized general BDDs. These results tell us that order tends to be a strong restriction, and the above question asks whether this same phenomenon occurs for CDCL. It is also worth noting that this question may be motivated as a way of understanding the strength of static decision strategies such as MINCE [1] and FORCE [2]. But since such decision strategies are rarely used in practice we will not dwell on this anymore.

Our contributions

Per the discussion above, a proof system that captures any class of CDCL solvers should be no stronger than general resolution. It can also be reasonably expected (and in two particular situations will be verified below as easy directions of Theorems 2.2, 2.2) that CDCL with the ordered decision strategy should be at least as strong as ordered resolution w.r.t. the same order. Our main results show that, depending on the learning scheme employed, both of these extremes can be attained. More specifically, we prove

  1. CDCL with the ordered decision strategy and a learning scheme we call is equivalent to ordered resolution (Theorem 2.2). In particular, it does not simulate general resolution.

  2. CDCL with the ordered decision strategy and a learning scheme we call FIRST-L is equivalent to general resolution (Theorem 2.2).

As the name suggests, is the same as the so-called DECISION learning scheme in the literature.111We use this slightly different name so that it fits our naming conventions below. Hence these two results, taken together, go somewhat against the “common wisdom”. Namely, it turns out that in the case of ordered decision strategy, an assertive learning scheme is badly out-performed by a scheme that, to the best of our knowledge, has not been used in practice. That said, FIRST-L is similar to the learning scheme FirstNewCut [6], and both schemes have the property that they are designed somewhat artificially to target particular resolution steps in a given refutation.

We also prove linear width lower bounds for the second variant (Theorem 2.2), which are in sharp contrast with the size-width relationship for general resolution proved by Ben-Sasson and Wigderson [9].

In all these results, the CDCL solver may arbitrarily choose the conflict/unit clause if there are several, may elect not to do conflict analysis/unit propagations at all, and may restart at any time. We work under these assumptions in part because our intention here is to focus on the impact of decision strategies. But this substantial amount of nondeterminism also allows us to identify two proof systems that are, more or less straightforwardly, equivalent to the corresponding CDCL variant. Determining the exact power of these systems constitutes the main technical part of this paper.

The first proof system might be of independent interest; we call it half-ordered resolution. For a given order on the variables, ordered resolution can be alternately described by the requirement that in every application of the resolution rule, the resolved variable is larger than any other variable appearing in both of the two antecedent clauses. We relax this requirement by asking that this property holds only for one of them, which reflects the inherent asymmetry in resolution rules resulting from clause learning in CDCL solvers. Somewhat surprisingly (at least to us), it turns out (Theorem 2) that this relaxation does not add any extra power, and half-ordered resolution is polynomially equivalent to ordered resolution w.r.t. the same order.

The second proof system (let us call it ) extends half-ordered resolution and is more auxiliary in nature. It is based on the observation that with the amount of nondeterminism we allow, all trails222A trail is essentially an ordered partial assignment constructed by CDCL during its execution. that a CDCL solver manages to create can be easily recreated when needed. Accordingly, the system works with lines of two types, one for clauses and another for trails. Clauses entail nontrivial trails via a unit propagation rule while trails can be used to enhance the half-ordered resolution rule. We show that is polynomially equivalent to resolution (Theorem 2.2), and since it is by far our most difficult result, let us reflect a bit on the ideas in its proof.

Like other CDCL-based proof systems, is not closed under restrictions or weakening, so many standard methods no longer apply. Instead, we use two operations on resolution proofs (lifting and variable deletion) in tandem with some additional structural information to give us a fine-grained understanding of the size and structure of the general resolution refutation being simulated. The properties of these operators allow for a surgery-like process; we simulate small local pieces of the refutation and then stitch them together into a new global refutation.

Theorem 2.2 may at first seem strange to those unfamiliar with CDCL-based proof systems. We allow nondeterminism in parts of CDCL that are typically deterministic, but then prove an upper bound rather than a lower bound. Morally speaking, we show that it is possible to redistribute some of the nondeterminism in the decision strategy to different parts of CDCL while maintaining the ability to simulate general resolution. Although the resulting algorithm deviates fairly drastically from standard implementations of CDCL, this deviation is not unprecedented. The correspondence between proof systems and algorithms here is very similar to the correspondence between regWRTI and a variant of CDCL with similar features called DLL-LEARN, both introduced by Buss et. al. [17]. Static proof systems are easier to analyze, but these nonstandard sources of nondeterminism manifest themselves naturally when translating CDCL into a static proof system. Like our systems, lower bounds on regWRTI imply lower bounds on standard implementations of CDCL, but recent results for regWRTI have been upper bounds [18, 14]. Of course, upper bounds are interesting in their own right, but even for those who are lower bound inclined, these results have value: they demonstrate, often nontrivially, what convenient features of simple proof systems must be dropped in order to prove separations.

Finally, in order to aid the above work (and, perhaps, even facilitate further research in the area), we present a model and language for studying CDCL-based proof systems. This model is not meant to be novel, and is heavily influenced by previous work [33, 3, 22]. However, the primary goal of our model is to highlight possible nonstandard sources of nondeterminism in variants of CDCL, as opposed to creating a model completely faithful to applications. For example, Theorem 2.2 can be written in this language as:

For any order , CDCL(FIRST-L, -D) is equivalent to general resolution.

We will also try to pay a special attention to finer details of the model sometimes left implicit in previous works. This entails several subtle choices to be made, and we interlace the mathematical description of our model with informal discussion of these choices.

The paper is organized as follows. In Section 2 we give all necessary definitions and formulate our main results as we go along.

In Section 3 we prove Theorem 2.2 on the power of with the ordered decision strategy and the learning strategy. Section 3.1 contains proof-complexity theoretic arguments about half-ordered resolution, while in Section 3.2 we establish its translation to the language of .

In Section 4 we prove Theorem 2.2 on the power of with the ordered decision strategy and the learning strategy. To that end, in Section 4.1 we show the equivalence of this system to the proof system mentioned above, and in Section 4.2 we establish that is actually equivalent to general resolution (Theorem 2.2).

In Section 5 we prove Theorem 2.2 that, roughly speaking, states that the simulation provided by Theorem 2.2 fails extremely badly with respect to width. Among other things, this implies that there does not seem to exist any useful width-size relation in the context of CDCL with ordered decision strategy.

We conclude in Section 6 with a few remarks and suggestions for future work.

2 Preliminaries and main results

Throughout the paper, we assume that the set of propositional variables is fixed as . A literal is either a propositional variable or its negation. We will sometimes use the abbreviation for and for (so that the Boolean assignment satisfies the literal ). A clause is a set of literals, thought of as their disjunction, in which no variable appears together with its negation. For a clause , is the set of variables appearing in . A CNF is a set of clauses thought of as their conjunction. For a CNF , is the set of variables appearing in , i.e. the union of for all . We denote the empty clause by 0. The width of a clause is the number of literals in it. A -CNF is a CNF in which all clauses have width .

The resolution proof system is a Hilbert-style proof system whose lines are clauses and that has only one resolution rule


We will sometimes make use of the notation .

The size of a resolution proof , denoted as , is the number of lines in it. For a CNF and a clause , is the minimal possible size of a resolution proof of the clause from clauses in ( if is not implied by ). Likewise, is the minimal possible width of such a proof, defined as the maximal width of a clause in it. For a proof that derives from , the clauses in that appear in are called axioms, and if then is called a refutation. Let denote the set of variables appearing in , i.e. the union of for appearing in .

Note that the weakening rule

is not included by default. In the full system of resolution it is admissible in the sense that does not change if we allow it. But this will not be the case for some of the CDCL-based fragments we will be considering below.

Despite the above distinction, it is often convenient to consider systems that do allow the weakening rule. We make it clear when we do this by adding the annotation ‘ weakening’ to the system. For example, resolution weakening is the resolution proof system with the weakening rule included (as in Section 4.2.1).

Resolution Graphs

Our results depend on the careful analysis of the structure of resolution proofs. For example, it will be useful for us to maintain structural properties of the proof while changing the underlying clauses and derivations. We build up the following collection of definitions for this analysis, to which we will refer throughout the later sections. The reader may skip this section for now and return to it in the future as needed.

For a resolution weakening proof , its resolution graph, , is an acyclic directed graph representing in the natural way: each clause in has a distinguished node, and for each node there are incoming edges from the nodes corresponding to the clauses from which it is derived. Every node has in-degree 0, 1, or 2 if its corresponding clause is an axiom, derived by weakening, or derived by resolving two clauses, respectively. Denote the set of nodes by , and the clause at by . We do not assume that is injective, that is we allow the same clause to appear in the proof several times. There is a natural partial order on reflecting the order of appearances of clauses in : if and only if is a descendant of , or equivalently, there is a (directed) path from to . We sometimes say that is above (resp. below) if (resp. ). If, moreover, is an edge (directed from to ), we say that is a parent of . A set of nodes is independent if any two nodes in the set are incomparable. Maximal and minimal nodes of any nonempty are defined with respect to this partial order: , and similarly for .

Let . The upward closure and downward closure of in are and , respectively. A subset of nodes is parent-complete if for any of in-degree 2, one parent of being in implies that the other parent of is also in . It is path-complete if for any directed path in , the two end points of being in implies all nodes of are.

The upward closure is path-complete but need not be parent-complete. The downward closure is always both path-complete and parent-complete.

These definitions behave naturally, as demonstrated by the following proposition.

Let be a nonempty set of nodes that is both parent-complete and path-complete. Then the following holds.

  1. The induced subgraph of on is the graph of a subproof in of from ;

  2. If has a parent that is not in then .


1. Let be the set of all nodes in “provable” from inside . Formally, it is the closure of according to the following rule: if and all its parents are in then is also in . We need to show that .

Assume not, and fix an arbitrary . Since , there exists below . Since is path-complete, we can assume w.l.o.g. that is a parent of , and since is parent-complete, all parents of are in . Now, since is minimal in , all of them must be actually in . Hence , a contradiction.

2. All parents of are not in by parent-completeness and, for all , it follows that by path-completeness. ∎

A resolution graph is connected if , i.e. there is a unique sink.

For a resolution proof and , the subgraph on is a connected resolution graph whose axiom nodes are among those of .

Ordered and Half-Ordered Resolution

Fix now an order . For any literal , . For , let denote the smallest variables according to . Say that a clause is -small with respect to if .

The proof system -ordered resolution is the subsystem of resolution defined by imposing the following restriction on the resolution rule (1):

That is, the two antecedents are -small. We note that in the literature this system is usually defined differently, namely in a top-down manner (see e.g. [15]). It is easy to see, however, that our version is equivalent.

-half-ordered resolution is the subsystem of resolution in which the rule (1) is restricted by the requirement


That is, at least one of the antecedents is -small.

Recall [20] that a proof system -simulates another proof system if there exists a polynomial time algorithm that takes any -proof to a -proof from the same axioms (in particular, the size of the -proof is bounded by a polynomial in the size of the original proof). Two systems and are polynomially equivalent if they -simulate each other.

We are now ready to state our first result.

For any order , -ordered resolution is polynomially equivalent to -half-ordered resolution.

The next proof system, , is even more heavily motivated by CDCL solvers. For this reason we interrupt our proof-complexity exposition to define the corresponding model.

2.1 CDCL-based proof systems

As we noted in Introduction, we will try to highlight certain subtle points in the definition of the model by injecting informal remarks.

A unit clause is a clause consisting of a single literal. An assignment is an expression of the form . A restriction is a set of assignments in which all variables are pairwise distinct. We denote by the set of all variables appearing in . Restrictions naturally act on clauses, CNFs and resolution proofs, etc.; we denote by the result of this action. Note that both -ordered resolution and -half-ordered resolution are closed under restrictions, i.e. if is a -(half)-ordered resolution proof, then is a -(half)-ordered resolution proof of no-bigger size, where is the order induced by on .

An annotated assignment is an expression of the form . Informally, a CDCL solver builds (ordered) restrictions one assignment at a time, and the annotation indicates in what way the assignment is made: ‘’ means by a decision, and ‘’ means by unit propagation. See Definition 2.1 and Remark 2.1 below for details about these annotations.

A trail is an ordered list of annotated assignments in which all variables are again pairwise distinct. A trail acts on clauses, CNFs etc. just in the same way as does the restriction obtained from it by disregarding the order and the annotations on assignments. For a trail and an annotated assignment such that does not appear in , we denote by the trail obtained by appending to its end. is the th assignment of . A prefix of a trail is any trail of the form denoted by . is the empty trail.

A state is a pair , where is a CNF and is a trail. The state is terminal if either for all or contains 0. All other states are nonterminal. We let denote the set of all states (recall that is reserved for the number of variables), and let be the set of all nonterminal states.

As unambiguous as Definition 2.1 may seem, it already reflects one important choice, to consider only positional333

The name is suggested by a similar term “positional strategy” in game theory.

solvers, i.e. those that are allowed to carry along only CNFs and trails, but not any other auxiliary information. The only mathematical ramification of this restriction is that we will have to collapse the whole clause learning stage into one step, but that is a sensible thing to do anyway. From the practical perspective, however, this restriction is far from obvious and we will revisit this issue in our concluding section 6.

We are now about to describe the core of our (or, for that matter, any other) model, that is transition rules between states. But since this definition is the longest one, we prefer to change gears and precede it with some informal remarks rather than give them after the definition.

Proof systems attempting to capture performance of modern CDCL solvers are in general much bulkier than their logical counterparts and are built from several heterogeneous blocks. At the same time, most papers highlight the impact of one or a few of the features, with a varying degrees of nondeterminism allowed, while the features out of focus are treated in often unpredictable and implicit ways. We have found this state of affairs somewhat impending for the effort of trying to compare different results to each other or to build useful structure around them of the kind existing in “pure” proof complexity. Therefore, we adapt an approach that in a sense is the opposite. Namely, we rigorously describe a basic model that is very liberal and nondeterministic and intends to approximate the union of most conceivable features of CDCL solvers. Then models of actual interest will be defined by their deviations from the basic model. These deviations will take the form of “amendments” forbidding certain forms of behavior or, potentially, allowing for new ones.

Besides this point, there are only few (although sometimes subtle) differences from the previous models, so our description is given more or less matter-of-factly.

For a (nonterminal) state , we define the finite nonempty set and the function ; the fact will be usually abbreviated to . Those are described as follows:

where the letters have the obvious meaning444Restarts will be treated as a part of the learning scheme..

  • consists of all annotated assignments such that does not appear in and . We naturally let

  • consists of all those assignments for which contains the unit clause ; the transition function is given by the same formula (3) but with a different annotation:

  • As should be expected, is the most sophisticated part of the definition (cf. [3, Section 2.3.3]). Let . By reverse induction on we define the set that, intuitively, is the set of clauses that can be learned by backtracking up to the prefix .

    We let

    be the set of all conflict clauses.

    For , we do the following: if the -th assignment of is of the form , then . Otherwise, it is of the form , and we build up by processing every clause as follows.

    • If does not contain the literal then we include into unchanged.

    • If contains , then we resolve with all clauses such that and include into all the results . itself is not included.

    To make sure that this definition is sound, we have to guarantee that and are actually resolvable (that is, they do not contain any other conflicting variables but ). For that we need the following observation, easily proved by reverse induction on , simultaneously with the definition: for every .

    Finally, we let



This completes the description of the basic model.

For nearly all modern implementations of CDCL, the annotations are redundant because CDCL solvers typically require unit propagation always to be performed when it is applicable (in our language of amendments, this feature will be called ALWAYS-U). Nevertheless, the presence of annotations makes the basic model flexible enough to carry on various, sometimes subtle, restrictions and extensions. In particular, we consider solvers that are not required to record unit propagations as such. This allows for the situation in which and are in , and the set of learnable clauses is sensible to this.

In certain pathological cases, mostly resulting from neglecting to do unit propagation, the set may turn out to be empty even if is nonterminal and is contradictory. But for the reasons already discussed above, we prefer to keep the basic model as clean as possible syntactically, postponing such considerations for later.

The transition graph is the directed graph on defined by erasing the information about actions; thus if and only if . It is easy to see (by double induction on ) that is acyclic. Moreover, both the set and the function are polynomially555in the size of the state , not in time computable. These observations motivate the following definition.

Given a CNF , a partial run on from the state to the state is a sequence


where . In other words, a partial run is an annotated path in . A successful run is a partial run from to a terminal state. A CDCL solver is a partial function on such that whenever is defined. The above remarks imply that when we apply a CDCL solver to any initial state , it will always result in a finite sequence like (6), with being a terminal state (successful run) or such that is undefined (failure).

Theoretical analysis usually deals with classes (i.e., sets) of individual solvers rather than with individual implementations, and there might be several different approaches to defining such classes. One might consider for example various complexity restrictions like demanding that be polynomially time computable. But in this paper we are more interested in classes defined by prioritizing and restricting various actions.

A local class of CDCL solvers is described by a collection of subsets . It consists of all those solvers for which , whenever is defined.

We will describe local classes of solvers in terms of amendments prescribing what actions should be removed from the set to form . Without further ado, let us give a few examples illustrating how do familiar restrictions look in this language. Throughout the description, we fix a nonterminal state .


If contains the empty clause, then and are removed from . In other words, this amendment requires the solver to perform conflict analysis if it can do so.


If contains a unit clause, then is removed from . This amendment insists on unit propagation, but leaves to nondeterminism the choice of the unit to propagate if there are several choices. Note that as defined, ALWAYS-U is a lower priority amendment than ALWAYS-C: if both a conflict and a unit clause are present, the solver must do conflict analysis.


In the definition (5) of learning actions we keep only those for which .


In the definition (5), we require that is the longest prefix of satisfying (in which case is necessarily a unit clause). As described, this amendment does not model nonchronological backtracking or require that the last assignment in the trail is a decision. However, this version is easier to state and it is not difficult to modify to have the aforementioned properties. Furthermore, all open questions pertaining to this amendment remain open for either version.


In the definition (5), we shrink to , where is the largest index for which is annotated as ‘’ in . This amendment is meaningful (and mostly used) only when combined with ALWAYS-C and ALWAYS-U, in which case we can state expected properties like the fact that every learned clause contains the literal .

In the definition (5), we shrink to .


In the definition (5), we shrink to those clauses that are obtained by resolving, in the notation of Definition 2.1, between pairs and with . As noted in the introduction, this is similar to the scheme FirstNewCut [6].

-D, where is an order on the variables

We keep in only the two assignments , , where is the smallest variable w.r.t. that does not appear in . Note that this amendment does not have any effect upon , and the main technical contributions of our paper can be also phrased as asking under which circumstances this “loophole” can circumvent the severe restriction placed on the set .

WIDTH-, where is an integer

In the definition (5), we keep in only clauses of width . Note that this amendment still allows us to use wide clauses as intermediate results within a single clauses learning step.

SPACE-, where is an integer

If , then is entirely removed from . This amendment makes sense when accompanied by the possibility to do bookkeeping by removing “unnecessary” clauses. We will briefly discuss positive amendments in Remark 2.1 below.

Thus, our preferred way to specify local classes of solvers and the corresponding proof systems is by listing one or more amendments, with the convention that their effect is cumulative: an action is removed from if and only if it should be removed according to at least one of the amendments present. More formally,

For a finite set of poly-time computable amendments, we let be the (possibly incomplete) proof system whose proofs are those successful runs (6) in which none of the actions is affected by any of the amendments .

The amendments ALWAYS-C, ALWAYS-U are present in almost all previous work and, arguably, it is precisely what distinguishes conflict-driven clause learning techniques. Nonetheless, we have decided against including them into the basic model as they may be distracting in theoretical studies focusing on other features; our work is one example. Also, from the practical point of view (this sentence is admittedly rather hypothetical and speculative!) it is not a priori clear why it is always a good idea to jump up at the very first opportunity to do unit propagation or conflict analysis instead of waiting for “more promising” clauses to pop up.

Let us briefly discuss the possibility of extending the basic model rather than restricting it. The most substantial deviation would be to forfeit the assumption of positionality (see Remark 2.1) or, in other words, to allow the solver to carry along more information than just a set of clauses and a trail. Two such examples are dynamic variable ordering and phase saving. The first is very pertinent to the technical part of our paper, so we defer the corresponding discussion to Section 6.

For positional solvers, extending the basic model amounts to introducing positive amendments enlarging the sets instead of decreasing them. Here are a few suggestions we came across during our deliberations.


For , we add to all subsets . The transition function is obvious:

This is the space model whose study was initiated in [22], and like in that paper, we do not see compelling reasons to differentiate between original clauses and the learned ones.


In the definition (5) of , we can allow arbitrary nonempty subsets instead of a single clause and require that for any , with the obvious transition

Though existing SAT-solver implementions tend not to do this, it is natural to consider when thinking of Pool resolution or RTL proof systems as variants of CDCL.


In the definition (5) of , we could remove the restriction on the prefix . This positive amendment could make sense in the absence of ALWAYS-C, that is, if we are prepared for delayed conflict analysis.

In this language, the (nonalgorithmic part of the) main result from [3, 35] can be roughly summarized as

CDCL(ALWAYS-C, ALWAYS-U, ALWAYS-R, ) is polynomially equivalent to resolution.

The algorithmic part from [3] roughly says that any CDCL solver in the associated class, subject to the only condition that the choice of actions from (when it is allowed by the amendments) is random, polynomially simulates bounded-width resolution666That is, has running time

with high probability, given an contradictory CNF

as an input.. The open question asked in [3, Section 2.3.4] can be reasonably interpreted as whether CDCL(ALWAYS-C, ALWAYS-U, WIDTH-) is as powerful as width- resolution, perhaps with some gap between the two width constraints (We took the liberty to remove those amendments that do not appear to be relevant to the question.) Finally, we would like to abstract the “no-restarts” question as

Does CDCL(ALWAYS-C, ALWAYS-U, NEVER-R) (or at least CDCL(NEVER-R)) simulate general resolution?

where we have again removed all other amendments in the hope that this will make the question more clean mathematically.

2.2 Our contributions

As they had already been discussed in the introduction, here we formulate our results (in the language just introduced) more or less matter-of-factly.

For any fixed order on the variables, the system CDCL(, -D) is polynomially equivalent to -ordered resolution.

For any fixed order on the variables, the system CDCL(FIRST-L, -D) is polynomially equivalent to general resolution.

For any fixed order on the variables and every there exist contradictory CNFs with not provable in CDCL(-D, WIDTH-).

Finally, let us mention that while is a (possibly incomplete) proof system in the Cook-Reckhow sense, it need not necessarily be a Hilbert-style proof system, operating with “natural” lines and inference rules. Assume, however, that the set additionally satisfies the following two properties:

  1. whenever , it contains an action leading to a state of the form (i.e, restarts are allowed);

  2. (monotonicity) If , and then .

Then every trail that appears in a run can always be recreated, at a low cost, when it is needed again. Thus, under these restrictions we get a “normal” proof system with nice properties. We formulate it explicitly for the case -D we are mostly interested in.

Fix an order on the variables. - is the following (two-typed) proof system. Its lines are either clauses or trails, and it has the following rules of inference:

where is the -smallest index such that does not appear in and is arbitrary;

where ;

where , and all other variables of appear before in .

It is straightforward to see that without the unit propagation rule, this is just the -half-ordered resolution.

Then, the main technical part in proving Theorem 2.2 is the following

For every fixed order on the variables, - is polynomially equivalent to general resolution.

3 -Ordered

In this section we prove Theorem 2.2. The proof breaks into two parts (Theorem 2, Theorem 3.2), with half-ordered resolution as the intermediate.

3.1 Half-Ordered Ordered

Half-ordered resolution trivially -simulates ordered resolution, so the core of Theorem 2 is the other direction. In this section we will depend heavily on resolution graphs (Definition 2) and related definitions from Section 2.

A resolution refutation is ordered up to (with respect to an order ) if it satisfies the property that , if is derived by resolving two clauses on some variables , then all resolution steps above are on variables in . We note that -ordered resolution proofs are precisely those that are ordered up to .

We now prove the main part of Theorem 2, namely that -ordered resolution -simulates -half-ordered resolution.


(of theorem 2) Let be a -half-ordered resolution refutation of . Without loss of generality, assume that (otherwise rename variables).

We will construct by induction on () a half-ordered resolution refutation of , which is ordered up to . For the base case, let . Suppose has been constructed; without loss of generality we can assume that is connected (otherwise take the subrefutation below any occurrence of 0).

Consider the set of nodes whose clauses are -small. Note that this set is parent-complete. We claim that it is also upward-closed (and hence path-complete). Indeed, let be a parent of , and assume that is -small. Then (since we disallowed weakenings), is obtained by resolving on a variable . But since is ordered up to , , as otherwise some variable in would have remained unresolved on a path connecting to the sink (here we have used connectedness). Hence is also -small.

So by Proposition 2(1), it defines the subrefutation of the independent set


Since any node in can be connected to the sink (which is -small) by a path, and the set of -small nodes is parent-complete, by Proposition 2, splits into two parts: , , where is (the graph of) a subproof of and is (the graph of) a subrefutation of . Denote these two subproofs by and , respectively: is comprised of all nodes in that either are marked by a clause that is not -small or belong to , and is comprised of all nodes marked by an -small clause. In particular, all axioms are in , all resolutions in are on the variables in and, since is ordered up to , all resolutions in are on the variables not in . Let


If is empty, .

Otherwise, suppose and let


We will eliminate all resolutions on in by the following process, during which the set of nodes stays the same while edges and clause-labeling function will possibly change. More precisely, we update in rounds, defining -half-ordered resolution weakening proofs . Initially , . Let denote the clause-labeling . To define the transition , we need the following structural properties of (that will also be proved by induction simultaneously with the definition).

  1. [label=., ref=]

  2. Compared to , has no new relation of ‘one node being above another’ (there might be fewer);

  3. , is either or or ;

  4. If then and, moreover, this clause is obtained in with the same resolution rule as in ;

  5. is a -half-ordered resolution weakening proof.

In the base case (), Claim 3.1 holds simply because .

Let us construct . By Claim 3.1(3), the resolution step at (which is not in ) is unchanged from to . Assume that it resolves and . Since is half-ordered, either or is -small. Assume without loss of generality that is -small.

Recall that there is no resolution in on variables in . Thus, for all , it follows that is a subclause of , and by Claim 3.1(2), we get the following crucial property:

For all , is a subclause of . (10)

Note that is upward closed in by Claim 3.1(1). Accordingly, as the first step, for any we set and we do not touch its incoming edges.

Next, we update vertices in an arbitrary -topological order maintaining the property (in particular, whenever contains a literal of the variable ).

First we set (recall that by Claim 3.1(3) and hence does not contain by (8)), and replace incoming edges by a weakening edge from .

For , we proceed as follows.

  1. If , keep the clause but replace incoming edges with a weakening edge . This is well-defined by (10), and note for the record that since , we do not enlarge the “above” relation compared to .

  2. If on where , set (or, equivalently, and replace incoming edges by a weakening edge .

  3. If is weakened from (and ), set . In other words, we append the literal to if and only if this was previously done for .

  4. Otherwise, , and on some , . In particular, . Set that is, like in the previous item, we append if and only if it was previously done for either or . Note that since , this step remains -half-ordered.

This completes our description of , but we still have to check Claim 3.1 for it. For (1), note that the only new edges were added in item 1, and see the remark made there. The cases and are straightforward. For , the only new resolution rules were introduced in item 4; again, see the remark made there.

The next claim summarizes the necessary properties of the end result, .

  1. [label=., ref=]

  2. is a -half-ordered resolution + weakening proof without resolutions on .

  3. If for some , then such that on , and this resolution is half-ordered. In fact, is a parent of some in , .


1. No new resolution on the variable has been introduced, while all old ones are in and thus have been eliminated. The conclusion follows from this observation together with Claim 3.1(4).

2. Suppose was changed in (and hence stayed unchanged afterwords) so that in particular . Set , where is the parent of from above. Note that since the latter contains the literal (say) . Then we readily have by (10), and it is half-ordered since is -small. ∎

Now to get , we try to reconnect with along and then clear out weakenings. The problem with this approach is the added appearances of in for , as in Claim 3.1(2). We introduce new nodes to deal with them. Namely, for , if , apply Claim 3.1(2) to create a new node to add to with the clause . Denote by the result of connecting and along and this new set of vertices. Since neither nor contain resolutions on , is a half-ordered refutation (with weakenings) that is ordered up to . Let be obtained by contracting all weakening rules. It will still be half-ordered and ordered up to , and it only remains to analyze its size (note that a priori it can be doubled at every step, which is unacceptable).



we only have to control . For that we will keep track of the invariant ; more precisely, we claim that


Let us prove this by constructing an injection from to ; we will utilize the previous notation.

First note that the resolution + weakening refutation and its weakening-free contraction can be related as follows. For every node there exists a node with which is minimal among those contracting to . If is an axiom node of then so is in . Otherwise, if and are the two parents of , and are the corresponding parents of ( may not be obtained by weakening due to the minimality assumption), then is a subclause of and is a subclause of . We claim that (which is injective by definition) is the desired injection. We have to check that its image is contained in .

Fix . Then either is an axiom or both its parents are not -small (by (7)). By the above mentioned facts about the contraction , this property is inherited by . In particular, as all nodes in this set have at least one -small parent due to half-orderedness. Finally, since the corresponding clauses in and differ only in the variable , cannot be in , for the same reason (recall that all axioms are in ). Hence .

Having thus proved (12), we conclude by the obvious induction that . Then (11) implies , as desired. ∎

Figure 1: A toy example of the transformation from to

3.2 Half-Ordered

In this section, we prove the following theorem.

The systems and -half-ordered resolution are