For Thursday Read chapter 9 Homework: Chapter 7, exercises 2 and - - PowerPoint PPT Presentation

For Thursday

• Read chapter 9
• Homework:

– Chapter 7, exercises 2 and 10

Program 1

• Any questions?

Rules of Inference

• Alternative to truth-table checking
• A sequence of inference rule applications

leading to a desired conclusion is a logical proof

• We can check inference rules using truth

tables, and then use to create sound proofs

• We can treat finding a proof as a search

problem

Propositional Inference Rules

• Modus Ponens or Implication Elimination
• And Elimination
• And Introduction
• Unit Resolution
• Resolution

Building an Agent with Propositional Logic

• Propositional logic has some nice properties

– Easily understood – Easily computed

• Can we build a viable wumpus world agent

with propositional logic???

The Problem

• Propositional Logic only deals with facts.
• We cannot easily represent general rules

that apply to any square.

• We cannot express information about

squares and relate (we can’t easily keep track of which squares we have visited)

More Precisely

• In propositional logic, each possible atomic

fact requires a separate unique propositional symbol.

• If there are n people and m locations,

representing the fact that some person moved from one location to another requires nm2 separate symbols.

First Order Logic

• Predicate logic includes a richer ontology:

– objects (terms) – properties (unary predicates on terms) – relations (n-ary predicates on terms) – functions (mappings from terms to other terms)

• Allows more flexible and compact

representation of knowledge

• Move(x, y, z) for person x moved from

location y to z.

Syntax for First-Order Logic

Sentence  AtomicSentence | Sentence Connective Sentence | Quantifier Variable Sentence | ¬Sentence | (Sentence) AtomicSentence  Predicate(Term, Term, ...) | Term=Term Term  Function(Term,Term,...) | Constant | Variable Connective   Quanitfier  $" Constant  A | John | Car1 Variable  x | y | z |... Predicate  Brother | Owns | ... Function  father-of | plus | ...

Terms

• Objects are represented by terms:

– Constants: Block1, John – Function symbols: father-of, successor, plus

• An n-ary function maps a tuple of n terms to

another term: father-of(John), succesor(0), plus(plus(1,1),2)

• Terms are simply names for objects.
• Logical functions are not procedural as in

programming languages. They do not need to be defined, and do not really return a value.

• Functions allow for the representation of an

infinite number of terms.

Predicates

• Propositions are represented by a predicate

applied to a tuple of terms. A predicate represents a property of or relation between terms that can be true or false:

– Brother(John, Fred), Left-of(Square1, Square2) – GreaterThan(plus(1,1), plus(0,1))

• In a given interpretation, an n-ary predicate

can defined as a function from tuples of n terms to {True, False} or equivalently, a set tuples that satisfy the predicate:

– {<John, Fred>, <John, Tom>, <Bill, Roger>, ...}

Sentences in First-Order Logic

• An atomic sentence is simply a predicate applied

to a set of terms.

– Owns(John,Car1) – Sold(John,Car1,Fred)

• Semantics is True or False depending on the

interpretation, i.e. is the predicate true of these arguments.

• The standard propositional connectives ( 

) can be used to construct complex sentences:

– Owns(John,Car1)  Owns(Fred, Car1) – Sold(John,Car1,Fred)  ¬Owns(John, Car1)

• Semantics same as in propositional logic.

Quantifiers

• Allow statements about entire collections of objects
• Universal quantifier: "x

– Asserts that a sentence is true for all values of variable x

• "x Loves(x, FOPC)
• "x Whale(x)  Mammal(x)
• "x ("y Dog(y)  Loves(x,y))  ("z Cat(z)  Hates(x,z))
• Existential quantifier: $

– Asserts that a sentence is true for at least one value of a variable x

• $x Loves(x, FOPC)
• $x(Cat(x)  Color(x,Black)  Owns(Mary,x))
• $x("y Dog(y)  Loves(x,y))  ("z Cat(z)  Hates(x,z))

Use of Quantifiers

• Universal quantification naturally uses implication:

– "x Whale(x)  Mammal(x)

• Says that everything in the universe is both a whale and a mammal.
• Existential quantification naturally uses conjunction:

– $x Owns(Mary,x)  Cat(x)

• Says either there is something in the universe that Mary does not
• wn or there exists a cat in the universe.

– "x Owns(Mary,x)  Cat(x)

• Says all Mary owns is cats (i.e. everthing Mary owns is a cat). Also

true if Mary owns nothing.

– "x Cat(x)  Owns(Mary,x)

• Says that Mary owns all the cats in the universe. Also true if there

are no cats in the universe.

Nesting Quantifiers

• The order of quantifiers of the same type doesn't matter:

– "x"y(Parent(x,y)  Male(y)  Son(y,x)) – $x$y(Loves(x,y)  Loves(y,x))

• The order of mixed quantifiers does matter:

– "x$y(Loves(x,y))

• Says everybody loves somebody, i.e. everyone has someone whom

they love.

– $y"x(Loves(x,y))

• Says there is someone who is loved by everyone in the universe.

– "y$x(Loves(x,y))

• Says everyone has someone who loves them.

– $x"y(Loves(x,y))

• Says there is someone who loves everyone in the universe.

Variable Scope

• The scope of a variable is the sentence to which

the quantifier syntactically applies.

• As in a block structured programming language, a

variable in a logical expression refers to the closest quantifier within whose scope it appears.

– $x (Cat(x)  "x(Black (x)))

• The x in Black(x) is universally quantified
• Says cats exist and everything is black
• In a well-formed formula (wff) all variables

should be properly introduced:

– $xP(y) not well-formed

• A ground expression contains no variables.

Relations Between Quantifiers

• Universal and existential quantification are logically

related to each other:

– "x ¬Love(x,Saddam)  ¬$x Loves(x,Saddam) – "x Love(x,Princess-Di)  ¬$x ¬Loves(x,Princess-Di)

• General Identities

– "x ¬P  ¬$x P – ¬"x P  $x ¬P – "x P  ¬$x ¬P – $x P  ¬"x ¬P – "x P(x)  Q(x)  "x P(x)  "x Q(x) – $x P(x)  Q(x)  $x P(x)  $x Q(x)

Equality

• Can include equality as a primitive predicate in the

logic, or require it to be introduced and axiomitized as the identity relation.

• Useful in representing certain types of knowledge:

– $x$y(Owns(Mary, x)  Cat(x)  Owns(Mary,y)  Cat(y) –  ¬(x=y)) – Mary owns two cats. Inequality needed to ensure x and y are distinct. – "x $y married(x, y) "z(married(x,z)  y=z) – Everyone is married to exactly one person. Second conjunct is needed to guarantee there is only one unique spouse.

Higher-Order Logic

• FOPC is called first-order because it allows quantifiers

to range over objects (terms) but not properties, relations, or functions applied to those objects.

• Second-order logic allows quantifiers to range over

predicates and functions as well:

– " x " y [ (x=y)  (" p p(x)  p(y)) ]

• Says that two objects are equal if and only if they have exactly the

same properties.

– " f " g [ (f=g)  (" x f(x) = g(x)) ]

• Says that two functions are equal if and only if they have the same

value for all possible arguments.

• Third-order would allow quantifying over predicates
• f predicates, etc.

Alternative Notations

• Prolog:

cat(X) :- furry(X), meows(X), has(X, claws). good_pet(X) :- cat(X); dog(X).

• Lisp:

(forall ?x (implies (and (furry ?x) (meows ?x) (has ?x claws)) (cat ?x)))

A Kinship Domain

"m,c Mother(c) = m  Female(m) Parent(m, c) "w,h Husband(h, w)  Male(h)  Spouse(h,w) " x Male(x)  Female(x) " p,c Parent(p, c)  Child(c, p) " g,c Grandparent(g, c)  $p Parent(g, p)  Parent(p, c) " x,y Sibling(x, y)  x  y  $p Parent(p, x)  Parent(p, y) " x,y Sibling(x, y)  Sibling(y, x)

Axioms

• Axioms are the basic predicates of a

knowledge base.

• We often have to select which predicates

will be our axioms.

• In defining things, we may have two

conflicting goals

– We may wish to use a small set of definitions – We may use “extra” definitions to achieve more efficient inference

A Wumpus Knowledge Base

• Start with two types of sentence:

– Percepts:

• Percept([stench, breeze, glitter, bump, scream], time)
• Percept([Stench,None,None,None,None],2)
• Percept(Stench,Breeze,Glitter,None,None],5)

– Actions:

• Action(action,time)
• Action(Grab,5)

Agent Processing

• Agent gets a percept
• Agent tells the knowledge base the percept
• Agent asks the knowledge base for an

action

• Agent tells the knowledge base the action
• Time increases
• Agent performs the action and gets a new

percept

• Agent depends on the rules that use the

knowledge in the KB to select an action

Simple Reflex Agent

• Rules that map the current percept onto an action.
• Some rules can be handled that way:

action(grab,T) :- percept([S, B, glitter, Bump, Scr],T).

• Simplifying our rules:

stench(T) :- percept([stench, B, G, Bu, Scr],T). breezy(T) :- percept([S, breeze, G, Bu, Scr], T). at_gold(T) :- percept([S, B, glitter, Bu, Scr], T). action(grab, T) :- at_gold(T).

• How well can a reflex agent work?

Situation Calculus

• A way to keep track of change
• We have a state or situation parameter to

every predicate that can vary

• We also must keep track of the resulting

situations for our actions

• Effect axioms
• Frame axioms
• Successor-state axioms

Frame Problem

• How do we represent what is and is not true

and how things change?

• Reasoning requires keeping track of the

state when it seems we should be able to ignore what does not change

Wumpus Agent’s Location

• Where agent is:

at(agent, [1,1], s0).

• Which way agent is facing:
• rientation(agent,s0) = 0.
• We can now identify the square in front of the

agent:

location_toward([X,Y],0) = [X+1,Y]. location_toward([X,Y],90) = [X, Y+1].

• We can then define adjacency:

adjacent(Loc1, Loc2) :- Loc1 = location_toward(L2,D).

Changing Location

at(Person, Loc, result(Act,S)) :- (Act = forward, Loc = location_ahead(Person, S), \+wall(loc)) ; (at(Person, Loc, S), A \= forward).

• Similar rule required for orientation that

specifies how turning changes the orientation and that any other action leaves the orientation the same

Deducing Hidden Properties

breezy(Loc) :- at(agent, Loc, S), breeze(S). Smelly(Loc) :- at(agent, Loc, S), Stench(S).

• Causal Rules

smelly(Loc2) :- at(wumpus, Loc1, S), adjacent(Loc1, Loc2). breezy(Loc2) :- at(pit, Loc1, S), adjacent(Loc1, Loc2).

• Diagnostic Rules
• k(Loc2) :-

percept([none, none, G, U, C], T), at(agent, Loc1, S), adjacent(Loc1, Loc2).

Preferences Among Actions

• We need some way to decide between the

possible actions.

• We would like to do this apart from the

rules that determine what actions are possible.

• We want the desirability of actions to be

based on our goals.

Handling Goals

• Original goal is to find and grab the gold
• Once the gold is held, we want to find the

starting square and climb out

• We have three primary methods for finding

a path out

– Inference (may be very expensive) – Search (need to translate problem) – Planning (which we’ll discuss later)

Wumpus World in Practice

• Not going to use situation calculus
• Instead, just maintain the current state of the

world

• Advantages?
• Disadvantages?

Inference in FOPC

• As with propositional logic, we want to be

able to draw logically sound conclusions from

• ur KB
• Soundness:

– If we can infer A from B, B entails A. – If B |- A, then B |= A

• Complete

– If B entails A, then we can infer A from B – If B |= A, then B |- A

Inference Methods

• Three styles of inference:

– Forward chaining – Backward chaining – Resolution refutation

• Forward and backward chaining are sound

and can be reasonably efficient but are incomplete

• Resolution is sound and complete for

FOPC, but can be very inefficient

Inference Rules for Quantifiers

• The inference rules for propositional logic also

work for first order logic

• However, we need some new rules to deal with

quantifiers

• Let SUBST(q, a) denote the result of applying a

substitution or binding list q to the sentence a.

SUBST({x/Tom, y,/Fred}, Uncle(x,y)) = Uncle(Tom, Fred)

Universal Elimination

• Formula:

"v a |- SUBST({v/g},a)

• Constraints:

– for any sentence, a, variable, v, and ground term, g

• Example:

"x Loves(x, FOPC) |- Loves(Califf, FOPC)

Existential Elimination

• Formula:

$v a |- SUBST({v/k},a)

• Constraints:

– for any sentence, a, variable, v, and constant symbol, k, that doesn't occur elsewhere in the KB (Skolem constant)

• Example:

$x (Owns(Mary,x)  Cat(x)) |- Owns(Mary,MarysCat)  Cat(MarysCat)

Existential Introduction

• Formula:

a |- $v SUBST({g/v},a)

• Constraints:

– for any sentence, a, variable, v, that does not

• ccur in a, and ground term, g, that does occur

in a

• Example:

Loves(Califf, FOPC) |- $x Loves(x, FOPC)

Sample Proof

1) "x,y(Parent(x, y)  Male(x)  Father(x,y)) 2) Parent(Tom, John) 3) Male(Tom) Using Universal Elimination from 1) 4) "y(Parent(Tom, y)  Male(Tom)  Father(Tom, y)) Using Universal Elimination from 4) 5) Parent(Tom, John)  Male(Tom)  Father(Tom, John) Using And Introduction from 2) and 3) 6) Parent(Tom, John)  Male(Tom) Using Modes Ponens from 5) and 6) 7) Father(Tom, John)

Generalized Modus Ponens

• Combines three steps of “natural deduction”

(Universal Elimination, And Introduction, Modus Ponens) into one.

• Provides direction and simplification to the proof

process for standard inferences.

• Generalized Modus Ponens:

p1', p2', ...pn', (p1  p2 ...pn  q) |- SUBST(q,q) where q is a substitution such that for all i SUBST(q,pi') = SUBST(q,pi)

Example

1) "x,y(Parent(x,y)  Male(x)  Father(x,y)) 2) Parent(Tom,John) 3) Male(Tom) q={x/Tom, y/John) 4) Father(Tom,John)

Canonical Form

• In order to use generalized Modus Ponens,

all sentences in the KB must be in the form

• f Horn sentences:

"v1 ,v2 ,...vn p1  p2 ...pm  q

• Also called Horn clauses, where a clause is

a disjunction of literals, because they can be rewritten as disjunctions with at most one non-negated literal.

"v1 ,v 2 ,...vn ¬p1  ¬p2  ...  ¬ pn  q

Horn Clauses

• Single positive literals (facts) are Horn

clauses with no antecedent.

• Quantifiers can be dropped since all

variables can be assumed to be universally quantified by default.

• Many statements can be transformed into

Horn clauses, but many cannot (e.g. P(x)Q(x), ¬P(x))

Unification

• In order to match antecedents to existing

literals in the KB, we need a pattern matching routine.

• UNIFY(p,q) takes two atomic sentences and

returns a substitution that makes them equivalent.

• UNIFY(p,q)=q where SUBST(q,p)=SUBST(q,q)
• q is called a unifier

Unification Examples

UNIFY(Parent(x,y), Parent(Tom, John)) = {x/Tom, y/John} UNIFY(Parent(Tom,x), Parent(Tom, John)) = {x/John}) UNIFY(Likes(x,y), Likes(z,FOPC)) = {x/z, y/FOPC} UNIFY(Likes(Tom,y), Likes(z,FOPC)) = {z/Tom, y/FOPC} UNIFY(Likes(Tom,y), Likes(y,FOPC)) = fail UNIFY(Likes(Tom,Tom), Likes(x,x)) = {x/Tom} UNIFY(Likes(Tom,Fred), Likes(x,x)) = fail

Same Variable

• Exact variable names used in sentences in the KB

should not matter.

• But if Likes(x,FOPC) is a formula in the KB, it does

not unify with Likes(John,x) but does unify with Likes(John,y)

• We can standardize one of the arguments to UNIFY to

make its variables unique by renaming them.

Likes(x,FOPC) -> Likes(x1 , FOPC) UNIFY(Likes(John,x),Likes(x1 ,FOPC)) = {x1 /John, x/FOPC}

Which Unifier?

• There are many possible unifiers for some

atomic sentences.

– UNIFY(Likes(x,y),Likes(z,FOPC)) =

• {x/z, y/FOPC}
• {x/John, z/John, y/FOPC}
• {x/Fred, z/Fred, y/FOPC}
• ......
• UNIFY should return the most general

unifier which makes the least commitment to variable values.