CS-E3220 Declarative Programming

Transcription

1 CS-E3220 Declarative Programming Lecture 5: Premises for Modern SAT Solving Aalto University School of Science Department of Computer Science Spring 2018

2 Motivation The Davis-Putnam-Logemann-Loveland (DPLL) procedure was proposed as early as in the 1960s! Since those days, computers have developed significantly both in terms of processor speed and memory available. Inventions that pushed the performance of SAT solvers forward: Conflict-driven clause learning Effective search heuristics Restart strategies Unit propagation with watched literals Preprocessing Moreover, efficient implementation techniques are highly critical for the scalability of SAT solving methods. 2/32

3 Agenda First Illustrations Conflict-Driven Clause Learning Preprocessing Unit Propagation Search Strategies Restarts Summary 3/32

4 1. FIRST ILLUSTRATIONS The DPLL procedure implements a backtracking search for satisfying assignments. The search is essentially based on the branch&bound strategy, i.e., in each node of the search tree 1. the remaining search space is bound by unit propagation, 2. the search branches by the assignment of a truth value for the next literal picked by the search heuristic to true and false, respectively. This strategy has obvious shortcomings that degrade the performance of DPLL-based SAT solver: It may take a while to recover from an early mistake, i.e., some variable is assigned a wrong truth value pre-empting the satisfaction of clauses. Dead-ends in the search space are rediscovered repeatedly. 4/32

5 How to Escape from Dead-Ends? Example Consider the following set of clauses: a d e, a d e, b f, b g, b f, b g, c d, c e, c d, c e. Consider the following DPLL-based search for models: a a f,g c b c b c f,g c... d, e, d,e, d,e, d, e, The dashed arrow illustrates backjumping (conflict does not involve b). 5/32

6 Conflict Analysis The conflict occurred after decisions a, b, and c. The clause falsified by these decisions is a d e. The clauses c d and c e (used to derive d and e) let us deduce a conflict clause using resolution backwards: a d e c e a c d c d a c Interestingly, the conflict has nothing to do with b! 6/32

7 Effect of Learned Clauses Example Recall the set of clauses from our previous example: f,g c b d, e, Assert a c a d e, a d e b f, b g, b f, b g, c d, c e, c d, c e. a a c,d,e, Assert a The learned clauses guide the search away from the region containing no satisfying assignments and branching over b is avoided altogether. 7/32

8 2. CONFLICT-DRIVEN CLAUSE LEARNING The set of decision literals l 1,...,l n along a path in a DPLL search tree can be understood as a partial truth assignment ν: 1. If l i = a for some 1 i n, then ν(a) = T. 2. If l i = a for some 1 i n, then ν(a) = F. 3. Otherwise, a remains undefined in ν. If can be deduced from S {l 1,...,l n } by unit resolution, then S {l 1,...,l n } is necessarily inconsistent and S = l 1... l n. However, the disjunction l 1... l n may be weakened by literals of l 1,...,l n that are not required in the derivation of from S. Thus a shorter clause could be potentially derived from the conflict and other other related clauses may be equally useful. 8/32

9 Which Clause Should be Learned? Example Recall the set of clauses S from our previous examples: a d e, a d e, b f, b g, b f, b g, c d, c e, c d, c e. Let us analyze the literals from the leftmost branch of our DPLL tree: Literals Clause All a, b,f,g,c, d, e a b f g c d e Decision a, b,c a b c Propagating a,c a c The former (longer) clauses are implied by a c. Learning short clauses is highly preferred! 9/32

10 Subroutines for the CDCL Algorithm The input is a set S of clauses and the main variables are the set L of literals over Vars(S), the set D of dynamic (learned) clauses, a clause C conflicting with L. Subroutines for S, L, and C in general: 1. Propagate(S,L): Expand L to L L by unit propagation using clauses from S. 2. ConflictAnalysis(S,L,C): Derive a conflict clause C from C and return C,dl where C is the clause to be learned and dl is the new decision level for backjumping. 3. Choose(S, L): Pick the next literal l to be asserted true. 10/32

11 The CDCL Algorithm function CDCL(S): Set of literals; L := /0; // Set of literals D := /0; // Set of dynamic clauses dl := 0; // Decision level loop L := Propagate(S D,L); if L = C for some C S D then // Conflict if max{level[l] l C} = 0 then return { }; C,dl := ConflictAnalysis(S D,L,C); D := D {C }; // Learn the clause L := L \ {l L dl < level[l]}; // Backjump elif Vars(S) = Vars(L) then return L; // Model found else l := Choose(S D,L); // Decision dl := dl + 1; level[l] = dl; L := L {l}; // No models exist 11/32

12 Sample Runs in More Detail dl l Reason 1 b DL 1 f UP: b f 1 g UP: b g 2 c DL 2 d UP: c d 2 e UP: c e 2 a UP: a d e L = { a,b,c, d, e,f,g} Abbreviations: DL Decision literal UP Unit propagation CL Clause learning dl l Reason 1 a DL 2 b DL 2 f UP: b f 2 g UP: b g 3 d DL 3 c UP: c d 3 e UP: c e 3 UP: a d e 1 CL: a d 1 d UP: a d 1 c UP: c d 1 e UP: c e 1 UP: a d e 0 CL: a 0 a UP: a /32

13 Implication Graphs Definition Let S be a set of clauses and l 1,...,l n a branch in a DPLL-style search tree for S. The induced implication graph is a DAG V,A where 1. V = {l 1,...,l n } { } and 2. A contains arcs { l,l i l C \ {l i }} for literals l i (and ) that were derived using a clause C S by unit resolution. Example For the branch a, b,f,g,c, d, e, in our running example: b f g c d e a 13/32

14 Conflict Analysis Cuts of the implication graph correspond to conjunctions of literals l 1... l k. Since the derivation of should be impeded, negating such conjunctions yields clauses l 1... l k that could be learned. If the implication graph is not readily available or never constructed, such clauses can be derived by resolution. dl = 1 a dl = 3 a c c d e a c d a d e a c a d e a c d Corresponding resolution: a d e c e a c d c d a c 14/32

15 Conflict Analysis Algorithm The goal is to characterize the origin of the conflict C: derive a conflict clause C with a unique literal l C referring to the current decision level. The literal l is the first unique implication point (first-uip). Let l 1,...,l n be the literals from the current decision level, derived using clauses C 1,...,C n before the conflict. The ConflictAnalysis(S,L {l 1,...,l n },C) procedure: Let C n+1 = C and do the following steps for i in n...1: 1. If l i C i+1, do the resolution C i = (C i+1 \ { l i }) (C i \ {l i }). 2. Otherwise, let C i = C i+1. The resulting conflict clause C 1 will guide the search to other regions of the search space after backjumping. If l is the first-uip literal in C 1, the new decision level after backjumping is max{level[l ] l C 1 \ {l}}. 15/32

16 Forgetting/Deleting Learned Clauses Clauses learned from conflicts guide the search effectively. The number of conflicts during a search can be high and consequently and a high number of clauses is learned. To free memory, many learned clauses have to be deleted at regular intervals, typically based on clause length, latest time used, and other criteria. Example For instance, the Glucose solver [Audemard and Simon, 2009] implements a strategy where 1. the numbers of decision levels of literals in each clause are counted and 2. the clauses with higher counts are deleted first. 16/32

17 3. PREPROCESSING The idea of preprocessing is to reason about the set of input clauses S before the actual search phase, e.g., by removing unuseful clauses (trivial consequences), removing certain variables altogether, and simplifying the remaining clauses in inexpensive ways. The correctness of preprocessing relies either on logical consequence and/or validity, or preservation of satisfiability (not necessarily model-preserving). The idea of inprocessing is to interleave similar reasoning with search, but this gets more expensive when done repeatedly. Example If a variable a occurs in the clauses of S with single polarity only, those clauses can be deleted while preserving satisfiability. 17/32

18 Some Principles for Simplification Unit resolution: if S contains a clause C = {l}: remove any other clause C such that l C and remove l for clauses C such that l C. The derivation of (empty disjunction) indicates contradiction! Subsumption: if there are clauses l 1... l n and k 1... k m such that {l 1,...,l n } {k 1,...,k m }, the latter can be deleted. Removal of tautologies: delete any C with l C and l C. Look-ahead: if S {l} yields by unit resolution, then S = l, l can be added to S and S { l} can be simplified accordingly. Example Let S have clauses a, a b c, b c d, and a b c: 1. Unit resolution with a yields b c and b c. 2. The clause b c d is subsumed and can be deleted. 3. Clauses b c and b c get deleted, since b propagates to ( b). 18/32

19 Equivalence Reasoning If S contains binary clauses l 1 l 2 and l 1 l 2, then S = l 1 l 2 It is possible to remove l 2 altogether from S by substituting every occurrence of the literal l 2 in S by the literal l 1, and every occurrence of the complement l 2 in S by the complement l 1. Example Let us reconsider our running example: a d e, a d e, b f, b g, b f, b g, c d, c e, c d, c e. The last four clauses imply c d and c e. Substituting d/ c, d/c, e/ c, and e/c: Turn the last four clauses into c c to be deleted. Turn the first two clauses into a c and and a c. We can infer a by binary resolution or look-ahead. 19/32

20 4. UNIT PROPAGATION Modern CDCL solvers spend most of their runtime on performing unit propagation ( 90 %). The Dowling-Gallier algorithm [1984] has traditionally been used to implement unit propagation using a counter for each (non-trivial) clause l 1... l n and by initializing the counter with the value n, decreasing the value of the counter whenever one literal is falsified, asserting the remaining literal when the value is set to 1. However, the counter-based approach has some issues: The counter need not be updated if l 1... l n gets satisfied. The counter must be updated when backtracking or backjumping, leading to a high number of memory accesses, and potentially many cache misses. It is highly important to minimize access to data structures! 20/32

21 The Watched Literals Scheme Moskewicz et al. [2001] designed lazy data structures for implementing unit propagation in the zchaff solver. Example For any two watched literals l 1 and l 2 in a clause C: If l 1 and l 2 are not assigned false, do nothing! If l i is assigned false and l 2 i is unassigned, replace l i by another unassigned literal from C to be watched next. If such an unassigned literal cannot be found in C (and no literal in C is assigned to true), assign l 2 i to true. Watched literals need not be updated when backjumping! Consider the following: ν c, a, b, e a b c d e = d 21/32

22 The Watched Literals Scheme Moskewicz et al. [2001] designed lazy data structures for implementing unit propagation in the zchaff solver. Example For any two watched literals l 1 and l 2 in a clause C: If l 1 and l 2 are not assigned false, do nothing! If l i is assigned false and l 2 i is unassigned, replace l i by another unassigned literal from C to be watched next. If such an unassigned literal cannot be found in C (and no literal in C is assigned to true), assign l 2 i to true. Watched literals need not be updated when backjumping! Consider the following: ν c, a, b, e a b c d e = d 22/32

23 The Watched Literals Scheme Moskewicz et al. [2001] designed lazy data structures for implementing unit propagation in the zchaff solver. Example For any two watched literals l 1 and l 2 in a clause C: If l 1 and l 2 are not assigned false, do nothing! If l i is assigned false and l 2 i is unassigned, replace l i by another unassigned literal from C to be watched next. If such an unassigned literal cannot be found in C (and no literal in C is assigned to true), assign l 2 i to true. Watched literals need not be updated when backjumping! Consider the following: ν c, a, b, e a b c d e = d 23/32

24 Unit Propagation for Two-Literal Clauses Handling 2-literal clauses l 1 l 2 is unnecessarily complex using the watched literal scheme. There are sets of clauses where 2-literal clauses dominate. The 2-literal clauses associated with each literal l can be treated separately (outside the watched literal scheme). Record l l 1,...,l l n by a set of literals L = {l 1,...,l n } (stored as an array in practice). Whenever l is made false, push all unassigned literals of L to the propagation queue/stack and carry out unit propagation. Many SAT solvers also treat 3-literal clauses in a special way. 24/32

25 5. SEARCH STRATEGIES Search heuristics is an essential part of the search strategy implemented by a SAT solver. Many solvers implement a variety of search heuristics: clasp --heuristic=heu where heu is one of Berkmin, Vmtf, Vsids, Domain, Unit, and None. When solving NP-complete problems with search algorithms the runtimes typically exhibit a heavy-tailed distribution. Restarts and a restart strategy provide means to escape regions of search space not containing satisfying assignments. 25/32

26 Variable State Independent Decaying Sum (VSIDS) Moskewicz et al. [2001] introduced VSIDS in the zchaff solver. For each literal l, two integer scores s(l) and r(l) are initialized: s(l) is the number of occurrences of l in S and r(l) := 0. The scores are updated and used as follows: The score r(l) is increased by 1 if a clause with l is learned. The scores are decayed periodically by the assignments s(l) := s(l)/2 + r(l) and r(l) := 0. The search heuristics: an unassigned literal l with the maximum score s(l) is always asserted next. Variations and extensions of VSIDS are most popular in contemporary solvers. 26/32

27 Heavy-Tailed Runtime Distributions Many NP-complete problems exhibit heavy-tailed distributions for runtimes of a randomized algorithm on a single instance and runtimes of a deterministic algorithm on a class of instances. The mean of the distribution does not converge. Chen et al. [2001] Gomes et al. [2000] 27/32

28 Heavy-tailed Runtimes: Cause and Cure A small number of wrong decisions may lead to a part of the search tree not containing any solutions (satisfying assignments). Backtracking search does not recover from wrong decisions well. Restarting the search after time t reduces the mean substantially, if t is close to the mean of the original runtime distribution. Restarts have been used in stochastic local search algorithms to escape local minima! Gomes et al. [2000] demonstrate the utility of restarts for systematic SAT solvers (such as Satz [Li and Anbulagan, 1997]). Small amount of randomness in branching variable selection. Restart the algorithm after a given amount of time. Restarts have been extensively used since the Chaff solver. 28/32

29 Restarts in CDCL-Style Solvers Learned clauses are preserved over restarts. Extra care is required when carrying out restarts: Optimal restart policy depends on the runtime distribution which is generally not known. Deletion of learned clauses with fast restarts may lead to non-termination for unsatisfiable formulas. These can be addressed by increasing restart interval gradually: One effective restart policy is obtained from the Luby-Ertel series n = 1,1,2,1,1,2,4,1,1,2,1,1,2,4,8,... to decide how many clauses are learned between consecutive restarts [Huang, 2007]. Such a policy has been shown optimal for Las Vegas algorithms with unknown runtime distribution [Luby and Ertel, 1994]. 29/32

30 Summary The shift of 1990s and 2000s led SAT solver technology to a new era when DPLL-style procedures were enhanced by CDCL techniques. However, this was not the only factor that played a role in the forthcoming success of SAT solver technology: many other supporting techniques were incorporated, and the performance and capacity of computers increased remarkably. The selection of appropriate data structures (memory management and cache effects) is also crucial for performance. Many state-of-the art SAT solvers can be found be consulting the results of the SAT Competition series. 30/32

31 Objectives You have a basic understanding of the main components required when implementing a modern SAT solver. You know how the correctness of SAT solvers can be justified using the semantical concepts of propositional logic (satisfiability, logical consequence, and equivalence). You are able to simulate the main algorithms and reasoning techniques given a smallish set of clauses as input (simplification, propagation, and CDCL). You should be able to make a straightforward implementation of a CDCL-based SAT solver on your own. 31/32

32 Bibliography G. Audemard and L. Simon: Predicting Learnt Clauses Quality in Modern SAT Solvers, A. Biere et al. (Eds.), Handbook of Satisfiability, H. Chen, C. Gomes, and B. Selman: Formal Models of Heavy-Tailed Behavior in Combinatorial Search, C. Gomes, B. Selman, N. Crato, and H. Kautz: Heavy-tailed Phenomena in Satisfiability and Constraint Satisfaction Problems, M. Luby and R. Ertel: Optimal Parallelization of Las Vegas Algorithms, J. Marques-Silva and K. Sakallah: GRASP: A New Search Algorithm for Satisfiability, M. Moskewicz et al.: Chaff: Engineering an Efficient SAT Solver, /32