Heuristics for Efficient SAT Solving. As implemented in GRASP, Chaff and GSAT.

Transcription

1 Heuristics for Efficient SAT Solving As implemented in GRASP, Chaff and GSAT.

2 Formulation of famous problems as SAT: k-coloring (1/2) The K-Coloring problem: Given an undirected graph G(V,E) and a natural number k, is there an assignment color:

3 Formulation of famous problems as SAT: k-coloring (2/2) x i,j = node i is assigned the color j (1 i n, 1 j k) Constraints: i) At least one color to each node: (x 1,1 x 1,2 x 1,k ) ii) At most one color to each node: ) (,, t i j i k j t k j n i x x + = = = iii) Coloring constraints: ) ( V, 1 1 j i k j n i x = = Λ ).( ), (,, c j c i n j n i k c x x E j i = = =

4 Formulation of famous problems as SAT: Bounded Model Checking (1/4) Given a property p: (e.g. always signal_a = signal_b ) Is there a state reachable within k cycles, which satisfies p? p p p p p... s 0 s 1 s 2 s k-1 s k

5 Formulation of famous problems as SAT: Bounded Model Checking (2/4) The reachable states in k steps are captured by: I( s0 ) ρ( s0, s1 ) ρ( s1, s2 )... ρ( sk 1, sk ) The property p fails in one of the cycles 1..k: p 1 p 2... p k

6 Formulation of famous problems as SAT: Bounded Model Checking (3/4) The safety property p is valid up to cycle k iff Ω(k) is unsatisfiable: k 1 Ω( k): I ρ ( s, s ) p 0 i= 0 i i+ 1 k i= 0 p p p p p... s 0 s 1 s 2 s k-1 s k i

7 Formulation of famous problems as SAT: Bounded Model Checking (4/4) Example: a two bit counter Initial state: Transition: Property: I0 : l r ρ : l' = ( l r) r' = r always ( l r). For k = 2: Fl 1 = ( l0 r0 ) r1 = r0 ϕ: ( l0 r0 ) l = ( l r ) r = r HG I F K GG J H ( l0 r0 ) ( l1 r1 ) ( l r ) 2 2 For k = 2, Ω(k) is unsatisfiable. For k = 4 Ω(k) is satisfiable I K J J

8 What is SAT? Given a propositional formula in CNF, find an assignment to Boolean variables that makes the formula true: ω 11 = (x (x 2 2 x 33 )) ω 22 = ( x 1 1 x x 44 )) ω 33 = ( x 2 2 x 44 )) A = {x {x 11 =0, x 22 =1, x 33 =0, x 44 =1}

9 Why SAT? Fundamental problem from theoretical point of view Numerous applications: CAD, VLSI Optimization Bounded Model Checking and other type of formal verification AI, planning, automated deduction

10 A Basic SAT algorithm Given ϕ in CNF: (x,y,z),(-x,y),(-y,z),(-x,-y,-z) x ϕ -x Decide() (y),(-y,z),(-y,-z) (y,z),(-y,z) y -y z -z (z),(-z) () () (y),(-y) z -z y -y () () X () () X X X X Deduce() Resolve_Conflict()

11 A Basic SAT algorithm Choose the next variable and value. Return False if all variables are assigned Apply unit clause rule. Return False if reached a conflict Backtrack until no conflict. Return False if impossible

12 Basic Backtracking Search Organize the search in the form of a decision tree Each node corresponds to a decision Depth of the node in the decision tree decision level Notation: x=v@d x{0,1} is assigned to v at decision level d

13 Backtracking Search in Action x 1 = 0@1 x 1 ω 11 = (x (x 2 2 x 33 )) ω 22 = ( x 1 1 x x 44 )) ω 33 = ( x 2 2 x 44 )) x 2 = 0@2 x 2 x 3 = 1@2 {(x 1,0), (x 2,0), (x 3,1)} x 1 = 1@1 x 4 = 0@1 x 2 = 0@1 x 3 = 1@1 {(x 1,1), (x 2,0), (x 3,1), (x 4,0)}

14 Backtracking Search in Action x 1 = 1@1 x 4 = 0@1 x 2 = 0@1 x 3 = 1@1 x 1 ω 11 = (x (x 2 2 x 33 )) x 1 = 0@1 x 2 ω 22 = ( x 1 1 x x 44 )) ω 33 = ( x 2 2 x 44 )) ω 44 = ( x 1 1 x 2 2 x x 33 )) x 2 = 0@2 x 3 = 1@2 {(x 1,0), (x 2,0), (x 3,1)}

15 Decision heuristics DLIS (Dynamic Largest Individual Sum) For a given variable x: C x,p # unresolved clauses in which x appears positively C x,n - # unresolved clauses in which x appears negatively Let x be the literal for which C x,p is maximal Let y be the literal for which C y,n is maximal If C x,p > C y,n choose x and assign it TRUE Otherwise choose y and assign it FALSE Requires l (#literals) queries for each decision. (Implemented in e.g. Grasp)

16 Decision heuristics Jeroslow-Wang method Compute for every clause ω and every variable l (in each phase): J(l) := 2 l ω, ω ϕ ω Choose a variable l that maximizes J(l). This gives an exponentially higher weight to literals in shorter clauses.

17 Decision heuristics MOM (Maximum Occurrence of clauses of Minimum size). Let f*(x) be the # of unresolved smallest clauses containing x. Choose x that maximizes: ((f*(x) + f*(!x)) * 2 k + f*(x) * f*(!x) k is chosen heuristically. The idea: Give preference to satisfying small clauses. Among those, give preference to balanced variables (e.g. f*(x) = 3, f*(!x) = 3 is better than f*(x) = 1, f*(!x) = 5).

18 Decision heuristics VSIDS (Variable State Independent Decaying Sum) 1. Each variable in each polarity has a counter initialized to When a clause is added, the counters are updated. 3. The unassigned variable with the highest counter is chosen. 4. Periodically, all the counters are divided by a constant. (Implemented in Chaff)

19 Decision heuristics VSIDS (cont d) Chaff holds a list of unassigned variables sorted by the counter value. Updates are needed only when adding conflict clauses. Thus - decision is made in constant time.

20 Decision heuristics VSIDS is a quasi-static strategy: - static because it doesn t depend on current assignment - dynamic because it gradually changes. Variables that appear in recent conflicts have higher priority. This strategy is a conflict-driven decision strategy...employing this strategy dramatically (i.e. an order of magnitude) improved performance...

21 Variable ordering (Abstract dependency graphs) A (CNF) dependency graph D (V,E): A partitioning C 1..C n : An abstract dependency graph D (V, E ):

22 Variable ordering (The natural order of Ω(k)) For Ω(k) there exists a partition C 1..C n s.t. the abstract dependency graph is linear V 0 V 1 V 2 V 3 V k-1 V k C 0 C 1 C 2 C 3... C k-1 C k

23 I 0 Ω(k) should satisfy I 0 Variable ordering (simple static ordering) Riding on unreachable states... P k I 0 Riding on legal executions... Ω(k) should satisfy P k P k

24 Implication graphs and learning {x 9 =0@1,x 10 =0@3, x 11 =0@3, x 12 =1@2, x 13 =1@2} {x 1 =1@6} ω 1 ω = 1 ( x ( x 1 1 x x 2 ) 2 ) ω 2 ω = 2 ( x ( x 1 1 x x 3 3 xx 9 ) 9 ) ω 3 ω = 3 ( x ( x 2 2 x x 3 3 xx 4 ) 4 ) ω 4 ω = 4 ( x ( x 4 4 x x 5 5 xx 10 ) x 10 ) 1 =1@6 ω 5 ω = 5 ( x ( x 4 4 x x 6 6 xx 11 ) 11 ) ω 6 ω = 6 ( x ( x 5 5 xx 6 ) 6 ) x 10 =0@3 ω 7 ω = 7 (x (x 1 1 xx 7 7 x x 12 ) 12 ) x 9 =0@1 x 11 =0@3 ω 8 ω = 8 (x (x 1 1 xx 8 ) 8 ) ω 9 ω = 9 ( x ( x 7 7 x x 8 8 xx 13 ) 13 ) ω 1 ω 2 ω 2 x 2 =1@6 x 3 =1@6 ω 3 ω 3 ω 4 ω 4 x 4 =1@6 ω 5 ω 5 x 5 =1@6 ω 6 ω 6 x6 =1@6 κ conflict We learn the conflict clause ω 10 : ( x 1 x 9 x 11 x 10 )

25 Implication graph, flipped assignment ω 1 ω = 1 ( x ( x 1 1 x x 2 ) 2 ) ω 2 ω = 2 ( x ( x 1 1 x x 3 3 xx 9 ) 9 ) ω 3 ω = 3 ( x ( x 2 2 x x 3 3 xx 4 ) 4 ) ω 4 ω = 4 ( x ( x 4 4 x x 5 5 xx 10 ) 10 ) ω 5 ω = 5 ( x ( x 4 4 x x 6 6 xx 11 ) 11 ) ω 6 ω = 6 ( x ( x 5 5 x x 6 ) 6 ) ω 7 ω = 7 (x (x 1 1 xx 7 7 x x 12 ) 12 ) ω 8 ω = 8 (x (x 1 1 xx 8 ) 8 ) ω 9 ω = 9 ( x ( x 7 7 x x 8 8 xx 13 ) 13 ) ω 10 ω : 10 :(( xx 1 1 xx 9 9 xx xx 10 ) 10 ) x 10 =0@3 x 9 =0@1 ω 10 x 11 =0@3 ω 10 ω 8 ω 9 x 1 =0@6 ω 10 Due to the conflict clause ω 7 ω 7 x 12 =1@2 x 8 =1@6 x 13 =1@2 ω 9 κ x 7 =1@6 ω 9

26 Non-chronological backtracking Which assignments caused the conflicts? x 9 = 0@1 x 10 = 0@3 x 11 = 0@3 x 12 = 1@2 x 13 = 1@2 These assignments Are sufficient for Causing a conflict. #! " x 1 κ κ Backtrack to decision level 3 Nonchronological backtracking

27 More engineering aspects of SAT solvers Observation: More than 90% of the time SAT solvers perform Deduction(). Deduction() allocates new implied variables and conflicts. How can this be done efficiently?

28 Grasp implements Deduction() with counters Hold 2 counters for each clause π: val1(π ) - # of negative literals assigned 0 in π + # of positive literals assigned 1 in π. val0(π) - # of negative literals assigned 1 in π + # of positive literals assigned 0 in π.

29 Grasp implements Deduction() with counters π is satisfied iff val1(π) > 0 π is unsatisfied iff val0(π) = π π is unit iff val1(π) = 0 val0(π) = π - 1 π is unresolved iff val1(π) = 0 val0(π) < π Every assignment to a variable x results in updating the counters for all the clauses that contain x. Backtracking: Same complexity.

30 Chaff implements Deduction() with a pair of observers Observation: during Deduction(), we are only interested in newly implied variables and conflicts. These occur only when the number of literals in π with value false is greater than π - 2 Conclusion: no need to visit a clause unless (val0(π) > π - 2) How can this be implemented?

31 Chaff implements Deduction() with a pair of observers Define two observers : O1(π), O2(π). O1(π) and O2(π) point to two distinct π literals which are not false. π becomes unit if updating one observer leads to O1(π) = O2(π). Visit clause π only if O1(π) or O2(π) become false.

32 Chaff implements Deduction() with a pair of observers O1 O V[2]= V[1]= V[5]=0, v[4]= Unit clause Backtrack v[4] = v[5]= X v[1] = Both observers of an implied clause are on the highest decision level present in the clause. Therefore, backtracking will un-assign them first. Conclusion: when backtracking, observers stay in place. Backtracking: No updating. Complexity = constant.

33 Chaff implements Deduction() with a pair of observers The choice of observing literals is important. Best strategy is - the least frequently updated variables. The observers method has a learning curve in this respect: 1. The initial observers are chosen arbitrarily. 2. The process shifts the observers away from variables that were recently updated (these variables will most probably be reassigned in a short time). In our example: the next time v[5] is updated, it will point to a significantly smaller set of clauses.

34 GSAT: A different approach to SAT solving Given a CNF formula α, choose # $% and # $%*!"# $% &! $# '( $ $(# )!"# $% * $α +,,**(-$($ ( $. $$/ $0 $# ', &! -$(# **,

35 Improvement # 1: clause weights 1$ ($$&" 1 $/'0 ($$, $ (# $% $ ( Clause weights is another example of conflict-driven decision strategy.

36 Improvement # 2: Averaging-in Q: Can we reuse information gathered in previous tries in order to speed up the search? A: Yes! Rather than choosing T randomly each time, repeat good assignments and choose randomly the rest.

37 Improvement # 2: Averaging-in (cont d) Let X1, X2 and X3 be equally wide bit vectors. Define a function bit_average : X1 X2 X3 as follows: b 3i := b 1 i random b 1i = b i 2 otherwise (where b ji is the i-th bit in Xj, j {1,2,3})

38 Improvement # 2: Averaging-in (cont d) Let T init i be the initial assignment (T) in cycle i. Let T best i be the assignment with highest # of satisfied clauses in cycle i. T 1 init := random assignment. T 2 init := random assignment. i > 2, T i init := bit_average(t i-1 best, T i-2 best )