First-Order Logic

Chapter 8

Outline

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

Pros & Cons of Propositional logic

Propositional logic is declarative
(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

Propositional logic allows

partial/disjunctive/negated information

First-order (Predicate) logic

Whereas propositional logic assumes the
world contains facts, first-order logic (like
natural language) assumes the world contains
Relations: Inside(car, passenger), Beside(driver,
passenger), BrotherOf(person, person), BiggerThan(object,
object), Inside(), part of(), HasColor(), OccurredAfter(),
Owns(), ComesBetween(),

Objects: wheel, door, body, engine, seat, car,

passenger, driver, people, houses, numbers,
theories, Ronald McDonald, colors, baseball
games, wars, centuries,

First-order (Predicate) logic

Functions: ColorOf(car), FatherOf(person),
BestFriend(person), ThirdInningOf(), OneMoreThan(),
EndOf(),

Properties: Color(car), IsOpen(door), IsOn(engine)

Functions are relations with single value
for each object

Semantics/Interpretation
there is a correspondence between
functions, which return values
predicates, which are true or false
Function: father_of(Mary) = Bill
Predicate: father_of(Mary, Bill)

Example : One plus two equals three

Objects: one, two, three, one plus two

Relations:equals
Properties:-Functions:plus (one plus two is the name of the
object obtained by applying function plus to one and
two; three is another name for this object)

Semantics/Interpretation
Example 2:Squares neighboring the
Wumpusare smelly
Objects: Wumpus, square
Relations: neighboring
Properties: smelly
Functions:--

Syntax of FOL: Basic elements

Constants
Predicates
Functions
Variables
Connectives
Equality
Quantifiers

KingJohn, 2, NUS,...
Brother, >,...
Sqrt, LeftLegOf,...
x, y, a, b,...
, , , ,
=
,

Atomic sentences
Atomic sentence = predicate (term1,...,termn)
or term1 = term2
Term

function (term1,...,termn)
or constant or variable

E.g SchoolOf(Ali)
Colleague(TeacherOf(Moona), TeacherOf( Ali))
>((+ x y), x)

Complex sentences
Complex sentences are made from atomic
sentences using connectives
S, S1 S2, S1 S2, S1 S2, S1 S2,

E.g. Colleague(Huma; Mehnaz)

Colleague(Mehnaz; Huma)
Student(Ali; Moona ) Teacher(Moona;
Ali)

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

Interpretation specifies referents for

constant symbols
predicate symbols
function symbols

objects
relations
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

Truth Example

Consider the interpretation in which

Richard Richard the Lionheart
John the evil King John
Brother the brother relation
Under this interpretation,

Brother(Richard; John) is true just in case

Richard the Lionheart and the evil King John are
in the brother relation in the model

Quantifiers
Expressing sentences about collections
of objects without enumeration (naming
individuals)
E.g.
All Trojans are clever
Someone in the class is sleeping

Universal quantification (for all):

Existential quantification (there exists):

Universal quantification
<variables> <sentence>
Everyone at AI is smart:
x At(x,AI) 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(Wasi,AI) Smart(Wasi)
At(M,AI) Smart(M)

At(Ali,AI) Smart(Ali)

A common mistake to avoid

Typically, is the main connective with
Common mistake: using as the main
connective with :
x At(x,AI) Smart(x)
means Everyone is at AI and everyone is smart

Existential quantification
<variables> <sentence>
Someone at NUS is smart:
x At(x,NUS) 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(KingJohn,NUS) Smart(KingJohn)
At(Richard,NUS) Smart(Richard)
At(NUS,NUS) Smart(NUS)
...

Another common mistake to

avoid
Typically, is the main connective with
Common mistake: using as the main
connective with :
x At(x,NUS) Smart(x)
is true if there is anyone who is not at NUS!

Properties of quantifiers
x y is the same as y x
x y is the same as y x
x y Loves(x,y)

There is a person who loves everyone in the world

y x Loves(x,y)

Everyone in the world is loved by at least one person

x y is not the same as y x

Fun with sentences

Brothers are siblings
x;yBrother(x,y) Sibling(x,y)
Sibling is symmetric
x,y Sibling(x,y)Sibling(y,x)
Ones mother is ones female parent
x,y Mother(x,y) (Female(x) ^ Parent(x,y))
A first cousin is a child of a parents sibling
x;y FirstCousin(x,y) p,ps
Parent(p,x)^Sibling(ps,p)^Parent(ps,y))

Some more Examples

Every gardener likes the sun.

x gardener(x) => likes(x,Sun)
You can fool some of the people all of the time.
x t (person(x) ^ time(t)) => can-fool(x,t)
You can fool all of the people some of the time.
x t (person(x) ^ time(t)) => can-fool(x,t)
All purple mushrooms are poisonous.
x (mushroom(x) ^ purple(x)) => poisonous(x)
No purple mushroom is poisonous.
( x) purple(x) ^ mushroom(x) ^ poisonous(x)
or, equivalently,
( x) (mushroom(x) ^ purple(x)) => poisonous(x)

Duality and Equality

Duality:
All likes icecream = there is not one person who doesnt
like icecream
x Likes(x,IceCream) x Likes(x,IceCream)
Some people likes broccoli= not all people likes broccoli
x Likes(x,Broccoli) x Likes(x,Broccoli)
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)]

Interacting with FOL KBs

Suppose a wumpus-world agent is using an FOL KB and perceives a smell

and a breeze (but no glitter) at t=5:
Tell(KB,Percept([Smell,Breeze,None],5))
Ask(KB,a BestAction(a,5))

I.e., does the KB entail some best action at t=5?

Answer: Yes, {a/Shoot}
substitution (binding list)

Given a sentence S and a substitution ,

S denotes the result of plugging into S; e.g.,
S = Smarter(x,y)
= {x/Hillary,y/Bill}
S = Smarter(Hillary,Bill)

Ask(KB,S) returns some/all such that KB

Wumpus world in FOL

the objects in the environment
terms: constants, variables, functions

constants:

times: 0, 1, 2, ...
headings: R, L, D, U
coordinates: 1, 2, 3, 4
locations: 16 squares
percepts: Stench, Breeze, Glitter, Bump, Scream, None
actions: Turn(Left), Turn(Right), Forward, Grab, Shoot
Agent, Wumpus

D. Goforth, fall 2006

24

Wumpus world in FOL

the objects in the environment
terms: constants, variables, functions

functions:
Square(x,y) // [x,y] p.259
Home(Wumpus)
Perception(s, b, g, h, y) // [s, b, g, h, y] p.258
Heading(t), Location(t)
D. Goforth, fall 2006

25

Wumpus world in FOL

the basic knowledge
atomic sentences: predicates, term=term

predicates: (true or false)

properties (of one term/object)

Breezy(t) // agent feeling breeze at time t

Breeze(s) // breeze blowing on square s
Pit(s), Gold(s), etc.
Time(x) // object x is a time
Coordinate(x), Action(x), Heading(x), etc.
D. Goforth, fall 2006

26

Wumpus world in FOL

the basic knowledge
atomic sentences: predicates, term=term

predicates: (true or false)

relations (of multiple terms/objects)

At(s,t) // agent on square s at time t*

Adjacent (r,s) // squares r and s are adjacent
Alive(x,t) // x is alive at time t
Percept(p,t) // perception at time t
BestAction(a,t) // action a to take at time t
D. Goforth, fall 2006

*compare with p.259

27

Wumpus world in FOL

the basic knowledge
atomic sentences: predicates, term=term

term = term: (true or false)

Home(Wumpus) = [3,3]
Heading(5) = U

D. Goforth, fall 2006

28

Exploring Wumpus world in FOL

Timed atomic sentences: Initial conditions
At([1,1],0)
Heading(R,0)
Alive(Agent,0)
Alive(Wumpus,0)
then First perception:
Percept([Stench,None, None, None, None],0)

D. Goforth, fall 2006

29

Exploring Wumpus world in FOL

Percept([Stench, None, None, None, None],0)
Understanding what is perceived
b g h y t Percept([Stench,b,g, h, y],t)Stinky(t)
s g h y t Percept([s,None,g, h, y],t)Glittery(t)
Stinky(0)
Glittery(0)
r t Stinky(t) At(r,t) Stinks(r)
r t Glittery(t) At(r,t) Glitters(r)
Fixed
knowledge

Stinks([1,1])
Glitters ([1,1])
D. Goforth, fall 2006

30

Exploring Wumpus world in FOL

Updating timed knowledge:
All atomic sentences may be different from t to t+1
BUT
Most are the same
UNLESS

Time t Time
t+1

An action changes them

r t At(r,t) (BestAction(Forward,t) (Bumped(t+1)) At(r,t+1)
t Screams(t) Alive(Wumpus,t)

D. Goforth, fall 2006

31

Deducing hidden properties

Knowledge engineering in FOL

1. Identify the task
2. Assemble the relevant knowledge
3. Decide on a vocabulary of predicates,
functions, and constants
4. Encode general knowledge about the domain
5. Encode a description of the specific problem
instance
6. Pose queries to the inference procedure and
get answers
7. Debug the knowledge base

The electronic circuits domain

One-bit full adder

The electronic circuits domain

1. Identify the task
XOR(X1)

Does the circuit actually add properly? (circuit verification)

Assemble the relevant knowledge
Composed of wires and gates; Types of gates (AND, OR, XOR,
NOT)
Irrelevant: size, shape, color, cost of gates
Decide on a vocabulary
Alternatives:
Type(X1) = XOR
Type(X1, XOR)

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

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

The electronic circuits domain

5. Encode the specific problem instance
Type(X1) = XOR
Type(A1) = AND
Type(O1) = OR

Type(X2) = XOR
Type(A2) = AND

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

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

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
Debug the knowledge base
May have omitted assertions like 1 0

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

Increased expressive power: sufficient to

define wumpus world