Satisifiability and Probabilistic Satisifiability

Satisifiability and Probabilistic Satisifiability Department of Computer Science Instituto de Matemática e Estatística Universidade de São Paulo 2010

Topics

Next Issue

The SAT Problem The Centrality of SAT Satisfiability is a central problem in Computer Science Both theoretical and practical interests

The SAT Problem The Centrality of SAT Satisfiability is a central problem in Computer Science Both theoretical and practical interests SAT was the 1st NP-complete problem

The SAT Problem The Centrality of SAT Satisfiability is a central problem in Computer Science Both theoretical and practical interests SAT was the 1st NP-complete problem SAT received a lot of attention [1960-now] SAT has very efficient implementations

The PSAT Problem Probabilistic satisfiability (PSAT) was proposed by [Boole 1854] On the Laws of Thought Classical probability No assumption of a priori statistical independence Rediscovered several times since Boole PSAT is also NP-complete

Applications of SAT SAT has good implementations SAT has many applications

Applications of SAT SAT has good implementations SAT has many applications Planning: SatPlan Answer Set Programming Integer Programming Map colouring, combinatorial problems Optimisation problems etc NP-complete problems reduced to SAT

Potential Applications of PSAT SAT has many potential applications

Potential Applications of PSAT SAT has many potential applications Computer models of biological processes Machine learning Fault tolerance. Software design and analysis. Economics, econometrics, etc. But there are no practical algorithms for PSAT

Next Issue

The Setting: the language Atoms: P = {p 1,...,p n } Literals: p i and p j p = p, p = p A clause is a set of literals. Ex: {p, q,r} or p q r A formula C is a set of clauses

The Setting: semantics Valuation for atoms v : P {0,1}

The Setting: semantics Valuation for atoms v : P {0,1} An atom p is satisfied if v(p) = 1

The Setting: semantics Valuation for atoms v : P {0,1} An atom p is satisfied if v(p) = 1 Valuations are extended to all formulas

The Setting: semantics Valuation for atoms v : P {0,1} An atom p is satisfied if v(p) = 1 Valuations are extended to all formulas v( λ) = 1 v(λ) = 0

The Setting: semantics Valuation for atoms v : P {0,1} An atom p is satisfied if v(p) = 1 Valuations are extended to all formulas v( λ) = 1 v(λ) = 0 A clause c is satisfied (v(c) = 1) if some literal λ c is satisfied

The Problem A formula C is satisfiable if exits v, v(c) = 1. Otherwise, C is unsatisfiable

The Problem A formula C is satisfiable if exits v, v(c) = 1. Otherwise, C is unsatisfiable The SAT Problem Given a formula C, decide if C is satisfiable. Witnesses: If C is satisfiable, provide a v such that v(c) = 1.

An NP Algorithm for SAT NP-SAT(C) Input: C, a formula in clausal form Output: v, if v(c) = 1; no, otherwise. 1: Guess a v 2: Show, in polynomial time, that v(c) = 1 3: return v 4: if no such v is guessable then 5: return no 6: end if

A Naïve SAT Solver NaiveSAT(C) Input: C, a formula in clausal form Output: v, if v(c) = 1; no, otherwise. 1: for every valuation v over p 1,...,p n do 2: if v(c) = 1 then 3: return v 4: end if 5: end for 6: return no

History Next Issue

History A Brief History of SAT Solvers [Davis & Putnam, 1960; Davis, Longemann & Loveland, 1962] The DPLL Algorithm, a complete SAT Solver

History A Brief History of SAT Solvers [Davis & Putnam, 1960; Davis, Longemann & Loveland, 1962] The DPLL Algorithm, a complete SAT Solver [Tseitin, 1966] DPLL has exponential lower bound

History A Brief History of SAT Solvers [Davis & Putnam, 1960; Davis, Longemann & Loveland, 1962] The DPLL Algorithm, a complete SAT Solver [Tseitin, 1966] DPLL has exponential lower bound [Cook 1971] SAT is NP-complete

History Incomplete SAT methods Incomplete methods compute valuation if C is SAT; if C is unsat, no answer. [Selman, Levesque & Mitchell, 1992] GSAT, a local search algorithm for SAT

History Incomplete SAT methods Incomplete methods compute valuation if C is SAT; if C is unsat, no answer. [Selman, Levesque & Mitchell, 1992] GSAT, a local search algorithm for SAT [Mitchell, Levesque & Selman, 1992] Hard and easy SAT problems [Kautz & Selman, 1992] SAT planning [Kautz & Selman, 1993] WalkSAT Algorithm

History DPLL: Second Generation Second Generation of DPLL SAT Solvers: Posit [1995], SATO [1997], GRASP [1999]. Heuristics but no learning.

History DPLL: Second Generation Second Generation of DPLL SAT Solvers: Posit [1995], SATO [1997], GRASP [1999]. Heuristics but no learning. SAT competitions since 2002: http://www.satcompetition.org/

History DPLL: Second Generation Second Generation of DPLL SAT Solvers: Posit [1995], SATO [1997], GRASP [1999]. Heuristics but no learning. SAT competitions since 2002: http://www.satcompetition.org/ Aggregation of several techniques to SAT, such as learning, unlearning, backjumping, watched literal, special heuristics. Very competitive SAT solvers: Chaff [2001], BerkMin [2002],zChaff [2004]. Applications to planning, microprocessor test and verification, software design and verification, AI search, games, etc.

Next Issue

The SAT Phase Transition

The Phase Transition Diagram 3-SAT, N is fixed Higher N, more abrupt transition M/N: low (SAT); high (UNSAT) Phase transition point: M/N 4.3, 50%SAT [Toby & Walsh 1994] Invariant with N Invariant with algorithm! No theoretical explanation There is another phase-transition for SAT based on Impurity [Lozinskii 2006]

Next Issue

DPLL Through Examples p q p q p t s p t s p s p s a

Initial Simplifications Delete all clauses that contain λ, if λ does not occur. p q p q p t s p t s p s p s a ////////////////

Construction of a Partial Valuation Choose a literal: s. V = {s} Propagate choice: Delete clauses containing s. Delete s from other clauses. p q p q p t s ////////////// p t s //////////////// p s /////

Unit Propagation Enlarge the partial valuation with unit clauses. V = {s, p} Propagate unit clauses as before. ////q p //// q p p //// Another propagation step leads to V = {s, p,q, q}

Backtracking Unit propagation may lead to contradictory valuation: V = {s, p,q, q} Backtrack to the previous choice, and propagate: V = { s} p q p q p t s /// p t s /// p s ///////////

New Choice When propagation finishes, a new choice is made: p. V = { s,p}. This leads to an inconsistent valuation: V = { s,p,t, t} Backtrack to last choice: V = { s, p} ////q p //// q p p t ///////// p t /////////// Propagation leads to another contradiction: V = { s, p, q, q}

The Formula is UnSAT There is nowhere to backtrack to now! The formula is unsatisfiable, with a proof sketched below. s p ( p s) q (p q) q (p q) s p t ( p t s) t ( p t s) p q (p q) q (p q)

Resolution Next Issue

Resolution The Resolution Inference For Clauses Usual Resolution C λ λ D C D Clauses as Sets Γ {λ} { λ} Γ Note that, as clauses are sets Γ {µ,λ} { λ,µ} Γ {µ}

Resolution DPLL Proofs and Resolution s p ( p s) q (p q) q (p q) s p t ( p t s) t ( p t s) p q (p q) q (p q)

Resolution DPLL Proofs and Resolution s p ( p s) p p q p q s p t ( p t s) t ( p t s) p q (p q) q (p q)

Resolution DPLL Proofs and Resolution s p p q p q p s s p t ( p t s) t ( p t s) p q (p q) q (p q)

Resolution DPLL Proofs and Resolution s p p q p q p s s p s p t s p t s p q (p q) q (p q)

Resolution DPLL Proofs and Resolution s p p q p q p s s p s p t s p t s p p q p q

Resolution Conclusion DPLL is isomorphic to (a restricted form of) resolution

Resolution Conclusion DPLL is isomorphic to (a restricted form of) resolution DPLL inherits all properties of this (restricted form of resolution

Resolution Conclusion DPLL is isomorphic to (a restricted form of) resolution DPLL inherits all properties of this (restricted form of resolution In particular, DPLL inherits the exponential lower bounds

Resolution Enhancing DPLL For the reasons discussed, DPLL needs to be improved to achieve better efficiency. Several techniques have been applied: Learning Unlearning Backjumping Watched literals Heuristics for choosing literals

Next Issue

WatchLit Next Issue

WatchLit Watched Literals

WatchLit The Cost of Unit Propagation Empirical measures show that 80% of time DPLL is doing Unit Propagation Propagation is the main target for optimization Chaff introduced the technique of Watched Literals Unit Propagation speed up No need to delete literals or clauses No need to watch all literals in a clause Constant time backtracking (very fast)

WatchLit DPLL and 3-valued Logic DPLL underlying logic is 3-valued Given a partial valuation V = {λ 1,...,λ k } Let λ be any literal. 1(true) if λ V V(λ) = 0(false) if λ V (undefined) otherwise

WatchLit The Watched Literal Data Structure Every clause c has two selected literals: λ c1,λ c2 For each c, λ c1,λ c2 are dynamically chosen and varies with time λ c1,λ c2 are properly watched under partial valuation V if: they are both undefined; or at least one of them is true

WatchLit Dynamics of Watched Literals Initially, V = A pair of watched literals is chosen for each clause. It is proper. Literal choice and unit propagation expand V One or both watched literals may be falsified If λ c1,λ c2 become improper then The falsified watched literal is changed if no proper pair of watched literals can be found, two things may occur to alter V Unit propagation (V is expanded) Backtracking (V is reduced)

WatchLit Example clause λ c1 λ c2 p q r p = q = p q s p = q = p r s p = r = Initially V = A pair of literals was elected for each clause All are undefined, all pairs are proper

WatchLit p is chosen V = { p} All watched literals become (0, ), improper New literals are chosen to be watched clause λ c1 λ c2 p q r r = q = p q s s = q = p r s s = r =

WatchLit r is chosen V = { p, r} WL in clauses 1,3 become improper No other *- or 1-literal to be chosen Unit propagation: q, s become true clause λ c1 λ c2 p q r r = 0 q = / 1 p q s s = q = p r s s = / 1 r = 0

WatchLit Unit propagation leads to backtracking V = { p, r,q, s} WL in clause 2 becomes improper No other *- or 1-literal to be chosen No unit propagation is possible: clause 2 is false clause λ c1 λ c2 p q r r = 0 q = 1 p q s s = 0 q = 0 p r s s = 1 r = 0

WatchLit Fast Backtracking V is contracted to last choice point V = { p, r,q, s} ////////////// { p,r} clause λ c1 λ c2 p q r r = 1 q = p q s s = q = p r s s = r = 1 Only affected WLs had to be recomputed No need to reestablish previous context from a stack of contexts Very quick backtracking

Further Techniques Next Issue

Further Techniques Improvements Techniques from Chaff Learning new clauses VSDIS Heuristics Random restarts Backjumping

Further Techniques Learning

Further Techniques When do we learn? Sages learn from their bad choices

Further Techniques When do we learn? Sages learn from their bad choices Every time a contradiction is derived (closed branch) we can lament our choice...

Further Techniques When do we learn? Sages learn from their bad choices Every time a contradiction is derived (closed branch) we can lament our choice...... or learn from our mistakes:

Further Techniques When do we learn? Sages learn from their bad choices Every time a contradiction is derived (closed branch) we can lament our choice...... or learn from our mistakes: We learn that a choice of literals lead to contradiction We learn that the clauses involved have enough information to avoid the mistake

Further Techniques Learning 1: Bad Choices Suppose we had choices which after propagation led to V = { p, r} V = { p, r,q, s,s} That is, in that context we learned that we cannot have both p and r.

Further Techniques Learning 1: Bad Choices Suppose we had choices which after propagation led to V = { p, r} V = { p, r,q, s,s} That is, in that context we learned that we cannot have both p and r. Add the new clause: p r

Further Techniques Learning 1: Properties From a closed branch with choices λ 1,...,λ k, learn λ 1... λ k

Further Techniques Learning 1: Properties From a closed branch with choices λ 1,...,λ k, learn λ 1... λ k In general, this form of learning does not improve efficiency, for

Further Techniques Learning 1: Properties From a closed branch with choices λ 1,...,λ k, learn λ 1... λ k In general, this form of learning does not improve efficiency, for it will only be used if k 1 literals occur in another branch not very likely

Further Techniques Learning 2: Relevant information Clauses involved in a contradiction present useful information

Further Techniques Learning 2: Relevant information Clauses involved in a contradiction present useful information In particular, some clauses leading to a contradiction can be resolved

Further Techniques Learning 2: Relevant information Clauses involved in a contradiction present useful information In particular, some clauses leading to a contradiction can be resolved We learn the resolved clause and add it For that, we have to store extra information in a partial valuation:

Further Techniques Learning 2: An Example In the previous example, the choices are represented as: V = {( p, ),( r, )}

Further Techniques Learning 2: An Example In the previous example, the choices are represented as: V = {( p, ),( r, )} After linear propagation, the contradiction V = {( p, ),( r, ),(q,p q r),( s,p r s),(s,p q s)} We learn the resolution of contradição: p r s e p q s That is, we add the clause: p r q This form of learning has better effects to proof efficiency

Further Techniques Heuristics for Choosing Literals

Further Techniques Choosing Literals A DPLL step starts when linear propagation ends without contradiction

Further Techniques Choosing Literals A DPLL step starts when linear propagation ends without contradiction A each step, a new literal has to be chosen to start a new cycle propagation/backtrack

Further Techniques Choosing Literals A DPLL step starts when linear propagation ends without contradiction A each step, a new literal has to be chosen to start a new cycle propagation/backtrack Several heuristics can be used to choose that literal Heuristics are rules that help the choice of one among several possibilities

Further Techniques Heuristics without Learning Do not take in consideration the learning of new clauses

Further Techniques Heuristics without Learning Do not take in consideration the learning of new clauses MOM Heuristics Maximum number of literal Ocorrences with Minimum length Easy to implement: select the literal that is present in the largest number of clauses of minimum size. Increases the probability of backtracking SATO Heuristics is a variation of MOM. Let f(p) be 1 plus the number of clauses of smallest size which contain p. Choose p that maximizes f(p) f( p). Choose p if f(p) > f( p); p otherwise.

Further Techniques Heuristics VSIDS Variable State Independent Decaying Sum

Further Techniques Heuristics VSIDS Variable State Independent Decaying Sum Takes the learning of clauses in consideration

Further Techniques Heuristics VSIDS Variable State Independent Decaying Sum Takes the learning of clauses in consideration One counter for each literal

Further Techniques Heuristics VSIDS Variable State Independent Decaying Sum Takes the learning of clauses in consideration One counter for each literal Initialize each with n. of occurrences of each literal Increment counter when a clause containing that literal is added Choose literal with highest count Periodically, counters are divided by a constant

Further Techniques Random Restarts

Further Techniques Forgetting, or Random Restarts Suppose a formula is SAT, but bad initial choices

Further Techniques Forgetting, or Random Restarts Suppose a formula is SAT, but bad initial choices A valuation will be found only after exhausting the consequences of those bad choices

Further Techniques Forgetting, or Random Restarts Suppose a formula is SAT, but bad initial choices A valuation will be found only after exhausting the consequences of those bad choices Idea: restart periodically the search for a valuation Problem: if the formula is UNSAT, this may lead to great inefficiency

Further Techniques Random Restart Consider ǫ, 0 < ǫ 1

Further Techniques Random Restart Consider ǫ, 0 < ǫ 1 When a branch is closed

Further Techniques Random Restart Consider ǫ, 0 < ǫ 1 When a branch is closed With probability (1 ǫ), perform usual backtracking

Further Techniques Random Restart Consider ǫ, 0 < ǫ 1 When a branch is closed With probability (1 ǫ), perform usual backtracking With probability ǫ, restart the search process with V =

Further Techniques Random Restart Consider ǫ, 0 < ǫ 1 When a branch is closed With probability (1 ǫ), perform usual backtracking With probability ǫ, restart the search process with V = Empirically checked: this brings efficiency gains

Further Techniques Backjumping

Further Techniques Backjumping via Examples Suppose we have the partial valuation V = {( p, ),( r, ),(a, ),(q,p q r),( s,p r s),(s,p q s

Further Techniques Backjumping via Examples Suppose we have the partial valuation V = {( p, ),( r, ),(a, ),(q,p q r),( s,p r s),(s,p q s The chose literal a does not occur in clauses associated with subsequent unit propagations That is, the choice of a is useless Backtracking would lead to useless repetition V = {( p, ),( r, ),(ā, ),(q,p q r),( s,p r s),(s,p q s Backtracking should jump back over a and ignore it, instead of generating V = {( p, ),( r, ),(ā, ), gera V = {( p, ),(r, )}

Next Issue

Conclusion of the Talk DPLL is > 40 years old, but still the most used strategy for SAT solvers

Conclusion of the Talk DPLL is > 40 years old, but still the most used strategy for SAT solvers Use of smart techniques have improved DPLL s performance: N = 15 N = 100000

Conclusion of the Talk DPLL is > 40 years old, but still the most used strategy for SAT solvers Use of smart techniques have improved DPLL s performance: N = 15 N = 100000 There are still very hard formulas that make DPLL exponential, e.g. PHP Experiments show that these formulas do occur in practice The future of SAT solvers may be in non-dpll, non-clausal methods

SAT is not a Panacea Reduction to SAT may be ok for some NPc problems, but...... some NPc problems with no known polynomial SAT-reduction. E.g. Answer Set Programming... some NPc problems with no efficient polynomial SAT-reduction. E.g. Probabilistic SAT