Inference in first-order logic

Artificial Intelligence 

Inference in first-order logic 

Inference in first-order logic – 1

Outline 

♦ Reducing first-order inference to propositional inference 

♦ Unification 

♦ Generalized Modus Ponens 

♦ Forward and backward chaining 

♦ Resolution 


Universal instantiation (UI) 

Every instantiation of a universally quantified sentence is entailed 

by it: 

∀v α 

SUBST({v/g},α) 

for any variable v and ground term g 

E.g., ∀x King(x) ∧ Greedy(x) → Evil(x) yields 

King(John) ∧ Greedy(John) → Evil(John) 

King(Richard) ∧ Greedy(Richard) → Evil(Richard) 

King(Father(John)) ∧ Greedy(Father(John)) 

→ Evil(Father(John)) 

. 


Existential instantiation (EI) 

For any sentence α, variable v, and constant symbol k not 

appearing in the knowledge base: 

k is called a Skolem constant 

∃v α 

SUBST({v/k},α) 

♦ E.g., ∃x Crown(x) ∧ OnHead(x,John) yields 

Crown(C 1 ) ∧ OnHead(C 1 ,John) 

provided C 1 is a new constant symbol 

♦ from ∃x d(x y )/dy =x y we obtain 

d(e y )/dy =e y 

provided e is a new constant symbol 


Existential instantiation contd. 

♦ UI can be applied several times to add new sentences; 

♦ the new KB is logically equivalent to the old 

♦ EI can be applied once to replace the existential sentence; 

♦ the new KB is not equivalent to the old, 

♦ but is satisfiable iff the old KB was satisfiable 


Existential instantiation contd. 

♦ UI can be applied several times to add new sentences; 

♦ the new KB is logically equivalent to the old 

♦ EI can be applied once to replace the existential sentence; 

♦ the new KB is not equivalent to the old, 

♦ but is satisfiable iff the old KB was satisfiable 

♦ trickier when ∃ in the scope of ∀ 

♦ e.g. “Every person has a heart” 

∀x(Person(x) → ∃yHas(x,y) ∧ Heart(y)) 

wrong: ∀x(Person(x) → Has(x,H 1 ) ∧ Heart(H 1 )) 

♦ we don’t share the same heart! 


Propositionalization 

Suppose the KB contains just the following: 

∀x King(x) ∧ Greedy(x) → Evil(x) 

King(John) 

Greedy(John) 

Brother(Richard,John) 

Instantiating the universal sentence in all possible ways, we have 




Greedy(John) 



Propositionalization 




Greedy(John) 


The new KB is propositionalized: proposition symbols are 

King(John), Greedy(John), Evil(John),King(Richard) etc. 


Problems with propositionalization 

♦ Propositionalization seems to generate lots of irrelevant 

sentences. 

E.g., from 

∀x King(x) ∧ Greedy(x) → Evil(x) 


∀y Greedy(y) 


♦ it seems obvious that Evil(John), but propositionalization 

produces lots of facts such as Greedy(Richard) that are 

irrelevant 

♦ With p k-ary predicates and n constants, there are p · n k 

instantiations 


Unification 

♦ looks for substitutions in a smarter way 

♦ e.g. θ = {x/John,y/John} makes King(x) and Greedy(x) 

match King(John) and ∀y Greedy(y) 

♦ in general: UNIFY(α,β) = θ if αθ =βθ 

α{x 1 /c 1 ,...,x n /c n } ≡ SUBST({x 1 /c 1 },α{x 2 /c 2 ,...,x n /c n }) 

α β θ 

Knows(John, x) Knows(John, Jane) 

Knows(John, x) Knows(y, OJ) 

Knows(John, x) Knows(y, Mother(y)) 

Knows(John, x) Knows(x, OJ) 


Unification 






α β θ 

Knows(John, x) Knows(John, Jane) {x/Jane} 

Knows(John, x) Knows(y, OJ) 




Unification 






α β θ 


Knows(John, x) Knows(y, OJ) {x/OJ, y/John} 




Unification 






α β θ 



Knows(John, x) Knows(y, Mother(y)) {y/John, x/Mother(John)} 



Unification 






α β θ 



Knows(John, x) Knows(y, Mother(y)) {y/John, x/Mother(John)} 

Knows(John, x) Knows(x, OJ) fail 

♦ Standardizing apart eliminates overlap of variables, e.g., 

Knows(z 17 ,OJ) 


Unification (contd.) 

♦ idea: Unify rule premises with known facts, apply unifier to 

conclusion 

♦ e.g. knowing β and assertion 

∀x Knows(John,x) → Likes(John,x) we can conclude 

♦ Likes(John,Jane) 

♦ Likes(John,OJ) 

♦ Likes(John,Mother(John)) 


Generalized Modus Ponens (GMP) 

p 1 ′ , p 2 ′ , ..., p n ′ , (p 1 ∧ p 2 ∧ ... ∧ p n → q) 

qθ 

where UNIFY(p i ′ ,p i ) =θ for all i 

p ′ 1 is King(John) 

p ′ 2 is Greedy(y) 

θ is {x/John,y/John} 

qθ is Evil(John) 

p 1 is King(x) 

p 2 is Greedy(x) 

q is Evil(x) 

♦ GMP used with KB of definite clauses (exactly one positive 

literal) 

♦ All variables assumed universally quantified 


Soundness of GMP 

♦ Need to show that 

p 1 ′ , ..., p n ′ , (p 1 ∧ ... ∧ p n → q) |= qθ 

provided that p i ′ θ =p i θ for all i 

♦ Lemma: For any definite clause p, we have p |= pθ by UI 

1. (p 1 ∧ ... ∧ p n → q) |= 

(p 1 ∧ ... ∧ p n → q)θ = (p 1 θ ∧ ... ∧ p n θ → qθ) 

2. p 1 ′ , ..., p n ′ |= p 1 ′ ∧ ... ∧ p n ′ |= p 1 ′ θ ∧ ... ∧ p n ′ θ 

3. From 1 and 2, qθ follows by ordinary Modus Ponens 


Forward chaining 

♦ When a new fact p is added to the KB 

♦ for each rule such that p unifies with a premise 

♦ if the other premises are known then add the conclusion to 

the KB and continue chaining 

♦ Forward chaining is data-driven 

E.g., inferring properties and categories from percepts 


¡ 

¢ 

¤ £ 

¤ 

¢ 

new 

Inference in first-order logic – 14 

Forward chaining algorithm 

false 

 

© 

¤¡¢ 

α 

§ 

¨KB 

¥¦ 

¢ 

FOL-FC-ASK 

 

¤ 

 

 

 

new ← { } 

¦ 

r 

¥ ¢ KB 

 

 

 

£ 

 

¦ 

 

r 

(p1 ∧ . . . ∧ pn → q) ← STANDARDIZE-APART 

© 

§ 

(p1 ∧ . . . ∧ pn)θ = (p 1 ′ ∧ . . . ∧ p n)θ 

′ 

p 1, ′ . . .,p n 

′ 

 

θ 

 

 

 

£ 

 

¦ 

 

¦ 

KB 

 

q 

© 

q ′ ← SUBST 

§ 

¨θ 

KB 

 

!" 

 

 

q ′ 

 

¥ 

 

 

new 

q ′ 

 

 

! 

α 

© 

§ 

¨q′ 

¤ 

¢ 

fail 

 

¥ 

¤¡¢ φ 

φ ← UNIFY 

φ 

new KB 

new 

false 

 

 

 

! 

" $ 

¤¡¢ 

¡ 

¤ ¢ 

¥ #

Properties of forward chaining 

♦ Sound and complete for first-order definite clauses 

(proof similar to propositional proof) 

♦ Datalog = first-order definite clauses and no functions 

♦ FC terminates for Datalog in poly iterations: at most p · n k 

literals 

♦ general case: may not terminate if α is not entailed 

♦ unavoidable: entailment with definite clauses (with 

functions) is semidecidable 


Efficiency of forward chaining 

♦ Simple observation: no need to match a rule on iteration k if 

a premise wasn’t added on iteration k − 1 

→ match each rule whose premise contains a newly added 

literal 

♦ Matching itself can be expensive 

♦ Database indexing allows O(1) retrieval of known facts 

♦ e.g., query Pig(x) retrieves Pig(babe) 

♦ Matching conjunctive premises against known facts is 

NP-hard 

♦ Forward chaining is widely used in deductive databases 


Backward chaining 

♦ When a query q is asked 

♦ if a matching fact q ′ is known, return the unifier 

♦ for each rule whose consequent q ′ matches q attempt to 

prove each premise of the rule by backward chaining 

♦ returns the unifiers (value for variables) 

♦ two versions: find any solution, find all solutions 


© 

¤¡¢ 

§ 

 

 

¥¦ 

¢ 

FOL-BC-ASK 

¡ 

¢ 

¤ £ 

¨ 

 

 

 

% 

" 

¤ 

© 

§ 

§ 

© 

§ 

& 

 

£ 

 

 

 

¦ 

 

! 

¦ 

§ 

! 

© 

§ 

© 

§ 

§ 

 

 

Backward chaining algorithm 

¨KB 

 

¨θ 

¨KB 

ans 

goals 

q ′ ← SUBST ¨θ FIRST goals 

r 

θ ′ ← UNIFY ¨q q ′ 

ans ← FOL-BC-ASK [p 1 , . . .,p n |REST 

 

 

 

{θ} 

" ¤¡¢ ¢ 

$ 

¥ 

¤ ¡¢ ans 

¥ ¢ KB 

" $ 

STANDARDIZE-APART 

© 

r 

goals 

'(p1 ∧ . . . ∧ pn → q) 

¨] 

COMPOSE 

¨θ′ 

θ 

∪ ans 

♦ KB is a list of (Horn) clauses 

♦ goals a list of conjuncts, the query 

♦ θ the current substitution, initially the empty substitution { } 

♦ SUBST(COMPOSE(θ 1 ,θ 2 ),p) = SUBST(θ 2 , SUBST(θ 1 ,p)) 


Properties of backward chaining 

♦ Depth-first recursive proof search: space is linear in size of 

proof 

♦ Incomplete due to infinite loops 

→ fix by checking current goal against every goal on stack 

♦ Inefficient due to repeated subgoals (both success and 

failure) 

→ fix using caching of previous results (extra space!) 

♦ widely used for logic programming; e.g., Prolog 


Completeness 

♦ procedure i is complete if and only if 

KB ⊢ i α whenever KB |= α 

♦ forward and backward chaining are complete for Horn KBs 

♦ but incomplete for general first-order logic 


Resolution: brief summary 

l 1 ∨ · · · ∨ l k , m 1 ∨ · · · ∨ m n 

(l 1 ∨ · · · ∨ l i−1 ∨ l i+1 ∨ · · · ∨ l k ∨ m 1 ∨ · · · ∨ m j−1 ∨ m j+1 ∨ · · · ∨ m n )θ 

where UNIFY(l i , ¬m j ) =θ 

♦ e.g., 

¬Rich(x) ∨ Unhappy(x) 

Rich(Ken) 

Unhappy(Ken) 

with θ = {x/Ken} 

♦ refutation: apply resolution steps to CNF(KB ∧ ¬α) 

♦ complete for FOL 


Conjunctive Normal Form (CNF) 

♦ literal: (possibly negated) atomic sentence, e.g., Rich(Ken) 

♦ clause: disjunction of literals, e.g., 

¬Rich(x) ∨ Unhappy(x) 

♦ KB is a set of clauses (conjunction) 

♦ variables are universally quantified 


Conversion to CNF 

Everyone who loves all animals is loved by someone: 

∀x (∀y Animal(y) → Loves(x,y)) → (∃y Loves(y,x)) 

1. Eliminate biconditionals and implications: p → q ≡ ¬p ∨ q 

∀x (¬∀y ¬Animal(y) ∨ Loves(x,y)) ∨ (∃y Loves(y,x)) 

2. Move ¬ inwards: ¬∀x p ≡ ∃x ¬p, ¬∃x p ≡ ∀x ¬p: 

∀x (∃y ¬(¬Animal(y) ∨ Loves(x,y))) ∨ (∃y Loves(y,x)) 

∀x (∃y ¬¬Animal(y) ∧ ¬Loves(x,y)) ∨ (∃y Loves(y,x)) 

∀x (∃y Animal(y) ∧ ¬Loves(x,y)) ∨ (∃y Loves(y,x)) 


Conversion to CNF contd. 

4. standardize variables: each quantifier should use a different 

one 

∀x (∃y Animal(y) ∧ ¬Loves(x,y)) ∨ (∃z Loves(z,x)) 

5. skolemization (general form of EI): Each existential variable is 

replaced by a Skolem function of the enclosing universally 

quantified variables 

∀x (Animal(F(x)) ∧ ¬Loves(x,F(x))) ∨ Loves(G(x),x) 

6. drop universal quantifiers (variables are UQ) 

(Animal(F(x)) ∧ ¬Loves(x,F(x))) ∨ Loves(G(x),x) 

7. distribute ∧ over ∨: 

(Animal(F(x)) ∨ Loves(G(x),x))∧ 

(¬Loves(x,F(x)) ∨ Loves(G(x),x))

Inference in first-order logic

Create successful ePaper yourself

Delete template?

Save as template?