1. AI Planning

2. The planning problem Inputs: Output:
1. A description of the world state
2. The goal state description
3. A set of actions
Output:
A sequence of actions that if applied to the initial state, transfers the world to the goal state

3. An example – Blocks world
Blocks on a table
Can be stacked, but only one block on top of another
A robot arm can pick up a block and move to another position
On the table
On another block
Arm can pick up only one block at a time
Cannot pick up a block that has another one on it

4. STRIPS Representation
State is a conjunction of positive ground literals
On(B, Table) Λ Clear (A)
Goal is a conjunction of positive ground literals
Clear(A) Λ On(A,B) Λ On(B, Table)
STRIPS Operators
Conjunction of positive literals as preconditions
Conjunction of positive and negative literals as effects

5. More on action schema Example: Move (b, x, y)
Precondition: Block(b) Λ Clear(b) Λ Clear(y) Λ On(b,x) Λ (b ≠ x) Λ (b ≠ y) Λ (y ≠ x)
Effect: ¬Clear(y) Λ ¬On(b,x) Λ Clear(x) Λ On(b,y)
An action is applicable in any state that satisfies its precondition
Delete list
Add list

6. STRIPS assumptions Closed World assumption STRIPS assumption
Unmentioned literals are false (no need to explicitly list out)
STRIPS assumption
Every literal not mentioned in the “effect” of an action remains unchanged
Atomic Time (actions are instantaneous)

7. STRIPS expressiveness
Literals are function free: Move (Block(x), y, z)
operators can be propositionalized (= actions)
Move(b,x,y) and 3 blocks and table can be expressed as 48 purely propositional actions
No disjunctive goals: On(B, Table) V On(B, C)
No conditional effects: On(B, Table) if ¬On(A, Table)

8. Planning algorithms Planning algorithms are search procedures
Which state to search?
State-space search
Each node is a state of the world
Plan = path through the states
Plan-space search
Each node is a set of partially-instantiated operators and set of constraints
Plan = node

9. State search
Search the space of situations, which is connected by operator instances (= actions)
The sequence of actions = plan
We have both preconditions and effects available for each operator, so we can try different searches: Forward vs. Backward

10. Planning: Search SpaceB C A B C B A B A C B A C B A B C C B A B A C A C A A B C B C C B A A B C

11. Forward state-space search (1)
Progression
Initial state: initial state of the problem
Actions:
Applied to a state if all the preconditions are satisfied
Succesor state is built by updating current state with add and delete lists
Goal test: state satisfies the goal of the problem

12. Progression (forward search)
ProgWS(world-state, goal-list, PossibleActions, path)
If world-state satisfies all goals in goal-list,
Then return path.
Else Act = choose an action whose precondition is true in world-state
If no such action exists
Then fail
Else return ProgWS( result(Act, world-state),
goal-list, PossibleActions,
concatenate(path, Act) )

13. Forward search in the Blocks world… …

14. Forward state-space search (2)
Advantages
No functions in the declarations goals  search state is finite
Sound
Complete (if algorithm used to do the search is complete)
Limitations
Irrelevant actions  not efficient
Need heuristic or pruning procedure

15. Backward state-space search (1)
Regression
Initial state: goal state of the problem
Actions:
Choose an action A that
Is relevant; has one of the goal literals in its effect set
Is consistent; does not negate another literal
Construct new search state
Remove all positive effects of A that appear in goal
Add all preconditions of A, unless already appears
Goal test: initial world state contains remaining goals

16. Regression (backward search)
RegWS(initial-state, current-goals, PossibleActions, path)
If initial-state satisfies all of current-goals
Then return path
Else Act = choose an action whose effect matches one of current-goals
If no such action exists, or the effects of Act contradict some of current-goals, then fail
G = (current-goals – goals-added-by(Act)) + preconds(Act)
If G contains all of current-goals, then fail
Return RegWS(initial-state, G, PossibleActions,
concatenate(Act, path))

17. Backward state-space search (2)
Advantages
Consider only relevant actions  much smaller branching factor
Limitations
Still need heuristic to be more efficient

18. Comparing ProgWS and RegWS
Both algorithms are
sound (they always return a valid plan)
complete (if a valid plan exists they will find one)
Running time is O(bn)
where b = branching factor,
n = number of “choose” operators

19. Efficiency of Backward Search…
a50 a3
initial state
goal
Backward search can also have a very large branching factor
E.g., many relevant actions that don’t regress toward the initial state
As before, deterministic implementations can waste lots of time trying all of them

20. Lifting
p(a,a)
foo(a,a)
p(a,b)
foo(x,y)
precond: p(x,y)
effects: q(x)
foo(a,b)
p(a,c)
q(a)
foo(a,c) …
Can reduce the branching factor of backward search if we partially instantiate the operators
this is called lifting
foo(a,y)
q(a)
p(a,y)

21. The Search Space is Still Too Large
Backward-search generates a smaller search space than Forward-search, but it still can be quite large
Suppose a, b, and c are independent, d must precede all of them, and d cannot be executed
We’ll try all possible orderings of a, b, and c before realizing there is no solution d a b c d b a d b a
goal b d a c d b c a d c b

22. A ground version of the STRIPS algorithm.

23. Blocks world: STRIPS operators
Pickup(x)
Pre: on(x, Table), clear(x), ae
Del: on(x, Table), ae
Add: holding(x)
Putdown(x)
Pre: holding(x)
Del: holding(x)
Add: on(x, Table), ae
UnStack(x,y)
Pre: on(x, y), ae
Del: on(x, y), ae
Add: holding(x), clear(y)
Stack(x, y)
Pre: holding(x), clear(y)
Del: holding(x), clear(y)
Add: on(x, y), ae

24. STRIPS Planning C D A B D A C Current state: Goal
on(A,table), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D), ae.
Goal
on(A,C), on(D, A)

25. STRIPS Planning Plan: Goalstack: on(A,C), on(D,A) on(A,C) Stack(A, C)
holding(A), clear(C)
holding(A)
Pickup(A)
on(A,Table), clear(A), ae C A B D
on(A,table), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D), ae.
Current State

26. STRIPS Planning Plan: Goalstack: on(A,C), on(D,A) on(A,C) Stack(A, C)
holding(A), clear(C)
Pickup(A)
Pre: on(A,Table), clear(A), ae
Del: on(A, Table), ae,
Add: holding(A)
holding(A)
Pickup(A) C A B D
holding(A), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D).
on(A,table), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D), ae.
Current State

27. STRIPS Planning Plan: Goalstack: on(A,C), on(D,A) Pickup(A) on(A,C)
Stack(A, C)
Stack(A, C)
Pre: holding(A), clear(C)
Del: holding(A), clear(C)
Add: on(A, C), ae A C B D
on(A,C), on(C, B), on(B,table), on(D,table), clear(A), clear(D), ae.
holding(A), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D).
Current State

28. STRIPS Planning Plan: Goalstack: on(A,C), on(D,A) Pickup(A) on(D, A)
Stack(A, C)
Stack(D,A)
holding(D), clear(A)
holding(D)
Pickup(D)
on(D,Table), clear(D), ae A C B D
on(A,C), on(C, B), on(B,table), on(D,table), clear(A), clear(D), ae.
on(A,C), on(C, B), on(B,table), holding(D), clear(A), clear(D)
on(A,C), on(C, B), on(B,table), on(D,A), clear(A), ae
Current State

29. STRIPS Planning Plan: Goalstack: on(A,C), on(D,A) Pickup(A) on(D, A)
Stack(A, C)
Stack(D,A)
Pickup(D)
holding(D), clear(A)
holding(D) D A C B
on(A,C), on(C, B), on(B,table), on(D,A), clear(A), ae
on(A,C), on(C, B), on(B,table), holding(D), clear(A), clear(D)
Current State

30. STRIPS Planning: Getting it Wrong!D
Plan:
Goalstack:
on(A,C), on(D,A) A C
on(D,A)
Stack(D, A)
holding(D), clear(A)
holding(D)
Pickup(D)
on(D,Table), clear(D), ae C A B D
on(A,table), on(C, B), on(B,table), holding(D), clear(A), clear(C), clear(D)
on(A,table), on(C, B), on(B,table), on(D,table), clear(A), clear(C), clear(D), ae.
Current State

31. STRIPS Planning: Getting it Wrong!D
Plan:
Goalstack:
on(A,C), on(D,A) A C
Pickup(D)
on(D,A)
Stack(D, A) D C A B
on(A,table), on(C, B), on(B,table), on(D,A), clear(C), clear(D), ae.
on(A,table), on(C, B), on(B,table), holding(D), clear(A), clear(C), clear(D)
Current State

32. STRIPS Planning: Getting it Wrong!D
Plan:
Goalstack:
on(A,C), on(D,A) A C
Pickup(D)
Stack(D, A)
Now What?
We chose the wrong goal first
A is no longer clear.
stacking D on A messes up the preconditions for actions to accomplish on(A, C)
either have to backtrack, or else we must undo the previous actions D C A B
on(A,table), on(C, B), on(B,table), on(D,A), clear(C), clear(D), ae.
Current State

33. Limitation of state-space search
Linear planning or Total order planning
Example
Initial state: all the blocks are clear and on the table
Goal: On(A,B) Λ On(B,C)
If search achieves On(A,B) first, then needs to undo it in order to achieve On(B,C)
Have to go through all the possible permutations of the subgoals

34. Search through the space of plans
Nodes are partial plans, links are plan refinement operations and a solution is a node (not a path).
POP creates partial-order plans following a “least commitment” principle.

35. Total Order Plans: Partial Order Plans: Start Start Start Start Start
Right
Sock
Right
Sock
Left
Sock
Left
Sock
Right
Sock
Left
Sock
Left
Sock
Right
Sock
Left
Sock
Left
Sock
Right
Sock
Right
Sock
Right
Shoe
Left
Shoe
Left Sock on
Right Sock on
Left
Shoe
Right
Shoe
Right
Shoe
Left
Sock
Right
Shoe
Left
Shoe
Left
Sock
Right
Sock
Right Shoe on
Left Shoe on
Right
Shoe
Left
Shoe
Right
Shoe
Left
Shoe
Right
Shoe
Left
Shoe
Finish
Finish
Finish
Finish
Finish
Finish
Finish

36. P.O. plans in POP Plan = (A, O, L), where
A is the set of actions in the plan
O is a set of temporal orderings between actions
L is a set of causal links linking actions via a literal
Causal link means that Ac has precondition Q that is established in the plan by Ap.
move-a-from-b-to-table move-c-from-d-to-b Ap Ac Q
(clear b)

37. Threats to causal links
Step At threatens link if:
At has (~Q) as an effect
At could come between Ap and Ac, i.e., O is consistent with Ap < At < Ac Ap Ac Q

38. Threat Removal Threats must be removed to prevent a plan from failing
Demotion adds the constraint At < Ap to prevent clobbering, i.e. push the clobberer before the producer
Promotion adds the constraint Ac < At to prevent clobbering, i.e. push the clobberer after the consumer

39. Initial (Null) Plan Initial plan has
A = { A0, A¥}
O = {A0 < A¥}
L = {}
A0 (Start) has no preconditions but all facts in the initial state as effects.
A¥ (Finish) has the goal conditions as preconditions and no effects.

40. POP algorithm POP((A, O, L), agenda, PossibleActions):
If agenda is empty, return (A, O, L)
Pick (Q, An) from agenda
Ad = choose an action that adds Q.
If no such action exists, fail.
Add the link Ad An to L and the ordering Ad < An to O
If Ad is new, add it to A.
Remove (Q, An) from agenda. If Ad is new, for each of its preconditions P add (P, Ad) to agenda.
For every action At that threatens any link
Choose to add At < Ap or Ac < At to O.
If neither choice is consistent, fail.
POP((A, O, L), agenda, PossibleActions) Q Ap Ac Q

41. Analysis
POP can be much faster than the state-space planners because it doesn’t need to backtrack over goal orderings (so less branching is required).
Although it is more expensive per node, and makes more choices than RegWS, the reduction in branching factor makes it faster, i.e., n is larger but b is smaller!

42. More analysis Does POP make the least possible amount of commitment?
Lifted POP: Using Operators, instead of ground actions,
Unification is required

43. POP in the Blocks world PutOn(x,y) Cl(x), Cl(y), On(x,z)
PutOnTable(x)
On(x, z) Cl(x)
On(x,Table), Cl(x), ~On(x,z)

44. POP in the Blocks world

45. POP in the Blocks world

46. POP in the Blocks world

47. POP in the Blocks world

48. Example 2 A0: Start A¥ : Finish
At(Home) Sells(SM,Banana) Sells(SM,Milk) Sells(HWS,Drill)
A¥ : Finish
Have(Drill) Have(Milk) Have(Banana) At(Home)
Have(y)
Buy (y,x)
At(x), Sells(x,y)
GO (x,y)
At(x)
At(y) ~At(x)

49. POP Example x1 = SM start x2 = SM At(x3) x3 = H
Sells(SM, M) Sells(SM,B) At(H)
GO (x3,SM)
At(SM)
At(x1) Sells(x1,M)
At(x2) Sells(x2, B)
Buy (M,x1)
Buy (B,x2)
Have(M)
Have(B)
Have(M) Have(B)
finish