CPS 270: Artificial Intelligence

http://www.cs.duke.edu/courses/fall08/cps270/

Planning

Instructor: Vincent Conitzer

 Planning
We studied how to take actions in the world
(search)
We studied how to represent objects, relations,
etc. (logic)
Now we will combine the two!
State of the world (STRIPS language)
State of the world = conjunction of positive,
ground, function-free literals
At(Home) AND IsAt(Umbrella, Home) AND
CanBeCarried(Umbrella) AND
IsUmbrella(Umbrella) AND HandEmpty AND Dry
Not OK as part of the state:
NOT(At(Home)) (negative)
At(x) (not ground)
At(Bedroom(Home)) (uses the function Bedroom)
Any literal not mentioned is assumed false
Other languages make different assumptions, e.g.,
negative literals part of state, unmentioned literals
unknown
 An action: TakeObject
TakeObject(location, x)
Preconditions:
HandEmpty
CanBeCarried(x)
At(location)
IsAt(x, location)
Effects (NOT something means that that
something should be removed from state):
Holding(x)
NOT(HandEmpty)
NOT(IsAt(x, location))
 Another action
WalkWithUmbrella(location1, location2,
umbr)
Preconditions:
At(location1)
Holding(umbr)
IsUmbrella(umbr)
Effects:
At(location2)
NOT(At(location1))
 Yet another action
WalkWithoutUmbrella(location1,
location2)
Preconditions:
At(location1)
Effects:
At(location2)
NOT(At(location1))
NOT(Dry)
 A goal and a plan
Goal: At(Work) AND Dry
Recall initial state:
At(Home) AND IsAt(Umbrella, Home) AND
CanBeCarried(Umbrella) AND IsUmbrella(Umbrella)
AND HandEmpty AND Dry
TakeObject(Home, Umbrella)
At(Home) AND CanBeCarried(Umbrella) AND
IsUmbrella(Umbrella) AND Dry AND Holding(Umbrella)
WalkWithUmbrella(Home, Work, Umbrella)
At(Work) AND CanBeCarried(Umbrella) AND
IsUmbrella(Umbrella) AND Dry AND Holding(Umbrella)
 Planning to write a paper
Suppose your goal is to be a co-author on an AI paper
with both theorems and experiments, within a year
ProveTheorems(x)
LearnAbout(x,y)
Preconditions: Knows(x,AI),
Preconditions: HasTimeForStudy(x) Knows(x,Math), Idea
Effects: Knows(x,y), Effect: Theorems, Contributed(x)
NOT(HasTimeForStudy(x))
PerformExperiments(x)
HaveNewIdea(x) Preconditions: Knows(x,AI),
Preconditions: Knows(x,AI), Knows(x,Coding), Idea
Creative(x) Effect: Experiments, Contributed(x)
Effects: Idea, Contributed(x)
WritePaper(x)
Preconditions: Knows(x,AI),
FindExistingOpenProblem(x) Knows(x,Writing), Idea, Theorems,
Experiments
Preconditions: Knows(x,AI)
Effect: Paper, Contributed(x)
Effects: Idea

Name a few things that are

Goal: Paper AND Contributed(You) missing/unrealistic
 Some start states
Start1: HasTimeForStudy(You) AND Knows(You,Math) AND Knows(You,Coding) AND Knows(You,Writing)

Start2: HasTimeForStudy(You) AND Creative(You) AND Knows(Advisor,AI) AND Knows(Advisor,Math) AND Knows(Advisor,Coding) AND Knows(Advisor,Writing)
(Good luck with that plan)

Start3: Knows(You,AI) AND Knows(You,Coding) AND Knows(OfficeMate,Math) AND HasTimeForStudy(OfficeMate) AND

Knows(Advisor,AI) AND Knows(Advisor,Writing)

Start4: HasTimeForStudy(You) AND Knows(Advisor,AI) AND Knows(Advisor,Math) AND Knows(Advisor,Coding) AND

Knows(Advisor,Writing)

Well use these as examples

 Forward state-space search
(progression planning)
Successors: all states that can be reached with an
action whose preconditions are satisfied in current state
At(Home) WalkWithUmbrella( At(Work)
Holding(Umbrella)
Home, Work, Holding(Umbrella)
TakeObject(Home, Umbrella) Umbrella)
CanBeCarried(Umbrella) CanBeCarried(Umbrella)
IsUmbrella(Umbrella) WalkWithoutUm IsUmbrella(Umbrella)
At(Home) brella(Home,
Dry Dry
IsAt(Umbrella, Home) Work)
GOAL!
CanBeCarried(Umbrella)
IsUmbrella(Umbrella) At(Work) WalkWithout
HandEmpty IsAt(Umbrella, Home) Umbrella(Wor At(Home)

Dry CanBeCarried(Umbrella) k, Home) IsAt(Umbrella, Home)

IsUmbrella(Umbrella) CanBeCarried(Umbrella)
WalkWithoutUm
brella(Home, HandEmpty IsUmbrella(Umbrella)

Work) HandEmpty

WalkWithoutUmbrella(
Home, Umbrella) (!)
 Backward state-space search
(regression planning)
Predecessors: for every action that accomplishes one of
the literals (and does not undo another literal), remove
that literal and add all the preconditions
WalkWithUmbrella(
TakeObject(location2, umbr)
location1, Work,
At(location1) At(location1)
umbr)
At(location2) Holding(umbr) At(Work)
IsAt(umbr, location2) IsUmbrella(umbr) Dry
CanBeCarried(umbr) Dry
GOAL
IsUmbrella(umbr)
HandEmpty
WalkWithUmbrella(location2, location1)
Dry

This is accomplished in the

start state, by substituting
location1=location2=Home, WalkWithoutUmbrella can never be used, because it undoes Dry
umbr=Umbrella
(this is good)
 Heuristics for state-space search
Cost of a plan: (usually) number of actions
Heuristic 1: plan for each subgoal (literal)
separately, sum costs of plans
Does this ever underestimate? Overestimate?
Heuristic 2: solve a relaxed planning problem in
which actions never delete literals (empty-delete-
list heuristic)
Does this ever underestimate? Overestimate?
Very effective, even though requires solution to (easy)
planning problem
Progression planners with empty-delete-list
heuristic perform well
 Blocks world
B D
A C

On(B, A), On(A, Table), On(D, C), On(C,

Table), Clear(B), Clear(D)
 Blocks world: Move action
B D
A C

Move(x,y,z)
Preconditions:
On(x,y), Clear(x), Clear(z)
Effects:
On(x,z), Clear(y), NOT(On(x,y)), NOT(Clear(z))
Blocks world: MoveToTable action
B D
A C

MoveToTable(x,y)
Preconditions:
On(x,y), Clear(x)
Effects:
On(x,Table), Clear(y), NOT(On(x,y))
 Blocks world example
B D
A C
Goal: On(A,B) AND Clear(A) AND On(C,D)
AND Clear(C)
A plan: MoveToTable(B, A), MoveToTable(D,
C), Move(C, Table, D), Move(A, Table, B)
Really two separate problems
 A partial-order plan
B D
Start
A C
MoveToTable( MoveToTable(
Goal: On(A,B) AND B,A) D,C)
Clear(A) AND
On(C,D) AND Move(A, Move(C,
Table, B) Table, D)
Clear(C)
Any total order on the actions consistent with
this partial order will work Finish
A partial-order plan (with more detail)
Start
On(B,A) Clear(B) On(A, Table) On(C, Table) Clear(D) On(D,C)

On(B,A) Clear(B) Clear(D) On(D,C)

MoveToTable(B, MoveToTable(D,
A) C)

Clear(A) Clear(B) On(A, Table) On(C, Table) Clear(D) Clear(C)

Move(A,T Move(C,T
able, B) able, D)

On(A, B) Clear(A) Clear(C) On(C, D)

Finish
 Not everything decomposes into
multiple problems: Sussman Anomaly
C
A B
Goal: On(A,B) AND On(B,C)
Focusing on one of these two individually first
does not work
Optimal plan: MoveToTable(C,A),
Move(B,Table,C), Move(A,Table,B)
An incorrect partial order plan for
the Sussman Anomaly
Start
Clear(C) On(C, A) On(A, Table) On(B, Table) Clear(B)

Clear(C) On(C, A)
Clear(C) On(B, Table) Clear(B)
MoveToTable(C,
A) Move(B,
Table,C)
Clear(A) On(A, Table) Clear(B) Move(B,Table,C) must be
Move(A, after MoveToTable(C,A),
otherwise it will ruin
Table,B)
Clear(C)
Move(A,Table,B) must be
On(A, B) On(B, C) after Move(B,Table,C),
Finish otherwise it will ruin
Clear(B)
Corrected partial order plan for the
Sussman Anomaly
Start
Clear(C) On(C, A) On(A, Table) On(B, Table) Clear(B)

Clear(C) On(C, A)
Clear(C) On(B, Table) Clear(B)
MoveToTable(C,
A) Move(B,
Table, C)
Clear(A) On(A, Table) Clear(B)

Move(A,
Table, B)
No more flexibility in the
order due to protection of
On(A, B) On(B, C) causal links
Finish
 Searching for partial-order plans
Somewhat similar to constraint satisfaction
Search state = partially completed partial order plan
Not to be confused with states of the world
Contains actions, ordering constraints on actions, causal links, some open
preconditions
Search works as follows:
Choose one open precondition p,
Consider all actions that achieve p (including ones already in the plan),
For each such action, consider each way of resolving conflicts using ordering
constraints
Why do we need to consider only one open precondition (instead of
all)? Is this true for backward state-space search?
Tricky to resolve conflicts if we leave variables unbound
 Searching for a partial-order plan
Start
At(Home) IsAt(Umbrella,Home) CanBeCarried(Umbrella) IsUmbrella(Umbrella) HandEmpty Dry

At(Home) IsAt(Umbrella,Home) CanBeCarried(Umbrella) HandEmpty

TakeObject(Home,
Umbrella)
At(Home)Holding(Umbrella) IsUmbrella(Umbrella)

WalkWithUmbrella(H
At(Home) ome, Work

WalkWithoutUmbrella(H
ome, Work

no way to resolve conflict!

At(Work) Dry

Finish
 Planning graphs
On(C, A) On(C, A)
Each level has literals
Move(C,A,B)
that could be true at
On(A, Table) On(A, Table) that level

Clear(C)
Mutex (mutual
Clear(C)
exclusion) relations
MoveToTable(C,A)
indicate incompatible
On(B, Table)
On(B, Table) actions/literals
Clear(B) Clear(B)
Move(B,Table,C) Clear(A) continued on board
On(C, B)

On(C, Table)

On(B, C)
 Reasons for mutex relations
between actions:
Inconsistent effects: one action negates effect of
the other
Interference: effect of one action negates
precondition of the other
Competing needs: the actions have preconditions
that are mutex
between literals:
Inconsistent support: any pair of actions that can
achieve these literals is mutex
 A problematic case for
planning graphs
FeedWith(x, y)
Preconditions: Edible(y)
Effects: NOT(Edible(y)), Fed(x)
Start: Edible(Bread1), Edible(Bread2)
Goal: Fed(Person1), Fed(Person2),
Fed(Person3)
 Planning graph for feeding
Edible(Bread1) Edible(Bread1)
FeedWith(Person1,
Any two of these could
Bread1)
simultaneously be true at
time 1, so no mutex
FeedWith(Person2,
Bread1) relations
Fed(Person1)
Really need 3-way mutex
FeedWith(Person3, relations, but experimentally
Bread1)
Fed(Person2) this is computationally not
worthwhile
FeedWith(Person1,
Bread2)
Fed(Person3)

FeedWith(Person2,
Bread2)

FeedWith(Person3,
Edible(Bread2) Bread2) Edible(Bread2)
 Uses of planning graphs
If the goal literals do not all appear at a level (or
have mutex relations) then we know we need
another level
Converse does not hold
Useful heuristic: first time that all goal literals
appear at a level, with no mutex relations
Graphplan algorithm: once all goal literals appear,
try to extract solution from graph
Can use CSP techniques by labeling each action as in
the plan or out of the plan
In case of failure, generate another level