Topic8 First Order Logic

Knowledge Representation using First-Order Logic
CS 271: Fall 2007

Instructor: Padhraic Smyth
Topic 8: First-Order Logic 2
CS 271, Fall 2007: Professor 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
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 B
1,1
P
1,2
is derived from meaning of B
1,1
and of P
1,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 , , , v,
Equality =
Quantifiers V, n
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).
( ( ), ) ( ( )) Brother LeftLeg Richard John Democrat Bush v
binary
relation
function
property
objects
connectives
More Examples
Brother(Richard, John) Brother(John, Richard)
King(Richard) v 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 V
V means for all
Allows us to make statements about all objects that have certain
properties
Can now state general rules:
V x King(x) => Person(x)
V x Person(x) => HasHead(x)
V i Integer(i) => Integer(plus(i,1))
Note that
V x King(x) Person(x) is not correct!
This would imply that all objects x are Kings and are People
V x King(x) => Person(x) is the correct way to say this
Existential Quantification n
n 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:
n x King(x)
n x Lives_in(John, Castle(x))
n i Integer(i) GreaterThan(i,0)
Note that is the natural connective to use with n
(And => is the natural connective to use with V )
More examples
2
[( 2) ( 3)] ( )
[( 1)] ( )
x x x x R false
x x x R false
V > >
n =
For all real x, x>2 implies x>3.
There exists some real x whose square is minus 1.
Combining Quantifiers
V x n y Loves(x,y)
For everyone (all x) there is someone (y) who loves them
n y V x Loves(x,y)
- there is someone (y) who loves everyone
Clearer with parentheses: n y ( V 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 dont have the property P
V x Likes(x, 271 class) n x Likes(x, 271 class)
In effect:
- V is a conjunction over the universe of objects
- n is a disjunction over the universe of objects
Thus, DeMorgans rules can be applied
De Morgans Law for Quantifiers
( )
( )
( )
( )
x P x P
x P x P
x P x P
x P x P
V n
n V
V n
n V
( )
( )
( )
( )
P Q P Q
P Q P Q
P Q P Q
P Q P Q
v
v
v
v
De Morgans Rule
Generalized De Morgans Rule
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, )
TELL(KB, King(John) )
These sentences are assertions
We also want to ASK things to the KB,
ASK(KB, )
these are queries or goals
The KB should return the list of xs for which Person(x) is true:
{x/John,x/Richard,...}
, ( ) ( ) Ki rs
, ( ) rs n
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:
V a BestAction(a,5)
ASK solves this and returns {a/Grab}
And TELL about the action.
Knowledge Base for Wumpus World
Perception
Vb,g,t Percept([Breeze,b,g],t) Breeze(t)
Vs,b,t Percept([s,b,Glitter],t) Glitter(t)
Reflex
Vt Glitter(t) BestAction(Grab,t)
Reflex with internal state
Vt Glitter(t) Holding(Gold,t) BestAction(Grab,t)
Holding(Gold,t) can not be observed: keep track of change.
Deducing hidden properties
Environment definition:
Vx,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:
Vs,t At(Agent,s,t) Breeze(t) Breezy(s)
Squares are breezy near a pit:
Diagnostic rule---infer cause from effect
Vs Breezy(s) n r Adjacent(r,s) Pit(r)
Causal rule---infer effect from cause (model based reasoning)
Vr Pit(r) [Vs 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)
s
1
_ s
2
(true if s1 is a subset of s2)
- binary functions:
intersection s
1
s
2
, union s
1
s
2 ,
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
Vs Set(s) (s = {} ) v (nx,s
2
Set(s
2
) s = {x|s
2
})
The empty set has no elements adjoined to it
nx,s {x|s} = {}
Adjoining an element already in the set has no effect
Vx,s x s s = {x|s}
The only elements of a set are those that were adjoined into it.
Expressed recursively:
Vx,s x s [ ny,s
2
(s = {y|s
2
} (x = y v x s
2
))]
A Possible Set of FOL Axioms for Set Theory
A set is a subset of another set iff all the first sets members are
members of the 2
nd
set
Vs
1
,s
2
s
1
_ s
2
(Vx x s
1
x s
2
)
Two sets are equal iff each is a subset of the other
Vs
1
,s
2
(s
1
= s
2
) (s
1
_ s
2
s
2
_ s
1
)
An object is in the intersection of 2 sets only if a member of both
Vx,s
1
,s
2
x (s
1
s
2
) (x s
1
x s
2
)
An object is in the union of 2 sets only if a member of either
Vx,s
1
,s
2
x (s
1
s
2
) (x s
1
v x s
2
)
Knowledge engineering in FOL
1. Identify the task
2.
2. Assemble the relevant knowledge
3.
3. Decide on a vocabulary of predicates, functions, and constants
4.
4. Encode general knowledge about the domain
5.
5. Encode a description of the specific problem instance
6.
6. Pose queries to the inference procedure and get answers
7.
7. Debug the knowledge base
8.
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
2.
Does the circuit actually add properly?
2. Assemble the relevant knowledge
3.
Composed of wires and gates; Types of gates (AND, OR, XOR, NOT)
Irrelevant: size, shape, color, cost of gates
3. Decide on a vocabulary
4.
Alternatives:
Type(X
1
) = XOR (function)
Type(X
1
, XOR) (binary predicate)
XOR(X
1
)
(unary predicate)
4. Encode general knowledge of the domain
5.
Vt
1
,t
2
Connected(t
1
, t
2
) Signal(t
1
) = Signal(t
2
)
Vt Signal(t) = 1 v Signal(t) = 0
1 0
Vt
1
,t
2
Connected(t
1
, t
2
) Connected(t
2
, t
1
)
Vg Type(g) = OR Signal(Out(1,g)) = 1 nn Signal(In(n,g)) = 1
Vg Type(g) = AND Signal(Out(1,g)) = 0 nn Signal(In(n,g)) = 0
Vg Type(g) = XOR Signal(Out(1,g)) = 1 Signal(In(1,g))

Signal(In(2,g))
Vg Type(g) = NOT Signal(Out(1,g)) Signal(In(1,g))

5. Encode the specific problem instance
6.
Type(X
1
) = XOR Type(X
2
) = XOR
Type(A
1
) = AND Type(A
2
) = AND
Type(O
1
) = OR
Connected(Out(1,X
1
),In(1,X
2
)) Connected(In(1,C
1
),In(1,X
1
))
Connected(Out(1,X
1
),In(2,A
2
)) Connected(In(1,C
1
),In(1,A
1
))
Connected(Out(1,A
2
),In(1,O
1
)) Connected(In(2,C
1
),In(2,X
1
))
Connected(Out(1,A
1
),In(2,O
1
)) Connected(In(2,C
1
),In(2,A
1
))
Connected(Out(1,X
2
),Out(1,C
1
)) Connected(In(3,C
1
),In(2,X
2
))
Connected(Out(1,O
1
),Out(2,C
1
)) Connected(In(3,C
1
),In(1,A
2
))
6. Pose queries to the inference procedure
7.
What are the possible sets of values of all the terminals for the adder
circuit?
ni
1
,i
2
,i
3
,o
1
,o
2
Signal(In(1,C_1)) = i
1
Signal(In(2,C
1
)) = i
2
Signal(In(3,C
1
))
= i
3
Signal(Out(1,C
1
)) = o
1
Signal(Out(2,C
1
)) = o
2
7. Debug the knowledge base
8.
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

Topic8 First Order Logic

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Topic8 First Order Logic

Încărcat de

Drepturi de autor:

Formate disponibile

Knowledge Representation using First-Order Logic

CS 271: Fall 2007

Irrelevant: size, shape, color, cost of gates

Vg Type(g) = OR Signal(Out(1,g)) = 1 nn Signal(In(n,g)) = 1

Vg Type(g) = AND Signal(Out(1,g)) = 0 nn Signal(In(n,g)) = 0

Vg Type(g) = XOR Signal(Out(1,g)) = 1 Signal(In(1,g))

Vg Type(g) = NOT Signal(Out(1,g)) Signal(In(1,g))

Much more expressive than propositional logic

Knowledge engineering using FOL

S-ar putea să vă placă și