Artificial Intelligence: Planning System

Artificial Intelligence
Planning System
L. Manevitz
All rights reserved L. Manevitz Lecture 6 1

©
Components of a Planning
System
• Chose the best rule to apply next based on
the best available heuristic information.
• Apply the chosen rule to compute the new

problem state that arises from its
application.
• Detect when a solution has been found.

©
Components of a Planning
System cont.
• Detect dead ends so that they can be
abandoned and the system’s effort directed
in more fruitful directions.
• Detect when an almost correct solution has

been found and employ special techniques
to make it totally correct.

©
The Blocks World
• Operators:
– UNSTACK(A,B) – Pick up block A from its
current position on block B. The arm must be
empty and block A must have no blocks on
top of it.
– STACK(A,B) – Place block A on block B.
The arm must already be holding A and the
surface of B must be clear.

©
The Blocks World cont.
– PICKUP(A) – Pick up block A from the table
and hold it. Te arm must be empty and there
must be nothing on top of block A.
– PUTDOWN(A) – Put block A down on the
table. The arm must have been holding block
A.

©
• Predicates:
– ON(A,B) – Block A is on block B.
– ONTABLE(A) – Block A is on the table.
– CLEAR(A) – There is nothing on top of
block A.
– HOLDING(A) – The arm is holding block
A.
– ARMEMPTY – The arm is holding nothing.

©
• Inference rules:
– [ x : HOLDING(x)] ARMEMPTY
– x : ONTABLE(x) y : ON(x,y)
– x:[ y : ON(y,x)] CLEAR(x)

©
A Simple Blocks World
Description
A
B
ON(A,B,S0)
ONTABLE(B,S0)
CLEAR(A,S0)

©
STRIPS – Style Operate for the
Blocks World
STACK(x,y)
P: CLEAR(y) HOLDING(x)
D: CLEAR(y) HOLDING(x)
A: ARMEMPTY ON(x,y)
UNSTACK(x,y)
P: ON(x,y) CLEAR(x) ARMEMPTY
D: ON(X,Y) ARMEMPTY
A: HOLDING(x) CLEAR(y)
©
STRIPS – Style Operate for the
Blocks World cont.
PICKUP(x)
P: CLEAR(x) ONTABLE(x) ARMEMPTY
D: ONTABLE(x) ARMEMPTY
A: HOLDING(x)
PUTDOWN(x)
P: HOLDING(x)
D: HOLDING(x)
A: ONTABLE(x) ARMEMPTY
©
A Simple Search Tree
1
UNSTACK(A,B)
2
PUTDOWN(A)
3
Global database at this point
ONTABLE(B) CLEAR(A)
CLEAR(B) ONTABLE(A)

©
A Very Simple Blocks World
Problem
B C B
A C D A D
Start: ON(B,A) Goal: ON(C,A)

ONTABLE(A) ON(B,D)
ONTABLE(C) ONTABLE(A)
ONTABLE(D) ONTABLE(D)
ARMEMPTY
©
Goal Stack Planning
1) Initial goal stack:
ON(C,A) ON(B,D) ONTABLE(A) ONTABLE(D)

©
Goal Stack Planning cont.
2) Choose to work on ON(C,A) before
ON(B,D):
ON(C,A)
ON(B,D)
ON(C,A) ON(B,D) OTAD

©
3) Achieve ON(C,A) with STACK(C,A):
ON(C,A)
STACK(C,A)
ON(B,D)

©
4) Add STACK’s preconditions:
CLEAR(A)
HOLDING(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)

©
5) Achieve CLEAR(A) with UNSTACK(B,A):
ON(B,A)
CLEAR(B)
ARMEMPTY
ON(B,A) CLEAR(B) ARMEMPTY
UNSTACK(B,A)
CLEAR(A)
HOLDING(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
6) Pop satisfied predicates:
ON(B,A)
CLEAR(B)
ARMEMPTY
ON(B,A) CLEAR(B) ARMEMPTY
UNSTACK(B,A)
HOLDING(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
7) Achieve HOLDING(C) with UNSTACK(C,x):
ON(C,x)
CLEAR(C)
ARMEMPTY
ON(C,x) CLEAR(C) ARMEMPTY
UNSTACK(C,x)
HOLDING(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
8) Achieve ON(C,x) by STACK(C,x):
CLEAR(x)
HOLDING(C)
CLEAR(x) HOLDING(C)
ON(C,x)
STACK(C,x)
CLEAR(C)
ARMEMPTY
UNSTACK(C,x)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
9) Terminate path because HOLDING(C) is
duplicated. CLEAR(x)
HOLDING(C)
CLEAR(x) HOLDING(C)
STACK(C,x)
CLEAR(C)
ARMEMPTY
UNSTACK(C,x)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
10) Achieve HOLDING(C) with PICKUP, not
UNSTACK:
ONTABLE(C)
CLEAR(C)
ARMEMPTY
ONTABLE(C) CLEAR(C) ARMEMPTY
PICKUP(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
11) Pop ONTABLE(C) and CLEAR(C), and
achieve ARMEMPTY by STACK(B,D):
CLEAR(D)
ONTABLE(C)
HOLDING(B)
CLEAR(C) HOLDING(B)
CLEAR(D)
ARMEMPTY
STACK(B,D)
ONTABLE(C) CLEAR(C) ARMEMPTY
PICKUP(C)
CLEAR(A) HOLDING(C)
STACK(C,A)
ON(B,D)
©
12) Pop entire stack, and return plan:
i. UNSTACK(B,A).
ii. STACK(B,D).
iii. PICKUP(C).
iv. STACK(C,A).

©
A Slightly Harder Blocks
Problem
A
C B
A B C
Start: ON(C,A) Goal: ON(A,B)

ONTABLE(A) ON(B,C)
ONTABLE(B)
ARMEMPTY
©
Goal Stack Planning
• There are two ways to begin solving:
1 2
ON(A,B) ON(B,C)
ON(B,C) ON(A,B)
ON(A,B) ON(B,C) ON(A,B) ON(B,C)

©
• Let’s choose alternative 1.we will eventually
produce this goal stack:
CLEAR(C)
ARMEMPTY
CLEAR(C) ARMEMPTY
UNSTACK(C,A)
CLEAR(A)
ARMEMPTY
CLEAR(A) ARMEMPTY
PICKUP(A)
HOLDING(A)
CLEAR(B) HOLDING(A)
STACK(A,B)
ON(A,B)
ON(B,C)
ON(A,B) ON(B,C)
©
• We can pop off the stack goals that have
already been satisfied:
CLEAR(C)
ARMEMPTY
To satisfy CLEAR(C) ARMEMPTY
UNSTACK(C,A)
HOLDING(C)
ARMEMPTY we ARMEMPTY
PUTDOWN(C)
need to CLEAR(A) ARMEMPTY
PUTDOWN(C). PICKUP(A)
CLEAR(B) HOLDING(A)
STACK(A,B)
ON(B,C)
ON(A,B) ON(B,C)
©
• We can continue popping:
HOLDING(C)
PUTDOWN(C)
CLEAR(A) ARMEMPTY
PICKUP(A)
CLEAR(B) HOLDING(A)
STACK(A,B)
ON(B,C)
ON(A,B) ON(B,C)

©
• The current state is:
A
ONTABLE(B)
C B
ON(A,B)
ONTABLE(C)
ARMEMPTY
• The sequence of operators applied so far is:
1. UNSTACK(C,A)
2. PUTDOWN(C)
3. PICKUP(A)
4. STACK(A,B)

©
• Now we can begin to work on ON(B,C).
We need to stack B on C. To do that we
need to unstack A from B. By the time we
have achieved the goal ON(B,C), and
popped it off the stack, we will have
executed the following additional sequence
of operators

©
• The sequence of operators :
5. UNSTACK(A,B)
6. PUTDOWN(A)
7. PICKUP(B)
8. STACK(B,C)
• The problem state will be:
ON(B,C)
ONTABLE(A) B
ONTABLE(C) C A
ARMEMPTY
©
• But now when we check the remaining goal on
the stack:
ON(A,B) ON(B,C)
we discover that it is not satisfied.
We have undone ON(A,B) in the process of
achieving ON(B,C).
• The sequence of operators we need to add:
9. PICKUP(A)
10. STACK(A,B)

©
The complete plan that has been discovered is:
1. UNSTACK(C,A)
2. PUTDOWN(C) Although this plan
3. PICKUP(A) will achieve the desired
4. STACK(A,B) goal, it does not do so
5. UNSTACK(A,B) very efficiently.
6. PUTDOWN(A)
7. PICKUP(B) The same would have
8. STACK(B,C) happened if we had
9. PICKUP(A) chosen the
10. STACK(A,B) second alternative.

©
• There are two approaches we can take to the
question of how a good plan could be found:
1. Look at ways to repair the plan we already have –
look for places in the plan where we perform an
operation and then immediately undo it. We can
eliminate both the doing and the undoing steps from
the plan.
2. Use a plan-finding procedure that could construct
efficient plans directly – the Nonlinear Planning.

©
Repairing the First Plan
1. UNSTACK(C,A)
2. PUTDOWN(C)
3. PICKUP(A) 1. UNSTACK(C,A)
4. STACK(A,B) 2. PUTDOWN(C)
5. UNSTACK(A,B) 3. PICKUP(B)
6. PUTDOWN(A) 4. STACK(B,C)
7. PICKUP(B) 5. PICKUP(A)
8. STACK(B,C) 6. STACK(A,B)
9. PICKUP(A)
10. STACK(A,B)

©
The Nonlinear Planning
• Begin work on the goal ON(A,B) by
clearing A, thus putting C on the table.
C
A B C

©
Nonlinear Planning cont.
• Achieve the goal ON(B,C) by stacking B
on C.
B
A B C

©
Nonlinear Planning cont.
• Complete the goal ON(A,B) by stacking A
on B.
A
B
A C

©
Backwards Non-Linear Planner
• Finds “Last Operator” recursively
• Uses theorem prover to prune paths

©
©
The Problem Solving System
NOAH
• NOAH plans by developing a hierarchy of
subgoals.
• The procedural net contains several levels of
representation of a plan, each level more detailed
than the previous one.
• For example: the node representing the abstract
goal make coffee may be expanded to : grind
coffee, boil water, put the coffee in a filter, pour
the water through it.
©
©
NOAH cont.
• We’ll use NOAH to solve the blocks problem.
• The operators used in this example are slightly
different from those we have been using .
• STACK – will put any object on any other
(including the table), provided that both objects
are clear. It includes the picking up of the object
to be moved.

©
The Blocks Problem
• A reminder of the problem : A
C B
A B C
Start: ON(C,A) Goal: ON(A,B)

ONTABLE(A) ON(B,C)
ONTABLE(B)
ARMEMPTY
©
NOAH Solution
• The initial state of the problem solver:
(ON(A,B) ON(B,C)) Level 1

©
NOAH Solution cont.
• The first thing that it does is to divide the
problem into two subproblems:
ON(A,B)
S J Level 2
ON(B,C)
Split Join

©
NOAH Solution cont.
• At the third level the preconditions of STACK
are considered – the two blocks involved must be
clear.
Level 3: before criticism
1 CLEAR(A)
S J 3 STACK(A,B)
2 CLEAR(B)
S J
4 CLEAR(B)
S J 6 STACK(B,C)
5 CLEAR(C)
©
NOAH Solution cont.
• Now NOAH employs a set of critics to
examine the plan and detect interactions
among the subplans.
• Each critic is a little program that makes

specific observations about the proposed
plan.

©
The Resolve Conflicts critic
• The Resolve Conflicts critic – constructs a
table that lists all the literals that are
mentioned more than once in the plan.
CLEAR(B): asserted: node 2 “Clear B”
denied: node 3 “Stack A on B”
asserted: node 4 “Clear B”
CLEAR(C): asserted: node 5 “Clear C”
denied: node 6 “Stack B on C”

©
cont.
• Constraints on the ordering of operation
arise when a given literal must be true
before one operation can be performed but
will be undone by another.
CLEAR(B): denied: node 3 “Stack A on B”
asserted: node 4 “Clear B”

©
cont.
• Conclusion:
Since putting A on B could undo the
preconditions for putting B on C, putting B
on C needs to be done first.

©
NOAH Solution cont.
• The third level after criticism to resolve
conflicts:
Level 3
CLEAR(A)
S J STACK(A,B)
CLEAR(B)
S
CLEAR(B)
S J STACK(B,C)
CLEAR(C)

©
Eliminate Redundant
Preconditions
• Can be invoked to eliminate the redundant
specification of subgoals. In this case
CLEAR(B) appears twice and is only
denied by the last step of the plan.

©
NOAH Solution cont.
• The third level after all criticism:
Level 3
CLEAR(A)
J STACK(A,B)
S
CLEAR(B)
S J STACK(B,C)
CLEAR(C)

©
NOAH Solution cont.
• To clear A, C must be removed from A. in
order to do that C must be clear :
Level 4: before criticism
CLEAR(C) STACK(C,x)
S J STACK(A,B)
CLEAR(B)
S J STACK(B,C)
CLEAR(C)

©
• The critic observes that putting B on C will
make CLEAR(C) false, so everything that
depends on C being clear will have to be
done before B is put on C.

©
NOAH Solution cont.
• The Resolve Conflicts critic is employed:
CLEAR(C) STACK(C,x)
S
J STACK(B,C) STACK(A,B)
CLEAR(B)
S
CLEAR(C) Level 4: after criticism to
resolve conflicts

©
Eliminate Redundant
Preconditions
• It notices that CLEAR(C) is required
twice.
• Since putting C somewhere must occur
before putting B on C, and both require C
being clear then we know that when we get
to putting B on C, C will be clear.
• CLEAR(C) can be eliminated from the
lower path.

©
NOAH Solution cont.
• The Eliminate Redundant Preconditions
critic is called: Level 4: after all criticism
CLEAR(C) STACK(C,x)
S
CLEAR(B) J STACK(B,C) STACK(A,B)

©
NOAH Solution cont.
• The system observes that the remaining
goals , CLEAR(C) and CLEAR(B), are
true in the initial state.
• Therefore the final plan is:
Final plan
STACK(C,x) STACK(B,C) STACK(A,B)

©

Artificial Intelligence: Planning System

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Artificial Intelligence: Planning System

Uploaded by

Copyright:

Available Formats

Artificial Intelligence

All rights reserved L. Manevitz Lecture 6 1

• Apply the chosen rule to compute the new

• Detect when a solution has been found.

• Detect when an almost correct solution has

All rights reserved L. Manevitz Lecture 6 3

All rights reserved L. Manevitz Lecture 6 4

All rights reserved L. Manevitz Lecture 6 5

All rights reserved L. Manevitz Lecture 6 6

– x:[ y : ON(y,x)] CLEAR(x)

All rights reserved L. Manevitz Lecture 6 7

All rights reserved L. Manevitz Lecture 6 8

All rights reserved L. Manevitz Lecture 6 11

Start: ON(B,A) Goal: ON(C,A)

ON(C,A) ON(B,D) ONTABLE(A) ONTABLE(D)

All rights reserved L. Manevitz Lecture 6 13

All rights reserved L. Manevitz Lecture 6 14

All rights reserved L. Manevitz Lecture 6 15

All rights reserved L. Manevitz Lecture 6 16

All rights reserved L. Manevitz Lecture 6 24

Start: ON(C,A) Goal: ON(A,B)

All rights reserved L. Manevitz Lecture 6 26

All rights reserved L. Manevitz Lecture 6 29

All rights reserved L. Manevitz Lecture 6 30

All rights reserved L. Manevitz Lecture 6 31

All rights reserved L. Manevitz Lecture 6 33

All rights reserved L. Manevitz Lecture 6 34

All rights reserved L. Manevitz Lecture 6 35

All rights reserved L. Manevitz Lecture 6 36

All rights reserved L. Manevitz Lecture 6 37

All rights reserved L. Manevitz Lecture 6 38

All rights reserved L. Manevitz Lecture 6 39

All rights reserved L. Manevitz Lecture 6 40

All rights reserved L. Manevitz Lecture 6 44

Start: ON(C,A) Goal: ON(A,B)

(ON(A,B) ON(B,C)) Level 1

All rights reserved L. Manevitz Lecture 6 46

All rights reserved L. Manevitz Lecture 6 47

• Each critic is a little program that makes

All rights reserved L. Manevitz Lecture 6 49

All rights reserved L. Manevitz Lecture 6 50

All rights reserved L. Manevitz Lecture 6 51

All rights reserved L. Manevitz Lecture 6 52

All rights reserved L. Manevitz Lecture 6 53

All rights reserved L. Manevitz Lecture 6 54

All rights reserved L. Manevitz Lecture 6 55

All rights reserved L. Manevitz Lecture 6 56

All rights reserved L. Manevitz Lecture 6 57

All rights reserved L. Manevitz Lecture 6 58

All rights reserved L. Manevitz Lecture 6 59

All rights reserved L. Manevitz Lecture 6 60

STACK(C,x) STACK(B,C) STACK(A,B)

All rights reserved L. Manevitz Lecture 6 61

You might also like