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

2 Given  in CNF: (x,y,z),(-x,y),(-y,z),(-x,-y,-z) Decide() Deduce() Resolve_Conflict()  X XX XX  A Basic SAT algorithm (1/3)

3 While (true) { if (!Decide()) return (SAT); while (!Deduce()) if (!Resolve_Conflict()) return (UNSAT); } 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 A Basic SAT algorithm (2/3)

4 bool Resolve_Conflict() { d = most recent decision not 'tried both ways’; if (d == NULL) return FALSE; flip the value of d; mark d as 'tried both ways’; undo invalidated implications; return true; } A Basic SAT algorithm (3/3)

5 Deduction() allocates new implied variables and conflicts. How can this be done efficiently ? A large set of CNF instances were used to identify the bottleneck of classical SAT solving. First conclusion: almost 90% of the time SAT solvers perform Deduction(). Second conclusion: dynamic decision strategies impose large overhead. Chaff enjoyed a ‘profiler-based’ development process.

6 Hold 4 counters for each clause  : Val1_neg_literals(  ) - # of negative literals assigned 0 in . Val1_pos_literals(  ) - # of positive literals assigned 1 in . Val0_neg_literals(  ) - # of negative literals assigned 1 in . Val0_pos_literals(  ) - # of positive literals assigned 0 in . Define: val1(  ) = Val1_pos_literals (  ) + Val1_neg_literals (  ) val0(  ) = Val0_pos_literals (  ) + Val0_neg_literals (  ) |  | = # literals in  Grasp implements Deduction() with counters (1/2)

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

8 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. (val0(  ) > |  | - 2) Chaff visits clause  only if O1(  ) or O2(  ) become ‘false’. Chaff implements Deduction() with a pair of observers (1/3) 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(  ).

9 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. Chaff implements Deduction() with a pair of observers (2/3) V[1]=0 V[5]=0, v[4]= 0 V[2]=0 O1O2 Unit clause Backtrack v[4] = v[5]= X v[1] = 1 Backtracking: 0 complexity.

10 Chaff implements Deduction() with a pair of observers (3/3) 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.

11 l: # literals, v: # vars, c: # clauses, d: # decisions + implied vars Grasp Assignments + backtracks # clauses per var The # of updating operations ratio is (e.g. for 3-sat that’s 1/6). Several missing factors in the equations: 1) the complexity of each updating operation. 2) the learning curve of the observers. A (rough) quantitative comparison Chaff Negative assignments # clauses per var Probability of observing Avg. Length of clause

12 Decision heuristics (1/3) Grasp's default (DLIS) - Choose the literal which appears most frequently in unresolved clauses. (Requires l queries for each decision).

13 Chaff’s default: (VSIDS) - (Variable State Independent Decaying Sum) Decision heuristics (2/3) 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. 4. Periodically, all the counters are divided by a constant. 3. The unassigned variable with the highest counter is chosen. 2. When a clause is added, the counters are updated. 1. Each variable in each polarity has a counter initialized to 0.

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

15 GSAT: A different approach to SAT solving for i = 1 to max_tries { T := randomly generated truth assignment for j = 1 to max_flips { if T satisfies  return TRUE choose v s.t. flipping v’s value gives largest increase in the # of satisfied clauses (break ties randomly). T := T with v’s assignment flipped. } } Given a CNF formula , choose max_tries and max_flips

16 Improvement # 1: clause weights Initial weight of each clause: 1 Increase by k the weight of unsatisfied clauses. Choose v according to max increase in weight Clause weights is another example of conflict-driven decision strategy.

17 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.

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

19 Improvement # 2: Averaging-in (cont’d) Let T i init be the initial assignment (T) in cycle i. Let T i best 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 )