1 / 18

Automated Theorem Proving

Presentation by Kenny Pearce CSE 391: Artificial Intelligence April 22, 2005. Automated Theorem Proving. The State of the Art. OTTER “Organized Techniques for Theorem-Proving and Effective Research” Proves theorems in first order logic with equality using resolution-based techniques

Download Presentation

Automated Theorem Proving

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Presentation by Kenny Pearce CSE 391: Artificial Intelligence April 22, 2005 Automated Theorem Proving

  2. The State of the Art • OTTER • “Organized Techniques for Theorem-Proving and Effective Research” • Proves theorems in first order logic with equality using resolution-based techniques • Written in C for Unix • Developed at Argonne National Lab • http://www-unix.mcs.anl.gov/AR/otter/

  3. ResolutionRussel and Norvig 7.5 • Consider this problem (to which we will return later): • Axiom Set: {(L&W), (L->(~F))} • Theorem: (~F) • Standard Proof: • (L&W) ⊧ L (& Elimination) • {(L->(~F)), L} ⊧ (~F) (Modus Ponens) • QED

  4. ResolutionRussel and Norvig 7.5 Consider this problem (to which we will return later): Axiom Set: {(L&W), (L->(~F))} Theorem: (~F) Resolution Proof: First, Translate into Conjunctive Normal Form, with Theorem Negated: (L&W&(~L|~F)&F) X X (L&W&~F&F) Yields an empty clause, therefore argument valid

  5. OTTER Successes • Found a shorter single axiom for lattice theory • Found several shorter single axioms for ternary boolean algebra • Proved that all Robbins algebras are boolean • Found a shorter axiom system for two-value sentential calculus • More at http://www-unix.mcs.anl.gov/AR/new_results/

  6. Is OTTER an AI Theorem Prover? • Uses Resolution • Guided by Heuristics • BUT relative weights of heuristics, restrictions, etc. must be customized by a human for each problem • The human has to have a good idea of what kinds of proof techniques will be useful on this problem; OTTER can't figure that out on its own.

  7. My Approach: A Computer That Does Logic Like a Human • Resolution is not the most effective proof procedure for humans. It is easy to do, but is time consuming. • Instead, humans use truth trees or derivation systems • These proof systems are better for humans because we are good at deciding which of several possible next steps will be most useful; an AI with a sufficiently powerful heuristic should perform better with one of these systems for the same reason humans do. • My program implements a subset of the derivation system found in The Logic Book by Merrie Bergmann, James Moor, and Jack Nelson

  8. Bergmann et al.'s Sentential Derivation System (SD) • SD Rules: • Reiteration (P ⊧ P) • Introduction and Elimination Rules for Each Operator • Rules I Implemented: • Those not requiring sub-derivations, namely: • & Elimination • ~ Elimination • & Introduction • Modus Ponens (-> and <-> Elimination) • -> Introduction • <-> Introduction • | Introduction • <-> Elimination

  9. classSentence: def __init__(self, rep=None, sent1=None, op=None, sent2=None): if op == None: self.op = None self.sent1 = None self.sent2 = None self.rep = rep elif op == "&"or op == "|"or op == "->"or op == "<->": self.op = op self.sent1 = sent1 self.sent2 = sent2 self.rep = None elif op == "~": self.op = op self.sent1 = sent1 self.sent2 = None self.rep = None else: raise Sentence.OpException() Implementation Details:The Sentence Class (Sentence.py)

  10. defnegate(self): """Returns the negation of this sentence""" return newComplexSentence(self, "~") defconjoin(self, other): """Returns the conjunction of this Sentence with the Sentence other""" return newComplexSentence(self, "&", other) defdisjoin(self, other): """Returns the disjunction of this Sentence with the Sentence other""" return newComplexSentence(self, "|", other) defcond(self, other): """Returns the Sentence "self -> other".""" return newComplexSentence(self, "->", other) defbicond(self, other): """Returns the Sentence "self <-> other".""" return newComplexSentence(self, "<->", other) Implementation Details:The Sentence Class (Sentence.py)

  11. classProof(Problem): defpath_cost(self, c, state1, action, state2): addCost = 1 if state2[len(state2)-1].complexity() > self.goal.complexity(): addCost = addCost + (state2[len(state2)-1].complexity() - \ self.goal.complexity()) * 2 S = state2[len(state2)-1].atoms() dups = 0 for s in S: dups = dups + S.count(s) - 1 if s not in self.goal.atoms(): addCost = addCost + 1 addCost = addCost + dups if action.find("Intro") != -1: addCost = addCost + 3 for op in self.goal.ops(): if(action.startswith(op)): if(addCost > 1): addCost = addCost - 1 else: addCost = 1 return addCost + c Implementation Details:The Proof Class (Proof.py)

  12. defgoal_test(self, state): return (self.goal in state or self.goal.negate() in state) defmissing_pieces(self, thm, state): """Helper function that counts the number of subcomponents of thm not in state. For use in recursive calls (see component_h below)""" if(thm in state): return 0 if(thm.sent1 == None and thm.sent2 == None): return 1 count = 1 if(thm.sent1 != None): count = count + self.missing_pieces(thm.sent1, state) if(thm.sent2 != None): count = count + self.missing_pieces(thm.sent2, state) return count defcomponent_h(self, n): """A heuristic that counts the number of subcomponents of the goal theorem which are not in the state""" val = self.missing_pieces(self.goal, n.state) return val Implementation Details:The Proof Class (Proof.py)

  13. p2.py from Proof import * Ax1 = Sentence("L").conjoin(Sentence("W")) Ax2 = Sentence("L").cond(Sentence("F").negate()) thm = Sentence("F").negate() p2 = Proof((Ax1,Ax2), thm) Console >>> from p2 import * >>> p2.initial ((L & W), (L -> ~F)) >>> p2.goal ~F Implementation Details:Defining a Problem

  14. Does It Work? • Yes! • Problems Solved: P1 (A* Only) Axioms: {(P&C), (T&M), (E&(I&R))} Theorem: ((P&T)&R) Solution: (P&C), (T&M), (E&(I&R)), P, T, (I&R), R, (P&T), ((P&T)&R) P2 (The one we looked at earlier) Solution: (L&W), (L->~F), L, ~F P3 Axioms: {(K<->(~E&Q)), K} Theorem: Q Solution: (K<->(~E & Q)), K, (~E&Q), Q P4 (A* Only) Axioms: {(P->(S<->(A&B))), (P&S)} Theorem: B Solution: (P->(S<->(A&B))), (P&S), S, P, (S<->(A&B)), (A&B), B

  15. Does It Work? • Yes! • Problems Solved: P5 (A* Only) Axioms: {(S&(S->E)), (C<->E), (C<->G)} Theorem: G Solution: (S&(S->E)), (C<->E), (C<->G), S, (S->E), E, C, G P6 (A* Only) Axioms: {((A&(B&C))&D), ((B&C)->E))} Theorem: E Solution: ((A&(B&C))&D), ((B&C)->E), (A&(B&C)), (B&C), E P7 Axioms: {A, C, (C->D)} Theorem: (A&D) Solution: A, C, (C->D), D, (A&D)

  16. Efficiency Comparison • P2 • Axioms: {(L&W), (L->~F)} • Theorem: ~F • P3 • Axioms: {(K<->(~E&Q)), K} • Theorem: Q • P7 • Axioms: {A, C, (C->D)} • Theorem: (A&D) • Format: <Calls to Successor/Goal Tests/States Expanded/Solution> Searcher P2 P3 P7 breadth_first_graph_search < 50/ 51/3221/((L > < 322/ 323/24703/((K > <2942/2943/362654/(A, > iterative_deepening_search < 3/ 54/ 91/((L > < 9/ 332/ 358/((K > < 39/2982/3051/(A, > astar_search < 8/ 9/ 345/((L > < 22/ 23/ 967/((K > < 2/ 3/ 125/(A, >

  17. Conclusions: Automated Theorem Proving • Computers are good at it! • But not as good as people... • Resolution works best right now • But with better heuristics other methods may overtake it • Having more rules requires fewer steps, but more code and more memory, and there's more opportunity for the prover to go down the wrong track. • Even with only very simple heuristics, a computer can solve all the logic problems on your 260 homework. Hmm...

  18. Bibliography • Argonne National Laboratory. “Automated Reasoning at Argonne”. [Cited 21 April 2005]. Available Online (http://www-unix.mcs.anl.gov/AR/). • Bergmann, Merrie, James Moor, and Jack Nelson. 1998. The Logic Book. New York: McGraw-Hill. • Boyer, Robert S. and J. Strother Moore. July 1990. “A Theorem Prover for a Computational Logic”. Keynote Address, 10th Conference on Automated Deduction. Available Online (http://www.cs.utexas.edu/users/boyer/cade90.pdf). • McCune, William. 2003. OTTER 3.3 Reference Manual. Argonne, IL: Argonne National Laboratory. Available Online (http://www-unix.mcs.anl.gov/AR/otter/otter33.pdf). • Norton, L. M., 1971. Experiments with a heuristic theorem proving program for the predicate calculus with equality. Artificial Intelligence 2:261-284. • Russell, Stuart and Peter Norvig. 2003. Artificial Intelligence: A Modern Aproach. Upper Saddle River, New Jersey: Pearson Education, Inc.

More Related