CMSC 671 Fall 2001

1
CMSC 671Fall 2001

• Class 13/14 Tuesday, October 16 / Thursday,
  October 18

2
Todays class

• Inference in first-order logic
• Inference rules
• Forward chaining
• Backward chaining
• Resolution
• Unification
• Proofs
• Clausal form
• Resolution as search

3
Inference in First-Order Logic

• Chapter 9

Some material adopted from notes by Andreas
Geyer-Schulz and Chuck Dyer
4
Inference rules for FOL

• Inference rules for propositional logic apply to
  FOL as well
• Modus Ponens, And-Introduction, And-Elimination,
  
• New (sound) inference rules for use with
  quantifiers
• Universal elimination
• Existential introduction
• Existential elimination
• Generalized Modus Ponens (GMP)

5
Universal elimination

• If (?x) P(x) is true, then P(c) is true, where c
  is any constant in the domain of x
• Example
• (?x) eats(Ziggy, x) gt eats(Ziggy, IceCream)
• The variable symbol can be replaced by any ground
  term, i.e., any constant symbol or function
  symbol applied to ground terms only

6
Existential introduction

• If P(c) is true, then (?x) P(x) is inferred.
• Example
• eats(Ziggy, IceCream) gt (?x) eats(Ziggy, x)
• All instances of the given constant symbol are
  replaced by the new variable symbol
• Note that the variable symbol cannot already
  exist anywhere in the expression

7
Existential elimination

• From (?x) P(x) infer P(c)
• Example
• (?x) eats(Ziggy, x) gt eats(Ziggy, Stuff)
• Note that the variable is replaced by a brand-new
  constant not occurring in this or any other
  sentence in the KB
• Also known as skolemization constant is a skolem
  constant
• In other words, we dont want to accidentally
  draw other inferences about it by introducing the
  constant
• Convenient to use this to reason about the
  unknown object, rather than constantly
  manipulating the existential quantifier

8
Generalized Modus Ponens (GMP)

• Apply modus ponens reasoning to generalized rules
• Combines And-Introduction, Universal-Elimination,
  and Modus Ponens
• E.g, from P(c) and Q(c) and (?x)(P(x) Q(x)) gt
  R(x) derive R(c)
• General case Given
• atomic sentences P1, P2, ..., PN
• implication sentence (Q1 Q2 ... QN) gt R
• Q1, ..., QN and R are atomic sentences
• substitution subst(?, Pi) subst(?, Qi) for
  i1,...,N
• Derive new sentence subst(?, R)
• Substitutions
• subst(?, a) denotes the result of applying a set
  of substitutions defined by ? to the sentence a
• A substitution list ? v1/t1, v2/t2, ...,
  vn/tn means to replace all occurrences of
  variable symbol vi by term ti
• Substitutions are made in left-to-right order in
  the list
• subst(x/IceCream, y/Ziggy, eats(y,x))
  eats(Ziggy, IceCream)

9
Automated inference for FOL

• Automated inference using FOL is harder than PL
• Variables can potentially take on an infinite
  number of possible values from their domains
• Hence there are potentially an infinite number of
  ways to apply the Universal-Elimination rule of
  inference
• Godel's Completeness Theorem says that FOL
  entailment is only semidecidable
• If a sentence is true given a set of axioms,
  there is a procedure that will determine this
• If the sentence is false, then there is no
  guarantee that a procedure will ever determine
  thisi.e., it may never halt

10
Completeness of some inference techniques

• Truth Tabling is not complete for FOL because
  truth table size may be infinite
• Natural Deduction is complete for FOL but is not
  practical because the branching factor in the
  search is too large (swe would have to
  potentially try every inference rule in every
  possible way using the set of known sentences)
• Generalized Modus Ponens is not complete for FOL
• Generalized Modus Ponens is complete for KBs
  containing only Horn clauses

11
Horn clauses

• A Horn clause is a sentence of the form
• (?x) P1(x) P2(x) ... Pn(x) gt Q(x)
• where
• there are 0 or more Pis and 0 or 1 Q
• the Pis and Q are positive (i.e., non-negated)
  literals
• Equivalently P1(x) ? P2(x) ? Pn(x) where the
  Pis are all atomic and at most one of them is
  positive
• Prolog is based on Horn clauses
• Horn clauses represent a subset of the set of
  sentences representable in FOL

12
Horn clauses II

• Special cases
• P1 P2 Pn gt Q
• P1 P2 Pn gt false
• true gt Q
• These are not Horn clauses
• p(a) ? q(a)
• P Q gt R ? S

13
Unification

• Unification is a pattern-matching procedure
• Takes two atomic sentences, called literals, as
  input
• Returns Failure if they do not match and a
  substitution list, ?, if they do
• That is, unify(p,q) ? means subst(?, p)
  subst(?, q) for two atomic sentences, p and q
• ? is called the most general unifier (mgu)
• All variables in the given two literals are
  implicitly universally quantified
• To make literals match, replace (universally
  quantified) variables by terms

14
Unification algorithm

• procedure unify(p, q, ?)
• Scan p and q left-to-right and find the
  first corresponding
• terms where p and q disagree (i.e., p
  and q not equal)
• If there is no disagreement, return ?
  (success!)
• Let r and s be the terms in p and q,
  respectively,
• where disagreement first occurs
• If variable(r) then
• Let ? union(?, r/s)
• Recurse and return unify(subst(?, p),
  subst(?, q), ?)
• else if variable(s) then
• Let ? union(?, s/r)
• Recurse and return unify(subst(?, p),
  subst(?, q), ?)
• else return Failure
• end

15
Unification Remarks

• Unify is a linear-time algorithm that returns the
  most general unifier (mgu), i.e., the
  shortest-length substitution list that makes the
  two literals match.
• In general, there is not a unique minimum-length
  substitution list, but unify returns one of
  minimum length
• A variable can never be replaced by a term
  containing that variable
• Example x/f(x) is illegal.
• This occurs check should be done in the above
  pseudo-code before making the recursive calls

16
Unification examples

• Example
• parents(x, father(x), mother(Bill))
• parents(Bill, father(Bill), y)
• x/Bill, y/mother(Bill)
• Example
• parents(x, father(x), mother(Bill))
• parents(Bill, father(y), z)
• x/Bill, y/Bill, z/mother(Bill)
• Example
• parents(x, father(x), mother(Jane))
• parents(Bill, father(y), mother(y))
• Failure

17
Forward chaining

• Proofs start with the given axioms/premises in
  KB, deriving new sentences using GMP until the
  goal/query sentence is derived
• This defines a forward-chaining inference
  procedure because it moves forward from the KB
  to the goal
• Natural deduction using GMP is complete for KBs
  containing only Horn clauses

18
Forward chaining algorithm
19
Backward chaining

• Backward-chaining deduction using GMP is complete
  for KBs containing only Horn clauses
• Proofs start with the goal query, find
  implications that would allow you to prove it,
  and then prove each of the antecedents in the
  implication, continuing to work backwards until
  you arrive at the axioms, which we know are true
• Example Does Ziggy eat fish
• (?x) eats(Ziggy, x) gt eats(Ziggy, Stuff)

20
Backward chaining algorithm
21
Completeness of GMP

• GMP (using forward or backward chaining) is
  complete for KBs that contain only Horn clauses
• It is not complete for simple KBs that contain
  non-Horn clauses
• The following entail that S(A) is true
• (?x) P(x) gt Q(x)
• (?x) P(x) gt R(x)
• (?x) Q(x) gt S(x)
• (?x) R(x) gt S(x)
• If we want to conclude S(A), with GMP we cannot,
  since the second one is not a Horn form
• It is equivalent to P(x) ? R(x)

22
Resolution

• Resolution is a sound and complete inference
  procedure for FOL
• Resolution Rule for PL
• P1 ? P2 ? ... ? Pn
• P1 ? Q2 ? ... ? Qm
• Resolvent P2 ? ... v Pn ? Q2 ? ... ? Qm
• Examples
• P and P ? Q, derive Q (Modus Ponens)
• (P ? Q) and (Q ? R), derive P ? R
• P and P, derive False contradiction!
• (P ? Q) and (P ? Q), derive True

23
FOL resolution

• Given sentences
• P1 ? ... ? Pn
• Q1 ? ... ? Qm
• where each Pi and Qi is a literal, i.e., a
  positive or negated predicate symbol with its
  terms, if Pj and Qk unify with substitution list
  ?, then derive the resolvent sentence
• subst(?, P1 ?... ? Pj-1 ? Pj1 ... Pn ? Q1 ?
  Qk-1 ? Qk1 ?... ? Qm)
• Example
• From clause P(x, f(a)) ? P(x, f(y)) ? Q(y)
• and clause P(z, f(a)) ? Q(z),
• derive resolvent clause P(z, f(y)) ? Q(y) ? Q(z)
  
• using ? x/z

24
A resolution proof tree
25
Resolution refutation proofs

• Given a consistent set of axioms KB and goal
  sentence Q, show that KB Q
• Proof by contradiction Add Q to KB and try to
  prove false.
• i.e., (KB - Q) ltgt (KB ? Q - False)
• Resolution can establish that a given sentence Q
  is entailed by KB, but cant (in general) be used
  to generate all logical consequences of a set
  sentences
• Also, it cannot be used to prove that Q is not
  entailed by KB.
• Resolution wont always give an answer since
  entailment is only semidecidable
• And you cant just run two proofs in parallel,
  one trying to prove Q and the other trying to
  prove Q, since KB might not entail either one

26
Procedure

• procedure resolution(KB, Q)
• KB is a set of consistent, true FOL
  sentences, Q is a goal sentence
• to derive. Returns success if KB -
  Q, and failure otherwise
• KB union(KB, Q)
• while false ? KB do
• Choose 2 sentences, S1 and S2, in KB
  that contain
• literals that unify
• if none, return Failure
• resolvent resolution-rule(S1, S2)
• KB union(KB, resolvent)
• return Success
• end

27
Refutation resolution proof tree
28
Resolution issues

• Resolution is only applicable to sentences in
  clausal form, e.g.
• P1 ? P2 ?... ? Pn
• where Pis are negated or non-negated atomic
  predicates
• Issues
• Can we convert every FOL sentence into this form?
  
• Yes as we will see shortly
• How to pick which pair of sentences to resolve?
• Determines the search strategy of the prover
  more later
• How to pick which pair of literals, one from each
  sentence, to unify?
• Again, part of the search strategy

29
Example proof Did Curiosity kill the cat?

• Jack owns a dog. Every dog owner is an animal
  lover. No animal lover kills an animal. Either
  Jack or Curiosity killed the cat, who is named
  Tuna. Did Curiosity kill the cat?
• The axioms can be represented as follows
• A. (?x) Dog(x) Owns(Jack,x)
• B. (?x) ((?y) Dog(y) Owns(x, y)) gt
  AnimalLover(x)
• C. (?x) AnimalLover(x) gt (?y) Animal(y) gt
  Kills(x,y)
• D. Kills(Jack,Tuna) ? Kills(Curiosity,Tuna)
• E. Cat(Tuna)
• F. (?x) Cat(x) gt Animal(x)

30
Example proof, cont. Did Curiosity kill the cat?

• Convert to implicative normal form
• A1. True gt Dog(D)
• A2. True gt Owns(Jack,D)
• B. Dog(y) Owns(x, y) gt AnimalLover(x)
• C. AnimalLover(x) Animal(y) Kills(x,y) gt
  False
• D. True gt Kills(Jack,Tuna) v
  Kills(Curiosity,Tuna)
• E. True gt Cat(Tuna)
• F. Cat(x) gt Animal(x)
• Add the query
• Q. Kills(Curiosity, Tuna) gt False

31
Example proof III Did Curiosity kill the cat?

• The Proof
• G. A1, B, y/D Owns(x,D) gt AnimalLover(x)
• H. A2, G, x/Jack True gt AnimalLover(Jack)
• I. E,F, x/Tuna True gt Animal(Tuna)
• J. C,I, y/Tuna AnimalLover(x) Kills(x,Tuna)
  gt False
• K. H,J x/Jack Kills(Jack,Tuna) gt False
• L. D,Q True gt Kills(Jack,Tuna)
• M. L,K True gt False

32
Curiosity Killed the Cat
33
Converting to clausal form

• The canonical (standard) form for resolution is
  Conjunctive Normal Form (conjunction of
  disjunctions), or equivalently, Implicative
  Normal Form (conjunction implies disjunction)
• Example If Johns house is big, then it is a lot
  of work, unless he has a housekeeper and does not
  have a garden
• FOL
• Big(h) House(h,j) gt Work(h) ? (Cleans(c,h)
  Garden(g,h))
• Implicative Normal Form
• Big(h) House(h,j) gt Work(h) ? Cleans(c,h)
• Big(h) House(h,j) Garden(g,h) gt Work(h)

34
Converting sentences to clausal form

• 1. Eliminate all ltgt connectives
• (P ltgt Q) gt ((P gt Q) (Q gt P))
• 2. Eliminate all gt connectives
• (P gt Q) gt (P v Q)
• 3. Reduce the scope of each negation symbol to a
  single predicate
• P gt P
• (P v Q) gt P Q
• (P Q) gt P v Q
• (?x)P gt (?x)P
• (?x)P gt (?x)P
• 4. Standardize variables rename all variables so
  that each quantifier has its own unique variable
  name

35
Converting sentences to clausal form Skolem
constants and functions

• 5. Eliminate existential quantification by
  introducing Skolem constants/functions
• (?x)P(x) gt P(c)
• c is a Skolem constant (a brand-new constant
  symbol that is not used in any other sentence)
• (?x)(?y)P(x,y) gt (?x)P(x, f(x))
• since ? is within the scope of a universally
  quantified variable, use a Skolem function f to
  construct a new value that depends on the
  universally quantified variable
• f must be a brand-new function name not occurring
  in any other sentence in the KB.
• E.g., (?x)(?y)loves(x,y) gt (?x)loves(x,f(x))
• In this case, f(x) specifies the person that x
  loves

36
Converting sentences to clausal form

• 6. Remove universal quantifiers by (1) moving
  them all to the left end (2) making the scope of
  each the entire sentence and (3) dropping the
  prefix part
• Ex (?x)P(x) gt P(x)
• 7. Put into conjunctive normal form (conjunction
  of disjunctions)
• (P Q) ? R gt (P ? R) (Q ? R)
• (P ? Q) ? R gt (P ? Q ? R)
• 8. Split conjuncts into a separate clauses
• 9. Standardize variables so each clause contains
  only variable names that do not occur in any
  other clause

37
An example

• (?x)(P(x) gt ((?y)(P(y) gt P(f(x,y)))
  (?y)(Q(x,y) gt P(y))))
• 2. Eliminate gt
• (?x)(P(x) ? ((?y)(P(y) ? P(f(x,y)))
  (?y)(Q(x,y) ? P(y))))
• 3. Reduce scope of negation
• (?x)(P(x) ? ((?y)(P(y) ? P(f(x,y)))
  (?y)(Q(x,y) P(y))))
• 4. Standardize variables
• (?x)(P(x) ? ((?y)(P(y) ? P(f(x,y)))
  (?z)(Q(x,z) P(z))))
• 5. Eliminate existential quantification
• (?x)(P(x) ?((?y)(P(y) ? P(f(x,y))) (Q(x,g(x))
  P(g(x)))))
• 6. Drop universal quantification symbols
• (P(x) ? ((P(y) ? P(f(x,y))) (Q(x,g(x))
  P(g(x)))))

38
Example

• 7. Convert to conjunction of disjunctions
• (P(x) ? P(y) ? P(f(x,y))) (P(x) ? Q(x,g(x)))
  
• (P(x) ? P(g(x)))
• 8. Create separate clauses
• P(x) ? P(y) ? P(f(x,y))
• P(x) ? Q(x,g(x))
• P(x) ? P(g(x))
• 9. Standardize variables
• P(x) ? P(y) ? P(f(x,y))
• P(z) ? Q(z,g(z))
• P(w) ? P(g(w))

39
Resolution TP as search

• Resolution can be thought of as the bottom-up
  construction of a search tree, where the leaves
  are the clauses produced by KB and the negation
  of the goal
• When a pair of clauses generates a new resolvent
  clause, add a new node to the tree with arcs
  directed from the resolvent to the two parent
  clauses
• Resolution succeeds when a node containing the
  False clause is produced, becoming the root node
  of the tree
• A strategy is complete if its use guarantees that
  the empty clause (i.e., false) can be derived
  whenever it is entailed

40
Breadth-first search

• Level 0 clauses are the original axioms and the
  negation of the goal
• Level k clauses are the resolvents computed from
  two clauses, one of which must be from level k-1
  and the other from any earlier level
• Compute all possible level 1 clauses, then all
  possible level 2 clauses, etc.
• Complete, but very inefficient

41
Strategies

• There are a number of general (domain-independent)
  strategies that are useful in controlling a
  resolution theorem prover
• Well briefly look at the following
• Breadth first
• Set of support
• Unit resolution
• Input resolution
• Ordered resolution
• Subsumption

42
Set of support

• At least one parent clause must be the negation
  of the goal or a descendant of such a goal
  clause (i.e., derived from a goal clause)
• Complete (assuming all possible set-of-support
  clauses are derived)
• Gives a goal-directed character to the search

43
Unit resolution

• Prefer resolution steps in which at least one
  parent clause is a unit clause, i.e., a clause
  containing a single literal
• Not complete in general, but complete for Horn
  clause KBs

44
Input resolution

• At least one parent must be one of the input
  sentences (i.e., either a sentence in the
  original KB or the negation of the goal)
• Not complete in general, but complete for Horn
  clause KBs
• Linear resolution
• Extension of input resolution
• One of the parent sentences must be an input
  sentence or an ancestor of an input sentece
• Complete

45
Ordered resolution

• Search for resolvable sentences in order (left to
  right)
• This is how Prolog operates
• Resolve the first element in the sentence first
• This forces the user to define what is important
  in generating the code
• The way the sentences are written controls the
  resolution

46
Subsumption

• Eliminate all sentences that are subsumed by
  (more specific than) an existing sentence to keep
  the KB small
• Like factoring, this is just removing things that
  merely clutter up the space and will not affect
  the final result
• E.g., if P(x) is already in the KB, adding P(A)
  makes no sense P(x) is a superset of P(A)
• Likewise adding P(A) ? Q(B) would add nothing to
  the KB

47
Proof tree that West is a criminal
48
A failed proof tree
49
Sketch of a completeness proof for resolution