cs 4100 artificial intelligence prof. c. hafner class notes jan 24, 2012
TRANSCRIPT
CS 4100 Artificial Intelligence
Prof. C. HafnerClass 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 BProve: A v B using refutation resolution
Any KB (i.e., any sentence) can be transformed into an equivalent CNF representation
1. Replace P => Q with P v Q2. Replace P with P3. Replace (P v Q) with P ^ Q4. Replace (P ^ Q) with P v Q5. Apply distributive rule replacing:
(P ^ Q) v R with (P v R) ^ (Q v R)
Class ExerciseConvert the following to CNF (a list of clauses)
Convert the CNF clauses to implicative form
a) A v B v C b) A ^ B ^ Cc) ~A v ~Bd) ~A ^ ~Be) ~A v ~B v C v D v Ef) (A ^ B) v Cg) ~(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 formIf the unicorn is mythical, then it is immortal, C1 mythical ~mortalC1a ~mythical v ~mortalIf not mythical, then it is a mortal mammal C2. ~mythical mortal ^ mammalC2a mythical v mortalC2b mythical v mammalIf the unicorn is either immortal or a mammal, then it is horned. C3 (~mortal v mammal) horned == (mortal ^ ~mammal) v
hornedC3a mortal v hornedC3b ~mammal v hornedThe unicorn is magical if it is horned. C4 horned magicalC4a ~horned v magicalProve “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 chainingP Q is an assertion in the KBP 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)
Notes: 1. An efficient implementation requires an index of the rules by LHS symbols
2. How are infinite loops prevented by this 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)
Review forward chaining algorithm
How are infinite loops prevented by this 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)
HW2: Input format for this knowledge base vegetable edible vegetable ^ green healthy edible ^ healthy recommended apple fruitedible
edible IF vegetablehealthy IF vegetable greenrecommended IF edible healthyfruit IF appleedible
Python: tokenlist = line.split() #string list of strings
Backward chaining: goal driven reasoning triggered by a new percept (fact)
• Basis of backward chainingP ^ R Q is an assertion in the KBQ 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 ediblevegetable edibleedible ^ green healthyapple fruitbanana fruitspinach vegetablespinach greenedible ^ healthy recommendedapple
Consider some queries: ? apple ? fruit ? banana ? edible ? healthy
Sketch of Backward Chaining algorithmbackwardChain(KB, query) returns Boolean
if query is in KB, return Truefor each rule r in KB such that RHS(r) == query
testing = Truefor each element e of the LHS(r) if backwardChain(KB, e) = False
testing = Falsebreak
if testing = True return True return FalseNOTE that backward chaining does not update the KB
The Wumpus World in PL
What we need to represent:I. Static knowledgeThe relevant ontology of possible world configurations:
locations on a 4 by 4 grid and their propertiesex: 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 P31Player’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 knowledgeThe agent’s possible actions: up, down, left right, grab, shootThe 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-arrow1The frame problem requires more: L110 ^ up0 L211 ^ ~L111But it is even worse: L110 ^ has-arrow0 ^ up0 L211 ^ ~L111 ^ has-arrow1 L110 ^ ~has-arrow0 ^ up0 L211 ^ ~L111 ^ ~has-arrow1The 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, …
Adjacent([x,y], [z,w]) ^ Pit([x,y]) Breeze([z,w])– and structured facts such as:
Syntax of FOL: Basic elements• Constant symbols KingJohn, 2, NU,... • Predicate symbols IsHappy, Likes, >,...• Function symbols Sqrt, Nationality,...• Variables x, y, a, b,...• Connectives , , , , • Equality = • Quantifiers ,
• 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 forconstant symbols → objectspredicate symbols → relationsfunction symbols → functions
• An atomic sentence P(term1,...,termn) is trueiff the objects referred to by term1,...,termnare 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