cs 2710 issp 2610 n.
Skip this Video
Loading SlideShow in 5 Seconds..
CS 2710, ISSP 2610 PowerPoint Presentation
Download Presentation
CS 2710, ISSP 2610

Loading in 2 Seconds...

play fullscreen
1 / 42

CS 2710, ISSP 2610 - PowerPoint PPT Presentation

  • Uploaded on

CS 2710, ISSP 2610. Chapter 9 Inference in First-Order Logic. Pages to skim. Storage and Retrieval (p. starts bottom 328) Efficient forward chaining (starts p. 333) through Irrelevant facts (ends top 337)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'CS 2710, ISSP 2610' - wilhelmina-carter

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
cs 2710 issp 2610

CS 2710, ISSP 2610

Chapter 9

Inference in First-Order Logic

pages to skim
Pages to skim
  • Storage and Retrieval (p. starts bottom 328)
  • Efficient forward chaining (starts p. 333) through Irrelevant facts (ends top 337)
  • Efficient implementation of logic programs (starts p. 340) through Constraint logic programming (ends p. 345)
  • Completeness of resolution (starts p. 350) (though see notes in slides)
inference with quantifiers
Inference with Quantifiers
  • Universal Instantiation:
    • Given X (person(X)  likes(X, sun))
    • Infer person(john)  likes(john,sun)
  • Existential Instantiation:
    • Given x likes(x, chocolate)
    • Infer: likes(S1, chocolate)
    • S1 is a “Skolem Constant” that is not found anywhere else in the KB and refers to (one of) the individuals that likes sun.
reduction to propositional inference
Reduction to Propositional Inference
  • Simple form (pp. 324-325) not efficient. Useful conceptually.
  • Replace each universally quantified sentence by all possible instantiations
    • All X (man(X)  mortal(X)) replaced by
    • man(tom)  mortal(tom)
    • man(chocolate)  mortal(chocolate)
  • Now, we essentially have propositional logic.
  • Use propositional reasoning algorithms from Ch 7
reduction to propositional inference1
Reduction to Propositional Inference
  • Problem: when the KB includes a function symbol, the set of term substitutions is infinite. father(father(father(tom))) …
  • Herbrand 1930: if a sentence is entailed by the original FO KB, then there is a proof using a finite subset of the propositionalized KB
  • Since any subset has a maximum depth of nesting in terms, we can find the subset by generating all instantiations with constant symbols, then all with depth 1, and so on
reduction to propositional inference2
Reduction to Propositional Inference
  • We have an approach to FO inference via propositionalization that is complete: any entailed sentence can be proved
  • Entailment for FOPC is semi-decidable: algorithms exist that say yes to every entailed sentence, but no algorithm exists that also says no to every nonentailed sentence.
  • Our proof procedure could go on and on, generating more and more deeply nested terms, but we will not know whether it is stuck in a loop, or whether the proof is just about to pop out
generalized modus ponens
Generalized Modus Ponens
  • This is a general inference rule for FOL that does not require instantiation
  • Given:
    • p1’, p2’ … pn’ (p1  … pn)  q
    • Subst(theta, pi’) = subst(theta, pi) for all i
  • Conclude:
    • Subst(theta, q)
gmp is a lifted version of mp
GMP is a lifted version of MP
  • GMP “lifts” MP from propositional to first-order logic
  • Key advantage of lifted inference rules over propositionalization is that they make only substitutions which are required to allow particular inferences to proceed
gmp example
GMP Example
  • x,y,z ((parent(x,y)  parent(y,z))  grandparent(x,z))
  • parent(james, john), parent(james, richard), parent(harry, james)
  • We can derive:
    • Grandparent(harry, john), bindings:{x/harry,y/james,z/john}
    • Grandparent(harry, richard), bindings: {x/harry,y/james,z/richard}
  • Process of finding all legal substitutions
  • Key component of all FO inference algorithms
  • Unify(p,q) = theta, where Subst(theta,p) == Subst(theta,q)

Assuming all variables universally quantified

standardizing apart
Standardizing apart
  • knows(john,X).
  • knows(X,elizabeth).
  • These ought to unify, since john knows everyone, and everyone knows elizabeth.
  • Rename variables to avoid such name clashes


all X p(X) == all Y p(Y)

All X (p(X) ^ q(X)) == All X p(X) ^ All Y p(Y)


def Unify (p, q, bdgs):

d = disagreement(p, q)

# If there is no disagreement, then success.

if not d: return bdgs

elif not isVar(d[0]) and not isVar(d[1]): return 'fail'


if isVar(d[0]): var = d[0] ; other = d[1]

else: var = d[1] ; other = d[0]

if occursp (var,other): return ‘fail’

# Make appropriate substitutions and recurse on the result.


pp = replaceAll(var,other,p)

qq = replaceAll(var,other,q)

return Unify (pp,qq, bdgs + [[var,other]])

For code, click here unify.py




['loves', ['dog', 'var_x'], ['dog', 'fred']]

['loves', 'var_z', 'var_z']

subs: [['var_z', ['dog', 'var_x']], ['var_x', 'fred']]

result: ['loves', ['dog', 'fred'], ['dog', 'fred']]



['loves', ['dog', 'fred'], 'fred']

['loves', 'var_x', 'var_y']

subs: [['var_x', ['dog', 'fred']], ['var_y', 'fred']]

result: ['loves', ['dog', 'fred'], 'fred']



['loves', ['dog', 'fred'], 'mary']

['loves', ['dog', 'var_x'], 'var_y']

subs: [['var_x', 'fred'], ['var_y', 'mary']]

result: ['loves', ['dog', 'fred'], 'mary']




['loves', ['dog', 'fred'], 'mary']

['loves', ['dog', 'var_x'], 'var_y']

subs: [['var_x', 'fred'], ['var_y', 'mary']]

result: ['loves', ['dog', 'fred'], 'mary']



['loves', ['dog', 'fred'], 'fred']

['loves', 'var_x', 'var_x']




['loves', ['dog', 'fred'], 'mary']

['loves', ['dog', 'var_x'], 'var_x']




['loves', 'var_x', 'fred']

['loves', ['dog', 'var_x'], 'fred']

var_x occurs in ['dog', 'var_x']




['loves', 'var_x', ['dog', 'var_x']]

['loves', 'var_y', 'var_y']

var_y occurs in ['dog', 'var_y']




['loves', 'var_y', 'var_y']

['loves', 'var_x', ['dog', 'var_x']]

var_x occurs in ['dog', 'var_x']



unify: (fails because vars not standardized apart)

['hates', 'agatha', 'var_x']

['hates', 'var_x', ['f1', 'var_x']]




['hates', 'agatha', 'var_x']

['hates', 'var_y', ['f1', 'var_y']]

subs: [['var_y', 'agatha'], ['var_x', ['f1', 'agatha']]]

result: ['hates', 'agatha', ['f1', 'agatha']]

most general unifier
Most General Unifier
  • The Unify algorithm returns a MGU

L1 = p(X,f(Y),b)

L2 = p(X,f(b),b)

Subst1 = {a/X, b/Y}

Result1 = p(a,f(b),b)

Subst2 = {b/Y}

Result2 = p(X,f(b),b)

Subst1 is more restrictive than Subst2. In fact,

Subst2 is a MGU of L1 and L2.

storage and retrieval
Storage and retrieval
  • Hash statements by predicate for quick retrieval (predicate indexing), e.g., of all sentences that unify with tall(X)
  • Why attempt to unify
    • tall(X) and silly(dog(Y))
  • Instead
    • Predicates[tall] = {all tall facts}
    • Unify(tall(X),s) for s in Predicates[tall]
  • Subsumption lattice for efficiency (see p. 329)
forward chaining over fo definite horn clauses
Forward Chaining over FO Definite (Horn) Clauses
  • Clauses (disjunctions) with at most one positive literal
  • First-order literals can include variables, which are assumed to be universally quantified
  • Use GMP to perform forward chaining

(Semi-decidable as for full FOPC)


Def FOL-FC-Ask(KB,A) returns subst or false

KB: set of FO definite clauses with variables standardized apart

A: the query, an atomic sentence

Repeat until new is empty

new  {}

for each implication (p1 ^ … ^ pn  q) in KB:

for each T such that SUBST(T,p1^…^pn) =

SUBST(T,p1’^…^pn’) for some p1’,…,pn’ in KB

q’  SUBST(T,q)

if q’ is not a renaming of a sentence already in KB or new:

add q’ to new

S  Unify(q’,A)

if S is not fail then return S

add new to KB

Return false

Process can be made more efficient; read on your own, for interest

backward chaining over definite horn clauses
Backward Chaining over Definite (Horn) Clauses
  • Logic programming
  • Prolog is most popular form
  • Depth-first search, so space requirements are lower, but suffers from problems from repeated states

american(X) ^ weapon(Y) ^ sells(X,Y,Z) ^ hostile(Z)  criminal(X).

owns(nono,m1). missile(m1).

missile(X1) ^ owns(nono,X1)  sells(west,X1,nono).

missile(X2)  weapon(X2).

enemy(X3,america)  hostile(X3).



Goal: criminal(west).

Backward chaining proof: in lecture

In Prolog:

criminal(X) :- american(X), weapon(Y), sells(X,Y,Z), hostile(Z).


Horn clauses are all of the form:

L1 ^ L2 ^ ... ^ Ln -> Ln+1

Or, equivalently, in clausal form:

~L1 v ~L2 v ... v ~Ln v Ln+1

Prolog (like databases) makes the "closed world assumption":

if P cannot be proved, infer not P

Think of the system as an arrogant know-it-all:

"If it were true, I would know it. Since I can't prove

it, it must not be true"

Thus, it uses "negation as failure".





?- neighbor(canada,india).


In full first-order logic, you would have to be able to

infer “~neighbor(canada,india)" for

"neighbor(canada,india)" to be false.

Be careful! “~neighbor(canada,india) is not entailed by the

Sentences above!


bachelor(X) :- male(X), \+ married(X).





An individual is a bachelor if it is male and it is

not married. \+ is the negation-as-failure operator in Prolog.

| ?- bachelor(bill).


| ?- bachelor(jim).


| ?- bachelor(mary).


| ?- bachelor(X).

X = jim;


| ?-

inference methods
Inference Methods
  • Unification (prerequisite)
  • Forward Chaining
    • Production Systems
    • RETE Method (OPS)
  • Backward Chaining
    • Logic Programming (Prolog)
  • Resolution
    • Transform to CNF
    • Generalization of Prop. Logic resolution
resolution theorem proving fol
Resolution Theorem Proving (FOL)
  • Convert everything to CNF
  • Resolve, with unification
    • Save bindings as you go!
  • If resolution is successful, proof succeeds
  • If there was a variable in the item to prove, return variable’s value from unification bindings
converting sentences to cnf
Converting sentences to CNF

1. Eliminate all ↔ connectives

(P ↔ Q)  ((P  Q) ^ (Q  P))

2. Eliminate all  connectives

(P  Q)  (P  Q)

3. Reduce the scope of each negation symbol to a single predicate

P  P

(P  Q) P Q

(P  Q) P Q

(x)P  (x)P

(x)P  (x)P

4. Standardize variables: rename all variables so that each quantifier has its own unique variable name

converting sentences to clausal form skolem constants and functions
Converting sentences to clausal form: Skolem constants and functions

5. Eliminate existential quantification by introducing Skolem constants/functions

(x)P(x)  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) becomes (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) becomes (x)loves(x,f(x))

In this case, f(x) specifies the person that x loves

E.g., x1 x2 x3 y p(… y …) becomes

x1 x2 x3 p(… ff(x1,x2,x3) …) (ff is a new name)

converting sentences to clausal form
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)  P(x)

7. Put into conjunctive normal form (conjunction of disjunctions) using distributive and associative laws

(P  Q)  R  (P  R)  (Q  R)

(P  Q)  R  (P  Q  R)

8. Split conjuncts into separate clauses

9. Standardize variables so each clause contains only variable names that do not occur in any other clause

an example
An example

(x)(P(x)  ((y)(P(y)  P(f(x,y))) (y)(Q(x,y)  P(y))))

2. Eliminate 

(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)))))

an example1
An 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))


1. all X (read (X) --> literate (X))

2. all X (dolphin (X) --> ~literate (X))

3. exists X (dolphin (X) ^ intelligent (X))

(a translation of ``Some dolphins are intelligent'')

``Are there some who are intelligent but cannot read?''

4. exists X (intelligent(X) ^ ~read (X))

Set of clauses (1-3):

1. ~read(X) v literate(X)

2. ~dolphin(Y) v ~literate(Y)

3a. dolphin (a)

3b. intelligent (a)

Negation of 4:

~(exists Z (intelligent(Z) ^ ~read (Z)))

In Clausal form:

~intelligent(Z) v read(Z)

Resolution proof: in lecture.

more complicated example did curiosity kill the cat
More complicated exampleDid 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?
  • These can be represented as follows:

A. (x) (Dog(x)  Owns(Jack,x))

B. (x) (((y) Dog(y)  Owns(x, y))  AnimalLover(x))

C. (x) (AnimalLover(x)  ((y) Animal(y) Kills(x,y)))

D. Kills(Jack,Tuna)  Kills(Curiosity,Tuna)

E. Cat(Tuna)

F. (x) (Cat(x)  Animal(x) )

G. Kills(Curiosity, Tuna)



D is a skolem constant

  • Convert to clause form

A1. (Dog(D))

A2. (Owns(Jack,D))

B. (Dog(y), Owns(x, y), AnimalLover(x))

C. (AnimalLover(a), Animal(b), Kills(a,b))

D. (Kills(Jack,Tuna), Kills(Curiosity,Tuna))

E. Cat(Tuna)

F. (Cat(z), Animal(z))

  • Add the negation of query:

G: (Kills(Curiosity, Tuna))

The resolution refutation proof

R1: G, D, {} (Kills(Jack, Tuna))

R2: R1, C, {a/Jack, b/Tuna} (~AnimalLover(Jack), ~Animal(Tuna))

R3: R2, B, {x/Jack} (~Dog(y), ~Owns(Jack, y), ~Animal(Tuna))

R4: R3, A1, {y/D} (~Owns(Jack, D), ~Animal(Tuna))

R5: R4, A2, {} (~Animal(Tuna))

R6: R5, F, {z/Tuna} (~Cat(Tuna))

R7: R6, E, {} FALSE





R1: K(J,T)



  • The proof tree


R2: AL(J)  A(T)


R3: D(y)  O(J,y)  A(T)



R4: O(J,D), A(T)



R5: A(T)



R6: C(T)




decidability and completeness
Decidability and Completeness
  • Resolution is a refutation complete inference procedure for First-Order Logic
    • If a set of sentences contains a contradiction, then a finite sequence of resolutions will prove this.
    • If not, resolution may loop forever (“semi-decidable”)
  • Here are notes by Charles Elkan that go into this more deeply
decidability and completeness1
Decidability and Completeness
  • Refutation Completeness: If KB |= A then KB |- A
    • If it’s entailed, then there’s a proof
  • Semi-decidable:
    • If there’s a proof, we’ll halt with it.
    • If not, maybe halt, maybe not
  • Logical entailment in FOL is semi-decidable: if the desired conclusion follows from the premises, then eventually resolution refutation will find a contradiction
decidability and completeness2
Decidability and Completeness
  • Propositional logic
    • logical entailment is decidable
    • There exists a complete inference procedure
  • First-Order logic
    • logical entailment is semi-decidable
    • Resolution procedure is refutation complete
Strategies (heuristics) for efficient resolution include
    • Unit preference. If a clause has only one literal, use it first.
    • Set of support. Identify “useful” rules and ignore the rest. (p. 305)
    • Input resolution. Intermediately generated sentences can only be combined with original inputs or original rules.
    • Subsumption. Prune unnecessary facts from the database.