1. Existential Graphs and Davis-Putnam April 3, 2002 Bram van Heuveln Department of Cognitive Science

2. Overview Automated Theorem Proving –Resolution –Strategies –Davis-Putnam Existential Graphs –Representation and Rules –Applying Davis-Putnam to EG: EGDP –Advantages of EGDP over DP

3. Automated Theorem Proving In ATP, one tries to come up with procedures that check whether some statement  (the conclusion, or theorem) logically follows from (is logically entailed by; is a logical consequence of) a set of statements  = {  1, ,  n } (the premises, or axioms). In this definition, ‘logically’ means ‘according to some system of logic’. Here, we will restrict ourselves to the system of truth-functional logic.

4. Logical Entailment and Logical Consistency Logical Entailment: –A statement  is a logical consequence of a set of statements  = {  1, …,  n } if and only if it is impossible for  to be false while each  i is true. We write this as  |=  Logical Consistency: –A set of statements  = {  1, …,  n } is logically consistent if and only if it is possible for each  i to be true. So, a statement  is logically entailed by a set of statements {  1, …,  n } if and only if the set {  1, …,  n,  } is logically inconsistent. Therefore, a decision procedure for logical entailment can be used as a decision procedure for logical consistency, and vice versa. For this reason, we’ll concentrate on procedures that test for logical consistency.

5. Decision Procedures A procedure P that checks for logical consistency is called a decision procedure if and only if for any set of statements  : –(P is a positive test) P declares that  is logically consistent if and only if  is indeed logically consistent. –(P is a negative test) P declares that  is not logically consistent if and only if  is indeed not logically consistent –these two properties are crucially different, since not declaring that something is the case is not the same as declaring that something is not the case. E.g. consider P going into an infinite loop

6. Resolution Resolution is a popular method to check for the logical consistency of a set of statements. Resolution requires all sentences to be put into Conjunctive Normal Form (CNF). A set of sentences in CNF is then 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  C 1 L’  C 2 C NEW = C 1 /L  C 2 /L’

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

8. 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} {P} {} {P,  Q}  

9. Soundness and Completeness of Resolution 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. A set of sentences is inconsistent if and only if the corresponding clause set is unsatisfiable. It can be shown that a clause set is unsatisfiable if and only if the empty clause (which is a generalized disjunction of 0 disjuncts, which is a contradiction) can be resolved from that clause set.

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

11. Resolutions as Decision Procedures While resolution is complete (I.e. the empty clause can always be resolved from an unsatisfiable clause set), we don’t have a decision procedure yet, since we don’t have an algorithm that tells us which clauses to resolve at any point. Now, 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.

12. Resolution Strategies Clause Elimination Strategies –Tautology Elimination –Subsumption Elimination –Pure Literal Elimination Resolving Strategies –Unit Preference Resolution –Etc.

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

14. Subsumption Elimination A clause C 1 subsumes a clause C 2 if and only if every literal contained in C 1 is contained in C 1, i.e. C 1  C 2. Obviously, if C 1 subsumes C 2, then any truth- value assignment that satisfies C 1 will satisfy C 2. 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.

15. Pure Literal Elimination The complement L’ of any literal L is the literal that is the negation of L (e.g. P and ~P are each other’s complement) 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 its complement 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.

16. Unit Preference Resolution A unit clause is a clause that contains one literal (e.g. C = {P} is unit clause) Unit preference resolution tries to resolve using unit clauses first.

17. Unit Literal Deletion and Splitting For any clause set S, S L 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 S L 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 S L is satisfiable or S L’ is satisfiable. The last observation suggests a splitting strategy that forms the basis of Davis-Putnam.

18. Davis-Putnam Where S is clause set, 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(S L ) || Satisfiable(S L’ ); end

19. Making Davis-Putnam Efficient: Adding Bells and Whistles The base DP routine on the previous slide is a decision procedure, but 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(S L ) –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.

20. Symbolization in EG P ~~                P      Expression in PL

21. Inference Rules in EG Double Cut (De)Iteration Erasure Insertion        12k  1   12k+1  1 

22. Unit Rule for EG Where L is a literal graph, and  any graph, the procedure Unit(L,  ), returns the graph  with all occurrences of L removed, and with all complements of L replaced with the empty cut. Again, we’ll write this as  L.

23. Example Unit Rule DEAE DA With G = G E’ =

24. Satisfiability Decision Procedure for EG boolean Satisfiable(G) begin if G = Satisfiable( end if G = return true; return false; return Satisfiable(  L ); L  if G = 11 22  ) || Satisfiable( 11  ); 22  if G =  return Satisfiable(  ); if G =  return Satisfiable(  );  return

25. Satisfiability Example A DE E CD BC AB D CD BC B A DCD) = Sat( Sat( ) = Sat() = Sat(D) = Sat(B BC ) = FalseD

26. 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 subgraph on which to split.

27. Tautology Elimination in EG Any subgraph of the following form is a tautology, and can therefore be eliminated: 

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

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

30. Advantage of EGDP over DP The advantages 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.

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