Decision heuristics based on an Abstraction/Refinement model

1. Decision heuristics based on an Abstraction/Refinement model (HaifaSat) Ofer Strichman Roman Gershman An earlier version was presented in IBM’s verification conference (Haifa, Oct. 05). Technion

2. SAT solving • “Naïve” point of view: • Searches in the decision tree, prunes subspaces. • Creates “blocking clauses” that do not allow the solver to choose the same path again. • This point of view fails to explain why • We can solve many formulas with 105 variables, • We cannot solve other formulas with 103 variables

3. A different point of view • Modern solvers act as proof engines based on resolution, rather than as search engines, with structured problems. • Evidence: adding the shortest conflict clauses is not the best strategy [R04]. • Furthermore: certain strategies resemble a proof by abstraction-refinement.

4. F! or simply: Abstraction of models and formulas • Model is an (over approximating) abstraction of M if: • A QF formula is an (over-approximating) abstraction of F if:

5. F! , ! or simply: Refinement of models and formulas • Model refines if: • Formula refines if:

6. over-approximates Abstraction of formulas • Now consider Binary Resolution:(A_x) ^ (B_:x) ! (A_B) • Conflict Clauses are derived through a process of BinaryResolution. F!

7. Collapsed DAG with multi-degree nodes C-3 C-3 i4 C-2 O7 C-2 C-1 i3 C-1 O6 i2 O5 O7 i1 O1 O2 O5 O3 O4 O6 O4 O3 O1 O2 Resolution Graph Binary DAG with intermediate and conflict clauses. Each node in the graph is an abstraction of its antecedents

8. Conflict clauses • Several modern Decision Heuristics are guided by the Conflict Clauses (e.g. Berkmin) • Hence, we can analyze them with the Abstraction/Refinement model.

9. Berkmin’s heuristic • Push conflict clauses to a ‘stack’. • Find the first unsatisfied clause and choose a variable from this clause. • Secondary heuristic: VSIDS (Zchaff).

10. Berkmin heuristic tail-first conflict clause A new conflict clause

11. Berkmin heuristic • LetF denote the original formula • abstracts F (F! ) • refines (F! , ! ) tail-first conflict clause Check of abstract assignment fails

12. Berkmin heuristic • Does not focus on a specific Abstraction/Refinement path. • Generally: hundreds of clauses can be between a clause and its resolving clauses. C-3 C-2 C-1

13. Choosing the next clause by traversing the resolution graph: a general scheme • Mark all sinks. • Choose an unresolved marked clause C (If there are none - exit) • process C// attempt to satisfy C. • Mark C’s antecedents. Berkmin chooses a clause only if all its descendents are already satisfied.

14. Progressing on the resolve graph • Progress with “Best-First” according to some criterion. • Must store the whole resolve graph in memory – this is frequently infeasible. • HaifaSat’s strategy: • Do not store graph • Be more abstraction-focused than Berkmin

15. The CMTF heuristic • Position conflict clauses together with their resolving clauses in the end of a list. • Find the first unsatisfied clause and choose a variable from this clause. • secondary strategy: the VMTF (Siege) heuristic. Gives us the ‘first-layer approximation’ of the graph.

16. CMTF C-3 • When C-3 is created, C-0, C-1 are moved to the head of the list together with C-3. • C-2 is left in place. C-2 C-1 C-0

17. News • A new technique developed in IBM-Haifa allows to shrink the graph stored in memory by ~ an order of magnitude. • So, assuming the graph is in memory, the search for new strategies is now open… • A contention between conflict-driven and abstraction-driven.

18. T2(C) T1(C) time dedicated for refutingx=1 Time C is asserting time dedicated for creating C C x=1 C5 C2 C1 C4 C3 Activity Score Decision Level Decision Time Conflict

19. Given a clause: choose a variable.The activity score. • The Activity of a variable v: • Let V be the set of variables that were resolved on in T1(C) on the resolution path of C. • Add +1 for each v 2 V in the interval T2(C) • Occasionally, divide all scores. • A cheap recursive computation embedded in the First-UIP scheme.

20. Results • 165 industrial hard benchmarks from previous SAT competitions. • All heuristics (Berkmin, VSIDS) implemented inside HaifaSat for fair comparison. • Berkmin a little better than zChaff 2004

21. (CMTF + RBS) Vs. Berkmin(both implemented inside HaifaSat)

22. HaifaSat Vs. zChaff 2004

23. Results –SAT05 (Industrial)

24. Results –SAT05 (Industrial)

25. Competition... • Independently, very similar principles were discovered by Dershowitz, Hanna and Nadel [SAT’05] • Reached very similar conclusions • Their ‘black-box’ Eureka SAT solver took several first and second places in last year’s competition.

26. What we explore now • We are currently investigating the possibility to use Hints for dealing with hard instances • Hints: a yet-unpublished work by Kroening, Yorav, Shacham. • The original use of hints: using presumed high-level knowledge to speed SAT.

27. Hints • Hints are constraints (clauses) that are conjectured to be true. • A separate BCP processes the set of conjectured clauses. • An implied literal becomes the next decision. • A conflict is only used for deriving more hints.

28. Hints (cont.) • Use hints to prune ‘seemingly hopeless branches (SHB)’ • Define a monotonically decreasing function f: decision-level  time-interval • If time at decision level dl > f(dl) move to another branch. It is seemingly hopeless. • Actively: force backtracking • Passively: wait for a restart

29. Hints: Example l1 l2 l3 : l3 • A hint clause: (:l1:l2:l3). • Option #1: hint = negation of partial assignment • Option #2: hint = projection of #1 to literals that were used in the SHB. SHB

30. Combining Hints and restarts • Some heuristics to be tried: • Change restart policy, using f. • Local restarts: only from a certain decision level • …

31. Hints and restarts • A restart is effective because of randomization and/or learning. Hints will add new conjectures. • Bart Selman: “You can not restart too much” • Perhaps now: “You can not hint too much”