Automated Theorem Proving: Resolution and Davis-Putnam

Automated Theorem Proving:Resolution and Davis-Putnam Intermediate Logic

Resolution • Resolution is, like the tree method, a method to check for the logical consistency of a set of statements. • Resolution requires all sentences to be put into CNF. • A set of sentences in CNF is made into a clause set: a set of clauses, where a clause is a set of literals. • Clauses are resolved using the resolution rule, and the resulting clause (the resolvent) is added to the clause set: L  C1 L’  C2 CNEW = C1/L  C2/L’

Putting into CNF  (Equiv) (P  Q) ((P  Q)  (Q  P))  (Impl) ((P  Q)  (Q  P))  (DeM) (P  Q)  (Q  P)  (DeM, DN) (P  Q)  (Q  P)  (Dist) ((P  Q)  Q)  ((P  Q)  P)  (Dist) (P  Q)  (Q  Q) (P  P) (Q  P)

Resolution Graph (P  Q) (Q  R) (P  R)    (P  Q)  (P  Q) (Q  R)  (Q  R) (P  R)  (P  R)    {P, Q} {P, Q} {Q, R} {Q, R} {P, R} {P, R} {P, R} {P, Q} {P} {P} {}

Satisfiability • A clause is satisfied by a truth-value assignment if and only if that assignment makes at least one literal in that clause true. • A clause set is satisfiable if and only if there is a truth-value assignment that satisfies all clauses in that clause set. • Figuring out whether some clause set is satisfiable is the satisfiability problem. • Note how the satisfiability problem relates directly to the consistency problem: figuring out whether some set of statements is consistent. • A set of sentences is consistent if and only if the corresponding clause set is satisfiable.

Soundness and Completeness of Resolution • The rule of Resolution is sound, making the method of resolution sound as well (so, if the empty clause (which is a generalized disjunction of 0 disjuncts, which is a contradiction) can be resolved from a clause set, then that means that that clause set is indeed unsatisfiable. • It can be shown that resolution is complete, i.e. that the empty clause can be resolved from any unsatisfiable clause set.

Resolutions as Derivations 1. {A, B} A  (B  C)  (A  B)  (A  C)  {A, C} 2. {A, D, E} 3. (A  B)  (D  E) (A  D  E)  (B  D  E)  {B, D, E} 4.   E  {E} 5. (A  B)  (D  E)  (A B)  (D  E) A  {A} 6. (C  D)  C  D  {C, D} 7. {B} 1,6 8. 17.42 from LPL: A  (B  C) E (A  B)  (D  E) A  C  D {C} 2,6 9. {D, E} 4,8 10. {D} 5,10 11. {D} 7,9 12. {} 11,12 13.

Resolutions as Decision Procedures • Resolution can be made into a decision procedure by systematically exhausting all possible resolvents (of which there are finitely many). • This will not be very efficient unless we add some resolution strategies.

Resolution Strategies • Clause Elimination Strategies • Tautology Elimination • Subsumption Elimination • Pure Literal Elimination • Resolving Strategies • Unit Preference Resolution • Linear Resolution • Ordered Resolution • Etc.

Tautology Elimination • A tautologous clause is a clause that contains an atomic statement as well as the negation of that atomic statement. • Obviously, for any tautologous clause C, any truth-value assignment is going to satisfy C. • Hence, with S any clause set, and with S’ the clause set S with all tautologous clauses removed: S is satisfiable if and only if S’ is satisfiable.

Subsumption Elimination • A clause C1subsumes a clause C2 if and only if every literal contained in C1 is contained in C1, i.e. C1 C2. • Obviously, if C1 subsumes C2 , then any truth-value assignment that satisfies C1 will satisfy C2. • Hence, with S any clause set, and S’ the clause set S with all subsumed clauses removed: S is satisfiable if and only if S’ is satisfiable.

Pure Literal Elimination • A literal L is pure with regard to a clause set S if and only if L is contained in at least one clause in S, but L’ is not. • A clause is pure with regard to a clause set S if and only if it contains a pure literal. • Obviously, with S any clause set, and with S’ the clause set S with all pure clauses removed: S is satisfiable if and only if S’ is satisfiable.

Unit Preference Resolution • A unit clause is a clause that contains one literal. • Unit preference resolution tries to resolve using unit clauses first.

Unit Literal Deletion and Splitting • For any clause set S, SL is the clause set that is generated from S as follows: • Remove all clauses from S that contain L. • Remove all instances of L’ from all other clauses • Obviously, with C = {L}  S, S is satisfiable if and only if SL is satisfiable. • It is also easy to see that for any clause set S, and any literal L: S is satisfiable if and only if SL is satisfiable or SL’ is satisfiable. • The last observation suggests a splitting strategy that forms the basis of Davis-Putnam.

Davis-Putnam • Recursive routine Satisfiable(S) returns true iff S is satisfiable: boolean Satisfiable(S) begin if S = {} return true; if S = {{}} return false; select L  lit(S); return Satisfiable(SL) || Satisfiable(SL’); end

Making Davis-Putnam Efficient: Adding Bells and Whistles • The routine on the previous slide is not very efficient. However, we can easily make it more efficient: • return false as soon as {}S • add the unit rule: if {L}S return Satisfiable(SL) • strategically add deletion strategies • strategically choose the literal on which to split • As far as I have gathered from the ATP literature, such efficient Davis-Putnam routines are credited to do well in comparison to other ATP routines.

Davis-Putnam as Trees {P, Q} {P, Q} {P, Q} {P, Q} (P) (P) {Q} {Q} {Q} {Q} (Q) (Q) (Q) (Q) {} {} {} {}

Davis-Putnam vs Truth-Trees • How does Davis-Putnam differ from Truth-Trees? • Davis-Putnam can be seen as an ‘inside-out’ approach: it assigns a truth-value to atomic statements and determines the consequences of that assignment for the complex statements involved. • Truth-Trees are more of an ‘outside-in’ approach: it assigns truth-values to complex statements as a whole, and decomposes them accordingly until they have been decomposed to literals. • How does the Davis-Putnam procedure stack up against the Truth-Tree procedure in terms of efficiency? • No idea … project!

Can we do DP without CNF? • Sure, simply consider a set of statements, and see what happens to each of the statements when some atomic claim is set to true or false, respectively. • For example, when we set A to True in (A  B)  (D  E), the claim becomes (True  B)  (D  E), which becomes True  (D  E), which becomes D  E. • Possible project: Investigate efficiency of this method

Rules for DP without CNF True  P  P True  P  True True  P  P True  P  P  True  False  False  True False  P  False False  P  P False  P  True False  P  P P  True  P P  True  True P  True  True P  True  P P  False  False P  False  P P  False  P P  False  P

Example: Doing DP without CNF A  (B  C) E (A  B)  (D  E) A (C  D) 17.42 from LPL: A  (B  C) E (A  B)  (D  E) A  C  D A A B  C E B  (D  E) (C  D) E D  E False (C  D) E E × B  C B  D (C  D) B  C False (C  D) Etc. ×

Can DP and TT be combined? • DP really starts to look like a tree method, even though DP works ‘inside-out’ and TT ‘outside-in’. • Can these two methods be combined into one method? • Sure! In fact, you can do some things to make this efficient, e.g: • Use ‘inheritance’ to keep from copying statements that are unaffected. • Project: Investigate efficiency of this method • Project: Do the KE rules add any further efficiency?

Example: DP and TT Combo 17.42 from LPL: A  B C  (D  E) D  C A  E  C B A  B C  (D  E) D  C A  E (C B) C B D  E D A A E E (you’ll probably have to reconstruct this one to follow it; it would help if it were annotated with justifications!) ×

EG and ATP • EGTT: Applying Truth-Trees to EG • EGDP: Applying Davis-Putnam to EG • EGTTDP: Applying both TT and DP to EG

EGTT: Applying Truth-Trees to EG • Applying the idea of truth-trees to EG is simple: • Two decomposition rules:   1 2   1 2 • Close any branch that contains a literal and its complement, or that contains an empty cut. • Rest remains the same

EGTT: A Satisfiability Procedure boolean Satisfiable(G) begin if G =  return false; if G = L L  return false; if G =   return Satisfiable(   ); return if G = 1 2  Satisfiable( 1  2  ); ) || Satisfiable( else return true; end

EGDP: Literal Reduction • For any graph , L is the graph that is generated from  as follows: • Remove all instances of L • Replace all instances of L’ with an empty cut

Example Literal Reduction A E D E With G = GE’ = A D

EGDP: Satisfiability Decision Procedure boolean Satisfiable(G) begin if G = return true; if G = return false; select L  lit(G); return Satisfiable(GL) || Satisfiable(GL’); end

Adding Bells and Whistles • Again, this procedure can be made a lot more efficient by dealing with empty cuts, double cuts, and duplicates more efficiently, by various other tautology, subsumption, and pure literal deletion strategies, and by strategically picking the literal on which to split.

Tautology Elimination in EG • Any subgraph of the following form (i.e. a cut containing an empty cut) is a tautology, and can therefore be eliminated:  • Note: This can be incorporated into the reduction routine. That is, rather than replacing any complement of a literal with an empty cut, we can remove any cut containing the complement.

Subsumption Elimination in EG   If a graph of the form: exists at a nested level with regard to:  then the first graph is said to be subsumed by the second (subsuming) graph, and can therefore be removed.

Pure-Literal Elimination in EG • A literal that exists at even levels only is said to be a pure literal, and can be eliminated for satisfiability purposes. • A literal that exists at odd levels only is also a pure literal, and can be replaced with the empty cut for satisfiability purposes.

Satisfiability Example E A C D A B C C D ) = Sat( ) = B C Sat( A B D E B D B C Sat( C D B D ) = Sat( D D ) = Sat( ) = False

Advantage of EGDP over DP? • The alleged advantage of EGDP over DP is that there is no need to put statements into clauses. This not only improves efficiency in that this preliminary step can eliminated, but by avoiding clauses, the algorithm actually becomes inherently more efficient in that 1) it leaves statements compact, and 2) it eliminates literals at any level. • Project: Investigate to see whether this is true!

Example: Gaining Efficiency by Avoiding Clauses A B B Clausifying DE (2x!) DC (2x!) A B C C A C No Clausifying! DE DC A B C A B C B C So, by keeping statements compact, less steps need to be taken!

EGTTDP • Can EG be combined with both TT and DP? • Yes, the characteristic rule of TT is the decomposition rule, and the characteristic rule for DP is the splitting rule. We can use both rules in a satisfiability procedure. • Question: When is a good time to use decomposition, and when is a good time to use splitting? … Project!

EGTTDP: A Satisfiability Procedure boolean Sat(G) begin remove double cuts; if G = return true; if G =  return false; if G = L  return Sat( L ); (TT) if G = 1 2  return Sat( 1  ) || Sat( 2  ); (DP) select L  lit(G); return Sat(GL) || Sat(GL’); end

HW 9 • Show the argument below to be valid using: • 1. Resolution • 2. Davis-Putnam (on clauses) • 3. Davis-Putnam (on original statements) • 4. Davis-Putnam and Truth-Tree combo • 5. EGTT, EGDP, and EGTTDP Q  S (P  Q)  R S  R ---- P  (Q  S)

Automated Theorem Proving: Resolution and Davis-Putnam