Over the last two decades, Conflict-Driven Clause-Learning (CDCL) SAT solvers have had a revolutionary impact on many areas of software engineering, security and AI primarily because of their ability to solve real-world instances with millions of variables and clauses in them, despite the fact the Boolean SAT problem is known to be NP-complete and considered intractable in general [5, 14, 13, 17, 3]. These SAT solvers use a variety of optimization methods to achieve such remarkable performance. Some sub-routines in CDCL solvers correspond to proof construction methods, while others are method aimed at optimally sequencing, selecting, and initializing proof rules [11, 12, 10].
Despite this remarkable success of solvers, our theoretical understanding of their efficacy remains poor. Having said that, a few seminal results have already been established that lay the groundwork for deeper understanding of SAT solvers. Perhaps the most important such result was proved by Knot Pipatsrisawat and Adnan Darwiche  and independently by Atserias et al. , wherein they showed that an idealized model of CDCL SAT with non-deterministic branching (variable selection), value selection, and restarts is polynomial equivalent to the general resolution proof system. However, an important question that remained open is whether this result holds even when restarts are disabled, i.e., for configurations of CDCL SAT solvers without restarts.
This question prompted considerable subsequent work on a theoretical understanding of the power of restarts. Recently, Bonet, Buss and Johannsen  showed that CDCL SAT solvers with no restart (but with non-deterministic variable and value selection) are strictly more powerful than regular resolution, and they also refuted several candidate class of formulas which were conjectured to be separators for CDCL solvers with restarts and without restarts. This is a strong result, given the well-known theorem of Alekhnovich et al. that regular resolution is strictly weaker than general resolution .
Our research is motivated by a widely-known open problem in SAT solving research, namely, how do we characterize and understand the interplay between different solver heuristics and further how do we isolate the effect of a single heuristic. As we studied this problem in depth, it became clear to us that there seems to be a subtle interplay between various solver heuristics and restarts, wherein it seems that the power of restarts becomes apparent only when one of the other important solver heuristics (e.g., variable or value selection) is weakened (e.g., solver configurations where non-deterministic value or variable selection heuristics are replaced by their weaker randomized cousins). This observation guided the kind of configurations we analyze in this paper.
In brief, the contributions we make in this paper are:
First, we prove that CDCL SAT solvers with backtracking, non-deterministic variable selection, randomized value selection, and restarts 111We often refer to this model of CDCL SAT solver with randomized value selection as the drunk CDCL solver. The reason is that this model was inspired by the drunk DPLL model introduced by Alekhnovich, Hirsch and Itsykson .
are exponentially faster than the same model, but without restarts, with high probability (w.h.p) for a class of satisfiable formulas we refer to asformulas. A notable feature of our proof is that we obtain this separation on a family of satisfiable instances. (See Section 3 for details.)
Second, we prove that CDCL SAT solvers with VSIDS variable selection, phase saving value selection and restarts (where activities of variables are reset to zero after restarts) are exponentially more powerful than the same solver configuration but without restarts for a class of unsatisfiable formulas, w.h.p. This result holds irrespective of whether the solver uses backtracking or backjumping. (See Section 4 for details.)
Finally, we prove several smaller separation and equivalence results for various configurations of CDCL and DPLL solvers with and without restarts. For example, we show that CDCL SAT solvers with non-deterministic static variable selection, non-deterministic static value selection, and with restarts, are polynomially equivalent to the same model but without restarts. Another result we show is that for DPLL SAT solvers, restarts do not add proof theoretic power as long as the solver configuration has non-deterministic dynamic variable selection. (See Section 5 for details.)
Below we provide relevant definitions and concepts used in this paper. We refer the reader to Handbook of Satisfiability for literature on CDCL and DPLL SAT solvers  and to  for literature on proof complexity. In order to show equivalence results between solvers, we use the notion of p-equivalence of proof systems () from the proof complexity literature .
Throughout this paper it will often be convenient to think of the trail of the solver during its run on a formula as a restriction to that formula. We will call a function a restriction, where denotes that the variable is unassigned by .
Additionally, we assume in the paper that our Boolean Constraint Propagation (BCP) scheme is greedy, i.e., BCP is performed till “saturation” as typically stated in the SAT solver literature.
Restarts in SAT solvers. One can define a restart policy as a method that erases part of the state of the solver at certain intervals during the run of a solver . In most modern CDCL SAT solvers, the restart policy erases the assignment trail upon invocation, but may choose not to erase the learnt clause database or variable activities. Restart policies222It is common in SAT literature to interchangeably use the terms policy, heuristic, method, algorithm, and technique. We shall continue this practice. in state-of-the-art CDCL SAT solvers fall into two categories: static and adaptive restart policies. These categories are defined in terms of a measure known as the restart sequence. The term restart sequence refers to points in time, during the run of a solver (starting at time = 0), at which a restart may be triggered. Static restart policies are ones whose restart sequence is predetermined prior to solver’s execution. On the other hand, adaptive (aka, dynamic) restart policies are ones that take into account the state of the solver and may adaptively change the interval between two restarts. In this paper, we assume that all restart policies are non-deterministic algorithms, i.e., the solver non-deterministically chooses a restart sequence to optimally solve a given instance.
Note on Solver Heuristics. We would like to note that most of our results hold irrespective of the choice of deterministic asserting clause-learning schemes (except the one on CDCL solver with weak decision learning scheme in Section 5). Additionally, it goes without saying that the questions we address in this paper make sense only when we assume that every individual solver heuristics (e.g., variable and value selection, learning scheme, Boolean constraint propagation, etc.) is a polynomial time method.
2.1 Notation for SAT Solver Configurations
Below we precisely define the different kinds of heuristics used to describe SAT solver configurations in this paper. The term “non-deterministic” heuristic in these theoretical SAT solver models refers to methods that make the optimal set of choices for a given input formula such that it is solved in the least amount of time and resources required. Note that making such assumptions is critical to getting the strongest possible set of separation results.
Non-deterministic Static (NS) Variable Selection Heuristic333Variable selection function takes input the state of the solver and outputs a variable that has not been assigned a value.: A non-deterministic algorithm that takes as input a formula, and outputs a total ordering (or ranking) of all variables of the input formula prior to solver’s execution. During the solver’s execution, the NS variable selection heuristic returns the unassigned variable with the highest rank in this total ordering.
Non-deterministic Dynamic (ND) Variable Selection Heuristic: A non-deterministic algorithm that, upon invocation, outputs an unassigned variable during the run of the solver.
VSIDS Variable Selection (VS) Heuristic : Each variable has an associated number, called its activity. Initially the activities of all variables are 0. Each time a solver learns a conflict, the activities of variables appearing on the conflict side of the implication graph receives a constant bump. The activities of all variables are decayed by a constant c, where , at regular intervals. The VSIDS variable selection heuristic returns the unassigned variable with highest activity. (If there are multiple variables with the highest activity, the tie may be broken randomly).
Non-deterministic Static (NS) Value Selection Heuristic444While we use the same abbreviation NS for both non-deterministic variable and value selection, we do not anticipate any confusion since it will be very clear from context which heuristic is being referred to.: A non-deterministic algorithm that takes as input a formula and outputs a map from variables of the input formula to truth values, prior to the solver’s execution. During the run of the solver, the NS value selection algorithm takes as input a variable, and returns its predetermined value.
Random Dynamic (RD) Value Selection Heuristic: A randomized algorithm takes as input a variable of the input formula and assigns it a truth value uniformly and independently (i.e., independent of any other invocation of the heuristic) at random.
Phase Saving (PS) Value Selection Heuristic: A phase saving value selection heuristic takes input an unassigned variable, and returns the “last” truth value that was assigned to the variable. Typically solver designers determine what value is returned when a variable has not been previously assigned. In our paper, we use the phase saving value selection heuristic that returns 0 if the variable has not been previously assigned.
Below we present notation that is used to describe configurations of SAT solvers that we study in this paper:
Solver Configurations and : By we denote CDCL SAT solvers with non-deterministic dynamic variable selection and random dynamic value selection without restarts, and by we denote the same configuration with restarts. We choose to refer to these models as drunk CDCL SAT solvers. We further assume these drunk CDCL solver configurations use backtracking instead of backjumping. All other solver configurations in this paper use backjumping.(Used in Section 3)
Solver configurations and : By we denote CDCL SAT solvers without restarts and with VSIDS variable selection and phase saving value selection where phases are initially set to 0. And by we denote the same configuration with restarts, and further restarts reset activities. (Used in Section 4)
Solver Configurations and : By we denote CDCL SAT solvers with non-deterministic static variable selection and value selection with no restarts, and by we denote the same configuration with restarts. (Used in Section 5)
Solver Configurations and : By the term arbitrary we mean that the value selection heuristic can be any polynomial time deterministic or randomized algorithm whatsoever, that take as input a variable of the input formula, and output a truth value. By we denote DPLL SAT solvers with non-deterministic dynamic variable selection and arbitrary value selection without restarts, and by we denote the same configuration with restarts. (Used in Section 5)
Solver Configurations and : By we denote DPLL SAT solvers with non-deterministic dynamic variable selection and value selection without restarts, and by we denote the same configuration with restarts. (Used in Section 5)
3 A Separation Result for Drunk CDCL Solvers with and without Restarts
Inspired by Alekhnovich et al. , where the authors proved exponential lowerbound for drunk DPLL SAT solvers over a class of satisfiable instances, we studied the behavior of restarts in a drunk style CDCL SAT solver. We introduce a class of satisfiable formulas, and use them to prove the separation between and (recall that these solver models are defined for backtracking). At the core of these formulas will be some unsatisfiable formula which is hard for Resolution and which is hard for Resolution even after some small adversarial restriction. For this, we will use the well-known unsatisfiable Tseitin graph formulas.
Definition 1 (Tseitin Formulas)
Let be a graph and . The formula is on variables and constraints , where .
For any graph , is unsatisfiable iff
is odd; in which case we call it anodd charge function. The specifics of the charge function will be irrelevant for our applications; any odd charge function will do. Therefore, we will often omit defining , and simply assume that it is odd.
The formulas contains two sets of variables, for and for . We will denote by the block of variables . These formulas will be constructed using the following gadgets.
Ladder gadgets: Denote . Observe that is falsified only by the all- and all- assignments.
Connecting gadgets: , where returns the th bit of the binary representation of , and , while . That is, is the conjunction that is satisfied only by the assignment encoding in binary.
Pairwise gadgets: . These clauses force that every variable in must take the same value.
Definition 2 (Ladder formulas)
For with , let be defined on the variables . The class of Formula is defined as the conjunction of the clauses representing
Note that the formulas have polynomial size provided that the degree of is . As well, this formula is satisfiable only by the assignments that sets and for every and .
The aim of this construction is to have any drunk solver enter an unsatisfiable subformula as quickly as possible, and thus be forced to refute the Tseitin formula. The Tseitin formulas are known to be hard to solve in any CDCL solver, even after a small adversarial restriction (the current trail of the solver). Both the ladder gadgets and pairwise gadgets act as trapdoors for the Tseitin formula. Indeed, if any -variable is set to then we have already in an unsatisfiable instance. Similarly, setting and for any , causes us to enter an unsatisfiable instance. This is because setting all -variables to together with this assignment would falsify a clause of the pairwise gadget. Thus, after the second decision of the solver, the probability that it is in an unsatisfiable instance is already at least !
With these formulas in hand, we will prove the following theorem, separating backtracking solvers with and without restarts.
There exists a family of -degree graphs such that
can be decided in time by , except with exponentially small probability.
requires exponential time to decide , except with probability .
The proof of this theorem will occupy the remainder of this section.
3.1 Upper Bound on the Ladder Formulas Via Restarts.
We will prove the following more general statement of (1) of Theorem 3.1.
For any graph , will solve in time , except with exponentially small probability.
The proof will rely on the following lemma, stating that given the all- restriction to the -variables, will find a satisfying assignment.
For any graph , will find a satisfying assignment to
in time .
When all variables are , we have . By the construction of the connecting gadget, for all . Under this assignment, the remaining clauses belong to , along with for . It is easy to see that, as soon as the solver sets an -variable, these clauses will causes propagate the remaining -variables to the same value. ∎
Putting it differently, the set of variables forms a weak backdoor for formulas. Lemma 1 shows that, with probability at least , can exploit this weak backdoor using only number of restart calls. Additionally, the lemma shows that the runtime of the solver is , and thus we have a polynomial upper bound on the solver model .
Proof (of Lemma 1)
Due to Lemma 2, if is able to assign all variables to before assigning any other variables, then the solver will find a satisfying assignment in time with probability 1. We will show that the solver can exploit restarts in order to find this assignment. The strategy the solver adopts is as follows: query each of the -variables; if at least one of the -variables was assigned to 0, restart. We argue that if the solver repeats this procedure times then it will find the all- assignment to the -variables, except with exponentially small probability. Because each variable is assigned and with equal probability, the probability that a single round of this procedure finds the all- assignment is . Therefore, the probability that the solver has not found the all- assignment after rounds is
3.2 Lower Bound on the Ladder Formulas Without Restarts
We now prove statement (2) in Theorem 3.1. The proof will rely on the following three technical lemmas. The first lemma claims that the solver is well-behaved (most importantly that it cannot learn anything) while it has not made many decisions.
Let be any graph of degree at least . Suppose that has made decisions since its invocation on . Let be the current trail, then
The solver has yet to enter a conflict, and thus has not learned any clauses.
The trail contains variables from at most different blocks .
The following technical lemma states that if a solver with backtracking has caused the formula to become unsatisfiable, then it must refute that formula before it can backtrack out of it. For a restriction and a formula , we will say that the solver has produced a refutation of an unsatisfiable formula if it has learned a clause such that . Note that because Resolution p-simulates CDCL, any refutation of a formula implies a Resolution refutation of of size at most polynomial in the time that that the solver took to produce that refutation.
Let be any CDCL SAT solver with an asserting learning scheme and backtracking. Let be any propositional formula, let be the current trail of the solver, and let be any literal in . Then, backtracks only after has produced a refutation of .
In order to backtrack (unlike solvers with back-jumping), the solver must have learned a clause asserting the negation of some literal that was set before . Therefore, must only contain the negation of literals in . Hence, . ∎
The third lemma reduces proving a Resolution lower bound on the formula under any well-behaved restriction to proving a lower bound on an associated Tseitin formula.
For any unsatisfiable formula , denote by the minimal size of any Resolution refutation of .
It is well-known that standard Resolution p-simulates CDCL solvers .
We will say that a restriction or trail to implies Tseitin if either sets some -variable to or and for some , . Observe that in both of these cases the formula is unsatisfiable. Indeed, the only satisfying assignment to sets and for every , .
Let be any restriction such each clause of is either satisfied or contains at least two free variables, and implies Tseitin. Suppose that sets variables from at most blocks . Then there exists a restriction that sets at most variables of such that
We defer the proof of these lemmas to the appendix, and show how to use them to prove statement (2) of Theorem 3.1. We will prove this statement for any degree graph with sufficient expansion.
The expansion of a graph is
where is the set of edges in with one endpoint in and the other in .
For every , Ramanujan Graphs provide an infinite family of -regular expander graphs for which . The lower bound on our runtime will rely on the following immediate corollary of Ben-Sasson and Wigderson .
Corollary 1 ()
For any connected graph with maximum degree and odd weight function ,
We are now ready to prove the lemma.
Proof (of (2) from Theorem 3.1)
Fix to be any degree- graph on edges such that . Ramanujan graphs satisfy these conditions.
First, we argue that within decisions from the solver’s invocation, the trail will imply Tseitin, except with probability . By Lemma 3, the solver has yet to backtrack or learn any clauses, and it has set variables from at most blocks (and so there are still unset variables). Let be the variable queried during the th decision. If is a variable, then with probability the solver sets . If is a variable , then unless this is the first time the solver sets an -variable, the probability that the solver sets to a different value than the previously set -variable is .
Conditioning on the event that, within the first decisions the trail of the solver implies Tseitin (which occurs with probability at least ), we argue that the runtime of the solver is exponential in . Let be the first decision level such that the current trail implies Tseitin. By Lemma 4 the solver must have produced a refutation of in order to backtrack out of the unsatisfying assignment. If the solver takes steps to refute then this implies a Resolution refutation of size . Therefore, in order to lower bound the runtime of the solver, it is enough to lower bound the size of Resolution refutations of .
By Lemma 3, the solver has not learned any clauses, and has yet to enter into a conflict and therefore no clause in is falsified. As well, sets variables from at most blocks . By Lemma 5 there exists a restriction such that . Furthermore, sets at most variables and therefore cannot falsify any constraint of , as each clause depends on at variables. Observe that if we set a variable of then we obtain a new instance of on a graph . Therefore, we are able to apply Corollary 1 provided that we can show that is large enough.
Let be a graph and let be obtained from by removing at most edges. Then .
Let with . Then, . ∎
It follows that . Note that . By Corollary 1,
Therefore, the runtime of this the solver is . ∎
4 Separation Result for CDCL+VSIDS with and without Restarts
In this section, we prove that CDCL SAT solvers with VSIDS variable selection, phase saving value selection and restarts (where activities of variables are reset to zero after restarts) are exponentially more powerful than the same solver configuration but without restarts, w.h.p.
There is a family of unsatisfiable formulas that can be decided in polynomial time with but requires exponential time with , except with exponentially small probability.
We show this separation using pitfall formulas , described below, where is an expander graph with vertices and edges, is a function with odd support, we think of as a constant and let grow. These formulas have blocks of variables named , , , , and , with , and the following clauses:
, expanded into CNF, for and ;
for , , and ;
for , , and ;
for and ;
, , , and for and ; and
We denote the last type of clauses by , and we use the following properties.
Given any pair of variables and from the same block , assigning and yields a conflict.
Theorem 4.1 ([18, Theorem 3.6])
For fixed, requires time to decide with , except with exponentially small probability.
To prove an upper bound we simply observe that pitfall formulas have small backdoors , which is enough for a formula to be easy for .
A set of variables is a strong backdoor for unit-propagation if every assignment to all variables in leads to a conflict, possibly after unit propagation.
If has a strong backdoor for unit-propagation of size , then can decide in time , except with exponentially small probability.
We say that the solver learns a beneficial clause if it only contains variables in . Since there are possible assignments to variables in and each beneficial clause forbids at least one assignment, it follows that learning beneficial clauses is enough to produce a conflict at level .
Therefore it is enough to prove that, after each restart, we learn a beneficial clause with large enough probability. Since all variables are tied, decisions after a restart are random, and hence with probability at least the first variables to be decided before reaching the first conflict are (a subset of) . If this is the case then, since is a strong backdoor, no more decisions are needed to reach a conflict, and furthermore all decisions in the trail are variables in , hence the learned clause is beneficial.
It follows that the probability of having a sequence of restarts without learning a beneficial clause is at most
hence by a union bound the probability of the algorithm needing more than restarts is at most . ∎
We prove Lemma 6 by showing that contains a backdoor of size .
Proof (of Lemma 6)
We claim that the set of variables is a strong backdoor for unit-propagation. Consider any assignment to . Each of the clauses forces a different variable to , hence by the pigeonhole principle there is at least one block with two variables assigned to . But by Proposition 1, this is enough to reach a conflict.
5 Minor Equivalences and Separations for CDCL/DPLL Solvers with and without Restarts
In this section, we prove four smaller separation and equivalence results for various configurations of CDCL and DPLL solvers with and without restarts.
5.1 Equivalence between CDCL Solvers with Static Configurations with and without Restarts
First, we show that CDCL SAT solvers with non-deterministic static variable and value selection without restart () is as powerful as the same configuration with restarts () for both satisfiable and unsatisfiable formulas. We assume that the BCP subrountine for the solver configurations under consideration is “fixed”. The BCP subroutine is “fixed” in the following sense: if there are more than one unit clause under a partial assignment, the BCP subroutine propagates the clause that is added to the clause database first.
We prove this theorem by arguing for any run of , the restarts can be removed without increasing the run-time.
Consider a run of on some formula , and suppose that the solver has made restart calls. Consider the trail for up to the variable from the second highest decision from the last learnt clause before the first restart call. Now, observe that because the decision and variable selection orders are static, once restarts, it will force it to repeat the same decisions and unit propagations that brought it to the trail . Suppose that this is not the case and consider the first literal on which the trails differ. This difference could not be caused by a unit propagation as the solver has not learned any new clauses since the restart. Thus, it must have been caused by a decision. However, because the clause databases are the same, this would contradict the static variable and value order.
Therefore, this restart can be ignored, and we obtain a run of with restarts without increasing the run-time. The proof follows by induction. Once all restarts have been removed, the result is a valid run of .
Note that in the proof for Theorem 5.1, we not only argue that is p-equivalent to , we also show that the two configurations produce the same run. The crucial observation is that given any state of , we can produce a run of which ends in the same state. In other words, our proof not only suggests that is equivalent to from a proof theoretic point of view, it also implies that the two configurations are equivalent for satisfiable formulas.
In Mull et al.’s paper , the authors proved that CDCL SAT solvers with arbitrary static variable selection, non-deterministic value selection and “non-greedy BCP” is p-equivalent to general resolution. The SAT solver configuration being studied in their paper is quite different from the solver configuration considered in Theorem 5.1, as the value selection for is non-deterministic static while the value selection for their configuration is non-deterministic dynamic, and they assume non-greedy BCP which is much stronger than greedy-BCP assumed in all our models. Thus we don’t believe that we can leverage their result to prove an equivalence result between and general resolution. However, we do note that this remains an open question.
5.2 Equivalence between DPLL Solvers with ND Variable Selection on UNSAT Formulas
We show that when considered as a proof system, a DPLL SAT solver with non-deterministic dynamic variable selection, arbitrary value selection and no restart () is p-equivalent to DPLL SAT solver with non-deterministic dynamic variable and value selection and restarts (), and hence, transitively p-equivalent to tree-like resolution.
To show that , we argue that every proof of can be converted to a proof of same size in . Let be an unsatisfiable formula. Recall that a run of on begins with non-deterministically picking some variable to branch on, and a truth value to assign to . W.l.o.g. suppose that the solver assigns to . Thus, the solver will first refute before backtracking and refuting .
To simulate a run of with , since variable selection is non-deterministic, also chooses the variable as the first variable to branch on. If the value selection returns for , then the solver focus on the restricted formula first. Because there is no clause learning, whether or is searched first does not affect the size of the search space for the other. The proof follows by recursively calling on and .
The converse direction (that ) is immediate since every run of is also a run of . ∎
This follows from the fact . Indeed, with non-deterministic branching and without clause learning, restarts cannot help. If ever queries a variable for and then later restarts to assign it to , then ignores the part of the computation when and instead immediately non-deterministically chooses . ∎
From Corollary 2, if we want to exponentially separate DPLL SAT solvers with and without restarts for unsatisfiable formulas, we have to weaken variable selection from having non-deterministic power. While counter-intuitively but interestingly, in the context of satisfiable formulas, we are able to show an exponential separation between restart and no restart for a model of DPLL SAT solver even with non-deterministic variable selection.
5.3 Separation Result for Drunk DPLL Solvers
We show that DPLL SAT solvers with non-deterministic variable selection, randomized value selection and no restarts () is exponentially weaker than the same configuration with restarts ().
runs exponentially slower on the class of satisfiable formulas than , with high probability.
The separation follows from the fact that our proof of the upper bound for (1) from Theorem 3.1 does not use the fact the solver has access to clause learning, which means the solver can also find a satisfying assignment for in time , except with exponentially small probability. On the other hand, the lower bound for (2) from Theorem 3.1 immediately implies an exponential lower bound for , since is strictly weaker than .
5.4 Separation Result for CDCL Solvers with Weak Decision Learning Scheme
Finally, we would like to state an observation on restarts in the context of what is often referred to as Weak Decision Learning Scheme (WDLS) 555Personal communication with Robert Robere.. The Weak Decision Learning Scheme (WDLS) for a CDCL solver is defined as follow: Upon deriving a conflict, the solver learns the clause over the disjunction of the negation of the decision variables on the current assignment trail.
with WDLS is exponentially weaker than with WDLS.
Clearly, the solver model with WDLS is only as powerful as , since each learnt clause will only be used once for propagation after the solver backtracks immediately after learning the conlict clause, and remains satisfied for the rest of the solver run. This is exactly how behaves under the same circumstances. On the other hand, WDLS is an asserting learning scheme , and hence satisfies the conditions in  which proved that CDCL with any asserting learning scheme and restarts p-simulates general resolution. Thus, we immediately have with WDLS is exponentially more powerful than the same solver but with no restarts (for unsatisfiable instances). ∎
We would like to add that WDLS is an unconventional clause learning scheme which does not quite capture the power of the state-of-the-art clause learning scheme used in modern CDCL solvers.
6 Related Work
The first paper to discuss restarts in the context of SAT solvers was one by Gomes and Selman . Since then there has been considerable empirical work on restart policies . Hypotheses aimed at explaining the power of restarts based on empirical observations have been proposed. Examples include, the heavy-tail explanation , and the “restarts compact assignment trail and hence produce clauses with lower literal block distance (LBD)” perspective . Having said that, the heavy-tailed distribution explanation of the power of restarts is not considered valid anymore in the CDCL setting . The best previous theoretical work on restarts is by Bonet, Buss and Johannsen . They showed that CDCL SAT solvers with no restart (with non-deterministic variable and value selection), when viewed as proof systems, are strictly more powerful than regular resolution.
In this paper, we prove results that establish the power of restarts (or lack thereof) for several models of CDCL and DPLL SAT solvers. We first showed that CDCL SAT solvers with backtracking, non-deterministic dynamic variable selection, randomized dynamic value selection, and restarts are exponentially faster on a class of satisfiable formulas than the same model without restarts. Second, we showed CDCL SAT solvers with VSIDS variable selection and phase saving without restarts are exponentially weaker than the same solver with restarts, for a family of unsatisfiable formulas. Finally, we proved four additional smaller separation and equivalence results for various configurations of DPLL and CDCL SAT solvers. In one of the results, we proved that CDCL SAT solvers with non-deterministic static variable and value selection without restarts is as powerful as the same configuration with restarts, and this result holds for both unsatisfiable and satisfiable formulas. Another interesting result that we proved is DPLL SAT solvers with non-deterministic dynamic variable selection and arbitrary value selection without restart is as powerful as any DPLL solvers with restarts, when considering unsatisfiable formulas.
-  Alekhnovich, M., Hirsch, E.A., Itsykson, D.: Exponential lower bounds for the running time of dpll algorithms on satisfiable formulas. In: SAT 2005, pp. 51–72. Springer (2006)
Alekhnovich, M., Johannsen, J., Pitassi, T., Urquhart, A.: An exponential separation between regular and general resolution. In: Proceedings of the thiry-fourth annual ACM symposium on Theory of computing. pp. 448–456. ACM (2002)
Atserias, A., Fichte, J.K., Thurley, M.: Clause-learning algorithms with many restarts and bounded-width resolution. Journal of Artificial Intelligence Research40, 353–373 (2011)
-  Ben-Sasson, E., Wigderson, A.: Short proofs are narrow—resolution made simple. Journal of the ACM (JACM) 48(2), 149–169 (2001)
-  Biere, A., Heule, M., van Maaren, H.: Handbook of satisfiability, vol. 185. IOS press (2009)
-  Bonet, M.L., Buss, S., Johannsen, J.: Improved separations of regular resolution from clause learning proof systems. Journal of Artificial Intelligence Research 49, 669–703 (2014)
Gomes, C.P., Selman, B., Crato, N., Kautz, H.: Heavy-tailed phenomena in satisfiability and constraint satisfaction problems. Journal of automated reasoning24(1-2), 67–100 (2000)
-  Krajícek, J.: Proof complexity. In: European Congress of Mathematics Stockholm, June 27–July 2, 2004. pp. 221–232 (2005)
Liang, J.H.: Machine Learning for SAT Solvers. Ph.D. thesis, University of Waterloo, Canada (2018)
-  Liang, J.H., Ganesh, V., Poupart, P., Czarnecki, K.: Learning rate based branching heuristic for sat solvers. In: International Conference on Theory and Applications of Satisfiability Testing. pp. 123–140. Springer (2016)
-  Liang, J.H., Oh, C., Mathew, M., Thomas, C., Li, C., Ganesh, V.: Machine learning-based restart policy for cdcl sat solvers. In: International Conference on Theory and Applications of Satisfiability Testing. pp. 94–110. Springer (2018)
-  Liang, J.H., Poupart, P., Czarnecki, K., Ganesh, V.: An empirical study of branching heuristics through the lens of global learning rate. In: International Conference on Theory and Applications of Satisfiability Testing. pp. 119–135. Springer (2017)
-  Marques-Silva, J.P., Sakallah, K.A.: Grasp: A search algorithm for propositional satisfiability. IEEE Transactions on Computers 48(5), 506–521 (1999)
-  Moskewicz, M.W., Madigan, C.F., Zhao, Y., Zhang, L., Malik, S.: Chaff: Engineering an efficient sat solver. In: Proceedings of the 38th annual Design Automation Conference. pp. 530–535. ACM (2001)
-  Mull, N., Pang, S., Razborov, A.: On cdcl-based proof systems with the ordered decision strategy. arXiv preprint arXiv:1909.04135 (2019)
-  Pipatsrisawat, K., Darwiche, A.: A new clause learning scheme for efficient unsatisfiability proofs. In: AAAI. pp. 1481–1484 (2008)
-  Pipatsrisawat, K., Darwiche, A.: On the power of clause-learning sat solvers as resolution engines. Artificial Intelligence 175(2), 512–525 (2011)
-  Vinyals, M.: Hard examples for common variable decision heuristics. In: Proceedings of the 34th AAAI Conference on Artificial Intelligence (AAAI ’20) (Feb 2020)
-  Williams, R., Gomes, C.P., Selman, B.: Backdoors to typical case complexity. In: IJCAI. vol. 3, pp. 1173–1178. Citeseer (2003)
Below we present detailed proofs of Lemmas from Section 3.
Proofs of Section 3 (Separation Results for CDCL with Non-Deterministic Variable Selection)
Lemma 3. Let be any graph of degree at least . Suppose that has made decisions since its invocation on . Let be the current trail, then
The solver has yet to enter a conflict, and thus has not learned any clauses.
The trail contains variables from at most different blocks .
To prove this lemma, we will first argue that solver is well-behaved on the formula
Let be the trail of after decisions from invocation on . Suppose that the solver has yet to encounter a conflict. Let be obtained from by deciding some literal and applying unit propagation. Then,
The solver does not encounter a conflict from deciding and propagating.
If does not contain an assignment , then contains assignments to at most -variables.
The trail contains variables from at most different blocks .
We will delay the proof, and first argue that until the solver has made at least decisions from its invocation, the clauses will not impact its behaviour. That is, until the solver has made decisions, the solver will behave on as if it were run on .
We say that behaves identically on two formulas and if given a trail , a decision variable , and an assignment , they produce the same trail and learned clauses after setting .
Let be any trail of after decisions from invocation on . Suppose that the solver has yet to encounter a conflict, and sets variables from at most blocks . Then, for any , behaves identically on and .
Let be a trail (closed under unit propagations) which sets variables from less than blocks and let be the current decision variable and be its assignment. Observe that the clauses of each depend on variables from different blocks . Thus, these clauses cannot cause any conflicts or propagations (and thus cause the behaviour on and to differ on decision ) unless the clauses of cause the solver to set more than a single literal from a previously untouched block . Because this propagation would depend only on the clauses of , this would contradict Lemma 8. ∎
Proof (of Lemma 3)
It remains to prove Lemma 8. The proof of the first point will rely on the following lemma which says that is satisfiable provided we have not set all -variables to . This will be crucial in the proof of statement 1 in Lemma 8. Indeed, the unit propagator cannot propagate a formula into a conflict if there is a satisfying assignment.
Let be a partial assignment to the variables of such that is closed under unit propagation, does not falsify any clause of , and either sets some or there are at least two -variables that have not been set by . Then, for any variable not set by , is satisfiable for any .
First, observe that is satisfiable by the assignment extending :
To see that this is satisfying, first note that is falsified as sets some . Therefore, the clauses of are satisfied. To see that the clauses of are satisfied, first observe that if sets all variables in a block to the same value then this falsifies and satisfies .
There can be at most a single for which there is such that and . Furthermore, the existence of such a pair forces to set for all .
This follows because the clausal expansion of contains for all . Because is closed under unit propagation, these clauses must have forced to set for all . Therefore, if there was a for which some and , then the clause for which would be falsified by . ∎
Therefore, there is at most one block that for which all variables are not set to the same value by . In which case for all and is satisfied.
Next, we construct a satisfying assignment for . If for some , then define
By Claim 5, does not exist , such that and , as this would imply that all -variables had already been set by . Thus, , and therefore , must set all variables in each block to the same value. As well, because has at least two -variables unset (one of which is ) must set at least one and therefore satisfy .
Next, suppose that for some , . If every variable in block either has not been set by , or has its value set to , then is a satisfying assignment to . So, suppose that this is not the case. Assume wlog that and let be such that . Then, we claim that there does not exist such that there is for which and . Indeed, by Claim 5 this would imply that the for all . Let be such that then, because sets and the clause of ,
That is, it is unitary under , contradicting our assumption that is closed under unit propagation. Next, observe that for every for that has set, we must have , for every , otherwise the clause of ,