Artificial Intelligence 9. Resolution Theorem Proving

Course V231

Department of Computing

Imperial College

Jeremy Gow

The Full Resolution Rule

If Unify(Pj, ¬Qk) = (¬ makes them unifiable)

P1 … Pm, Q1 … Qn

Subst(, P1 … (no Pj) … Pm Q1 … (no Qk) ... Qn)

Pj and Qk are resolved Arbitrary number of disjuncts Relies on preprocessing into CNF

A More Concise Version

E.g. for A = {1, 2, 7} first clause is L1 L2 L7

Resolution Proving

Knowledge base of clauses– Start with the axioms and negation of theorem in CNF

Resolve pairs of clauses– Using single rule of inference (full resolution)– Resolved sentence contains fewer literals

Proof ends with the empty clause– Signifies a contradiction– Must mean the negated theorem is false

(Because the axioms are consistent)

– Therefore the original theorem was true

Empty Clause means False

Resolution theorem proving ends– When the resolved clause has no literals (empty)

This can only be because:– Two unit clauses were resolved

One was the negation of the other (after substitution)

– Example: q(X) and ¬q(X) or: p(X) and ¬p(bob)

Hence if we see the empty clause– This was because there was an inconsistency– Hence the proof by refutation

Resolution as Search

Initial State: Knowledge base (KB) of axioms and negated theorem in CNF

Operators: Resolution rule picks 2 clauses and adds new clause

Goal Test: Does KB contain the empty clause?

Search space of KB states We want proof (path) or just checking (artefact)

Aristotle’s Example (Again)

Socrates is a man and all men are mortal Therefore Socrates is mortal

Initial state1) is_man(socrates)

2) is_man(X) is_mortal(X)

3) ¬is_mortal(socrates) (negation of theorem)

Resolving (1) & (2) gives new state(1)-(3) & 4) is_mortal(socrates)

Aristotle’s Example: Search Space

1) is_man(socrates)2) is_man(X) is_mortal(X)3) ¬is_mortal(socrates) 4) is_mortal(socrates)

1) is_man(socrates)2) ¬is_man(X) is_mortal(X)3) ¬is_mortal(socrates) 4) ¬is_man(socrates)

1) is_man(socrates)2) is_man(X) is_mortal(X)3) ¬is_mortal(socrates)

1) is_man(socrates)2) is_man(X) is_mortal(X)3) ¬is_mortal(socrates) 4) is_mortal(socrates)5) False

1) is_man(socrates)2) is_man(X) is_mortal(X)3) ¬is_mortal(socrates) 4) ¬is_man(socrates)5) False

Resolution Proof Tree (Proof 1)

Resolution Proof Tree (Proof 2)

Reading Proof Tree 2

You said that all men were mortal. That means that for all things X, either X is not a man, or X is mortal [CNF step]. If we assume that Socrates is not mortal, then, given your previous statement, this means Socrates is not a man [first resolution step]. But you said that Socrates is a man, which means that our assumption was false [second resolution step], so Socrates must be mortal.

Russell & Norvig Example

Reminder: Kowalski NF

Can reintroduce to CNF, e.g.¬A ¬C B becomes (A C) B

Kowalski normal form

(A1 … An) (B1 … Bn) Resolve in KNF using ‘KNF style’ rules

– e.g. Binary resolution…

AB, BCAC

R&N Example: Kowalski NF

R&N Example: Proof Tree

R&N Example: Prover9 Input

R&N Example: Prover9 Proof

Equality Axioms

is_pres(obama) and is_pres(b_obama)– will not unify (syntactically different)

unification algorithm does not allow this

– Even if we add to the knowledge base: obama = b_obama

Solution: add equality axioms to KB– X=X, X=YY=X, etc.– Special axiom for every predicate/function:

X = Y P(X) = P(Y)

Equality & Demodulation

Alternative solution: rewrite with equalities Demodulation inference rule

X=Y, A[S]

Subst(, A[Y])

– Two input clauses (one an equality X=Y)– Unify X with a subterm S of other– Apply unifier to clause with subterm Y (not S)– Also works unifying with Y and putting in X

Unify(X, S) =

Heuristic Strategies

Pure resolution search tends to be slow For interesting problems

– Many clauses in the initial knowledge base– Each step adds a new clause (which can be used)– Num. of possible resolution combinations explodes

Selection Heuristics– Intelligently choose which pair to resolve

Pruning Heuristics– Forbid certain pairs

Unit Preference Strategy

Prefer to resolve unit clauses– Contain only a single literal– Selection heuristic

Searching for smallest (empty) clause– Resolving with the unit clauses keeps small

Very effective early on for simple problems– Doesn’t reduce branching rate for medium problems

Set of Support Strategy

Distinguished subset of KB clauses– Set of support (SOS) clauses– Every step must involve SOS (pruning heuristic)

Must be careful not to lose completeness

Example SOS strategy:– Initial SOS is negated theorem– Add new clauses to SOS– Hence False will be deduced (strategy is complete)

Many provers use SOS, e.g. Prover9

Input Resolution Strategy

Special case of SOS strategy– SOS = clauses in the initial knowledge base

Clearly reduces search space– Every resolution must involve an original clause– So number of possible resolutions grows slowly

Not complete for first order logic But complete for Horn-clauses, e.g. Prolog

Subsumption

Clause C subsumes clause D– if C is more ‘general’ (D is more specific)

Naive check for subsumption– Select C2, a subset of literals of C– Find Unify(C2, D) = does not add anything to D (only renames vars)

Example:– p(george) q(X) subsumed by p(A) q(B) r(C)∨ ∨ ∨– Substitution: {A/george, X/B}– Second clause is more general

Subsumption Strategy

Check each new clause is not subsumed by KB Complete strategy

– Specific clauses can be inferred from general ones– So we can throw specific clauses away– Reduced search space still contains False

Can be inefficient– expense must be outweighed by the reduction in the

search space

Applications: Axioms for Algebras

Bill McCune and Larry Wos– Argonne National Laboratories– FO resolution provers: EQP, Otter, Prover9

Robbins Problem (axioms of Boolean algebras)– Stated 60+ years ago, mathematicians failed– 1996: EQP solved in 8 days in 1996 (+human work)

General application to algebraic axiomatisations– Generate possible axioms for algebras– Prove new axioms equivalent to old

Applications: Theory Formation

Simon’s HR system: Automated Theory Formation– Used in mathematical (and bioinformatics) domains

Theories = concepts, examples, conjectures, proofs HR uses Otter to prove conjectures it makes Effective in algebraic domains

– See notes for anti-associative algebra results Otter not so effective in number theory

– Used as a ‘triviality’ filter (discard theorems it can prove)– Example conjectures made by HR (and proved by Simon):

Sum of divisors is prime → number of divisors is prime Sum of divisors of a square is an odd number Perfect numbers are pernicious [and many more…..]

Inductive Theorem Proving

Deduction by mathematical induction

Induction over many different structures Allows reasoning about recursion/iteration

– Useful for hardware/software verification Don’t confuse inductive learning (next lecture)

Interactive Theorem Proving

Necessary to interact with humans in order to prove theorems of any difficulty

Mathematician’s assistant– Let a theorem prover do simple tasks while you

develop a theory (e.g., Buchberger’s Theorema)

Guided theorem prover– User follows and guides computer proof attempt– Needs visualisation tools for proof trees

Higher Order Theorem Proving

Deduction in higher order logics– See lecture 4– Allows more natural and succinct statements– Logics much less well-behaved

HOL theorem prover – Larry Paulson’s group in Cambridge– Has been used for verification tasks

E.g. verification of crytographic protocols

– Uses induction and interactive control

Proof Planning

Initially Alan Bundy’s group in Edinburgh Human proofs often follow a similar structure

– Express this as a outline plan– Methods represent a patterns of deduction

Outline plan guides proof search– Results in specific plan for theorem– Critics deal with common problems

Particularly useful for inductive theorems– Proof of base case and step case follow pattern

Databases & Competitions

TPTP library (Sutcliffe & Suttner)– Thousands of Problems for Theorem Provers– Benchmarks for first order provers– HR is only non-human to add to this library

Annual CASC competition (Sutcliffe et al.)– Which is fastest/most accurate FO prover on planet? – Uses blind selection from the TPTP library– 2002-08 champion: Vampire (Voronkov & Riazonov)