Class first order logic

Knowledge Representation using First-Order Logic

CS 271: Fall 2007

Instructor: Padhraic Smyth

Logistics

• Midterm results
– Graded, solutions mailed out

• Extra-credit projects
– Treated as 2 additional homeworks
• Lowest 2 scoring homeworks dropped, rest averaged
– no- extra-credit project
• Single lowest homework score dropped, rest averaged
– More information on the Web site (if not now, then soon)

• Homework 3
– Should be graded by Thursday

• Homework 4
– Up on the Web shortly

CS 271, Fall 2007: Professor Padhraic Smyth Topic 8: First-Order Logic 2

Outline

• What is First-Order Logic (FOL)?
– Syntax and semantics

• Using FOL

• Wumpus world in FOL

• Knowledge engineering in FOL

• Required Reading:
– All of Chapter 8


Pros and cons of propositional logic

 Propositional logic is declarative
- Knowledge and inference are separate

 Propositional logic allows partial/disjunctive/negated information
– unlike most programming languages 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 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

• 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, …


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

• Epistemological Commitment:
– What an agent believes about facts — BELIEF


Syntax of FOL: Basic elements

• Constant Symbols:
– Stand for objects
– e.g., KingJohn, 2, UCI,...

• Predicate Symbols
– Stand for relations
– E.g., Brother(Richard, John), greater_than(3,2)...

• Function Symbols
– Stand for functions
– E.g., Sqrt(3), LeftLegOf(John),...


Syntax of FOL: Basic elements

• Constants KingJohn, 2, UCI,...

• Predicates Brother, >,...

• Functions Sqrt, LeftLegOf,...

• Variables x, y, a, b,...

• Connectives ¬, ⇒, ∧, ∨, ⇔

• Equality =

• Quantifiers ∀, ∃


Relations

• Some relations are properties: they state
some fact about a single object: Round(ball), Prime(7).

• n-ary relations state facts about two or more objects:
Married(John,Mary), LargerThan(3,2).

• Some relations are functions: their value is another object:
Plus(2,3), Father(Dan).


Models for FOL: Example


Terms

• Term = logical expression that refers to an object.

• There are 2 kinds of terms:
– constant symbols: Table, Computer
– function symbols: LeftLeg(Pete), Sqrt(3), Plus(2,3) etc


Atomic Sentences

• Atomic sentences state facts using terms and predicate symbols
– P(x,y) interpreted as “x is P of y”

• Examples:
LargerThan(2,3) is false.
Brother_of(Mary,Pete) is false.
Married(Father(Richard), Mother(John)) could be true or false

• Note: Functions do not state facts and form no sentence:
– Brother(Pete) refers to John (his brother) and is neither true nor false.

• Brother_of(Pete,Brother(Pete)) is True.

Binary relation Function


Complex Sentences

• We make complex sentences with connectives (just like in
propositional logic).
property

¬Brother (LeftLeg (Richard ), John ) ∨ (Democrat (Bush ))

binary function
relation

objects

connectives


More Examples

• Brother(Richard, John) ∧ Brother(John, Richard)

• King(Richard) ∨ King(John)

• King(John) => ¬ King(Richard)

• LessThan(Plus(1,2) ,4) ∧ GreaterThan(1,2)

(Semantics are the same as in propositional logic)


Variables

• Person(John) is true or false because we give it a single
argument ‘John’

• We can be much more flexible if we allow variables which can
take on values in a domain. e.g., all persons x, all integers i,
etc.
– E.g., can state rules like Person(x) => HasHead(x)
or Integer(i) => Integer(plus(i,1)


Universal Quantification ∀

∀ ∀ means “for all”

• Allows us to make statements about all objects that have certain
properties

• Can now state general rules:

∀ x King(x) => Person(x)

∀ x Person(x) => HasHead(x)

∀ i Integer(i) => Integer(plus(i,1))

Note that
∀ x King(x) ∧ Person(x) is not correct!
This would imply that all objects x are Kings and are People

∀ x King(x) => Person(x) is the correct way to say this


Existential Quantification ∃

∀ ∃ x means “there exists an x such that….” (at least one object x)

• Allows us to make statements about some object without naming it

• Examples:

∃ x King(x)

∃ x Lives_in(John, Castle(x))

∃i Integer(i) ∧ GreaterThan(i,0)

Note that ∧ is the natural connective to use with ∃

(And => is the natural connective to use with ∀ )


More examples

For all real x, x>2 implies x>3.

∀x [(x > 2) ⇒ (x > 3)] x ∈ R (false )
∃x [(x 2 = −1)] x ∈ R (false )

There exists some real x whose square is minus 1.


Combining Quantifiers

∀ x ∃ y Loves(x,y)
– For everyone (“all x”) there is someone (“y”) who loves them

∃ y ∀ x Loves(x,y)
- there is someone (“y”) who loves everyone

Clearer with parentheses: ∃y(∀x Loves(x,y) )


Connections between Quantifiers

• Asserting that all x have property P is the same as asserting
that does not exist any x that don’t have the property P

∀ x Likes(x, 271 class)  ¬ ∃ x ¬ Likes(x, 271 class)

In effect:
- ∀ is a conjunction over the universe of objects
- ∃ is a disjunction over the universe of objects
Thus, DeMorgan’s rules can be applied


De Morgan’s Law for Quantifiers

De Morgan’s Rule Generalized De Morgan’s Rule
P ∧ Q ≡ ¬(¬P ∨ ¬Q ) ∀x P ≡ ¬∃x (¬P )
P ∨ Q ≡ ¬(¬P ∧ ¬Q ) ∃x P ≡ ¬∀x (¬P )
¬(P ∧ Q ) ≡ ¬P ∨ ¬Q ¬∀x P ≡ ∃x (¬P )
¬(P ∨ Q ) ≡ ¬P ∧ ¬Q ¬∃x P ≡ ∀x (¬P )

Rule is simple: if you bring a negation inside a disjunction or a conjunction,
always switch between them (or and, and  or).


Using FOL

• We want to TELL things to the KB, e.g.
TELL(KB, ∀x , King (x ) ⇒ Person (x ) )
TELL(KB, King(John) )

These sentences are assertions

• We also want to ASK things to the KB,
ASK(KB, ∃x , Person (x ) )

these are queries or goals

The KB should return the list of x’s for which Person(x) is true:
{x/John,x/Richard,...}


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.


Knowledge Base for Wumpus World

• Perception
∀b,g,t Percept([Breeze,b,g],t) ⇒ Breeze(t)
∀s,b,t Percept([s,b,Glitter],t) ⇒ Glitter(t)

• Reflex
∀t Glitter(t) ⇒ BestAction(Grab,t)

• Reflex with internal state
∀t Glitter(t) ∧¬Holding(Gold,t) ⇒ BestAction(Grab,t)

Holding(Gold,t) can not be observed: keep track of change.


Deducing hidden properties

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) ∧ Breeze(t) ⇒ Breezy(s)

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


Set Theory in First-Order Logic

Can we define set theory using FOL?
- individual sets, union, intersection, etc

Answer is yes.

Basics:
- empty set = constant = { }

- unary predicate Set( ), true for sets

- binary predicates:
x∈ s (true if x is a member of the set x)
s1 ⊆ s2 (true if s1 is a subset of s2)

- binary functions:
intersection s1 ∩ s2, union s1 ∪ s2 , adjoining {x|s}


A Possible Set of FOL Axioms for Set Theory

The only sets are the empty set and sets made by adjoining an
element to a set
∀s Set(s) ⇔ (s = {} ) ∨ (∃x,s2 Set(s2) ∧ s = {x|s2})

The empty set has no elements adjoined to it
¬∃x,s {x|s} = {}

Adjoining an element already in the set has no effect
∀x,s x ∈ s ⇔ s = {x|s}

The only elements of a set are those that were adjoined into it.
Expressed recursively:
∀x,s x ∈ s ⇔ [ ∃y,s2 (s = {y|s2} ∧ (x = y ∨ x ∈ s2))]


A Possible Set of FOL Axioms for Set Theory

A set is a subset of another set iff all the first set’s members are
members of the 2nd set
∀s1,s2 s1 ⊆ s2 ⇔ (∀x x ∈ s1 ⇒ x ∈ s2)

Two sets are equal iff each is a subset of the other
∀s1,s2 (s1 = s2) ⇔ (s1 ⊆ s2 ∧ s2 ⊆ s1)

An object is in the intersection of 2 sets only if a member of both
∀x,s1,s2 x ∈ (s1 ∩ s2) ⇔ (x ∈ s1 ∧ x ∈ s2)

An object is in the union of 2 sets only if a member of either
∀x,s1,s2 x ∈ (s1 ∪ s2) ⇔ (x ∈ s1 ∨ x ∈ s2)


Knowledge engineering in FOL

1. Identify the task

3. Assemble the relevant knowledge

5. Decide on a vocabulary of predicates, functions, and constants

7. Encode general knowledge about the domain

9. Encode a description of the specific problem instance

11. Pose queries to the inference procedure and get answers

13. Debug the knowledge base

•

The electronic circuits domain

One-bit full adder

Possible queries:
- does the circuit function properly?
- what gates are connected to the first input terminal?
- what would happen if one of the gates is broken?
and so on



1. Identify the task
– Does the circuit actually add properly?

2. Assemble the relevant knowledge
– Composed of wires and gates; Types of gates (AND, OR, XOR, NOT)
– Irrelevant: size, shape, color, cost of gates

3. Decide on a vocabulary
– Alternatives:
Type(X1) = XOR (function)
Type(X1, XOR) (binary predicate)
XOR(X1)
(unary predicate)
–

–
–

•



1. 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))

–



1. 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))

•



1. 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:
– Much more expressive than propositional logic
– Allows objects and relations as semantic primitives
– Universal and existential quantifiers
– syntax: constants, functions, predicates, equality, quantifiers

• Knowledge engineering using FOL
– Capturing domain knowledge in logical form

• Inference and reasoning in FOL
– Next lecture

• Required Reading:
– All of Chapter 8

–

Class first order logic

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Class first order logic (20)

Recently uploaded (20)

Class first order logic