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.Replace P => Q with  P v Q 2.Replace   P with P 3.Replace  (P v Q) with  P ^  Q 4.Replace  (P ^ Q) with  P v  Q 5. 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)A v B v C b)A ^ B ^ C c)~A v ~B d)~A ^ ~B e)~A v ~B v C v D v E f)(A ^ B) v C g)~(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) 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  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  L 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 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 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 symbolsKingJohn, 2, NU,... Predicate symbolsIsHappy, Likes, >,... Function symbolsSqrt, Nationality,... Variablesx, 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 (term 1,...,term n ) | term 1 = term 2 Term =constant | variable | function (term 1,...,term n ) 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, S 1  S 2, S 1  S 2, S 1  S 2, S 1  S 2, 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(term 1,...,term n ) is true iff the objects referred to by term 1,...,term n are in the relation I (P)

Meaning and truth in first-order logic (cont.) Complex sentences: truth is defined using the same truth tables: S 1  S 2 is true iff S 1 is true and S 2 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