From: AAAI Technical Report WS-98-02. Compilation copyright © 1998, AAAI (www.aaai.org). All rights reserved.
Planning
R.
Barrufll
and
with incomplete and dynamic knowledge via
Interactive Constraint Satisfaction
E.
Lamina
and M. Milano
DEIS
Universit~ di Bologna
Viale Risorgimento 2, 40136 Bologna, Italy
{rbarruf
f i,el ~mma,mmilano
} @dei s. unibo,
it
Abstract
Planning activity needs to deal with the
problem of incomplete and dynamic knowledge. In a typical real environment, knowledge has to be dynamically acquired during the computational process, while traditionai planners reason by assuming that
the world is closed and static. Wedeal with
this problemby defining the planning problem as a constraint satisfaction problem
(CSP) in whichvariables range on partially
or completely unknown domains. While
typical CSPs work exclusively with completely knownvariable domains, in our solution, someconstraints, called Interactive
Constraints (IC), may result in a knowledge acquisition and a consequent propagation Knowledgeacquisition can be guided
by ICs in order to retrieve only consistent
information for the planner. Wepresent a
hybrid approach to planning which exploits
this framework both in the generative and
reactive phase.
Introduction
Planning in complex and dynamic domains has
to deal with the problem of incomplete knowledge and changes. Traditional generative planners are based on the unrealistic
assumption of
omniscience (Weld 1994), i.e., the planner requires a complete knowledge of the initial state
of the world. Thus, while those planners manage
to produce correct solutions into simple and static
domains, they cannot cope with most of the real
world domains, such as a networked system domain (Golden 1997), where the knowledge model
is typically incomplete and highly dynamic.
Constraint Satisfaction (CS) techniques (Hentenryck 1989) have been widely used for modeling
and solving planning problems. Weadopt this approach and allow CS techniques to deal with the
problem of incomplete and changing knowledge.
A Constraint Satisfaction Problem (CSP) is defined on a set of variables {vl, v2,.. ¯, vn} ranging
33
P. Mello
Dipartimento di Ingegneria
Universit~ di Ferrara
Via Saragat, 44100 Ferrara, Italy
pmelio@ing.unife. it
on a domain{dl, d2,..., d,~}. Variables are linked
by constraints e(vl,,...,vk~)
that define a subset of the cartesian product of variable domains,
i.e., combinations of values that can appear in a
consistent solution. A solution to a CSPis an assignment of values to variables which is consistent
with constraints. It can be found by interleaving
a propagation and a search process. Standard
CS approaches need all the information on variable domains at the beginning of the computation. This is not the case in a typical real environment where knowledge has to be dynamically
acquired during the computational process. Thus,
we extend the CSP framework in order to treat
constraints on variables ranging on partially or
completely unknown domains. Those constraints,
called Interactive Constraints (IC) (Lammaet al.
1997), may result in a knowledge acquisition process and a consequent propagation.
For example, suppose we have a variable P representing a
printer,
and we do not know beforehand which
printers are available in the system, thus the domain of variable P is unknown. If the consistency
of the constraint onLine(P) is checked, a knowledge acquisition process starts in order to identify
the printers available. On the other hand, if P has
an already known domain (already retrieved by
other constraints),
onLine(P) behaves as a standard constraint by removing those printers which
are not on line.
A more interesting feature of this framework is
that the knowledge acquisition can be driven by
interactive constraints in order to retrieve only
consistent information. For example, the constraint onLine(P) can guide the knowledge acquisition process in order to retrieve only printers on
line and not all the printers of the domain. This
feature is useful from a computational viewpoint
since it allows the planner to work with significantly smaller domains containing only consistent
values.
This general framework is suitable for all the applications that process a large amount of con-
strained data provided by a lower level system, as,
for instance, a vision system used for extracting
visual features of objects from an image (Lamma
et al. 1997).
Wetailor this general solution to planning
problems. We represent a planning problem
as a CSP, where variables appearing in action
schemata are associated with a domain of possible values. In our architecture, the planner is
not awareof all the true facts of the real world.
Thus, whenthe planner tries to verify if a precondition is alreadysatisfied in the initial state, if the
neededinformationis not available, it needs to acquire knowledgefrom the underlying system. We
consider action preconditions as interactive constraints. They act as both usual preconditions
and constraints whenthey work on variables ranging on knowndomains. Otherwise, they perform
knowledgeacquisition in order to retrieve variable
domainvalues. It is worth noting that in this way
the knowledgeacquisition process is transparent
to the planner which does not need to take into
account declarative sensing actions.
Weare currently workingon howto exploit the
Interactive CS frameworkto cope with dynamicity and non deterministic action effects. Basically,
we argue that the interactive constraint propagation mechanismcan be used not only for gathering information, but also for verifying preconditions before action execution and effects after
execution. In this way, we can monitor the system behavior and check if it corresponds to the
one expected by the planner.
Wepropose an integrated architecture based
on Constraint Satisfaction (CS) techniques that
combines the problem solving ability of generative planners, as typical Partial Order Planners,
in charge of producing a plan schemata, and the
capability of reactive planners to acquire information on demandin charge of refining the plan at
execution time.
The aim of this paper is to describe the Interactive CSP(ICSP) framework and to suggest how
planning activity can benefit from it. The paper
is organized as follows: in the first part we discuss the problems related with incomplete knowledge; then we focus on the ICSPmodeland define
the generative planning algorithm. Weshow how
it works by means of an examplein the field of
network management.In the second part we discuss howto exploit the Interactive CS approach
to cope with dynamicity. Conclusion and future
work follow.
meaning that: (i) all the information about the
world is known(ii) everything not knownis false.
This hypothesis does not allow planning techniques to be applied to most of the real domains
where knowledgeis typically incomplete.
Planners making the Open World Assumption
(OWA)(Golden 1997; Olawsky & Gini 1990)
based on the hypothesis that anything not indicated into the list of the knownfacts is unknown. These planners can be divided in two
groups: those performing off-line knowledgeacquisition after the planning process, i.e., during
execution, and those performing on-line acquisition during the planning process.
Amongthe first group, some planners base
their planning decisions on assumptions madeon
unknownfacts (Golden 1997) which will be verified during execution by means of sensing actions previously introduced into the plan. In
case of wrong esteem, the agent needs to replan.
Other planners build conditional plans (M.Peot
Smith1992), i.e., plans with different alternative
branches selected at run time according to the response of the corresponding sensing action. This
can lead to a computationalexplosion of the planning process when manyalternatives have to be
considered. Other approaches shift the complexity from the planning process to the action definition activity, by embeddinginto action descriptions every possible alternative in whicha situation can come(Firby 1989). In general, all these
options are appropriate whena limited numberof
possible alternatives is given.
Planners performing on-line knowledgeacquisition gather information in a dynamicway during
the planning process. Those planners interleave
planning and execution of sensing action (Golden
&Weld 1996) needed to retrieve information on
demandand go on in planning. Our solution follows this latter approach.
Note that most of the OWA-basedplanners
mentioned make use of sensing actions. Sensing
actions are explicitly defined in the action domain; thus, they are defined similarly to causal
actions in a declarative formal language by pre
and post conditions so that the planner automatically inserts sensing action instances into the
plan, each time an information is required. Our
goal is to provide a sensing mechanismtransparent to the planner which does not need to take
into account any further declarative action apart
from the causal actions.
Interactive Constraints Satisfaction
techniques
The problem of incomplete
information
ManymodernArtificial Intelligence planners are
based on Constraint Satisfaction techniques. CS
techniques can be used to augmentthe search effi-
Traditional planners are based on the unrealistic Close World Assumption (CWA)(Weld 1994),
34
ciency of the planner by avoiding failures instead
of recovering from them, thus reducing computationally heavy backtracking steps (Weld1994;
Joslin & Pollack 1995; Lever & Richards 1994).
In order to exploit this feature, we have to map
the planning probleminto a Constraint Satisfaction Problem (CSP). Manyapproaches to planning as CSPhave been proposed. Particularly,
some of them exploit CS techniques for temporal reasoning (Lever & Richards 1994; Tate,
Drabble, & Dalton 1994), resource allocation
(Lever & Richards 1994; Tate, Drabble, & Dalton
1994), conflict resolution (Kambhampati1996;
Yang1992; Joslin & Pollack 1995) and open condition achievement(Joslin & Pollack 1995).
We model the planning problem as a CSP
whose variables are those appearing in the pre
and post condition of action schemata instances
introduced into the plan. Preconditions act
as constraints on those variables which are associated with a domain that can be reduced
during the computation thanks to constraint
propagation. For instance, the precondition
logged(User, Machine) represents a constraint
linking variables User and Machinewhich is satisfied if the user User is logged on the machine
Machine. Both variables can be associated with
a domainof possible values. Generally speaking,
User domainrepresents all users in the system,
while Machine domain contains all machines
available in the networkedsystem. The constraint
logged(User, Machine) prunes variable domains
in order to removecouples of inconsistent values.
In a typical real environment, such as a networked system domain (Golden 1997), knowledge
is not completely defined at the beginning of the
computation, given the huge amount of data the
agent needsto deal with. In fact, it is really inefficient if not impossible to makethe agent load
all the hierarchical knowledgeof the real system
configuration whenthe planner needs to satisfy a
goal. Thus, there is need of interaction between
the low level system and the data processing module, which in our case is a constraint solver. We
define an Interactive CSPframeworkwhere variables range on partially or completely unknown
domains. A solution to the ICSPis an assignment
of values to variables whichis consistent with constraints.
Wegive, now, a formal definition of the ICSP
framework. Note that we make the assumption
that all predicates are expressed as binary constraints.
Definition
0.1 A binary ICSP is a tuple
(V, D, C) where V is a finite set of variables
X1,...,Xn,
D is set of interactive domains
D1,. . . , DnandC is a set of interactive (binary)
constraints.
Definition 0.2 A interactive domain Di of a
variable Xi is the set of all possible values that
can be assigned to that variable.
Vi Di = [Knowni U UnKnowni] where Knowni
represents the set of knownvalues for variable Xi,
and UnKnownsis a domain variable itself representing (intensional) information which is not
yet available for variable Xi. Both Knownland
1.
UnKnownican possibly be empty
Vi Knownl N UnKnownl = O.
Definition 0.3 An interactive constraint IC on
variables Xi and Xj, i.e., IC(c(XI,Xj), defines
a possibly partially knownsubset of the cartesian
product of variable interactive domains Di × Dj
representing sets of possible assignmentsof values
to variables. The syntax of an interactive constraint is IC(c(Xi, Xj)).
The interesting part of the frameworkconcerns
the constraint operational behavior. Consider an
interactive constraint IC(c(X, Y)
1. If both variables are associated with a partially
or completely unknown domain, suspend the
constraint;
2. else, if both variables range on a completely
knowndomain, propagate the constraint as in
classical CSPs;
3. else, if variable X (resp. Y) ranges on a fully
known domain and Y (resp. X) is associated
with a partially or fully unknownone, knowledge acquisition for variable Y (resp. X)
performed; it returns:
(a) a finite set of consistent values representing
the domain of Y (resp. X),
(b) an emptyset representing failure.
These constraints are awaked, during the planning process, whensomevariables are instantiated or their domainpruned.
ICSP and Planning
Weembedthe interactive Constraint Satisfaction
model in a Partial Order Planner (POP) whose
kernel is similar to the UCPOP
algorithm (Weld
1994). As all the POPalgorithms, our planner
performs least commitmenton ordering decisions.
It does not commit prematurely to a complete,
totally ordered sequenceof actions. Plans are represented as a partially ordered sequence, and only
the essential ordering decisions are recorded into
a set O. During the planning process the consistency of O has to be ensured. In this context,
the planner needs also to ensure that different actions introduced to satisfy different goals do not
interfere each other. Causal links (set L) record
1Whenboth are emptyan inconsistency arises.
35
the dependencies between actions so that, when
a threat to one of these links is detected, (i.e.,
newlyintroduced action interferes with past decisions), the planner makes some commitments in
order to remove it. As in UCPOP
algorithm, our
planner starts by generating the NullPlan with
the dummyactions Start and End. Start has
no preconditions and its postconditions consist of
a set, called InitialState (IS). IS contains the
knowledgeof the underlying system that the planner is aware of, while in a traditional generative
planner it represents all the true facts in the real
world.
Knowledgeis retrieved and organized in information clusters according to the "type" of
the object to which the information is referred.
For instance, as far as the object type file
is concerned, the following fact is retrieved:
file(rights, name,path, disk, dim, type, date).
Weproperly translate this information into the
initial state IS in terms of binary predicates.
Thus, IS is not a static set, but grows continuously according to the new information retrieved
by the planner.
The End action has no effect, and its preconditions are the conjunction of the goals of the
planning problem. All these conjuncts are initially put into an Agendarepresenting the set of
subgoals the planner has to satisfy. During the
planning process, as soon as a newaction is introduced into the plan, its preconditions are added
to Agenda. Since the planner treats preconditions
as constraint, as soon as it selects one item from
the Agenda,it will put it into the constraint store.
Interactive Constraints (IC) are uniformly associated with most of the predicates, appearing
as preconditions in the basic actions. Whenthese
preconditions are tested, they act both as usual
preconditions and constraints whenthey work on
variables ranging on knowndomains. Otherwise,
knowledgeacquisition is performedin order to acquire domainvalues. The retrieved knowledgeis
alwaysreferred to the initial state since the execution of the plan has not already been performed.
It is worth noting that, those constraints retrieve
only information consistent with the context so as
to simplify the task of pruninginconsistent alternatives.
Domainvalues are retrieved (case 3 of interactive constraint propagation) either by inferring
the information required from the facts contained
in IS or, whennecessary, by running a low level
function whichworks as access moduleto the real
world.
Weneed to avoid sensor abuse (Golden 1997)
i.e., avoid to run these functions whenall the possible values have been already retrieved. Weexplicit the fact that IS contain already all the in-
36
formation regarding a specific resource by adding
an all annotation to that item. This reasoning
methodology is based on the Local Closed Word
(LCW) assumption described in (Golden 1997;
Golden & Weld 1996).
There are predicates representing no logical
preconditions (Weld1994) with no associated information gathering activity (domain independent constraints) which will be treated in a uniform wayas the other constraints on the plan. For
instance, the precondition X _> Y checks domain
values with no need to perform any knowledge
acquisition procedure.
The main steps of the planning algorithm are
the following:
PLAN((A, O, L))
1. Termination. If the Agendais empty then return (A, O, L)
2. Goal selection. Choosea pair (Q, Aa) from the
Agenda where Ak belongs to the set A of actions already instantiated and Q is a precondition of Ak.
3. Action selection. Call the Interactive Constraint associated with Q (IC(Q)) in order
verify Q in the initial state:
if IC(Q)fails, (i.e., Start does not satisfy Q)
then non-deterministically choose an action
Aj (different from Start) which can be
consistently ordered prior to Ak and
whose effects contain a conjunct R that
unifies with Q consistently with other
constraints:
if Aj is a newly instantiated action
then Update A: A = A U {Aj},
V Qi precondition of Aj
do Agenda = Agenda + (Q~, Aj);
elseif Aj C A
then Unify Q with R;
else fail;
else Aj = Start;
Update L: L = LU {Aj ~ Ak};
Update O: if {Aj < Ak} ¢ 0
then O = O U {Aj < Ak}.
4. Update the goal set. Agenda = Agenda(Q, Ak)
5. Causal link protection. For each causal link
c = {Ai -~ Aj} 6 L and for each Action At
threatening c choosea consistent ordering constraint, by either demotion(Aj < At) or promotion (At < Ai). If neither constraint is consistent, then return failure.
6. Recursiveinvocation of PLAN(( A, O, L )
Example in the field
systems
of network
- Updatesets:
A = A U [MoveToDisk(mydoc, D1, b)];
0 = 0 U [MoveToDisk(rnydoc,
D], b) < End,
Stars < MoveToDisk(raydoc, D1, b)];
In order to see howour planner works, we present
an example in the field of network management.
Let’s suppose to have as goal the task to move
the file mydocin the disk b and let’s supposethat
this file is initially located on disk a. In the domain theory there are the following two action
schemata:
L = [MoveToDisk(...)
- L = L U {Start
Action MoveToDisk(file : F, disk : D1, D2)
Preconditions
D1 ~ D2, dspace(D1, Fsl),
onDisk( F , D1), ]dim( F , Dim),
dspace(D2, Fsg), Fs$ >_ Dim.
Postconditions
onDisk( F , DP),dspace( D 2 , Fs $ - Dim),
notonDisk(F, D1), dspaee(D1, Fsl + Dim).
onDiak(~oc,D1)
MoveToDisk(...)}
- Select the open condition fdim(mydoe, Dim)
and call IC(/dim(File, Dim)). The information
on mydocsize is already contained in IS: Start
satisfies fdim( mydoe,5MB).
-Select dspace(b, Fs2) from Agenda and call
IC(dspace(b, Fs2)). This time IS does not contain the information required thus the IC needs
to directly access the real worldsince. The only
value returned is the actual free space of the
disk b, 3.8MB.
- All the information concerning disk B is added
to IS. Constraint propagation of Fs2 =
3.8MBresults in a failure (i.e., inconsistency
of Fs2 > Dim): Start cannot satisfy this condition.
-An action different from Start is selected
that satisfies the condition dspace(b, Fs2), consistently with the constraint Fs2 > 5MB.
Makespace(Disk)contains an effect which unifies with dspace(b, Fs2) with Disk = b and
Fs2 = Fs + Dimens.
By constraint propagation Fs2 > 5MB becomes Fs + Dimens > 5MB.
- Select the condition onDisk(File, b) and call
IC(onDisk(File, b)) which gathers all the files
of the disk b and puts them into the domainof
File.
- Select type(File, tmp) from Agendaand call the
associated IC. It will result in a propagationof
the constraint on the domainof File. All the
values but the files .tmp will be pruned from
this domain. In this case File domainbecomes
[tmpl, trap2, tmp3, tmp4]
The former is devoted to free somespace on disk
by deleting some .tmp files. The latter movesa
file from a location to another.
The final goal is
G = (onDisk(mydoc, b), notonDisk(mydoc,
IS is empty.
Supposethe initial real situation is the following:
¯ A copy of file mydocis (only) on disk
¯ mydoc size is 5MB,
¯ Free space on disk b is 3.8MB,
¯ File .tmp on disk b are tmpl (size = 200KB),
trap2 (size = 1MB), trap3 (size = 2MB), tmp4
(size = 1.4MB).
- Initialize sets:
b), notonDisk(mydoc,
End;
-Select onDisk(mydoc, D1) from Agenda2 and
call IC(onDisk(mydoc, D1)). The domain of
D1is still unknown
(case 3). Thus, the planner
needs to acquire, from the underlying system,
values for variable D1satisfying the predicate
onDisk. Given the initial condition mentioned
above, the domainof D1 is represented exclusively from the value a: no further propagation
is needed,D1can be instantiated to the value a.
The information concerning mydocis retrieved
Action MakeSpace(disk :Disk,file :File)
Preconditions
type(File, "tmp"), onDisk(File, Disk),
/dim(File, Dimens
) , dspace(Disk, Fs
Postconditions
dspace(Disk, Fs +Dimens),not file(File),
notonDisk(File, Disk).
Agenda = [onDisk(rnydoc,
onDi,~_~doc,b)
Agenda = Agenda U [dspace( D1, Fsl ),
onDisk( F, D1 ), fdim( F, Dim), dspace( FOP)].
a)]
A ---- [Start, End]
0 = [Start < End]
-Select and remove onDisk(mydoe, b) from
Agenda;call IC( onDisk(mydoe,b) Both variables are bound(case 2), the IC returns false:
the goal is not satisfied in the initial state.
- Select action MoveToDisk(F, D1, D2) whose
effects contain a conjunct onDisk(F, D2)
that unifies with onDisk(mydoc, b), with
F = mydoc, and D2 = b.
Add MoveToDisk preconditions D1 ~ D2 and
Fs2 > Dimto the constraint store.
2Notethat here we are driving the planner in its
non deterministic choice as the selection of the open
condition from Agendain order to focus on the main
steps of the algorithmexecution.
37
- Select fdim(File, Dimens) and call the corresponding IC to retrieve the Dimens domain.
- Select dspace(b, Fs) and call IC(dspace(b,Fs));
Start satisfies the condition with Fs = 3.SMB.
By constraint
propagation the domain of
File is pruned by removing those files whose
dimensions do not satisfy the constraint
3. File domain af(3.SMB + Dimens) >_ 5MB
ter propagation becomesFile~tmp3, tmp4}.
Planning
in dynamic environment
The hypothesis of static world is another unrealistic assumption of traditional planners, since
most of the real domainsare typically highly dynamic. The problem of dynamic world is due to
the facts that (i) typically the planner is not the
only agent that causes changeson the system (ii)
often changes are not deterministic. This can lead
to a failure of the plan execution, either because
action preconditions are no longer verified at execution time and the corresponding action cannot
be successfully executed, or because action effects
are not those expected because of a non deterministic behaviorof the system. A typical approachis
to avoid to modelvolatile information, thus falling
into the above described problem of incomplete
knowledge. Generative planners tackle the problem by delaying verification of unknowninformation until execution. Thus, they base their choice
on assumptionsor simply do not take any decision
and build conditional plans; reactive planners interleave planning and execution so that they can
acquire, during execution, the information needed
to continue planning and verify action effects.
Wepropose an hybrid planning architecture
which combinesa generative planner in charge of
producing a set of alternative plans (see section
above) and a reactive planner to refine the final
plan and verify its execution.
It is worth reminding that we have modeled
the planning problemas a constraint satisfaction
problem. In a CSP, a solution is found by interleaving constraint propagation with a search step
devoted to remove, from variable domains, those
values which cannot appear in any consistent solution. The search process can be performed either by the generative planner itself or directly in
the underlying system during plan execution. We
choosethe latter solution thus resulting in a generative/reactive approach. In a pure generative
3If the domain becomes empty it means that
Start can not satisfy the conditiondspace(b,Fs). In
this case there wouldbe need to delete more than
one file in order to obtain the free space needed;
thus iteratively the plan would add an instance
of the action Makespace(Disk)until the constraint
3.8MB{+Dimens}
>_ 5MBwill be satisfied.
approach, whenno further propagation is possible and a variable domaincontain more than one
value, a non deterministic labeling is performed.
Instead, we do not want PLAN((A,O, L))to
turn a single final solution, i.e., variables mightbe
associated with a domain containing more than
one value since the labeling step does not take
place in the generative algorithm itself. The reason of our choice is based on the consideration
that solutions consistent for the generative planner can be inconsistent whenexecuted in the real
world, since we assumethat the underlying system can change and non-deterministic effects can
take place when executing an action. Thus, a
search process should be performed at execution
time, in order to choose, at run time, a (still) consistent solution amongthe possible alternatives.
In order to realize the reactive module,weneed:
¯ a run-time precondition verification mechanism
which checks whether action preconditions are
still true at executiontime;
¯ an effect verification mechanismable to check
if the corresponding action has been properly
executed;
¯ an executable backtracking mechanism which
allows to "retract" action effects whenthe real
world situation does not correspond to the one
expected by the planner.
As far as the first point is concerned, we can
use the same mechanismused in order to retrieve
information during the generative planning process.
Duringthe reactive phase, we need to check, before executing an action, if its preconditions are
still verified. This can be performedby an interactive constraint propagation activity checking the
satisfiability of the preconditionin the real world.
Obviously, if precondition variables are already
instantiated, the interaction with the underlying
systemresults in a boolean value, while if those
variables are associated to a domain, the domain
can be pruned in order to remove values which
are no longer consistent with the current state of
the system. Note that all the variable domains
are knownand most of them are already instantiated, thus the interaction with the real world results in a consistency checking more than proper
knowledgeacquisition which is computationally
less complex.
Actually, an alternative approach could be to
provide an event tracking mechanismdealing with
the update of IS as soon as somegathered information changes, but right now our planner does
not provide such a mechanismthus the verification process is performedby interact directly with
the real system.
The effect verification mechanismchecks if the
corresponding action has been properly executed.
For this purpose, again, we can use the interactive
constraint propagation mechanismby associating
with each action effect an interactive constraint
whosegoal is to query the underlying system and
check whether the action has achieved the desired
effect. Note that in this case variables appearing
in action effects are already ground and the effect verification results in a booleanvalue. If the
verification succeeds, the execution of the plan
goes on by selecting the next action. Otherwise,
a backtracking mechanismis performed in order
to select an alternative plan execution. The planner has to support backtracking steps over causal
actions and repair activity for dealing with irreversible actions. In this paper we make the assumptionthat all the actions are backtrackable.
Weare currently working on a repair mechanism
able to deal with irreversible actions.
Let us analyze the reactive algorithm: the generative planner producesa set of alternative (possibly inconsistent) plans PLAN((A,O, L)) which
are passed along with the domainvariables to the
reactive modulein charge of refining the plan during its execution. Note that the plan refinement
results only in action schematavariables instantiation in order to find the most appropriate values
accordingto the current situation of the real system. A total order amongplan actions has been
already committedby the generative module.
The main steps of the reactive algorithm follow:
if
IC(Ej) fails
then perform backtracking of the last
action executed Aj:
go back to step 3.
With regards to the example described above
PLAN((A,O, L)) is returned without instantiating File. It will be the Reactive phase to commit
to a final choice so as if in the meanwhileeither
trap3 or trap4 is not available any longer it will not
fail. Finally each effect is verified after execution
by means of Interactive Constraints associated
with the predicates. If something goes wrong,
a repair mechanismis triggered as described in
EXEC((A, O, L) algorithm.
Conclusion
and future
work
Wepresented an hybrid approach to planning
which integrates the problemsolving ability of a
generative planner and the capability of gathering knowledgeon demandand consequently refine
the final plan, typical of a reactive planner. We
provided it with an ICSPmodel which allows the
planner to exploit Constraint Satisfaction techniques to improveits efficiency both during the
plan construction and in the knowledgeacquisition activity. Weargued that the same approach
can be used for coping with changes and non deterministic action effects during execution.
The implementationof this architecture is being carried on by using the finite domain library of ECLIPSe (ECRC1992) properly extended to cope with the interactive framework.
ECLIPSe is a Constraint Logic Programming
(CLP) (Jaffar & Maher 1994; Hentenryck 1989)
system mergingall the features and advantages of
Logic Programmingand Constraint Satisfaction
techniques. CLP on Finite Domains, CLP(FD),
can be used to represent planning problems as
CSPs.
The work in progress mostly regards the application of the planner to a computer network
domain. Weare also considering the possibility to interface the planner with a "proxy" system, instead than directly with the real world,
which would behave as a knowledge acquisition
module. In this context it would be possible
to further reduce the number of sensing operations by querying this system with conjunction of goals concerning the same variable so as
to retrieve only information consistent with all
the conjuncts. In the example above, the preconditions type(File, "trap") and onDisk( File,
would be verified as conjunction by retrieving,
for the variable File, those values whosetype is
"trap" and whoselocation is disk b.
Finally, we are currently working on a repair
mechanismwhich will support the cases in which
EXEC((A, O, L))
1. Termination. If the set A is emptythen return
success.
2. Action selection. Select the first action instance
Ai E A (following the order inferred by the set
of constraints O)
3. Constraint checking and propagation. For each
Pj precondition of Ai call IC(Pj) where Pj are
variables associated with the domainsacquired
in the previous phase of planning:
if
IC(Pj) fails (no domainvalue
any longer consitent)
then perform backtracking of the last
action executed Aj
go back to step 3.
else
.
5.
Action execution. Perform the labeling of not
yet instantiated variables and execute the action Aj
Effects verification. Verifythe effects of the action on the real world: for each Ej effect of Aj
call IC(Ej):
39
on Principles of KnowledgeRepresentation and
Reasoning.
Olawsky,D., and Gini, M. 1990. Deferred planning and sensor use. In Proceedings DARPA
Workshop on Innovative Approaches to Planning, Scheduling, and Control.
Tate, A.; Drabble, B.; and Dalton, J. 1994. Reasoning with constraints within o-plan2. Technical report, AI Applications Institute Univeristy
of Edinburgh.
Weld, D. 1994. An introduction to least commitment planning. AI Magazine 15:27-61.
Yang, Q. 1992. A theory of conflict resolution
in planning. Artificial Intelligence 58:361-392.
the planner, through IC-driven verification, realizes that the effects of one of the action are not the
one expected. The problem of reactive planners
(Golden1997) are mostly related with backtracking of irreversible actions. Wewant to provide
the planer with Backupactions to insert into the
plan each time one irreversible action is instantiated. The effects of backup actions will then be
used in charge of synthesizing a repair plan that
will retract the effects of the failed action.
Acknowledgments
Authors’ work has been partially supported by
Hewlett Packard Laboratories of Bristol-UK (Internet Business Management Department) and
CNR, Committee 12 on Information Technology
(Project SCI*SIA).
References
ECRC. 1992. ECLIPSe User Manual Release
3.3.
Firby, R. 1989. Adaptive Execution in Complex
DynamicWorlds. Ph.D. Dissertation, Yale University.
Golden, K., and Weld, D. 1996. Representing
sensing actions: The middle ground revisited.
In Proceedings of 5th Int. Conf. on Knowledge
Representation and Reasoning.
Golden, K. 1997. Planning and Knowledge
Representation for So~tbots. Ph.D. Dissertation,
University of Washington.
Hentenryck, P. V. 1989. Constraint Satisfaction
in Logic Programming. MITPress.
Jaffar, 3., and Maher, M. 1994. Constraint logic
programming: a survey. Journal of Logic Programming- Special Issue on 10 years of Logic
Programming.
Joslin, D., and Pollack, M. 1995. Passive and
active decision postponment. In Proceedings of
European Workshop of Planning.
Kambhampati,S. 1996. Using disjunctive orderings instead of conflict resolution in partial
order planning. Technical report, Department
of Computer Science and Engineering Arizona
State University.
Lamma,E.; Milano, M.; Cucchiara, R.; and
Mello, P. 1997. Aninteractive constraint based
systemfor selective attention in visual search.
Proceedings of the ISMIS.
Lever, J., and Richards, B. 1994. parcplan: a
planning architecture with parallel actions, resources and constraints. In Proceedings of 8th
ISMIS.
M.Peot, and Smith, D. 1992. Conditional nonlinear planning. In Proceedingsof 1st Int. Conf.
40