CIT 6261:

Advanced Artificial Intelligence

First-Order-Logic

Lecturer: Dr. Md. Saiful Islam

Acknowledgement:
Tom Lenaerts, SWITCH, Vlaams Interuniversitair Instituut voor Biotechnologie

Outline

Why FOL?
Syntax and semantics of FOL
Using FOL
Wumpus world in FOL
Knowledge engineering in FOL

2
 Pros and cons of propositional logic

• Propositional logic is declarative:

knowledge + inference (domain-independent)
• 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

First-order logic

Whereas propositional logic assumes the

world contains facts,
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, …

4
 Logics in General

Ontological Commitment: What exists in the world

— TRUTH
– PL : facts hold or do not hold.
– FOL : objects with relations between them that hold or do not hold
Epistemoligical Commitment: What an agent
believes about facts — BELIEF

Syntax of FOL: Basic elements

Constants KingJohn, 2, IUT,...

Predicates Brother, >,...
Functions Sqrt, LeftLeg,...
Variables x, y, a, b,...
Connectives ¬, ⇒, ∧, ∨, ⇔
Equality =
Quantifiers ∀, ∃

6
 Atomic sentences

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

or term1 = term2

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

or constant or variable

E.g.,
Brother(John, Richard),
Length(LeftLegOf(Richard),
Length(LeftLegOf(John)))

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)

8
 Truth in first-order logic
Sentences are true with respect to a model and an
interpretation

The domain of a model is the set of objects it contains.

Model contains objects (domain elements) and relations

among them

Interpretation specifies referents for

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

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

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

Models for FOL: Example

10
 Models for FOL

We can enumerate the models for a given KB

vocabulary:

Computing entailment by enumerating the models

will not be easy !!

11

Quantifiers

Quantifiers allows us to express properties

of collections of objects instead of
enumerating each of the objects by name
Universal: “for all” ∀
Existential: “there exists” ∃

12
 Universal quantification

∀<variables> <sentence>
Everyone at IUT is smart:
∀x At(x, IUT) ⇒ Smart(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
At(Faisal, IUT) ⇒ Smart(Faisal)
∧ At(Musa, IUT) ⇒ Smart(Musa)
∧ At(IUT, IUT) ⇒ Smart(IUT)
∧ ...

13

A common mistake to avoid

Typically, ⇒ is the main connective

with ∀
– A universally quantifier is also equivalent to a set of
implications over all objects
Common mistake: using ∧ as the main
connective with ∀:
∀x At(x, IUT) ∧ Smart(x)
means “Everyone is at IUT and everyone is smart”

14
 Existential quantification

∃<variables> <sentence>
Someone at IUT is smart:
∃x At(x, IUT) ∧ Smart(x)
∃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
At(Faisal, IUT) ∧ Smart(Faisal)
∨ At(Musa, IUT) ∧ Smart(Musa)
∨ At(IUT, IUT) ∧ Smart(IUT)
∨ ...

15

Another common mistake to avoid

Typically, ∧ is the main connective with ∃

Common mistake: using ⇒ as the main

connective with ∃:
∃x At(x, IUT) ⇒ Smart(x)
is true even if there is anyone who is not at
IUT (i.e. At(x, IUT) is false)!

16
 Properties of quantifiers
∀x ∀y is the same as ∀y ∀x
∃x ∃y is the same as ∃y ∃x

∃x ∀y is not the same as ∀y ∃x

∃x ∀y Loves(x,y)
– “There is a person ‘x’ who loves everyone in the world”
∀y ∃x Loves(x,y)
– “There is someone ‘x’ who is loved by everyone”

Quantifier duality: each can be expressed using the other

∀x Likes(x, IceCream) ≡ ¬∃x ¬Likes(x, IceCream)
∃x Likes(x, Broccoli) ≡ ¬∀x ¬Likes(x, Broccoli)

17

Equality

term1 = term2
is true under a given interpretation if and
only if term1 and term2 refer to the same
object
– Father(John) = Henry

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)]

18
 Using FOL
Assertions:
Sentences are added to a knowledge base using TELL.
Example: we can assert that John is a king and kings
are persons:
TELL(KB, King(John)).
TELL(KB, ∀x King(x) ⇒ Person(x)).

Queries:
We can ask questions to knowledge base using ask.
Example:
ASK(KB, King(John)). return true
ASK(KB, Person(x)). returns substitution/binding list {x/john}

19

The kinship domain

Objects: Elezabeth, Charles, William, …
Unary Predicates: Male, Female, …
Binary Predicates: Parent, Sibling, Brother, Sister, Husband, …
Functions: Mother, Father
Axioms:
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))

One’s husband is one’s male spouse:

∀w,h Husband(h, w) ⇔ Male(h) ∧ Spouse(h, w))
……….
Theorems:
“Sibling” is symmetric
∀x,y Sibling(x,y) ⇔ Sibling(y,x)
A first cousin is a child of a parent’s sibling
∀x,y FirstCousin(x,y) ⇔ ∃p,ps Parent(p,x) ∧ Sibling(ps,p) ∧ Parent(ps,y)

……….
20
 The set domain
One possible set of axioms:

∀s Set(s) ⇔ (s = {} ) ∨ (∃x,s2 Set(s2) ∧ s = {x|s2})

¬∃x,s {x|s} = {}
∀x,s x ∈ s ⇔ s = {x|s}
∀x,s x ∈ s ⇔ [ ∃y,s2} (s = {y|s2} ∧ (x = y ∨ x ∈ s2))]
∀s1,s2 s1 ⊆ s2 ⇔ (∀x x ∈ s1 ⇒ x ∈ s2)
∀s1,s2 (s1 = s2) ⇔ (s1 ⊆ s2 ∧ s2 ⊆ s1)
∀x,s1,s2 x ∈ (s1 ∩ s2) ⇔ (x ∈ s1 ∧ x ∈ s2)
∀x,s1,s2 x ∈ (s1 ∪ s2) ⇔ (x ∈ s1 ∨ x ∈ s2)

21

FOL Version of Wumpus World

Typical percept sentence:

Percept([Stench,Breeze,Glitter,None,None],5)
Actions:
Turn(Right), Turn(Left), Forward, Shoot, Grab, Release, Climb
To determine best action, construct query:
∀a BestAction(a,5)
ASK solves this and returns {a/Grab}
– And TELL about the action.

22
Knowledge base for the wumpus world

Perception:
– ∀t, s, g, m, c Percept([s, Breeze, g, m, c], t) ⇒ Breeze(t)
– ∀t, s, g, m, c Percept([s, b, Glitter, m, c], t) ⇒ Glitter(t)
‘Reflex’ behavior:
– ∀t Glitter(t) ⇒ BestAction(Grab,t)
Environment definition:
∀x,y,a,b Adjacent([x,y],[a,b]) ⇔
[a,b] ∈ {[x+1,y], [x-1,y],[x,y+1],[x,y-1]}
Properties of locations:
∀s,t At(Agent,s,t) ∧ Smelt(t) ⇒ Smelly(s)
∀s,t At(Agent,s,t) ∧ Breeze(t) ⇒ Breezy(s)

23

Deducing hidden properties

Squares are breezy near a pit:

– Diagnostic rule---infer cause from effect
∀s Breezy(s) ⇒ ∃ r Adjacent(r,s) ∧ Pit(r)
– Causal rule---infer effect from cause (model
based reasoning)
∀r Pit(r) ⇒ [∀s Adjacent(r,s) ⇒ Breezy(s)]

24
 Knowledge engineering in FOL
Knowledge Engineering: Process of knowledge based
construction.
Knowledge Engineer: Investigates a particular domain, learns the
important concepts in the domain, and creates a formal
representation of the objects and relations in the domain.
Steps:
1. Identify the task (what will the KB be used for)
2. Assemble the relevant knowledge
Knowledge acquisition.
3. Decide on a vocabulary of predicates, functions, and constants
Translate domain-level knowledge into logic-level names.
4. Encode general knowledge about the domain
define axioms
5. Encode a description of the specific problem instance
6. Pose queries to the inference procedure and get answers
7. Debug the knowledge base

25

The electronic circuits domain

One-bit full adder

26
 The electronic circuits domain
Identify the task
– Does the circuit actually add properly? (circuit verification)
– If all the inputs are high, what is the output of gate A2?
Assemble the relevant knowledge
– Composed of wires and gates;
– Types of gates (AND, OR, XOR, NOT)
– Connections between terminals
– Irrelevant: size, shape, color, cost of gates
Decide on a vocabulary
Choose functions, predicates, and constants
– Gates are named with constants: X1, X2 …
– Type(X1) = XOR/AND/OR …
– First input terminal for gate X1 :In(1, X1)
– Connections: Connected(Out(1, X1), In(1, X2))

27

The electronic circuits domain

4. Encode general knowledge of the domain

– ∀t1,t2 Connected(t1, t2) ⇒ Signal(t1) = Signal(t2)
– ∀t Signal(t) = 1 ∨ Signal(t) = 0
– 1≠0
– ∀t1,t2 Connected(t1, t2) ⇒ Connected(t2, t1)
– ∀g Type(g) = OR ⇒ Signal(Out(1,g)) = 1 ⇔ ∃n
Signal(In(n,g)) = 1
– ∀g Type(g) = AND ⇒ Signal(Out(1,g)) = 0 ⇔ ∃n
Signal(In(n,g)) = 0
– ∀g Type(g) = XOR ⇒ Signal(Out(1,g)) = 1 ⇔
Signal(In(1,g)) ≠ Signal(In(2,g))
– ∀g Type(g) = NOT ⇒ Signal(Out(1,g)) ≠ Signal(In(1,g))

28
 The electronic circuits domain
5. Encode the specific problem instance

Type(X1) = XOR Type(X2) = XOR

Type(A1) = AND Type(A2) = AND
Type(O1) = OR

Connected(Out(1,X1),In(1,X2)) Connected(In(1,C1),In(1,X1))
Connected(Out(1,X1),In(2,A2)) Connected(In(1,C1),In(1,A1))
Connected(Out(1,A2),In(1,O1)) Connected(In(2,C1),In(2,X1))
Connected(Out(1,A1),In(2,O1)) Connected(In(2,C1),In(2,A1))
Connected(Out(1,X2),Out(1,C1)) Connected(In(3,C1),In(2,X2))
Connected(Out(1,O1),Out(2,C1)) Connected(In(3,C1),In(1,A2))

29

The electronic circuits domain

6. Pose queries to the inference procedure

What are the possible sets of values of all the terminals for the
adder circuit?
∃i1,i2,i3,o1,o2 Signal(In(1,C_1)) = i1 ∧ Signal(In(2,C1)) = i2
∧ Signal(In(3,C1)) = i3 ∧ Signal(Out(1,C1)) = o1 ∧
Signal(Out(2,C1)) = o2

7. Debug the knowledge base

May have omitted assertions like 1 ≠ 0

30
 Summary

First-order logic:
– syntax: constants, functions, predicates, equality,
quantifiers.
– objects and relations are semantic primitives

Increased expressive power: sufficient

to define wumpus world

31