1

First Order Logic

Artificial Intelligence

Slides are mostly adapted from AIMA and MIT Open Courseware,
and Milos Hauskrecht (U. Pittsburgh)

CS461 Artificial Intelligence © Pinar Spring

 2

Pros and cons of propositional logic

☺ Propositional logic is declarative
☺ Propositional logic allows partial/disjunctive/negated
information
– (unlike most data structures and databases)
☺ Propositional logic is compositional:
– meaning of B1,1  P1,2 is derived from meaning of B1,1 and of P1,2
☺ Meaning in propositional logic is context-independent
– (unlike natural language, where meaning depends on context)
 Propositional logic has very limited expressive power
– (unlike natural language)
– E.g., cannot say "pits cause breezes in adjacent squares“
• except by writing one sentence for each square
 3

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 4

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 5

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 6

First Order Logic

 7

First-order logic
• First-order logic (like natural language) assumes the
world contains
– Objects: people, houses, numbers, colors, baseball games,
wars, …
– Relations: red, round, prime, brother of, bigger than, part
of, comes between, …
– Functions: father of, best friend, one more than, plus,
• (relations in which there is only one value for a given input)
 8

FOL Motivation
 9

Syntax of FOL: Basic elements

• Constants : KingJohn, 2, ...

• Predicates: Brother, >,...
• Functions : Sqrt, LeftLegOf,...
• Variables x, y, a, b,...
• Connectives , , , , 
• Equality =
• Quantifiers , 
 10

Atomic sentences

Term = function (term1,...,termn)

or constant
or variable

Atomic sentence = predicate (term1,...,termn)

or term1 = term2

• E.g., Brother(KingJohn,RichardTheLionheart)
• > (Length(LeftLegOf(Richard)), Length(LeftLegOf(KingJohn)))
 11

Complex sentences

Complex sentences are made from atomic sentences using

connectives
S, S1  S2, S1  S2, S1  S2, S1  S2,

E.g.
Sibling(KingJohn,Richard)  Sibling(Richard,KingJohn)
>(1,2)  ≤ (1,2)
>(1,2)   >(1,2)
 12

Quantifiers
Universal quantification,  (pronounced as “For all”)
 x Cat(x)  Mammal(x)
All cats are mammals

Existential quantification,  (pronounced as “There exists”)

 x Sister (x, Spot)  Cat(x)
Spot has a sister who is a cat

• x P is true in a model m
iff P is true with x being each possible object in the model
• x P is true in a model m
iff P is true with x being some possible object in the model
 13

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 14

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 15

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 16

Slide credit : HarvardX CS50AICS50's Introduction to Artificial Intelligence with Python,

David J. Malan and Brian Yu
 17

Truth in first-order logic

• Sentences are true with respect to a model and an interpretation

• Model contains objects (domain elements) and relations among them

• An atomic sentence predicate(term1,...,termn) is true

iff the objects referred to by term1,...,termn
are in the relation referred to by predicate

• Interpretation specifies referents for

constant symbols → objects
predicate symbols → relations
function symbols → functional relations
 18

Interpretation
 19

Models for FOL: Example

 20

Semantics
 21

Semantics
 22

Universal quantification
 <variables> <sentence>

All Kings are persons:

x King(x)  Person(x)

x P is true in a model m
iff P is true with x being each possible object in the model

Roughly speaking, equivalent to the conjunction of instantiations of P

Richard the Lionheart is a king  Richard the Lionheart is a person
 King John is a king  King John is a person
 Richard’s left leg is a king  Richard’s left leg is a person
 John’s left leg is a king  John’s left leg is a person
 The crown is a king  The crown is a person
 23

A common mistake to avoid

• Typically,  is the main connective with 

x King(x)  Person(x)

• Common mistake: using  as the main connective with :

x King(x)  Person(x)
means “Everyone is a king and everyone is a person”
Richard the Lionheart is a king  Richard the Lionheart is a person
 King John is a king  King John is a person
 Richard’s left leg is a king  Richard’s left leg is a person
 John’s left leg is a king  John’s left leg is a person
 The crown is a king  The crown is a person
 24

Existential quantification
<variables> <sentence>
x Crown(x)  OnHead(x,John)

x P is true in a model m
iff P is true with x being some possible object in the model

Roughly speaking, equivalent to the disjunction of

instantiations of P
The crown is a crown  the crown is on John’s head
 Richard the Lionheart is a crown  Richard the Lionheart is on John’s head
 King John is a crown  King John is on John’s head
 ...
 25

Another common mistake to avoid

• Typically,  is the main connective with 

• x Crown(x)  OnHead(x,John)

• Common mistake: using  as the main connective with :

x Crown(x)  OnHead(x,John)
is true even if there is anything which is not a crown

The crown is a crown  the crown is on John’s head

 Richard the Lionheart is a crown  Richard the Lionheart is on John’s head
 King John is a crown  King John is on John’s head
 26

Properties of quantifiers
x y is the same as y x, and can be written as x,y
x y is the same as y x , and can be written as x,y

x y is not the same as y x

y x Loves(x,y)
– “Everyone in the world is loved by at least one person”
x y Loves(x,y)
– “There is a person who loves everyone in the world”

x y P(x,y) : every object in the universe has a particular property, given by P

x y P(x,y) : there is some object in the world that has a particular property

Rule: the variable belongs to the innermost quantifier that mentions it

x [Cat(x) V (x Brother(Richard,x))]
x [Cat(x) V (z Brother(Richard,z))]
 27

Properties of quantifiers

• Quantifier duality: each can be expressed using the other

x Likes(x,Broccoli) = x Likes(x,Broccoli)

x Likes(x,IceCream) = x Likes(x,IceCream)

• De Morgan’s rules for quantifiers:

x P = x P
 x P = x  P
x P = x  P
 x P = x P
 28

Equality

• term1 = term2 is true under a given interpretation if

and only if term1 and term2 refer to the same object

• E.g., definition of Sibling in terms of Parent:

x,y Sibling(x,y)  [(x = y)  m,f  (m = f) 
Parent(m,x)  Parent(f,x)  Parent(m,y)  Parent(f,y)]
 29

Writing FOL

There is somebody who is loved by everybody

 30

Writing FOL
 31

Using FOL
The kinship domain:
• Brothers are siblings
x,y Brother(x,y)  Sibling(x,y)
• One's mother is one's female parent
m,c Mother(c) = m  (Female(m)  Parent(m,c))
• “Sibling” is symmetric
x,y Sibling(x,y)  Sibling(y,x)
• One's husband is one's male spouse
w,h Husband(h,w)  (Male(m)  Spouse(h,w))
• Sibling is another child of one’s parents
x,y Sibling(x,y)  [(x = y)  m,f  (m = f)  Parent(m,x) 
Parent(f,x)  Parent(m,y)  Parent(f,y)]
 32

Inference in
First Order Logic
Artificial Intelligence

Slides are mostly adapted from AIMA and MIT Open Courseware,
Milos Hauskrecht (U. Pittsburgh)
and Max Welling (UC Irvine)
 33

Logical Inference
 34

Inference in Propositional Logic

 35

Inference in FOL : Truth Table Approach

 37

Inference Rules
 38

Sentences with variables

 39

Sentences with variables

 40

Variable Substitutions

θ= SUBST(θ, α)
 41

Universal elimination
• 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), {x/John}
King(Richard)  Greedy(Richard)  Evil(Richard), {x/Richard}
King(Father(John))  Greedy(Father(John))  Evil(Father(John)),
{x/Father(John)}

.
.

{x/Ben}
 42

Existential elimination

• For any sentence α, variable v, and constant symbol k that does not
appear elsewhere in the knowledge base:
v α
Subst({v/k}, α)

• E.g., x Crown(x)  OnHead(x,John) yields:

Crown(C1)  OnHead(C1,John)

provided C1 is a new constant symbol, called a Skolem constant

 43

Inference rules for quantifiers

α
v Subst({g/v}, α)
 44

Example Proof

• The law says that it is a crime for an American to sell weapons to

hostile nations. The country Nono, an enemy of America, has some
missiles, and all of its missiles were sold to it by Colonel West, who is
American.

• Prove that Col. West is a criminal

 45

Example knowledge base contd.

... it is a crime for an American to sell weapons to hostile nations:

x,y,z American(x)  Weapon(y)  Sells(x,y,z)  Nation(z)  Hostile(z)  Criminal(x)
Nono … has some missiles, i.e.,
x Owns(Nono,x)  Missile(x):
… all of its missiles were sold to it by Colonel West
x Missile(x)  Owns(Nono,x)  Sells(West,x,Nono)
Missiles are weapons:
 x Missile(x)  Weapon(x)
An enemy of America counts as "hostile“:
x Enemy(x,America)  Hostile(x)
West, who is American …
American(West)
The country Nono
Nation(Nono)
Nono, an enemy of America …
Enemy(Nono,America), Nation(America)
 46

Example knowledge base contd.

1.  x,y,z American(x)  Weapon(y)  Sells(x,y,z)  Nation(z)  Hostile(z)  Criminal(x)
2. x Owns(Nono,x)  Missile(x):
3. x Missile(x)  Owns(Nono,x)  Sells(West,x,Nono)
4.  x Missile(x)  Weapon(x)
5. x Enemy(x,America)  Hostile(x)
6. American(West)
7. Nation(Nono)
8. Enemy(Nono,America)
9. Nation(America)
10. Owns(Nono,M1) and Missile(M1) Existential elimination 2
11. Owns(Nono,M1) And elimination 10
12. Missile(M1) And elimination 10
13. Missile(M1)  Weapon(M1) Universal elimination 4
14. Weapon(M1) Modus Ponens, 12, 13
15. Missile(M1)  Owns(Nono,M1)  Sells(West,M1,Nono) Universal Elimination 3
16. Sells(West,M1,Nono) Modus Ponens 10,15
17. American(West)  Weapon(M1)  Sells(West,M1,Nono)  Nation(Nono)  Hostile(Nono)  Criminal(Nono) Universal
elimination, three times 1
18. Enemy(Nono,America)  Hostile(Nono) Universal Elimination 5
19. Hostile(Nono) Modus Ponens 8, 18
20. American(West)  Weapon(M1)  Sells(West,M1,Nono)  Nation(Nono)  Hostile(Nono) And Introduction 6,7,14,16,19
21. Criminal(West) Modus Ponens 17, 20
 48

Reduction to propositional inference

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 (there are only two ground
terms: John and Richard) , we have:
King(John)  Greedy(John)  Evil(John)
King(Richard)  Greedy(Richard)  Evil(Richard)
King(John)
Greedy(John)
Brother(Richard,John)

• The new KB is propositionalized: proposition symbols are

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

 49

Reduction contd.
• Every FOL KB can be propositionalized so as to preserve
entailment
– A ground sentence is entailed by new KB iff entailed by original KB

• Idea for doing inference in FOL:

– propositionalize KB and query
– apply inference
– return result

• Problem: with function symbols, there are infinitely many

ground terms,
– e.g., Father(Father(Father(John))), etc
 50

Reduction contd.

Theorem: Herbrand (1930). If a sentence α is entailed by an FOL KB, it is entailed

by a finite subset of the propositionalized KB

Idea: For n = 0 to ∞ do
create a propositional KB by instantiating with depth-n terms
see if α is entailed by this KB

Problem: works if α is entailed, loops if α is not entailed

Theorem: Turing (1936), Church (1936)

Entailment for FOL is semidecidable (algorithms exist that say yes to every
entailed sentence, but no algorithm exists that also says no to every
nonentailed sentence.)
 51

Problems with propositionalization

• Propositionalization seems to generate lots of irrelevant sentences.

• E.g., from:
x King(x)  Greedy(x)  Evil(x)
King(John)
y Greedy(y)
Brother(Richard,John)

• it seems obvious that Evil(John) is entailed, but propositionalization produces

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

• With p k-ary predicates and n constants, there are p·nk instantiations.

• Lets see if we can do inference directly with FOL sentences

 53

Generalized Modus Ponens (GMP)

where we can unify pi‘ and pi for all i
p1', p2', … , pn', ( p1  p2  …  pn q) i.e. pi'θ = pi θ for all i

Subst(θ,q)
Example: x King(x)  Greedy(x)  Evil(x)
p1' is King(John) p1 is King(x)
p2' is Greedy(y) p2 is Greedy(x)
θ is {x/John, y/John} q is Evil(x)
Subst(θ,q) is Evil(John)

Example:x Missile(x)  Owns(Nono,x)  Sells(West,x,Nono)

p1' is Missile(M1) p1 is Missile(x)
p2' is Owns(y, M1) p2 is Owns(Nono,x)
θ is {x/M1, y/Nono} q is Sells(West, Nono, x)
Subst(θ,q) is Sells(West, Nono, M1)

• Implicit assumption that all variables universally quantified

GMP used with KB of definite clauses (exactly one positive literal)
 54

Soundness and completeness of GMP

GMP is sound
Only derives sentences that are logically entailed
• Need to show that p1', …, pn', (p1  …  pn  q) ╞ qθ
provided that pi'θ = piθ for all I
• Lemma: For any sentence p, we have p ╞ pθ by UI

1. (p1  …  pn  q) ╞ (p1  …  pn  q)θ = (p1θ  …  pnθ  qθ)

2. p1', \; …, \;pn' ╞ p1'  …  pn' ╞ p1'θ  …  pn'θ
3. From 1 and 2, qθ follows by ordinary Modus Ponens

GMP is complete for a KB consisting of definite clauses

– Complete: derives all sentences that entailed
– OR…answers every query whose answers are entailed by such a KB
–
– Definite clause: disjunction of literals of which exactly 1 is positive,
e.g., King(x) AND Greedy(x) -> Evil(x)
NOT(King(x)) OR NOT(Greedy(x)) OR Evil(x)
 55

Generalized Modus Ponens (GMP)

p1', p2', … , pn', ( p1  p2  …  pn q)

Subst(θ,q)

Convert each sentence into cannonical form prior to inference:

Either an atomic sentence or an implication with a conjunction of
atomic sentences on the left hand side and a single atom on the right
(Horn clauses)
 56

Unification
 57

Unification
 59

Unification

• We can get the inference immediately if we can find a substitution θ such that
King(x) and Greedy(x) match King(John) and Greedy(y)

θ = {x/John,y/John} works

• Unify(α,β) = θ if αθ = βθ
p q θ
Knows(John,x) Knows(John,Jane) {x/Jane}}
Knows(John,x) Knows(y, Elizabeth) {x/ Elizabeth,y/John}}
Knows(John,x) Knows(y,Mother(y)) {y/John,x/Mother(John)}}
Knows(John,x) Knows(x, Elizabeth) {fail}

• Standardizing apart eliminates overlap of variables,

e.g., Knows(z17, Elizabeth)
 60

Unification

• To unify Knows(John,x) and Knows(y,z),

θ = {y/John, x/z } or θ = {y/John, x/John, z/John}

• The first unifier is more general than the second.

• Most general unifier is the substitution that makes the least
commitment about the bindings of the variables
• There is a single most general unifier (MGU) that is unique
up to renaming of variables.
MGU = { y/John, x/z }
 61

The unification algorithm

 62

The unification algorithm

 63

Example knowledge base revisited

1.  x,y,z American(x)  Weapon(y)  Sells(x,y,z)  Nation(z)  Hostile(z)  Criminal(x)
2. x Owns(Nono,x)  Missile(x):
3. x Missile(x)  Owns(Nono,x)  Sells(West,x,Nono)
4.  x Missile(x)  Weapon(x)
5. x Enemy(x,America)  Hostile(x)
6. American(West)
7. Nation(Nono)
8. Enemy(Nono,America)
9. Nation(America)
Convert the sentences into Horn form
1. American(x)  Weapon(y)  Sells(x,y,z)  Nation(z)  Hostile(z)  Criminal(x)
2. Owns(Nono,M1)
3. Missile(M1)
4. Missile(x)  Owns(Nono,x)  Sells(West,x,Nono)
5. Missile(x)  Weapon(x)
6. Enemy(x,America)  Hostile(x)
7. American(West)
8. Nation(Nono)
9. Enemy(Nono,America)
10. Nation(America)
11. Proof
12. Weapon(M1)
13. Hostile(Nono)
14. Sells(West,M1,Nono)
15. Criminal(West)
 64

Inference appoaches in FOL

• Forward-chaining
– Uses GMP to add new atomic sentences
– Useful for systems that make inferences as information streams in
– Requires KB to be in form of first-order definite clauses

• Backward-chaining
– Works backwards from a query to try to construct a proof
– Can suffer from repeated states and incompleteness
– Useful for query-driven inference

• Note that these methods are generalizations of their propositional equivalents

 65

Forward chaining algorithm

 66

Forward chaining proof

 67

Forward chaining proof

 68

Forward chaining proof

 69

Properties of forward chaining

• Sound and complete for first-order definite clauses

• Datalog = first-order definite clauses + no functions

• FC terminates for Datalog in finite number of iterations

• May not terminate in general if α is not entailed

• This is unavoidable: entailment with definite clauses is

semidecidable
 70

Efficiency of forward chaining

Incremental forward chaining: 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 positive literal

Matching itself can be expensive:

Database indexing allows O(1) retrieval of known facts
– e.g., query Missile(x) retrieves Missile(M1)

Forward chaining is widely used in deductive databases

 71

Backward chaining algorithm

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

Backward chaining example

 73

Backward chaining example

 74

Backward chaining example

 75

Backward chaining example

 76

Backward chaining example

 77

Backward chaining example

 78

Backward chaining example

 79

Backward chaining example

 80

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
 81

Logic programming: Prolog

• Algorithm = Logic + Control

• Basis: backward chaining with Horn clauses + bells & whistles

• Program = set of clauses = head :- literal1, … literaln.

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

• Depth-first, left-to-right backward chaining

• Built-in predicates for arithmetic etc., e.g., X is Y*Z+3
• Built-in predicates that have side effects (e.g., input and output
• predicates, assert/retract predicates)
• Closed-world assumption ("negation as failure")
– e.g., given alive(X) :- not dead(X).
– alive(joe) succeeds if dead(joe) fails
 82

Resolution in
First Order Logic
Artificial Intelligence

Slides are mostly adapted from AIMA and MIT Open Courseware

and Milos Hauskrecht (U. Pittsburgh)

 83

Resolution Inference Rule

 84

First Order Resolution

 85

Clausal Form
 86

Converting to Clausal Form

Also move all quantifiers left

 87

Converting to Clausal Form - Skolemization

 88

Converting to Clausal Form - Skolemization

 89

Converting to Clausal Form

 90

Inference with resolution rule

91
 92

Dealing with Equality

 93

Example
 94

More examples
 95

First Order Resolution

 96

Substitutions
 97

Unification
 98

Most General Unifier

 99

Unification Algorithm
 100

Unify-var subroutine
 101

Examples
 102

Resolution with Variables

 103

Curiosity Killed the Cat

 104

Proving Validity
 105

Example
 106

Example
 107

Green’s Trick
 108

Equality
 109

Proof Example
 110

The Clauses
 111

The Query
 112

The Proof
 113

Hat of D
 114

Who is Jane’s Lower