Exploring A Two-Solver Architecture for Clause Learning CSP Solvers. Ozan Erdem

Transcription

1 Exploring A Two-Solver Architecture for Clause Learning CSP Solvers by Ozan Erdem A thesis submitted in conformity with the requirements for the degree of Doctor of Philosophy Graduate Department of Computer Science University of Toronto c Copyright 2017 by Ozan Erdem

2 Abstract Exploring A Two-Solver Architecture for Clause Learning CSP Solvers Ozan Erdem Doctor of Philosophy Graduate Department of Computer Science University of Toronto 2017 Many real world problems can be encoded as Constraint Satisfaction Problems (CSPs). Constraint satisfaction problems contain variables over nite domains, as well as constraints over these variables. There exists many solvers that can solve these problems eciently. Once these problems are solved, their solutions correspond to solutions of the real world problem the CSP encodes. Similarly, many problems can be encoded as instances of the Satisability Problem (SAT). In SAT all the variables are binary propositions, and the only kind of constraint they allow is the disjunction of a set of variables. SAT and CSP are closely related, and they both are NP-complete. These two approaches have their own advantages and disadvantages. SAT solvers perform clause learning, which prevents them from visiting similar subtrees in the search tree. The advantage of CSP solvers is that the CSP instances contain higher level constraints, which allows better reasoning. Recently, methods combining the advantages of SAT and CSP solvers have emerged. In such methods, solvers maintain a propositional representation of the CSP problem, and perform clause learning over this representation. Such solvers are called clause learning CSP solvers. However, the question of how to handle constraints in such solvers is unresolved. For each constraint, a solver must choose whether to encode the constraint entirely in SAT or use a special purpose propagator, and this choice also determines the propagation strength and eciency. Dierent choices perform better in dierent scenarios, hence hybrid methods which can be adaptive are promising. In this thesis, we propose an alternative architecture for clause learning CSP solvers, which incorporates two solvers of dierent strength. One of the solvers directs the search using fast and weak propagators. Once it gets into a dead end, it produces a conict clause, and asks the other solver to enhance it using stronger but slower propagators. In this way, the slower propagators are run only whenever they are likely to be needed, instead of each node in the search tree. We instantiate this architecture in dierent ways, and perform experiments to demonstrate the trade-os between these instantiations. ii

3 Contents 1 Introduction Contributions Background Constraint Satisfaction Problems Satisability Problem Watched literals Assumption mechanism Clause learning CSP solvers Historical background Getting reasons from GAC propagators Getting reasons from forward checking Comparison of reason clauses Global constraints The New Solver Architecture Introduction Overview of the new architecture Related Work Lazy Clause Generation Satisability Modulo Theories Logic-Based Benders Decomposition Probe backtrack search iii

4 3.3.5 Stubbornness MiniRed Non-intrusive conict minimization Clause database Clauses learnt by auxiliary solver VSIDS scores Unit clauses Building the assumptions Skipping calls to auxiliary solver Reducing the trail Instantiating the Main Solver as a Forward Checker Introduction Design choices GAC reason clauses generated in the auxiliary solver Setting the VSIDS scores Analysis of the reduced conict Skipping calls to the auxiliary solver Number of learnt clauses per conict Experiments Benchmarks Methodology Results Discussion Propagation strength of forward checking Reasons from forward checking Eciency of forward checking Conclusions Main Solver with alldifferent Decomposition Introduction iv

5 5.2 Propagating the all-dierent constraint Decomposing the all-dierent constraint Implementation Theoretical comparison Generating synthetic problems The basic scheme Extending the generated constraints Details of the generation Experiments MiniZinc Benchmarks Discussion Testing the VSIDS scoring Testing the blocked branches Testing the learnt clauses Conclusions Main solver with cumulative Decomposition Introduction Formal description of the cumulative constraint Decomposing cumulative Energetic Reasoning Getting reasons from energetic reasoning Experiments Scheduling Problems (RCPSP) Stacking Number Comparison with minicsp using the energy based propagator Conclusions Conclusion Future Work v

6 Bibliography 134 vi

7 Chapter 1 Introduction Constraint satisfaction is a powerful paradigm for solving combinatorial problems. To make use of this paradigm, one only needs to model problems using constraints over nite domain variables. Such a model is called a Constraint Satisfaction Problem (CSP), and a CSP solver can be used to compute a solution to this problem. For example, let P be a CSP over the variables X 1, X 2 and X 3 with the domain {1, 2, 3, 4}. Assuming that P contains the constraints X 1 + X 2 < 4 and X 1 X 2 = X 3, a possible solution to P is {X 1 1, X 2 2, X 3 2}. However, the assignments {X 1 2, X 2 2, X 3 2} is not a solution since it violates the rst constraint. Another similar paradigm is Satisability (SAT), where the problems are modelled using only logical constraints over propositional variables. For example, the formula (x 1 x 2 ) ( x 1 x 2 ) is a SAT instance over the two propositional variables x 1 and x 2, where the assignment of x 1 to true and the assignment of x 2 to false is a solution to this instance. The SAT and CSP paradigms can be used to solve NP-complete problems as SAT is the canonical NP-complete problem, and CSP is a generalization of SAT. These two paradigms have their own advantages and disadvantages, as we describe as follows. The most compelling advantage of SAT over CSP is a technique called clause learning during search. The main idea behind clause learning is to learn a new clause that prevents similar mistakes in the future by analyzing dead-ends. Clause learning has theoretical benets, and has demonstrated a huge success in practice [54, 55, 80]. Traditionally, CSP solvers have also used learning, called nogood learning [24, 31], however it is more restricted than clause 1

8 Chapter 1. Introduction 2 learning [46, 45]. For this reason, nogood learning was not as widely used in CSP solvers, since it did not yield speedups to justify the bookkeeping. The advantage of CSP solvers over SAT solvers is the expressivity of the constraints. For instance, a CSP can contain the well-known alldifferent(x 1, x 2,..., x n ) constraint, which denotes that the variables x 1, x 2,..., x n should take dierent values [49]. It is possible to model this constraint in SAT by rst encoding the CSP variables and their domains as propositional variables, and using propositional clauses denoting x i x j for all i, j [1.. n]. However, reasoning with this decomposition is less eective than using the well known propagators for the alldifferent constraint, such as the generalized arc consistency (GAC) propagator [64]. It was shown in [15] that there is no SAT encoding of equivalent power to GAC propagators for alldifferent which is polynomial in size. Traditional CSP solvers combine backtracking search with doing inference at each node. Dierent levels of inference correspond to dierent levels of consistency in the solvers, and traditional CSP solvers maintain a high order of consistency, usually GAC, at each node. However, especially for global constraints, maintaining this consistency comes at a high runtime cost, which is to the disadvantage of the CSP solvers. For instance, the alldifferent constraint can be made GAC in O(n 2.5 ) time [64], and it is an NP-hard problem to make the cumulative constraint GAC [57]. One can imagine many scenarios where enforcing such a high order of consistency performs poorly. For instance, expensive propagations might result in pruned values that do not play any role in the conict found along the current path. These pruned values will be restored on backtrack and thus no information is obtained from them. Lately, state-of-the-art CSP solvers have adopted many features of SAT solvers, most importantly clause learning [46, 45]. In order to use clause learning, two simple changes are needed in a CSP solver. Firstly, the domains of the CSP variables need to be encoded as propositional variables. There are various encodings which can achieve this [20, 6, 78]. Secondly, each propagation of the solver must be explained by a reason clause in order for conict analysis to work. In a SAT solver, clauses in the input naturally serve as these reasons, however CSP solvers need additional mechanisms to generate them. One way to obtain these reasons in a CSP solver is to encode the constraint in SAT [8, 72], and another way is to craft propagators which produce a reason clause for each inference [58, 45]. After making these enhancements

9 Chapter 1. Introduction 3 to the CSP solver, it gains additional theoretical power, and performs better than a standard CSP solver in practice [58, 45]. However it is still not clear how to achieve the best of the both worlds. One of the most important questions which researchers deal with is how should the constraints be handled?, especially for constraints requiring heavy propagation such as global constraints. In clause learning CSP solvers, every constraint can be handled in various ways: (1) it can be decomposed into SAT variables and clauses, if there exists such an encoding, (2) a propagator which supplies clausal explanations can be used, or (3) hybrid methods can be used, such as a lazy decomposition [2], or decomposing some of the constraints on-the-y [1]. In practice, none of these methods dominate the other ones, as there are various trade-os. Clause learning solvers solvers are eective in practice, since they learn information during search that can be used to make the remaining search more ecient. Even though SAT solvers enforce a very weak form of consistency via unit propagation, the overall search is very eective. This indicates that good clause learning can be useful in controlling the search. Enforcing higher degrees of consistency in a SAT solver, as CSP solvers do, can increase the eectiveness of clause learning as it enables deriving shorter clauses at the expense of more computation at each node. In this thesis, we investigate whether using higher degrees of propagation in a clause learning CSP solver can be used only to derive better clauses, or are there other benets of higher degree propagation during search? In order to achieve that, we suggest an alternative approach for handling constraints which require heavy duty propagation. We propose an architecture where we use a solver which does cheap propagation throughout search. Once the solver nds a conict it computes a weak conict clause, which is due to the cheap propagators that can only produce weak reasons. It is then possible to make use of another solver with strong propagators, which does not do search at all but works only to improve the given conict clause. In general strong propagators yield shorter reason clauses for propagations, which result in better learnt clauses. This way, the learnt clause in the solver can be improved by the additional help from the stronger solver. This method is likely to demonstrate better performance in some classes of problems. For instance, in a satisable problem instance with many redundant constraints, enforcing GAC on only a subset of the constraints would suce to nd a solution. However, this would require

10 Chapter 1. Introduction 4 identifying this subset, and in order to do that we can utilize a weaker solver that explores the search space eciently. The stronger solver would reason about these constraints using highly specialized and more expensive methods, only after getting a conict. Similarly, in an unsatisable problem instance it is often possible to prove unsatisability using (and enforcing GAC on) only a subset of the constraints. If some of the constraints in the problem are not in this subset, we would like to prevent propagating these constraints using the expensive algorithms, instead propagating them only after they prove themselves relevant is more desirable. The architecture we propose in this thesis is aimed at exploiting these ideas, and we investigate the behaviour of the architecture by instantiating it in dierent ways. 1.1 Contributions In Chapter 2 we present the formal background that will be used in the rest of the thesis. In Chapter 3 we introduce a novel architecture for solving CSP problems, which is based on two solvers. The main solver of the architecture performs weak propagation while directing the search, and the auxiliary solver performs stronger propagation to enhance clause learning. We also discuss the technical implementation in detail. The main solver and the auxiliary solver in this architecture can be instantiated in many ways. In general, the main solve performs weaker propagation than the auxiliary solver. In Chapter 4, we instantiate this architecture with a solver that performs forward checking on all constraints, and perform experiments using this instantiation. In Chapter 5 we follow a more rened approach. In Chapter 4 all the constraints were propagated using forward checking, even though GAC was cheap for many types of constraints. For this reason we picked the alldifferent constraint, which is one of the constraints for which GAC propagation is expensive, as the only constraint propagated dierently in both solvers. We also prove that this particular instantiation of our architecture does not lose any theoretical power over a standard clause learning solver. Most CSP solvers propagate alldifferent using GAC propagators at each node, even though they are expensive propagators, since the propagations pay o at the end. As an alternative, in Chapter 6 we pick a propagator which is not used widely in practice, which is the

11 Chapter 1. Introduction 5 energy propagator for the cumulative constraint that runs in O(n 3 ) time [11]. Our contributions in this chapter include introducing methods for obtaining reasons from the cumulative propagator to be used in a clause learning CSP solver. We then demonstrate empirically that our architecture works well in some domains. In Chapter 7, we summarize our contributions, and suggest some future directions for our research.

12 Chapter 2 Background 2.1 Constraint Satisfaction Problems A constraint satisfaction problem (CSP) is a triple P = V, D, C, where V is a set of variables, D is a domain function which maps each variable V V to a nite domain D(V ), and C is a set of constraints which species the allowed values to the variables. Given a problem P we denote its variables with V(P) and its constraints with C(P). When the problem is clear from the context, we refer to the variables as just V. When there is an ordering for the elements of D(V ), we denote the lower bound of D(V ) as lb(v ) and the upper bound as ub(v ). An assignment is a variable value pair, (V, d), also written as V d where d D(V ). An assignment set is a set of assignments A = {V 1 d 1, V 2 d 2,..., V n d n } such that every variable in A is assigned to only one value. If the distinction between an assignment and an assignment set is not important, we refer to the assignment sets simply as assignments. Each constraint C involves a set of variables called scope(c), and maps assignment sets that include all of the variables in scope(c) to true or false. Whenever an assignment set is mapped to true by a constraint we say that it satises the constraint. An assignment set is a solution to a CSP problem if it contains all the variables in the problem, and it satises all the constraints. A satisfying tuple of a constraint C is an assignment set containing an assignment to every variable in scope(c) which satises C. A satisfying tuple of C which contains the assignment (V, d) is called a support for (V, d) on C. Also, if a satisfying tuple containing (V, d) also contains an assignment (V, d ) with d [min(d(v )).. max(d(v ))], the tuple is called a 6

13 Chapter 2. Background 7 interval support. A constraint is generalized arc-consistent (GAC) i for every V scope(c) and d D(V ) we have that (V, d) has support on C. In other words (V, d) can be extended to an assignment set that satises the constraint. A CSP is GAC i every constraint in the problem is GAC [66]. Furthermore, a constraint is range consistent i for every V scope(c) and d D(V ) there is an interval support on C. Algorithm 1 Backtracking algorithm for solving CSPs 1: function BT(level) 2: if all variables are assigned then return SUCCESS 3: end if 4: V pick-unassigned-variable() 5: Assigned[V] true 6: for d D(V ) do 7: D(V) {d} 8: if constraint-propagation({v}) then 9: BT(level+1) 10: end if 11: restore-values() 12: end for 13: Assigned[V] false 14: return 15: end function Solvers typically use backtracking search to solve CSPs. We present a backtracking algorithm in Algorithm 1, and the details are as follows. Lines 15. The current level of the search tree is given as input to the algorithm. At each level, either all variables are assigned to a value, in which case the current assignment set is a solution to the problem, or some variables are not already assigned and a variable is picked for assignment. If we want to nd a single solution, the algorithm might be terminated on Line 1 instead. Lines 612. The picked variable V is tentatively assigned to the possible values in D(V ), and some form of propagation is performed, which ensures some level of consistency. Constraint propagation either modies the domain of some of the variables, or reports a conict. If there is no conict, the search continues from the next level. Lines In the case where all possible values in the domain of V is tried, and none

14 Chapter 2. Background 8 of them led to a solution V gets unassigned and the algorithm returns. Algorithm 2 Algorithm to enforce GAC 1: function enforce-gac(vars) 2: constraintqueue update-cons-queue(, Vars) 3: while constraintqueue null do 4: C constraintqueue.pop() 5: prunedvariables enforce-gac-on-constraint(c) 6: if prunedvalues == then return false 7: else 8: constraintqueue update-cons-queue(constraintqueue, prunedvariables) 9: end if 10: end while 11: return true 12: end function 13: function enforce-gac-on-constraint(c, ν) 14: prunedvariables 15: for V scope(c) do 16: for d D(V ) do 17: if (V, d) cannot be extended to a assignment set which satises C then 18: D(V ) D(V ) {d} 19: if D(V ) == then return 20: end if 21: prunedvariables prunedvariables {V } 22: end if 23: end for 24: end for 25: return prunedvariables 26: end function 27: function update-cons-queue(q, prunedvariables) 28: for V prunedvariables do 29: for C : V scope(c ) do 30: Q Q {C } 31: end for 32: end for 33: return Q 34: end function The constraint-propagation procedure in Algorithm 1 can be instantiated in several ways. One common instantiation enforces GAC on the problem at each node, which is also referred to as the maintaining GAC algorithm [52]. We present the GAC enforcement algorithm in Algorithm 2. Some details of this algorithm are as follows. Line 2. The algorithm maintains a constraint queue during this process, and updates it

15 Chapter 2. Background 9 whenever there are new inferences using the update-cons-queue function. Lines 39. The constraint queue is processed one constraint at a time. For each constraint, GAC is enforced on it using the enforce-gac-on-constraint function. After GAC is enforced on the constraint, if there was not a conict the constraint queue is updated by a call to update-cons-queue. Lines To enforce GAC on a constraint, each possible variable-value pair (V, d) in the scope of the constraint is checked whether it can be extended to a satisfying assignment set. If this is not possible, d is pruned from the domain of V. In practice, it is often sucient to iterate over only a subset of the variable-value pairs by taking the structure of the specic constraint into consideration. Line 21. The set of pruned values is updated by adding the variable-value pairs which denote the prunings. These values will be used to update the constraint queues in updatecons-queue function. Lines In the update-cons-queue function, each variable which had a value pruned is examined and the constraints which have that variable in their scope is added to the constraint queue. Another way of instantiating constraint-propagation is using forward checking (FC), which is weaker than enforcing GAC. FC was initially developed for binary constraint networks [36], however it can be easily generalized to n-ary networks as described in [74]. FC has been used in a clause learning CSP solver in [45], with methods for generating reasons from them. In the general version, forward checking picks variables that are left as the only unassigned variable in the scope of a constraint, tries out all the values for that variable, and repeats this until a xpoint. We present this procedure formally in Algorithm Satisability Problem A proposition p is a Boolean variable. A literal is either a proposition p (a positive literal), its negation p (a negative literal),, or. The complement of a literal l is denoted l where the

16 Chapter 2. Background 10 Algorithm 3 Forward checking algorithm 1: function ForwardCheck(Vars) 2: Q all pairs (C, V f ) s.t. constraint C, scope(c) Vars, a unique V f scope(c) with D(V f ) > 1 3: while Q is not empty do 4: (C, V f ) Q.pop() 5: for each d D(V f ) do 6: if V f d violates C then 7: D(V f ) D(V f ) {d} 8: if D(V f ) == then 9: return false 10: end if 11: if D(V f ) == {d} then 12: for C : V f scope(c ) do 13: if a unique V f ) with D(V f ) > 1 then 14: Q.push((C, V f )) 15: end if 16: end for 17: end if 18: end if 19: end for 20: end while 21: return true 22: end function

17 Chapter 2. Background 11 complement is l if l is positive, is l if l is a negative literal l, is if l is, and otherwise. A clause C = (l 1 l 2... l n ) is a disjunction of literals, and we also treat it as a set of literals. A clause with a single literal is called a unit clause. Sometimes it is useful to view a clause as an implication: An implication of the form p 0 p 1... p n l is equaivalent to the clause ( p o p 1... p n l). A propositional formula is in conjunctive normal form (CNF) if it is a conjunction of clauses. We say that a clause C subsumes another clause C if C C. In the SAT context, an assignment is a mapping from a variable to either or. Given an assignment ν, we can view it as a mapping from a literal as well: For a variable v, let l be a literal over this variable. Then, ν(l) = ν(v) if l is positive and ν( l) = l if l is negative. In some cases it is convenient to denote an assignment as literal, i.e., for a variable v, the literal v denotes that ν(v) = and v denotes that ν(v) =. Moreover, an assignment set, in the context of SAT, is a set of literals, which we refer to as assignments, again when the meaning is clear. An assignment set satises a clause if one of its literals appear in the clause. An assignment set is a solution to a CNF if it satises each clause of the CNF. The satisability problem (SAT) is to determine whether there is a solution to a given CNF [33]. Resolution is an inference rule over two clauses C {x} and C { x}, which produces the clause C C [65]. Resolution can be used as the only rule for the resolution proof system, which is a complete proof system for unsatisable formulas, i.e., given an unsatisable formula it is always possible to derive the empty clause using resolution. Modern SAT solvers are based on the conict directed clause learning (CDCL) algorithm, which is an improvement over the well-known DPLL algorithm [65]. DPLL searches for an assignment to variables in a depth-rst manner, and at each node it performs unit propagation. Unit propagation is a method for simplifying a formula after a unit clause {l} is detected. During unit propagation, all the clauses containing l are removed and l is deleted from all the clauses. In Algorithm 4 we present the unit propagation algorithm. The inputs to the algorithm are a CNF ϕ and an assignment set ν. The algorithm looks for unit clauses {l} in the input theory, and assigns each such literal l to true. The assignment of l shortens the clauses which contain l, and the clauses which contain l are removed from the theory. Shortening of some clauses may yield other unit clauses, and this procedure is repeated until a xpoint is achieved. In Algorithm 5 we present a typical conict directed clause learning (CDCL) algorithm [16].

18 Chapter 2. Background 12 Algorithm 4 Unit propagation 1: function UnitPropagation(ϕ, ν) 2: for each clause C ϕ do 3: if C ν then 4: ϕ ϕ C 5: else 6: C C { l l ν} 7: end if 8: end for 9: if C ϕ such that C = 0 then 10: return CONFLICT 11: end if 12: if C ϕ such that C = 1 then 13: for all C ϕ such that C = 1 do 14: ϕ ϕ {C} 15: ν ν C 16: end for 17: return UnitPropagation(ϕ, ν) 18: end if 19: end function Algorithm 5 Typical CDCL algorithm 1: function CDCL(ϕ, ν) 2: dl 0 3: while true do 4: if UnitPropagation(ϕ, ν) == CONFLICT then 5: if dl == 0 then return UNSAT 6: else 7: conict ConflictAnalysis(ϕ, ν) 8: Backtrack(ϕ, ν, conict.assertionlevel) 9: add(conict) 10: end if 11: else 12: (x, v) PickBranchingVariable(ϕ, ν) 13: if x does not exist then return SAT 14: end if 15: dl dl : ν ν {(x, v)} 17: end if 18: end while 19: end function

19 Chapter 2. Background 13 CDCL is an improvement over DPLL. The key dierence is that CDCL learns new clauses, which are implied by the input formula. These new clauses enable non-chronological backtracking. They are also added to the formula and used to improve the remaining search. The details of the CDCL algorithm are as follows: Line 4. The algorithm performs unit propagation. Line 79. The conict analysis procedure derives a clause to be learned, the solver backtracks to the assertion level of the newly learnt clause [16] and adds it to the database. Line 12. Next variable to branch on is selected according to the VSIDS heuristic [55]. This heuristic scores each variable with respect to its occurrence in the learnt clauses (also called conict clauses), and more recent occurrences are scored higher. Search continues until either all variables are assigned, in which case the current set of assignments is a solution, or a conict is detected at decision level 0, in which case the input formula is unsatisable. Conict analysis in SAT Behind the scenes CDCL keeps more information to be used in conict analysis, which are described as follows. In CDCL there are two ways a variable can be assigned: Decisions: These are made on Line 16 of Algorithm 5. Unit propagation: On Line 4 of Algorithm 5 unit propagation can uncover some of the consequences of the literals assigned so far. Whenever all but one of the literals of a clause C are assigned to false, the remaining literal l of the clause is assigned to true. In this case we say clause C forces l. For each assigned literal l the algorithm keeps track of why it was assigned, called the reason of l, and we denote this with reason(l). This is either the clause which forced l to be assigned, or it is the empty reason in the case l was a decision literal. If the reason of l is not empty, it contains l itself, and a number of other literals that were assigned to false which led to forcing of l by unit propagation.

20 Chapter 2. Background 14 Whenever the literals in a clause are all assigned to false after propagation, the clause is identied as a conict. For any literal in the conict clause, x such that x has a reason, the conict clause and x's reason can be resolved. The result is a new (conict) clause that also is falsied and that does not contain x (nor x). Literals that have become true are put on a stack called the trail in the order they are assigned. Conict analysis works on the trail in reverse chronological order by resolving away the literals with their reasons until a stopping condition is met [55, 54]. All that is needed for it to work is for every propagated literal to have an associated reason containing only the propagated literal, and the literals made false by previous propagations and decisions (i.e., the literals that forced the propagated literal). The stopping condition widely used in SAT solvers is called the 1UIP condition, which is that there is only one literal in the conict clause which was assigned at the current decision level [54]. A clause obtained by conict analysis using this condition is called a 1UIP clause. 1UIP clauses are special cases of asserting clauses [80]. An asserting clause at level L of a solver is a clause that has only one literal l assigned at level L. For such an asserting clause, we call l the asserting literal. Learning asserting clauses α l in solvers is useful, since if such a clause is derived (1) l was an actual implication of α but it was missed (2) learning α l will make the solver catch this implication in the future. 1UIP clauses are only one form of asserting clauses. It is possible to continue resolving away literals after 1UIP condition is met, and dierent asserting clauses can be obtained. However, in practice 1UIP clauses have proven to be the most useful type of asserting clauses [80, 16]. Asserting clauses have the property of 1-empowerment [61]. A clause of the form α l is said to be 1-empowering with respect to a CNF ϕ via l if: ϕ = (α l) Unit resolution on ϕ α cannot derive l. By the denition of 1-empowerment, an asserting clause α l is 1-empowering via l. Learning 1-empowering clauses is benecial to the solvers, as each time such a clause is learned unit propagation can discover an implication which was missed before.

21 Chapter 2. Background 15 Quality of learnt clauses The quality of dierent learnt clauses can sometimes be compared. Given two learnt clauses C C, we can say that C is a better conict clause since it subsumes C. This means that in every path in search that makes C false also makes C false. Moreover, literals blocks distance (LBD) is another important metric for the quality of the learnt clauses [7]. Given a conict clause C, the assignment levels of the literals in it partition C into n dierent blocks, and we say that the LBD of C is n. 1UIP clauses with an LBD of exactly 2 are called glue clauses, and they are found to be highly useful in solvers [7]. Intuitively, these clauses glue the asserting literal to the other block in the clause to create a single block Watched literals A high performance SAT solver needs to handle unit propagation eciently. For this reason, modern SAT solvers maintain two watch literals per clause [55], where the watches are picked from literals that are not assigned to false. Every watch literal is associated with an array of clauses it watches, and whenever the literal is assigned to false a new watch has to be found. The following example illustrates how watched literals are assigned. Example 1. Let C = (x 1 x 2 x 3 x 4 ) be a clause in a solver at its initial state, where none of the variables in the problem are assigned to a value yet. At this point, the solver can pick x 1 and x 2 as the two watch literals for C. However, if at some point in search x 2 gets assigned to false, then it will not be a valid watch for C anymore. The solver then will look for another variable which is not to assigned to false to replace the invalid watch, which can be either x 3 or x 4. Assume that after x 1 is assigned to false, and in the next decision level both x 2 and x 3 are assigned to false as well. The solver will fail to pick two dierent watches for C at this point, and will force x 4 to be true as the result of unit propagation. However, if after assigning x 1, x 2, x 3, the variable x 4 is forced to false as well as a consequence of some constraints, then the solver will fail to nd any replacement watches. In this case, it will identify this situation as a conict, as C becomes the empty clause. This approach is ecient in two ways: (1) assigning any of the unwatched literals occurring

22 Chapter 2. Background 16 in the clause does not require any update, and (2) since backtracking does not invalidate watches, no updates are needed to the clauses when the solver backtracks Assumption mechanism It is possible to query some solvers, such as minisat [26], to nd an inconsistent subset of a sequence of literals L. This mechanism works as follows: The solver considers the next literal l in L (L has a xed but arbitrary order). Only after all literals in L have been assigned will the solver pick a variable using its branching heuristic. If l is unassigned, it is assigned true as the next decision and propagated. If l is already assigned true, it is skipped over. If l is assigned to false, then we know that the previous literals of L, which have been made true, have forced l to be false. This means that the set of assumptions L is inconsistent (they cannot all be made true). Conict analysis is then employed to determine a smaller subset of the currently true literals of L, that suce to force l. This works as follows: If l was already assigned to false, then it was forced by a clause. Every literal in the reason clause of l is either an assumption, or was forced by a clause. We can start with reason( l) and start resolving away literals that were forced, until a clause C of only assumptions is obtained. Then C {l} is an inconsistent subset of L, and it is returned. 2.3 Clause learning CSP solvers Historical background Traditionally, CSP solvers made use of many techniques in combination with backtracking algorithms. One popular technique is intelligent backtracking [62], where the solver can jump

23 Chapter 2. Background 17 back over irrelevant assignments after a conict is found. In order to achieve that, a solver can record the reason of each pruning, and these reasons are called nogoods. A nogood is a set of assignments {V 1 d 1, V 2 d 2,..., V n d n } that cannot be extended to a solution, which is similar to reason clauses in SAT. After a domain becomes empty in Algorithm 1, the nogoods that led to an empty domain can be combined to derive other nogoods, and dierent nogoods determine dierent backtrack levels. For instance, in a traditional CSP solver let the domain D(X) = {1, 2, 3} become empty at some point in search, and let the reason nogoods be the following: {Y 1 d 1, X 1} {Y 2 d 2, X 2} {Y 3 d 3, X 3} These nogood indicate that for i {1, 2, 3} the assignment of Y i to d i and the assignment of X to the value i at the same time cannot be extended to a solution. Hence, after D(X) becomes empty, it is possible to combine these nogoods to get another nogood {Y 1 d 1, Y 2 d 2, Y 3 d 3 } over the Y i variables. This way of deriving new nogoods is similar in nature to using 1UIP clauses to determine the backtrack level in SAT, however a few dierences exist. The main dierence is that these nogoods are not as powerful, and as a result these nogoods are not recorded and are only used to determine a backjump level. We explain this in more detail in the following paragraphs. There have been attempts to record the derived nogoods in order to prune the search space later on [24, 31], however they were not as successful as clause learning in SAT. This stems from the fact that these nogoods consists of only assignments to variables, which have limited power. Later on, there emerged works realizing this, and introduced generalized nogoods that also contained non-assignments [46, 45]. For instance, a standard nogood states that the given combination of assignments cannot be extended to a solution. However, in order to express that certain prunings cannot be extended to a solution an exponential number of standard

24 Chapter 2. Background 18 nogoods are required. Hence, generalized nogoods that can also express non-assignments are exponentially more powerful than the standard nogoods. The concept of generalized nogoods led to the development of CSP solvers that exploited them, such as lazy clause generation systems [58, 29, 8]. These systems make use of a SAT engine that drives the search, and derives generalized nogoods in the form of propositional clauses. Due to the dierences in SAT and CSP, several modications have to be made in the SAT engine. First, the CSP variables have to be represented as SAT variables. Second, arbitrary CSP constraints must be propagated. Encoding the CSP variables It is possible to encode CSP variables in SAT. This typically requires a number of literals to represent the domains, and a number of clauses to guarantee their consistency. For instance, to encode a CSP variable X with D(X) = [l.. u] we can introduce u l + 1 literals JX = lk, JX = l + 1K,..., JX = uk. Also, we will simplify the notation for JX = dk as JX dk. In addition to the literals, we need the following clauses to establish the consistency of the domain [78]: (JX = lk JX = l + 1K... JX = uk) (2.1) (JX ik JX jk) i j (2.2) Clause (2.1) ensures that a variable is assigned to at least one value, and clauses in (2.2) ensure that a variable is assigned to at most one value. This encoding takes O(n 2 ) space, however more ecient encodings are known, such as the linear encoding [20, 6, 58]. In this encoding, for each variable X, we have JX = dk for each d D(X) (called equality literals) and we have JX dk for lb(x) d < ub(x) (called inequality literals). Intuitively, JX = dk holds whenever X takes the value d and JX dk holds whenever X is less than or equal to d. To enforce these conditions, we post the following clauses for each variable X with domain [l.. u]:

25 Chapter 2. Background 19 JX dk JX d + 1K l d u 1 JX = dk JX dk JX = dk JX d 1K l d u l < d u JX lk JX = lk JX dk JX = dk JX d 1K l < d < u JX = uk JX u 1K The total number of clauses in the order encoding is O(n), and it has the same unit propagation power as the direct encoding [58]. In the rest of this thesis we assume that the order encoding is used, unless stated otherwise. Constraint propagation In a SAT engine, constraint propagation of arbitrary constraints can be done in two ways: If a SAT encoding of a constraint is known, it can be added to the input CNF [8]. This approach ts well into the clause learning mechanism since every pruning is automatically associated with a reason clause. However, this approach often works poorly for constraints of large scope since the solver then has to handle and propagate many clauses. Alternatively, a special purpose propagator can be used to propagate the constraint. The CSP literature contains many examples of such propagators [66]. To make this approach work with clause learning, propagators must supply clausal reasons for each pruning they make [45, 58, 34, 69, 70]. In this case, the UnitPropagation method in Algorithm 5 is replaced with a more general propagation method, which does unit propagation and also propagation of the CSP constraints. Contrary to encoding the constraints, this approach prevents the possible exponential expansion of constraints into clauses. Solvers which can make use of propagators that supply clausal reasons are called lazy clause generation (LCG) systems [58]. These systems can be viewed as generating a clausal encoding of constraints on-the-y, as they propagate literals. If a constraint is not active (i.e., if it

26 Chapter 2. Background 20 does not propagate anything) no clauses are produced for that constraint. Regardless of the variable encoding and propagation strength, we call the resulting algorithm CDCL-CSP Getting reasons from GAC propagators There are GAC propagators for various constraints in the literature [66]. For any GAC propagator, a generic reason clause can always be formed in the following way. Say that the GAC propagator for constraint C prunes d from D(V ) for some V scope(c). For each remaining variable V i in scope(c) consider the following formula Ch(V i ), which simply encodes the changes to D(V i ): JV i = d (i,v) K if V i is assigned to v Ch(V i ) = JV i d (i,0) K JV i d (i,1) K... JV i d (i,ji ) K d (i,0),..., d (i,ji ) are pruned from D(V i ) V = d: Then, this set of pruning of domain values and variable assignments led to the pruning of Ch(V i ) JV dk (2.3) V i scope(c) which is equivalent to the following clause: Ch(V i ) JV dk (2.4) V i scope(c) However, it is possible that not every variable in scope(c) or literal in Ch(V i ) is relevant to the conict. GAC propagators can make use of the structure of the constraints and produce shorter clauses than the generic reason [32, 34, 45, 69, 70]. Example 2. Consider a CSP with four variables X 0, X 1, X 2, X 3 with domains D(X i ) = {0, 1, 2, 3, 4}, and a single alldifferent constraint over these four variables. At some point in search, let the new domains be D(X 0 ) = {1}, D(X 1 ) = D(X 2 ) = {2, 3}.

27 Chapter 2. Background 21 At this point, one of the values to be pruned is X 3 = 2 since either X 1 or X 2 has to be assigned to 2. The reason clause we would get from the generic method above would be: Ch(X 0 ) Ch(X 1 ) Ch(X 2 ) JX 3 = 2K JX 0 = 1K JX 1 = 0K JX 1 = 1K JX 1 = 4K JX 2 = 0K JX 2 = 1K JX 2 = 4K JX 3 = 2K However, the assignment to X 0 is not relevant to this pruning, the changes to D(X 1 ) and D(X 2 ) are sucient to explain it: Ch(X 1 ) Ch(X 2 ) X 3 2 JX 1 = 0K JX 1 = 1K JX 1 = 4K JX 2 = 0K JX 2 = 1K JX 2 = 4K JX 3 = 2K This is a stronger clause than the generic reason, and a good GAC propagator might generate this clause instead Getting reasons from forward checking In order to use FC in a clause learning CSP solver, the FC engine must also supply a clausal reason for each pruning it makes. FC naturally yields a reason clause in the following way. When FC prunes a value V = d, then there exists a constraint C such that all the remaining variables in its domain are assigned. In other words all these assignments have led to that pruning. This is expressed with the following propositional formula: V i scope(c) {V } JV i = d i K JV = dk which is equivalent to the following clause:

28 Chapter 2. Background 22 JV i = d i K JV = dk (2.5) V i scope(c) {V } Hence the propagation engine in a CDCL algorithm can make use of FC easily by supplying such reason clauses. Conict analysis can then naturally produce a 1UIP clauses by using these clausal reasons Comparison of reason clauses Example 3. Consider the following linear equation constraint: X 1 + X 2 + X 3 + X 4 > 2 where the domain of each variable is D(X i ) = {0, 1}. Say that at some point in the search, the assignment X 1 = 0 is made. Depending on the propagation engine, there are two possible scenarios on what happens during propagation: A GAC propagator would detect that X 2 = 0, X 3 = 0 and X 4 = 0 should be pruned, since it cannot be extended to a satisfying assignment set. The reason clause for the pruning of X 4 = 0 would be C 1 = ( JX 1 = 0K JX 4 = 0K). A forward checker would not prune anything. However, if the search goes on and if the assignments X 2 = 0 and X 3 = 0 are made, X 4 = 0 would then be pruned, along with X 4 = 1. The reason clause would be C 2 = ( JX 1 = 0K JX 2 = 0K JX 3 = 0K JX 4 = 0K) in this case. This is a worse reason clause than C 1, since it is a superset of C 1. Note that after the mentioned decisions are made, a dead end is achieved. During the conict analysis after achieving this dead end, this clause would be used to produce a longer conict clause and it would induce a worse jumpback level. In general, a stronger propagator yields better reasons than a weaker propagator. This is not a coincidence: A stronger propagator makes the same set of inferences after fewer assign-

29 Chapter 2. Background 23 ments to the variables in the constraint's scope, and this assignments themselves constitute the explanations. Given two reason clauses for a literal l, C 1 and C 2, we say that C 1 is a stronger reason clause than C 2 if C 1 subsumes C 2. If C 1 is a stronger clause than C 2 it may possibly yield a better backtrack level than C 2 to assert l. Not all clauses can be compared in strength, as dierent sets of literals do not necessarily have a subset/superset relationship. 2.4 Global constraints A global constraint is a constraint of large arity that grows as the number of variables in the CSP increases [13]. In practice, global constraints are computationally expensive to propagate and for this reason there has been a signicant amount of work on building ecient propagators for them. Some examples of global constraints include the alldifferent constraint, the global cardinality constraint gcc and, the cumulative constraint cumulative. Some global constraints can be made GAC eciently, such as the alldifferent constraint which admits a GAC propagator that runs in O(n 2.5 ) time [64]. Even though it is a costly propagator, the inference pays o in practice. However, enforcing GAC on the cumulative propagator is NP-hard [57], and CSP solvers usually enforce a weaker notion of consistency.

30 Chapter 3 The New Solver Architecture 3.1 Introduction In this chapter, we describe the circumstances where a CSP solver can do redundant work, and suggest a new architecture for solving CSPs which aims to eliminate these redundancies. We also describe the design choices we make, along with their motivations. State-of-the-art CSP solvers contain propagators which reason about global constraints. However, these propagators often incur high runtime cost. For this reason, we would like to avoid excessive use of these propagators, when possible. A CSP solver can perform many propagations that do not play any role in a conict, and that are erased after a backtrack. Consider the following scenario where the CDCL-CSP algorithm would perform badly: Example 4. Assume we have a CSP with the variables X 1, X 2,..., X 100, X 101 with domains D(X i ) = {0, 1} and many alldifferent constraints of arity 100: A 1 : alldifferent(x 1, Y 1 ) A 2 : alldifferent(x 2, Y 2 )... A 100 : alldifferent(x 100, Y 100 ) 24

31 Chapter 3. The New Solver Architecture 25 Figure 3.1: A search tree. L0 JX 1 =1K L1 JX 2 =1K L2 JX 3 =1K JX 100 =1K. JX 99 =1K JX 100 =1K where each Y i is a sequence of 99 dierent variables. Also assume that the CSP contains the following linear constraints: L 1 : X 1 + X 100 X 101 X 99 < 1 L 2 : X 2 + X X 101 < 3 Let a clause learning CSP solver S GAC decide on JX 1 = 1K, JX 2 = 1K,..., JX 100 = 1K in order, and establish GAC at each node. Figure 3.1 illustrates a search tree containing this path on the left. After JX 100 = 1K is decided on, the GAC propagator for L 1 will infer JX 101 = 1K with the reason clause C 1 = ( JX 1 = 1K JX 100 = 1K JX 101 = 1K), and L 2 will fail while producing the conict clause C 2 = ( JX 2 = 1K JX 100 = 1K JX 101 = 1K). A step of resolution of the conict clause C 2 with C 1, which is the reason clause of the last assigned literal JX 100 = 1K, will yield the 1UIP clause C 1UIP = ( JX 1 = 1K JX 2 = 1K JX 100 = 1K). The solver will jump back to the second highest decision level in the 1UIP clause, which is the second decision level, and force the newly discovered unit JX 100 = 1K.