First-Order Deduction

•Want to be able to draw logically sound conclusions from a

knowledge-base expressed in first-order logic.

•Several styles of inference:

-Forward chaining
-Backward chaining
-Resolution refutation
Inference in First-Order Logic
•Properties of inference procedures:
-Soundness: If A |− B then A |= B
-Completeness: If A |= B then A |− B

•Forward and backward chaining are sound and can be

reasonably efficient but are incomplete.

•Resolution is sound and complete for FOPC but can be

very inefficient.

1 2

Inference Rules for Quantifiers Sample Proof

•Let SUBST(θ, α) denote the result of applying a substitution 1) ∀x,y(Parent(x,y) ∧ Male(x) ⇒ Father(x,y))
or binding list θ to the sentence α. 2) Parent(Tom,John)
-SUBST({x/Tom, y,/Fred}, Uncle(x,y)) = Uncle(Tom, Fred) 3) Male(Tom)

Using Universal Elimination from 1)

•Inference rules
4) ∀y(Parent(Tom,y) ∧ Male(Tom) ⇒ Father(Tom,y))
-Universal Elimination: ∀v α |− SUBST({v/g},α)
for any sentence, α, variable, v, and ground term, g
Using Universal Elimination from 4)
∀x Loves(x, FOPC) |− Loves(Ray, FOPC)
5) Parent(Tom,John) ∧ Male(Tom) ⇒Father(Tom,John)
-Existential Elimination: ∃v α |− SUBST({v/k},α)
for any sentence, α, variable, v, and constant symbol, k, Using And Introduction from 2) and 3)
that doesn’t occur elsewhere in the KB (Skolem
constant) 6) Parent(Tom,John) ∧ Male(Tom)

∃x (Owns(Mary,x) ∧ Cat(x)) |− Owns(Mary,MarysCat) ∧

Using Modes Ponens from 5) and 6)
Cat(MarysCat)
7) Father(Tom,John)
-Existential Introduction: α |- ∃v SUBST({g/v},α)
for any sentence, α, variable, v, that does not occur in α,
and ground term, g, that does occur in α

Loves(Ray, FOPC) |− ∃x Loves(x, FOPC)

3 4
 Generalized Modus Ponens Canonical Form
•In order to utilize generalized Modus Ponens, all sentences
•Combines three steps of “natural deduction” (Universal in the KB must be in the form of Horn sentences:
Elimination, And Introduction, Modus Ponens) into one.
∀v1,v2,...vn p1 ∧ p2 ∧...∧pm ⇒ q

•Provides direction and simplification to the proof process for

standard inferences. •Also called Horn clauses, where a clause is a disjunction
of literals, because they can be rewritten as disjunctions
with at most one non-negated literal.
•Generalized Modus Ponens:
p1´, p2´, ...pn´, (p1 ∧ p2 ∧...∧pn ⇒ q) |− SUBST(θ,q) ∀v1,v2,...vn ¬p1 ∨ ¬p2∨ ... ∨ ¬ pn ∨ q

where θ is a substitution such that for all i If θ is the constant False, this simplifies to
SUBST(θ,pi´)=SUBST(θ,pi)
∀v1,v2,...vn ¬p1 ∨ ¬p2∨ ... ∨ ¬ pn

•1) ∀x,y(Parent(x,y) ∧ Male(x) ⇒ Father(x,y)) Otherwise the sentence is called a definite clause (exactly
2) Parent(Tom,John) one non-negated literal).
3) Male(Tom)
Single positive literals (facts) are Horn clauses with no
θ={x/Tom, y/John) antecedent.

4) Father(Tom,John) •Quantifiers can be dropped since all variables can be

assumed to be universally quantified by default.

•Many statements can be transformed into Horn clauses, but

many cannot (e.g. P(x)∨Q(x), ¬P(x))

5 6

Unification Unification
(cont.)
•In order to match antecedents to existing literals in the KB, •Exact variable names used in sentences in the KB should not
need a pattern matching routine. matter.

•UNIFY(p,q) takes two atomic sentences and returns a •But if Likes(x,FOPC) is a formula in the KB, it does not unify
substitution that makes them equivalent. with Likes(John,x) but does unify with Likes(John,y).

UNIFY(p,q)=θ where SUBST(θ,p)=SUBST(θ,q)

•To avoid such conflicts, one can standardize apart one of the
θ is called a unifier. arguments to UNIFY to make its variables unique by
renaming them.

•Examples Likes(x,FOPC) -> Likes(x1, FOPC)

UNIFY(Likes(John,x),Likes(x1,FOPC)) = {x1/John, x/FOPC}
UNIFY(Parent(x,y), Parent(Tom, John)) = {x/Tom, y/John}

UNIFY(Parent(Tom,x), Parent(Tom, John)) = {x/John}) •There are many possible unifiers for some atomic sentences.
UNIFY(Likes(x,y), Likes(z,FOPC)) = {x/z, y/FOPC} UNIFY(Likes(x,y),Likes(z,FOPC)) = {x/z, y/FOPC}
{x/John, z/John, y/FOPC}
UNIFY(Likes(Tom,y), Likes(z,FOPC)) = {z/Tom, y/FOPC} {x/Fred, z/Fred, y/FOPC}
......
UNIFY(Likes(Tom,y), Likes(y,FOPC)) = fail UNIFY should return the most general unifier which makes
the least commitment to variable values.
UNIFY(Likes(Tom,Tom), Likes(x,x)) = {x/Tom}

UNIFY(Likes(Tom,Fred), Likes(x,x)) = fail

7 8
 Forward Chaining Forward Chaining Algorithm

•Use modus ponens to always deriving all consequences •A sentence is a renaming of another if it is the same except for a
from new information. renaming of the variables.

•Inferences cascade to draw deeper and deeper

conclusions •The composition of two substitutions combines the variable
bindings of both such that:

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

procedure FORWARD-CHAIN(KB, p)

if there is a sentence in KB that is a renaming of p then return

•To avoid looping and duplicated effort, must prevent
^ ^ )
Add p to KB
addition of a sentence to the KB which is the same as one for each ( p1 . . . pn q) in KB such that for some i, UNIFY( pi , p) =  succeeds do
already present. FIND-AND-INFER(KB, [p1 , . . . , pi 1 , pi+1 , . . . , pn ], q, )
end

procedure FIND-AND-INFER(KB, premises, conclusion, )

•Must determine all ways in which a rule (Horn clause) can
match existing facts to draw new conclusions. if premises = [ ] then
FORWARD-CHAIN(KB, SUBST(, conclusion))
else for each p0 in KB such that UNIFY( p0 , SUBST(, FIRST( premises))) = 2 do
FIND-AND-INFER(KB, REST( premises), conclusion, COMPOSE(, 2 ))
end

9 10

Forward Chaining Example

Problems with Forward Chaining
Assume in KB
1) Parent(x,y) ∧ Male(x) ⇒ Father(x,y)
2) Father(x,y) ∧ Father(x,z) ⇒ Sibling(y,z) •Inference can explode forward and may never terminate.
Add to KB Even(x) ⇒ Even(plus(x,2))
3) Parent(Tom,John) Integer(x) ⇒ Even(times(2,x))
Even(x) ⇒ Integer(x)
Rule 1) tried but can’t “fire” Even(2)
Add to KB 14 28
12 26
4) Male(Tom) 24 48
6
Rule 1) now satisfied and triggered and adds: 22
2 4 10 20
5) Father(Tom, John) 40
8
16 18 36
Rule 2) now triggered and adds: 34
6) Sibling(John, John) {x/Tom, y/John, z/John} 32 64
Add to KB
7) Parent(Tom,Fred)
•Inference is not directed towards any particular conclusion
Rule 1) triggered again and adds: or goal. May draw lots of irrelevant conclusions.
8) Father(Tom,Fred)
Rule 2) triggered again and adds:
9) Sibling(Fred,Fred) {x/Tom, y/Fred, z/Fred}
Rule 2) triggered again and adds:
10) Sibling(John, Fred) {x/Tom, y/John, z/Fred}
Rule 2) triggered again and adds:
11) Sibling(Fred, John) {x/Tom, y/Fred, z/John}
11 12
 Backward Chaining Backward Chaining Algorithm

•Start from query or atomic sentence to be proven and look •Given a conjunction of queries, first get all possible answers to
for ways to prove it. the first conjunct and then for each resulting substitution try to
prove all of the remaining conjuncts.

•Query can contain variables which are assumed to be •Assume variables in rules are renamed (standardized apart)
existentially quantified. before each use of a rule.

Sibling(x,John) ?
Father(x,y) ? function BACK-CHAIN(KB, q) returns a set of substitutions

Inference process should return all sets of variable bindings BACK-CHAIN-LIST(KB, [q], fg)
that satisfy the query. function BACK-CHAIN-LIST(KB, qlist, ) returns a set of substitutions
inputs: KB, a knowledge base
qlist, a list of conjuncts forming a query ( already applied)
, the current substitution
•First try to answer query by unifying it to all possible facts in static: answers, a set of substitutions, initially empty
the KB.
if qlist is empty then return  fg
q FIRST(qlist)
for each q0i in KB such that i UNIFY(q, q0i ) succeeds do
•Next try to prove it using a rule whose consequent unifies Add COMPOSE(, i ) to answers

^ ^ )
with the query and then try to recursively prove all of it’s end
q0i ) in KB such that i UNIFY(q, q0i ) succeeds do
[
for each sentence ( p1 ... pn
antecedents. answers BACK-CHAIN-LIST(KB, SUBST(i , [ p1 . . . pn ]), COMPOSE(, i )) answers

2
end
return the union of BACK-CHAIN-LIST(KB, REST(qlist), ) for each  answers

13 14

Backchaining Examples
Backchaining Examples (cont)
KB: Query: Father(f,s)
1) Parent(x,y) ∧ Male(x) ⇒ Father(x,y) Subgoal: Parent(f,s) ∧ Male(f)
2) Father(x,y) ∧ Father(x,z) ⇒ Sibling(y,z) {f/Tom, s/John}
3) Parent(Tom,John) Subgoal: Male(Tom)
4) Male(Tom) Answer: {f/Tom, s/John}
7) Parent(Tom,Fred) {f/Tom, s/Fred}
Subgoal: Male(Tom)
Answer: {f/Tom, s/Fred}
Query: Parent(Tom,x) Answers: ({f/Tom,s/John}, {f/Tom,s/Fred})
Answers: ( {x/John}, {x/Fred})
Query: Sibling(a,b)
Subgoal: Father(f,a) ∧ Father(f,b)
{f/Tom, a/John}
Query: Father(Tom,s) Subgoal: Father(Tom,b)
Subgoal: Parent(Tom,s) ∧ Male(Tom) {b/John}
{s/John} Answer: {f/Tom, a/John, b/John}
Subgoal: Male(Tom) {b/Fred}
Answer: {s/John} Answer: {f/Tom, a/John, b/Fred}
{s/Fred} {f/Tom, a/Fred}
Subgoal: Male(Tom) Subgoal: Father(Tom,b)
Answer: {s/Fred} {b/John}
Answers: ({s/John}, {s/Fred}) Answer: {f/Tom, a/Fred, b/John}
{b/Fred}
Answer: {f/Tom, a/Fred, b/Fred}
Answers: ({f/Tom, a/John, b/John},{f/Tom, a/John, b/Fred}
{f/Tom, a/Fred, b/John}, {f/Tom, a/Fred, b/Fred})

15 16
 Incompleteness Completeness

•Rule-based inference is not complete, but is reasonably •In 1930 GÖdel showed that a complete inference
efficient and useful in many circumstances. procedure for FOPC existed, but did not demonstrate one
(non-constructive proof).

•Still can be exponential or not terminate in worst case.

•In 1965, Robinson showed a resolution inference
procedure that was sound and complete for FOPC.
•Incompleteness example:
P(x) ⇒ Q(x) •However, the procedure may not halt if asked to prove a
¬P(x) ⇒ R(x) (not Horn) thoerem that is not true, it is said to be semidecidable
Q(x) ⇒ S(x) (a type of undecidability).
R(x) ⇒ S(x)
If a conclusion C is entailed by the KB then the procedure
Entails S(A) for any constant A but not inferable from modus will eventually terminate with a proof. However if it is not
ponens entailed, it may never halt.

•It does not follow that either C or ¬C is entailed by a KB

(may be independent). Therefore trying to prove both
a conjecture and its negation does not help.

•Inconsistency of a KB is also semidecidable.

17 18

Resolution Conjunctive Normal Form

(CNF)
•Propositional version. •For resolution to apply, all sentences must be in
conjunctive normal form, a conjunction of disjunctions of
{α ∨ β, ¬β ∨ γ} |− α ∨ γ OR {¬α⇒ β, β ⇒ γ} |− ¬α ⇒ γ literals

Reasoning by cases OR transitivity of implication (a1 ∨ ...∨ am) ∧

(b1 ∨ ... ∨ bn) ∧
..... ∧
•First-order form (x1 ∨ ... ∨ xv)

For two literals pj and qk in two clauses

•Representable by a set of clauses (disjunctions of literals)
p1 ∨ ... pj ... ∨ pm
q1 ∨ ... qk ... ∨ qn
•Also representable as a set of implications (INF).
such that θ=UNIFY(pj, ¬qk), derive

SUBST(θ, p1 ∨...pj-1∨pj+1...∨pm ∨ q1∨... qk-1∨qk+1 ... ∨qn) •Example

Initial CNF INF
•Can also be viewed in implicational form where all negated P(x) ⇒ Q(x) ¬P(x) ∨ Q(x) P(x) ⇒ Q(x)
literals are in a conjunctive antecedent and all positive ¬P(x) ⇒ R(x) P(x) ∨ R(x) True ⇒ P(x) ∨R(x)
literals in a disjunctive conclusion. Q(x) ⇒ S(x) ¬Q(x) ∨ S(x) Q(x) ⇒ S(x)
R(x) ⇒ S(x) ¬R(x) ∨ S(x) R(x) ⇒ S(x)
¬p1 ∨ ...∨ ¬pm ∨ q1 ∨ ...∨ qn ⇔

p1∧... ∧ pm ⇒ q1 ∨ ...∨ qn

19 20
 Resolution Proofs Refutation Proofs

•INF (CNF) is more expressive than Horn clauses. •Unfortunately, resolution proofs in this form are still
incomplete.

•Resolution is simply a generalization of modus ponens. •For example, it cannot prove any tautology (e.g. P∨¬P)
from the empty KB since there are no clauses to resolve.

•As with modus ponens, chains of resolution steps can be •Therefore, use proof by contradiction (refutation,
used to construct proofs. reductio ad absurdum). Assume the negation of the
theorem P and try to derive a contradiction (False, the
empty clause).
P(w) => Q(w) Q(y) => S(y)
(KB ∧ ¬P ⇒ False) ⇔ KB ⇒ P
{y/w}

P(w) => S(w) True => P(x) R(x) P(w) => Q(w) Q(y) => S(y)
>

{y/w}
{w/x}
P(w) => S(w) True => P(x) R(x)

>
True => S(x) R(x) R(z) => S(z)
>

{w/x}
{x/A, z/A}
True => S(x) R(x) R(z) => S(z)

>
True => S(A) {z/x}

True => S(x) S(A) => False

•Factoring removes redundant literals from clauses {x/A}

S(A) ∨ S(A) −> S(A) True => False

21 22

Resolution Theorem Proving Conversion to Clausal Form

•Eliminate implications and biconditionals by rewriting

•Convert sentences in the KB to CNF (clausal form) them.

p ⇒ q −> ¬p ∨ q p ⇔ q -> (¬p ∨ q) ∧ (p ∨ ¬q)

•Take the negation of the poposed theorem (query), convert

it to CNF, and add it to the KB. •Move ¬ inward to only be a part of literals by using
deMorgan’s laws and quantifier rules.
-¬(p ∨ q) −> ¬p ∧ ¬q
•Repeatedly apply the resolution rule to derive new clauses. -¬(p ∧ q) −> ¬p ∨¬q
-¬∀x p −> ∃x ¬p
-¬∃x p −> ∀x ¬p
•If the empty clause (False) is eventually derived, stop and -¬¬p −> p
conclude that the proposed theorem is true.

•Standardize variables to avoid use of the same variable

name by two different quantifiers.

∀x P(x) ∨ ∃x P(x) −> ∀x1 P(x1) ∨ ∃x2 P(x2)

•Move quantifiers left while maintaining order. Renaming

above guarantees this is a truth-preserving transformation.

∀x1 P(x1) ∨ ∃x2 P(x2) −> ∀x1∃x2 (P(x1) ∨ P(x2))

23 24
 Conversion to Clausal Form Conversion to Clausal Form
(cont) (cont)

•Skolemize: Remove existential quantifiers by replacing •Distribute ∧ over ∨ to convert to conjunctions of clauses
each existentially quantified variable with a Skolem
constant or Skolem function as appropriate. (a ∧ b) ∨ c −> (a ∨ c) ∧ (b ∨ c)
(a ∧ b) ∨ (c ∧ d) −> (a ∨ c) ∧ (b ∨ c) ∧ (a ∨ d) ∧ (b ∨ d)
-If an existential variable is not within the scope of any
universally quantified variable, then replace every
Can exponentially expand size of sentence.
instance of the variable with the same unique constant
that does not appear anywhere else.

∃x (P(x) ∧ Q(x)) −> P(C1) ∧ Q(C1)

•Flatten nested conjunctions and disjunctions to get
final CNF

-If it is within the scope of n universally quantified (a ∨ b) ∨ c −> (a ∨ b ∨ c)

variables, then replace it with a unique n-ary function over (a ∧ b) ∧ c −> (a ∧ b ∧ c)
these universally quantified variables.

∀x1∃x2 (P(x1) ∨ P(x2)) −> ∀x1(P(x1) ∨ P(f1(x1))) •Convert clauses to implications if desired for readability
∀x(Person(x) ⇒ ∃y(Heart(y) ∧ Has(x,y))) −> (¬a ∨ ¬b ∨ c ∨ d) −> a ∧ b ⇒ c ∨ d
∀x(Person(x) ⇒ Heart(HeartOf(x)) ∧
Has(x,HeartOf(x)))

-Afterwards, all variables can be assumed to be

universally quantified, so remove all quantifiers.

25 26

Sample Clausal Conversion Sample Resolution Proof

∀x((Prof(x) ∨ Student(x)) ⇒ (∃y(Class(y) ∧ Has(x,y)) ∧ •Jack owns a dog.

∃y(Book(y) ∧ Has(x,y)))) Every dog owner is an animal lover.
No animal lover kills an animal.
∀x(¬(Prof(x) ∨ Student(x)) ∨ (∃y(Class(y) ∧ Has(x,y)) ∧ Either Jack or Curiosity killed Tuna the cat.
∃y(Book(y) ∧ Has(x,y)))) Did Curiosity kill the cat?
∀x((¬Prof(x) ∧ ¬Student(x)) ∨ (∃y(Class(y) ∧ Has(x,y)) ∧
∃y(Book(y) ∧ Has(x,y)))) •A) ∃x Dog(x) ∧ Owns(Jack,x)
B) ∀x (∃y Dog(y) ∧ Owns(x,y)) ⇒ AnimalLover(x))
∀x((¬Prof(x) ∧ ¬Student(x)) ∨ (∃y(Class(y) ∧ Has(x,y)) ∧
C) ∀x AnimalLover(x) ⇒ (∀y Animal(y) ⇒ ¬Kills(x,y))
∃z(Book(z) ∧ Has(x,z)))) D) Kills(Jack,Tuna) ∨ Kills(Cursiosity,Tuna)
∀x∃y∃z((¬Prof(x)∧¬Student(x))∨ ((Class(y) ∧ Has(x,y)) ∧ E) Cat(Tuna)
(Book(z) ∧ Has(x,z)))) F) ∀x(Cat(x) ⇒ Animal(x))

(¬Prof(x)∧¬Student(x))∨ (Class(f(x)) ∧ Has(x,f(x)) ∧ Query: Kills(Curiosity,Tuna)

Book(g(x)) ∧ Has(x,g(x))))
(¬Prof(x) ∨ Class(f(x))) ∧ •A1) Dog(D)
(¬Prof(x) ∨ Has(x,f(x))) ∧ A2) Owns(Jack,D)
(¬Prof(x) ∨ Book(g(x))) ∧ B) Dog(y) ∧ Owns(x,y) ⇒ AnimalLover(x)
(¬Prof(x) ∨ Has(x,g(x))) ∧ C) AnimalLover(x) ∧ Animal(y) ∧ Kills(x,y) ⇒ False
(¬Student(x) ∨ Class(f(x))) ∧ D) Kills(Jack,Tuna) ∨ Kills(Curiosity,Tuna)
(¬Student(x) ∨ Has(x,f(x))) ∧ E) Cat(Tuna)
F) Cat(x) ⇒ Animal(x)
(¬Student(x) ∨ Book(g(x))) ∧
(¬Student(x) ∨ Has(x,g(x)))) Query: Kills(Curiosity,Tuna) ⇒ False

27 28
 Resolution Proof Answer Extraction

•If the query contains existentially quantified variables, these

become universally quantified in the negation.
Owns(x,y) => AnimalLover(x) Kills(x,y) => False
Dog(D) Dog(y) AnimalLover(x) Animal(y)
∃w Kills(w,Tuna) −> Kills(w,Tuna) ⇒ False
>

>

>
{y/D}

Owns(x,D) => AnimalLover(x) Owns(Jack,D) Cat(Tuna) Cat(x) => Animal(x)

{x/Jack} {x/Tuna} •If you compose the substitutions from all unifications made
AnimalLover(Jack) Animal(Tuna)
in the course of a proof, you obtain an answer substitution
{y/Tuna} that gives a binding for the query variables.
Kills(Jack,Tuna} Kills(Curiosity,Tuna) AnimalLover(x) Kills(x,Tuna) => False

>
>

{x/Jack}
•To find all answers, must find all distinct resolution proofs
Kills(Curiosity,Tuna) => False Kills(Jack,Tuna) => False since each one may provide a different answer.
{}

Kills(Jack,Tuna)

{}

False

29 30

Resolution Strategies Resolution Strategies

(cont)
•Need heuristics and strategies to decide what resolutions to
make in order to control the search for a proof. •Linear Resolution: Generalization of input resolution.
Allow resolutions of clauses P and Q if P is in the input or is
an ancestor of Q in the proof tree.
•Unit preference: Prefer to make resolutions with single
literals (facts, unit clauses) since this generates a shorter
clause and the goal is to derive the empty clause. •Subsumption: Clauses that are more specific than other
clauses should be eliminated as redundant. Such clauses
P + ¬P ∨ Q1∨...∨ Qn −> Q1∨...∨ Qn are said to be subsumed.

P(x) subsumes P(A)

•Set of Support: Always resolve with a clause from the P subsumes P∨Q
query or a clause previously generated from such a P(x,y) subsumes P(z,z) ∨ Q(y)
resolution. Directs search towards answering the query
rather than deducing arbitrary consequences of the KB. Clause A subsumes clause B is there exists a substitution
Assuming the original KB is consistent, this strategy is θ such that the literals in SUBST(θ,A) are a subset of the
complete. literals in B.

•Input Resolution: One of the resolving clauses should

always be from the input (i.e. from the KB or the negated
query). Complete for Horn clauses but not in general.

31 32
 GÖdel’s Incompleteness Theorem Logicist Program

•If FOPC is extended to allow for the use of mathematical •Encode general knowledge about the world and/or any
induction for showing that statements are true for all natural given domain as a set of sentences in first-order logic.
numbers, there are true statements that can never be
proven.
•Use general logical inference to solve problems and answer
questions.
•The logical theory of numbers starts with a single constant
0, the function S (successor) for generating the natural
numbers, and axioms defining functions for multiplication, •Focus on epistemological problems of what and how to
addition, and exponentiation. represent knowledge rather than the heuristic problems of
how to efficiently conduct search.

•Proof relies on producing a unique number for each

sentence in the logic (GÖdel number) and constructing a •Problems with the logicist program:
sentence whose number is n which states “Sentence
number n is not provable.”
-Knowledge representation problem
-Knowledge acquisition problem
•If this sentence is provable from the axioms, then it is a -Intractable search problem
false statement which is provable and therefore the axioms
are inconsistent.

•If this sentence is not provable from the axioms, then it is a

true statement which is not provable and inference is
incomplete.

33 34