Download presentation

1
**Boolean Satisfiability**

The most fundamental NP-complete problem, and now a powerful technology for solving many real world problems

2
**Overview CNF, SAT, 3SAT and 2SAT Resolution and Unit Propagation**

DPLL search Conflict-driven Nogood Learning Activity-based Search Modelling for SAT

3
**Conjunctive Normal Form**

SAT solvers solve problems in Conjunctive Normal Form (CNF) Boolean variable: b (true/false) or (0/1) Literal: l variable b or its negation –b negating a literal: -l = -b if l = b, and -l = b if l = -b Clause: C disjunction or set of literals CNF: theory T set of clauses Assignment: set of literals A with {b,-b} not subset: e.g. {-b1,b2} Assign b1=false, b2=true

4
**Boolean Satisfiability (SAT)**

This is the most basic NP-complete problem. SAT: Given a set of clauses T, find an assignment A such that for each C in T Each clause C in T is satisfied by A

5
3SAT 3SAT: SAT with the restriction that each clause has length at most 3. SAT -> 3SAT {l1, l2, l3, l4, l5, l6} l1 ∨ l2 ∨ l3 ∨ l4 ∨ l5 ∨ l6 becomes the set of clauses {l1, l2, b1}, {-b1, l3, b2}, {-b2, l4, b3}, {-b3, l5, l6} where b1, b2, b3 are new Boolean variables 3SAT is NP-complete (by the above reduction)

6
2SAT 2SAT: SAT with the restriction that each clause has length at most 2. 2SAT is decidable in polynomial time (n3) 2SAT is NL-complete which is a crazy complexity class Nondeterministic Turing machine with log writeable memory!

7
**Resolution The fundamental inference for CNF Or**

{l1, l2, l3, b} {-b, l4, l5, l6} implies {l1, l2, l3, l4, l5, l6} Or (l1 ∨ l2 ∨ l3 ∨ b) ∧ (-b ∨ l4 ∨ l5 ∨ l6) -> l1 ∨ l2 ∨ l3 ∨ l4 ∨ l5 ∨ l6 One can prove unsatisfiability of a CNF formula by repeatedly applying all possible resolutions if this generates an empty clause then UNSAT otherwise SAT Exponential process!

8
**Unit Propagation Resolution = too expensive**

Unit Propagation (=unit resolution) Restricted form of resolution = finds unit clauses {l1, l2, …, ln, l} where –li in A forall 1 ≤ i ≤ n Add l to assignment A {-b1, b2, b} A = {b1, -b2} {-b1, b2, b} A := {b1, -b2, b} (-b1 ∨ b2 ∨ b) ∧ b1 ∧ -b2 -> b

9
**Unit Propagation Repeatedly apply unit propagation,**

until no new unit consequences can be found or failure detected A = {b1, -b2, b3, -b4} C = {-b1, -b3, b4} {-b1, -b3, b4} Failure detected

10
**Unit Propagation Example**

T = {{-e11,-e21}, {-e11,-e31},{-e11,-e41}, {e21,-b21}, {e31,-b31},{e41,-b41}, {b21,-b51},{b51,-b52,e52},{b41,-e52}, A = {e11,b52} {-e31,-b31} {b51,-b52,e52} {-e41,-b41} {-e21,-b21} {-e11,-e41} {-e11,-e21} {b21,-b51} {-e11,-e31} {b41,-e52} A ={e11,b52,-e21,-e31,-e41,-b21,-b31,-b41,-b51,e52} A = false A ={e11,b52,-e21,-e31,-e41,-b21,-b31,-b41,-b51} A ={e11,b52,-e21} A ={e11,b52,-e21,-e31} A ={e11,b52,-e21,-e31,-e41,-b21,-b31,-b41} A ={e11,b52,-e21,-e31,-e41} A ={e11,b52,-e21,-e31,-e41,-b21} A ={e11,b52,-e21,-e31,-e41,-b21,-b31} -e21 -b21 -b51 e52 e11 -e31 -b31 b52 fail -e41 -b41

11
Implication Graph Records the reason why each Boolean literal became true Decision Propagation(and why) Used for nogood reasoning! -e21 -b21 -b51 e52 e11 -e31 -b31 b52 fail -e41 -b41

12
**DPLL search Davis-Putnam-Logemann-Loveland algorithm**

interleave decisions + unit propagation dpll(A) A' = unitprop(A) if A' == false return false else if exists Boolean variable b not appearing in A if dpll(A' union {b}) return true else if dpll(A' union {-b}) return true else return false else return true

13
**DPLL Search Example {-b1,-b4,-b5} {-b1,-b4,b5} {-b2,b3} {b4,-b5}**

{} X X b1 X {b1} {-b1} X X b2 b2 {b1,b2,b3} {b1,-b2} {-b1,b2,b3} b4 b4 b3 {-b1,b2,b3 b4} {b1,b2,b3, b4,b5,fail} {b1,b2,b3, -b4,b5,fail} {b1,-b2,b3} b4 b5 {b1,-b2,b3, b4,b5,fail} {b1,-b2,b3, -b4,b5,fail} {-b1,b2,b3 b4,b5}

14
**DPLL search with nogood learning**

dpll(A) A' = unitprop(A) if A' == false Add a clause C explaining the failure to T Backjump to the first place C can give new information else if exists Boolean variable b not appearing in A if dpll(A' union {b}) return true else if dpll(A' union {-b}) return true else return false else return true

15
**Nogood Learning The implication graph shows a reason for failure**

Any cut separating the fail node from decisions explains the failure b52 ∧ e11 false b52 ∧ -b51 ∧-b41 false b52 ∧ -b51 ∧-e41 false e52 ∧ -b41 false {e41,b51,-b52} {b41,b51,-b52} {-e11,-b52} {b41,-e52} b52 -e21 -b21 -b51 e52 e11 -e31 -b31 fail -e41 -b41

16
**Which Nogood? SAT solvers almost universally use the**

First Unique Implication Point (1UIP) Nogood Closest nogood to failure only one literal from the last decision level Asserting: on backjump it will unit propagate General: more general than many other choices Fast: doesn’t require too much computation replace last literal in nogood until only one at last level

17
**1UIP Nogood Creation 1 UIP Nogood {-b21,-b31,-b41,-e32,-e42} false**

fail -e41 -b41 -b41 -e42 -e42 -b42 -b42 b43 b43 e43 e43 -b51 b52 e52 1 UIP Nogood {-b21,-b31,-b41,-e32,-e42} false {-b21,-b31,-b41,e22} false {-b21,-b31,-b41,e22,-e32} false {-b21,-b41,-e42,-b32} false {-b21,-b32,-b42,b33} false {-b21,-b32,-b42} false -b42 ∧ b43 ∧ e33 false {-b32,-b42,b33,b43} false e33 ∧ e43 false {-e33,-e43} {b32,b42,-b33,-b43} {b42,-b43,-e33} {b21,b41,e42,b32} {b21,b32,b42} {b21,b32,b42,-b33} {b21,b31,b41,e32,e42} {b21,b31,b41,-e22} {b21,b31,b41,-e22,e32}

18
**Backjumping Backtrack to second last level in nogood**

Nogood will propagate e.g. {b21,b31,b41,-e22} -e21 -b21 -e22 -b22 -e31 -b31 -e41 -b41 {b21,b31,b41,-e22} -b51 -b52 Continue unit propagation then make next choice

19
**Why Add Nogoods We will not make the same choices again**

{e11,b52} leads to failure After choosing e11 we infer –b52 Better yet, any choice that leads to b21,b31,b41 prevents the choice b52 Drastic reduction in search space Faster solving

20
**DPLL Search Example Again**

{-b1,-b4,-b5} {-b1,-b4,b5} {-b2,b3} {b4,-b5} {b4,b5} {b4,-b1} {} b2 b1 {b1,-b4,-b5,fail} {b1} {b4,-b1,b2,b3} b2 b5 Nogood {b4} {b1,b2,b3} {b4,-b1,b2,b3,b5} b4 {b1,b2,b3, b4,b5,fail} Backjump Nogood {-b1,-b4}

21
**Restarts Periodically**

Restart the search from the beginning! Stored nogoods prevent search doing the same thing again New search decisions drive search to new places

22
Activity Each time a Boolean variable is seen during nogood creation, i.e. appears in final nogood, or is eliminated in the reverse propagation Increase activity by one These variables are helping cause failure Periodically divide all activities by some amount activity reflects helping cause recent failure

23
**Activity-based Search**

Select the unfixed variable with highest activity MiniSat: set to false RSAT: set to the last value it took works with backjumping to recreate the same path e.g. -b1, b3, -b11, b4, -b5, b7, fail backjump to -b1, b3, -b11 If b4 is now highest activity variable set it true [b4] If b5 is next highest activity variable set it false [-b5] Activity-based search concentrates on the variables causing failure learns shorter nogoods by failing earlier

24
**Activity-based Search**

Works well with restart On restart we concentrate on the now most active variables a new part of the search space learn new nogoods about this

25
**Modern SAT Solvers Modern SAT solvers can handled problems with**

(low) millions of clauses millions of variables assuming the input has structure Random CNF is much harder (but uninteresting) Before the advent of nogood learning (low) thousands of clauses hundreds of variables

26
SAT Successes Hardware model checking; Software model checking; Termination analysis of term-rewrite systems; Test pattern generation (testing of software &hardware); Model finding; Symbolic trajectory evaluation; Planning; Knowledge representation; Games (n-queens, sudoku, etc.); Haplotype inference; Pedigree checking; Equivalence checking; Delay computation; Fault diagnosis; Digital filter design; Noise analysis; Cryptanalysis; Inversion attacks on hash functions; Graph coloring; Traveling salesperson;

27
**The Future SAT Modulo Theories Lazy Clause Generation**

combine theory propagators with SAT solving Lazy Clause Generation combine constraint propagators with SAT solving Extended Clause Resolution introduce new literals during resolution to exponentially shorten proofs Parallelism adapt to new multi-core computing environment

Similar presentations

Presentation is loading. Please wait....

OK

First-Order Logic and Inductive Logic Programming.

First-Order Logic and Inductive Logic Programming.

© 2018 SlidePlayer.com Inc.

All rights reserved.

By using this website, you agree with our use of **cookies** to functioning of the site. More info in our Privacy Policy and Google Privacy & Terms.

Ads by Google

Ppt on glasgow coma scale Download ppt on civil disobedience movement gandhi Ppt on online shopping site project Ppt on water our life line screening Ppt on data collection methods for qualitative research Ppt on relations and functions for class 11th physics Ppt on network security using quantum cryptography Ppt on model view controller Ppt on odisha culture Ppt on quality education basketball