Download jan24

CS 4100 Artificial Intelligence
Prof. C. Hafner
Class Notes Jan 24, 2012
Topics for today
• Finish discussion of propositional logic
–
–
–
–
•
•
•
•
Forms of clauses
Refutation resolution
Forward chaining in PL (review)
Backward chaining in PL
Discussion of Homework 2
Review wumpus world model using PL
First order logic
Wumpus world model using FOL
Disjunctive and Implicative form of clauses
• ~P1 v ~P2 v . . . v ~Pn v Q V R – disjunctive form
• Same as: P1 ^ P2 ^ . . . ^ Pn  Q V R -- implicative
form
• What about: ~P1 v ~P2 v . . . v ~Pn
Implicative form is:
P1 ^ P2 ^ . . . ^ Pn  {} {} == False
• What about Q (single positive literal).
Implicative form is: True  Q (or just Q)
Any logical sentence can be converted to (one or more)
clauses!!
Horn clauses and Definite clauses
All Clauses
Horn clauses: 0 or 1
positive literals
Definite clauses: 1
positive literal
Review: The Resolution Rule for Propositional Logic
[P1 v P2 v . . . Pk ]  [ P1 v Q2 v . . . Qn ]
--------------------------------------------------P2 v . . . Pk v Q2 v . . . Qn
A generalization of modus ponens:
P1  [ P1 v Q] Note: [ P1 v Q] equivalent to
-----------------------P1  Q
Q
Refutation Resolution
• Assert the negation of what you want to prove and
resolve with current database to obtain {}. Very
useful when we move to FOL
• A simple example:
EA
~E  B
Prove: A v B using refutation resolution
Any KB (i.e., any sentence) can be transformed
into an equivalent CNF representation
1.
2.
3.
4.
5.
Replace P => Q with  P v Q
Replace   P with P
Replace  (P v Q) with  P ^  Q
Replace (P ^ Q) with  P v  Q
Apply distributive rule replacing:
(P ^ Q) v R with (P v R) ^ (Q v R)
Class Exercise
Convert the following to CNF (a list of clauses)
Convert the CNF clauses to implicative form
a)
b)
c)
d)
e)
f)
g)
AvBvC
A^B^C
~A v ~B
~A ^ ~B
~A v ~B v C v D v E
(A ^ B) v C
~(A ^ ~B) v C
Class Exercise (from text)
• Given the following, can you prove that the unicorn
is mythical? Magical? Horned?
If the unicorn is mythical, then it is immortal, but if it is
not mythical, then it is a mortal mammal. If the
unicorn is either immortal or a mammal, then it is
horned. The unicorn is magical if it is horned.
Convert to Clause form
If the unicorn is mythical, then it is immortal,
C1 mythical  ~mortal
C1a ~mythical v ~mortal
If not mythical, then it is a mortal mammal
C2. ~mythical  mortal ^ mammal
C2a mythical v mortal
C2b mythical v mammal
If the unicorn is either immortal or a mammal, then it is horned.
C3 (~mortal v mammal)  horned == (mortal ^ ~mammal) v
horned
C3a mortal v horned
C3b ~mammal v horned
The unicorn is magical if it is horned.
C4 horned  magical
C4a ~horned v magical
Prove “magical” by refutation
A common error
• Derive: ~mortal v mortal v horned
• Does this imply horned ?? NO
• Why? Because it is true whether horned is T or F
Review: Forward chaining: takes a KB of Horn
clauses
• Basis of forward chaining
P  Q is an assertion in the KB
P is a new percept
---------Conclude Q
• Two views of KB
– All implications are made explicit vs.
– Reasoning on demand
• “Pure” forward chaining suggests the former
Forward chaining algorithm (KB of Definite Clauses)
ALGORITHM (recursive):
PLForwardChain()
uses KBase -- a knowledge base of Horn clauses
for each new percept p
PLForwardChain1(p) #use a recursive "helper function"
PLForwardChain1(percept)
if percept is already in KBase, return
else
add percept to KBase
for r in rules where conclusion of r is not already in KBase
if percept is a premise of r and all the other
premises of r are known
PLForwardChain1(conclusion of r)
Notes: 1. An efficient implementation requires an index of the
rules by LHS symbols
2. How are infinite loops prevented by this algorithm ?
Review forward chaining algorithm
ALGORITHM (recursive):
PLForwardChain()
uses KBase -- a knowledge base of Horn clauses
for each new percept p
PLForwardChain1(p) #use a recursive "helper function"
PLForwardChain1(percept)
if percept is already in KBase, return
else
add percept to KBase
for r in rules where conclusion of r is not already in KBase
if percept is a premise of r and all the other
premises of r are known
PLForwardChain1(conclusion of r)
How are infinite loops prevented by this algorithm ?
HW2: Input format for this knowledge base
vegetable  edible
vegetable ^ green  healthy
edible ^ healthy  recommended
apple  fruit
edible
edible IF vegetable
healthy IF vegetable green
recommended IF edible healthy
fruit IF apple
edible
Python: tokenlist = line.split() #string  list of strings
Backward chaining: goal driven reasoning
triggered by a new percept (fact)
• Basis of backward chaining
P ^ R  Q is an assertion in the KB
Q is a query we want to prove (or disprove)
---------Set up P and R as sub-queries, if they are true
then Q is proved
• What if we cannot find Q or a rule that succeeds in proving Q.
Then we answer False. This is called negation by failure. (It is not
the same as a real logical proof of ~Q).
• Note: P  ~Q is not a Horn Clause. It normalizes to P V Q, which
has two positive literals
Backward chaining: goal-driven reasoning –
triggered by a question being asked
KB:fruit  edible
vegetable  edible
edible ^ green  healthy
apple  fruit
banana  fruit
spinach  vegetable
spinach  green
edible ^ healthy  recommended
apple
Consider some queries:
? apple
? fruit ? banana
? edible
? healthy
Sketch of Backward Chaining algorithm
backwardChain(KB, query) returns Boolean
if query is in KB, return True
for each rule r in KB such that RHS(r) == query
testing = True
for each element e of the LHS(r)
if backwardChain(KB, e) = False
testing = False
break
if testing = True return True
return False
NOTE that backward chaining does not update the KB
The Wumpus World in PL
What we need to represent:
I. Static knowledge
The relevant ontology of possible world configurations:
locations on a 4 by 4 grid and their properties
ex: Pxy means a pit at location x,y
Player’s current state (Lxy, has-arrow)
The axioms of the world’s configurations
L21 ^ Breeze  P22 v P31
Player’s current percepts: Breeze, Stench, etc.
The Wumpus World in PL
Additional static world axioms:
There is exactly one wumpus:
W21 v W31 v . . . W44 == there is at least one
There is at most one:
~(W21 ^ W22) -- one axiom like this for each pair
The Wumpus World in PL (cont)
What we need to represent:
II. Dynamic knowledge
The agent’s possible actions: up, down, left right, grab, shoot
The result of the agent’s actions:
requires temporal indexing:
L110 ^ up0  L211 -- one for each location X action X timestep
L110 ^ has-arrow0 ^ shoot0  L111 ^ ~has-arrow1
The frame problem requires more:
L110 ^ up0  L211 ^ ~L111
But it is even worse:
L110 ^ has-arrow0 ^ up0  L211 ^ ~L111 ^ has-arrow1
L110 ^ ~has-arrow0 ^ up0  L211 ^ ~L111 ^ ~has-arrow1
The frame problem arises when we use temporal indexing!!!
It causes axioms to multiply almost without limit.
First Order Logic (FOL)
•
•
•
•
•
Why FOL?
Syntax and semantics of FOL
Using FOL
Wumpus world in FOL
Knowledge engineering in FOL
Pros and cons of propositional logic
 Propositional logic is declarative
 Propositional logic allows partial/disjunctive/negated
information
– (unlike most data structures and databases)
– (Horn clauses an intermediate form)
 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 limits world models to
atomic facts such as P12  B22
• first-order logic (like natural language) can manipulate
world models that include:
– Objects: people, houses, numbers, colors, baseball games,
wars, …
– Relations: red, round, prime, brother of, bigger than, part of,
comes between, …
– Functions: father, nationality, one more than, plus, …
– and structured facts such as:
Adjacent([x,y], [z,w]) ^ Pit([x,y])  Breeze([z,w])
Syntax of FOL: Basic elements
•
•
•
•
•
•
•
Constant symbols
Predicate symbols
Function symbols
Variables
Connectives
Equality
Quantifiers
KingJohn, 2, NU,...
IsHappy, Likes, >,...
Sqrt, Nationality,...
x, y, a, b,...
, , , , 
=
, 
• The constant, predicate and function symbols are
called a “logical language”. Given a LL we can then
define all the logical sentences that can be
expressed.
Atomic sentences
Atomic sentence =
predicate (term1,...,termn) |
term1 = term2
Term
constant |
variable |
function (term1,...,termn)
=
• E.g., Brother(KingJohn,RichardTheLionheart)
• Greater (AgeOf(Richard), AgeOf(John))
• Brother (AgeOf(Richard), AgeOf(John))
Complex sentences
• Complex sentences are made from atomic sentences
using connectives (with the same semantics as
propositional logic)
•
S, S1  S2, S1  S2, S1  S2, S1  S2,
E.g. Sibling(John,Richard) < Sibling(Richard,John)
>(1,2)  ≤ (1,2)
>(1,2)   >(1,2)
Complex sentences (cont.)
• Additional complex sentences may include
quantifiers:  and 
var [S]
 var [S]
Abbreviate:  x  y  z [S] as  x, y, z [S]
Abbreviate:  x  y  z [S] as  x, y, z [S]
Meaning and truth in first-order logic
• Sentences of FOL are true with respect to a model and an
interpretation
• A model for a FOL language is a “world” of objects (domain
elements) and relations among them (compare with
propositional logic model)
• Interpretation I specifies referents for
constant symbols
→
objects
predicate symbols
→
relations
function symbols
→
functions
• An atomic sentence P(term1,...,termn) is true
iff the objects referred to by term1,...,termn
are in the relation I(P)
Meaning and truth in first-order logic (cont.)
• Complex sentences: truth is defined using the same
truth tables: S1  S2 is true iff S1 is true and S2 is true.
• x [S] is true iff, for any object C in the model
S[x/C] is true
•  x [S] is true iff, for at least one object C in the
model
S[x/C] is true
Models for FOL: Example
symbols: constant
relation
function