ArticlePDF Available

Extending TIM domain analysis to handle ADL constructs


Abstract and Figures

Planning domain analysis provides information which is useful to the domain designer, and which can also be exploited by a planner to reduce search. The TIM domain analysis tool infers types and invariants from an input domain definition and initial state. In this paper we describe extensions to the TIM system to allow e#cient processing of domains written in a more expressive language with features of ADL: types, conditional e#ects, universally quantified e#ects and negative preconditions.
Content may be subject to copyright.
Extending TIM domain analysis to handle ADL constructs
Stephen Cresswell, Maria Fox and Derek Long
Department of Computer Science, University of Durham, UK.
Planning domain analysis provides information which
is useful to the domain designer, and which can also
be exploited by a planner to reduce search. The TIM
domain analysis tool infers types and invariants from
an input domain definition and initial state. In this
paper we describe extensions to the TIM system to al-
low efficient processing of domains written in a more
expressive language with features of ADL: types, con-
ditional effects, universally quantified effects and neg-
ative preconditions.
The analysis of a planning domain can reveal its im-
plicit type structure and various kinds of state invari-
ants. This information can be used by domain designer
to check the consistency of the domain and reveal bugs
in the encoding. It has also been successfully exploited
in speeding up planning algorithms by allowing incon-
sistent states to be eliminated (Fox & Long 2000), by
revealing hidden structure that can be solved by a spe-
cialised solver (Long & Fox 2000), or as a basis for or-
dering goals (Porteous, Sebastia, & Hoffmann 2001).
Many other researchers are also interested in domain
analysis. Planners based on propositional satisfiabil-
ity (Kautz & Selman 1998) and CSP (van Beek &
Chen 1999) often require hand-coded domain knowl-
edge, much of which could be derived from domain
analysis. TLPlan (Bacchus & Kabanza 2000) and
TALPlanner (Doherty & Kvarnstrom 1999) rely on con-
trol knowledge which might be inferrable from the un-
derlying structures describing the behaviour of the do-
main. Our analysis produces not just invariants, but
the underlying behavioural models from which they can
be produced. These models provide a basis for further
analysis, giving an advantage over other invariant al-
gorithms, such as DISCOPLAN (Gerevini & Schubert
1998), which do not produce these structures.
The TIM system performs its analysis by construct-
ing from the planning operators a set of finite state
machines (FSMs) describing all the transitions possible
Copyright c
°2002, American Association for Artificial In-
telligence ( All rights reserved.
for single objects in the domain. The type structure
and domain invariants are derived from analysis of the
Earlier versions of TIM have accepted planning prob-
lems expressed only in the basic language of STRIPS.
A more expressive language for describing planning do-
mains using features derived from ADL (Pednault 1989)
is in widespread use. The use of these extensions makes
life easier for the domain designer, but it is difficult to
handle them efficiently in planning systems.
In this paper we describe work to extend the lan-
guage handled by TIM to include the main features of
ADL, whilst also attempting to preserve the efficiency
of TIM processing. The features we describe here are
types, conditional effects, universally quantified effects
and negative preconditions.
For example, in the briefcase domain, consider the
move operator, shown below. The operator includes
a universally quantified conditional effect which says
that when the briefcase is moved between locations, all
the portable objects which are inside the briefcase also
change their location. 1
(:action move
:parameters (?m ?l - location)
:precondition (is-at ?m)
:effect (and (is-at ?l)
(not (is-at ?m))
(forall (?x - portable)
(when (in ?x)
(and (at ?x ?l)
(not (at ?x ?m)))))))
A typical invariant that we would like to get from
this domain is that portable objects are at exactly one
x: portable · y· z·at(x, y)at(x, z)y=z
x: portable ·(y: location ·at(x, y ))
For a full account of the TIM processing, see (Fox &
Long 1998). Here we briefly summarise those parts of
the algorithm which are relevant to the extension to
1This encoding of the domain is from IPP problem set.
We are concerned with extracting state descriptions
for individual objects. These are described using prop-
erties, which describe a predicate and an argument po-
sition in which the object occurs. For example, if we
have at(plane27, durham) in the initial state, then we
consider the object plane27 to have property at1, and
the object durham to have property at2.
To explain the processing of domain operators by
TIM, we must introduce two kinds of derived struc-
ture the property relating structure (PRS) and the
transition rule.
The PRS is derived from an operator, and records
the properties forming preconditions, add effects and
delete effects for a single parameter of an operator. For
example, consider the operator fly:
(:action fly
:parameters (?p ?from ?to)
:precondition (and (at ?p ?from) (fuelled ?p) (loc ?to))
:effect (and (not (at ?p ?from))
(at ?p ?to)
(not (fuelled ?p))
(unfuelled ?p)))
The parameters of the operator give us the following
pre: at1,fuelled1
add: at1,unfuelled1
del: at1,fuelled1
pre: at2
del: at2
pre: loc1
add: at2
Atransition rule is derived from a PRS, and describes
properties exchanged. Transition rules are of the form:
Enablers Start F inish
where Enablers is a bag of precondition properties
which are not deleted, Start is a bag of precondition
properties which are deleted, and F inish is a bag of
properties which are added. Empty bags are shown as
null, or may be omitted in the case of enablers. The
transition rules corresponding to the above PRSs are:
loc1null at2
The part of the TIM processing that we discuss in the
rest of the paper consists of the following main stages:
1. Construct PRSs from operators.
2. Construct transition rules from PRSs.
3. Unite the properties in the start and finish parts
of transition rules, to group properties into prop-
erty and attribute spaces. Property spaces arise
where transition rules define a finite number of pos-
sible states (as the rules involving at1,fuelled1, and
unfuelled1) these define an FSM. Attribute spaces
arise where transition rules allow properties to be
gained without cost (as for at2) these spaces must
be treated in a separate way, as it is not possible to
enumerate all of their possible states.
4. Project the propositions from the initial state of the
planning problem to form bags of properties repre-
senting the initial states for each state space.
5. Extend the states in each space by application of
transition rules.
This process derives information that can be used
to extract types and invariants. Each unique pattern of
membership of property and attribute spaces for the do-
main objects defines a type. From the generated FSMs,
domain invariants can be extracted.
ADL extensions to TIM
The original version of TIM (Fox & Long 1998) deals
only with untyped STRIPS domains. We are interested
in extension to a subset of ADL, and our extensions fall
into four areas:
Universally quantified effects
Conditional effects
Negative preconditions
A generic means of transforming ADL domain de-
scriptions into simple STRIPS representations has been
given by Gazen and Knoblock (Gazen & Knoblock
1997). Although it would be possible to apply this di-
rectly as a preprocessing stage to TIM, an undesirable
feature of this approach is that several stages of the
processing may lead to an exponential blow-up in the
size of domain descriptions or initial state descriptions.
In particular, universally quantified effects lead to an
expansion in the size of the operator proportional to the
number of domain objects that can match the quanti-
fied variable. Conditional effects lead to generation of
multiple operators, with one operator for each possible
combination of secondary conditions.
In the following work, we seek to avoid the combi-
natorial blow-up with a combination of simplifying as-
sumptions, and by avoiding operator expansions which
are irrelevant to the TIM processing.
TIM analysis only needs to work with structures de-
scribing what transitions are available to individual ob-
jects, and what states they can reach. The transitions
generated must capture all possible transitions, and
generate all possible states of individual objects. The
transitions are only partial descriptions of operators,
and the object states are only partial descriptions of a
planning state. This representation does not preserve
or make use of all the conditions present in the original
operator, and could not be correctly used in a planner.
Hence, some of the information which is painstakingly
preserved in the Gazen-Knoblock expansion (e.g. in-
stantiation of forall effects) makes no difference to
the resulting TIM analysis, and can be avoided.
Now we consider the processing of each language fea-
ture in more detail. In most cases, we describe the
conversion by showing a transformation on the opera-
tor and domain description before the standard TIM
analysis is performed on the modified descriptions.
In general, the transformations carried out on opera-
tor descriptions will not yield operators that are correct
for use in a planner. They are correct for the TIM anal-
ysis, because they yield all possible legal transitions for
objects in the domain.
Part of the processing performed by TIM is to derive a
system of types for the domain. Clearly, if types have
already been specified in the domain, these should be
taken into account. Type restrictions on the parameters
of an operator are transformed into additional static
preconditions on the operators.
Types declared for the objects in the domain also give
rise to additional propositions in the initial state. Note
that since PDDL allows for a hierarchy of types, each
object must have a proposition for every type of which
it is a member.
The predicates which are automatically introduced
to discriminate will be recognised as static conditions
by TIM, and will then be taken into account when de-
termining the derived types inferred by TIM. Hence, we
can be sure that TIM types will always be at at least
as discriminating as the declared types.
Conditional Effects
Treatment of conditional effects is rather more challeng-
ing, but offers far more scope for interesting results from
the analysis. Consider the following example operator:
(:action A
:parameters (?x)
:precondition (p ?x)
:effect (and (not (p ?x)) (q ?x)
(when (r ?x) (and (not (r ?x)) (s ?x)))))
From this operator we would like to infer (assuming
no other operators affect the situation) that parameter
?x can make transitions p1q1and p1r1s1.
This would enable us to identify two potential state
spaces and consequent invariants: pand qare mutex
properties and sand rare mutex properties.
In considering treatment of conditional effects, sev-
eral proposals were examined and these are discussed
in the following sub-sections.
Separated dependent effects One technique by
which we hoped to harness the power of existing TIM
analysis was to construct a collection of standard tran-
sition rules that capture the behaviour encoded in con-
ditional effects. The previous example shows that
this is possible in certain cases. The first proposal
for achieving this was based assuming all (when ...
...) clauses in an operator to be mutually exclusive, in
which case there is no problem with exponential blow-
up. Under this assumption, we can generate a sepa-
rate pseudo-operator for each conditional effect. The
pseudo-operator has the primary preconditions and ef-
fects from the original operator, and the when clause is
absorbed by merging its preconditions into the primary
preconditions, and its effects into the primary effects.
We also create an operator with only the primary ef-
fects. These operators are pseudo-operators because
they do not always encode the same behaviour as the
original operators and could not be used for planning.
However, this does not prevent them from being used
to generate valid transition structures that reflect the
transitions described by the original conditional effects
Unfortunately, conditional effects do not always sat-
isfy the assumption that at most one conditional effect
is triggered during a single application of an action. In
fact, the assumption required for correct behaviour can
be weakened: it is only necessary that at most one con-
ditional effect is triggered to affect the state of each pa-
rameter of the operator. Even this condition is stronger
than is appropriate for some domains.
An example where the assumption is violated is the
(:action op_with_non_exclusive_conditions
:parameters (?ob)
:precondition (a ?ob)
:effect (and (not (a ?ob)) (x ?ob)
(when (b ?ob) (and (not (b ?ob)) (y ?ob)))
(when (c ?ob) (and (not (c ?ob)) (z ?ob)))))
For an object with initial properties {a1, b1, c1}, this
operator should allow the state {x1, y1, z1}to be reach-
Instead, we actually generate the rules (a1x1),
(a1, b1x1, y1) and a1, c1x1, z1, since the opera-
tor leads to the creation of three pseudo-operators, one
with the pure simple effects of deleting aand asserting
xand the others each taking a precondition from their
respective conditional effect and the appropriate addi-
tional effect. With these rules it is not possible to reach
the state {x1, y1, z1}.
Failure to correctly generate all reachable states leads
to the generation of unsound invariants, so this ap-
proach cannot be used unless it is possible to guarantee
the necessary conditions for valid application.
Separating conditional effects The strong as-
sumption, that at most one of the conditional effects
of an operator will apply, can be replaced with a much
weaker assumption: that any number of the conditional
effects of an operator could be applicable. This as-
sumption can be characterised using the original TIM
machinery by creating pseudo-operators, one with the
complete collection of primary preconditions and effects
from the original operator and one for each conditional
effect, adding the condition for the effect to the pre-
conditions of the original and replacing the effect of
the original with the conditional effect. In the example
above, this would lead to the following transition rules:
a1x1,b1y1and c1z1.
With these rules it is possible for extension (the pro-
cess by which TIM generates complete state spaces from
the initial state properties of objects) to generate all
the states we want, and more besides. For instance, we
could generate a state {a1, y1, c1}, by applying one of
the conditional effects without the corresponding pri-
mary effect.
The weakened assumption leads to correspondingly
weaker invariants, since the opportunity to apply rules
that do not correspond to actual operator applications
allows apparent access to states that are not, in fact,
reachable. More seriously, however, we have separated
the primary and secondary effects of the operator into
distinct transitions which can only be applied sequen-
tially. This does not fit with the intended meaning of
the operator, which is that all the preconditions (pri-
mary and secondary) are tested in the state before the
effects take place. In the previous example this does
not make any difference to the behaviour of the rules.
The circumstances under which it makes a difference
When any (primary or secondary) effect deletes a sec-
ondary precondition (for a different conditional ef-
fect). This is because sequentialising the rules will
cause the deleted effect to be unavailable for the ap-
plication of the rule with the secondary precondition
if the deleting rule is applied first. However, rules
can be applied in all possible orders so this leads to a
problem only when the second rule deletes a precon-
dition of the first rule, so that applying the rules in
either order prevents them from both being applied.
When any (primary or secondary) effect deletes a
(primary or secondary) effect (where not both are
primary components or are in the same conditional
effect). In this case, as an operator, the classical se-
mantics (Lifschitz 1986) causes the add effects to oc-
cur after the delete effects and the apparently para-
doxical effects are resolved.
A simple example of the first case is an effect of the
(when (and (q ?y) (p ?x))
(and (q ?x) (not (p ?x))))
(when (and (p ?y) (p ?x))
(and (r ?x) (not (p ?x))))
In both secondary effects, (p ?x) is deleted. If both
when conditions apply, the condition is deleted once.
The proposed compilation of the operators into transi-
tions will not deal with this correctly. The rules created
from these effects (supposing no primary pre- or post-
conditions affect them) will be of the form: p1q1
and p1r1. It looks as though a p1property must
given up to gain either q1or r1, but in fact both can be
purchased by giving up a single p1.
To handle this problem we can identify the common
deleted literal and collapse the rules to arrive at a third
rule: p1q1, r1. Notice that we cannot replace the
other rules with this one, since the conditions cannot
be assumed to always apply together. More generally,
we cannot assume that two rules generated from the
same operator that have a common element on their
left-hand-sides will always be exchanging different in-
stances of the property (even if derived from different
variables the variables could refer to the same ob-
ject). Therefore, such rules have to be combined to
collapse the exchanged property into a single instance.
(It is interesting to observe that the pathological case,
in which the rules derive from primary effects affecting
different variables, can lead to a similar problem in the
original TIM analysis). There is a minor problem in
that the process of collapse could, in principle, be ex-
ponentially expensive in the size of the operator, since
every combination of collections of rules sharing a left-
hand-side element must be used to generate a collapsed
rule (in which the shared collection is collapsed into a
single instance of each property). In practice the size
of these sets of rules is very small and the growth is
not a problem. A more significant problem is that the
combinations of these rules can lead to further weaken-
ing of the possible invariants through over-generation
of states.
An example of the second case is:
(:action A
:parameters (?x)
:precondition (p ?x)
:effect (and (not (p ?x)) (q ?x)
(when (q ?x) (and (not (q ?x)) (r ?x)))))
Notice that in order to delete an effect that is added
by the primary effect of an operator, or another con-
ditional effect, the deleted condition must be a precon-
dition of the effect. The overall behaviour of (A a)
applied to a state in which (p a) and (q a) hold is to
generate a state with (q a) and (r a). This is because
the delete effect is enacted before the add effect, so that
the net effect on (q a) is for it to be left unchanged.
Application of the operator to a state in which only (p
a) holds will yield the state in which only (q a) holds.
The rules generated from this operator using the pro-
posal of this section are p1q1and p1q1r1.
Testing the enablers in application of these rules allows
a precise generation of states in both cases. However,
it is generally not possible to consider enabling condi-
tions without compromising correct behaviour. Sup-
pose that the additional primary precondition (s ?x)
and primary effect (not (s ?x)) are added to the pre-
vious operator. Then the rules will become: p1, s1q1
and p1, s1q1q1. It is now impossible to apply the
rules sequentially to the property space state {p1, s1}
if we take enablers into account, because the first rule
will consume the s1property and prevent the second
rule from being applied. Consequently, this approach
cannot restrict rule application using enabling condi-
tions and we will therefore be forced to generate the
unwanted states, weakening the invariants.
Conditional transitions The most radical treat-
ment of conditional effects involves a significant ex-
tension of the TIM machinery in order to extend the
expressive power of the rules in parallel with the ex-
tended expressive power of the operators. This is a
less attractive option, since it requires new algorithmic
treatments, but this price must be offset against the im-
proved analysis and the more powerful invariants that
can be inferred from domain encodings.
The proposal is to extend the expressiveness of the
transition rules to include conditional transitions. The
conditional component of the transition rule is an addi-
tional transition denoted by the keyword if. Satisfac-
tion of the condition depends on the presence in a state
of both enablers and the start conditions.
if b1y1
if c1z1
Generating conditional transitions Firstly, we
must generalise the notion of a PRS into a nested
structure to represent operators including when condi-
tions. We include an extra field cnd to record an em-
bedded PRS for the conditional part of the operator.
op_with_non_exclusive_conditions then yields the
following PRS.
pre :a1
add :x1
del :a1
cnd :"pre :b1
add :y1
del :b1#
"pre :c1
add :z1
del :c1#
Now we use the generalised PRSs to generate con-
ditional transition rules. PRS analysis for secondary
conditions is essentially the same as the analysis for pri-
mary conditions, except that only the adds and deletes
of the secondary rule are considered, but all the precon-
ditions of the containing structures must be included.
In general this construction is straightforward, but
there is an important case that presents a minor com-
plication. If a conditional effect deletes a primary pre-
condition then the primary precondition will be seen
as enabling the outer rule, but it will not appear as a
precondition for the conditional effect. One solution is
to simply handle the proposition as if it were a pre-
condition of the conditional effect, so that the prop-
erty appears as a start condition for the conditional
rule. However, this leaves the enabling condition out-
side, apparently required as an additional property for
the application of the conditional transition rule. This
presents the problem that if enablers are used in deter-
mining applicability of rules it will not be clear whether
the rule demands one or two copies of the property to be
applied. One way to solve this problem is to promote
the precondition, so that deleted conditions in condi-
tional effects are always explicit preconditions of the
conditional effects. To achieve this, a new conditional
effect must be added to the original operator, with the
deleted literals as its preconditions and all of the origi-
nal primary effects as its effects. The deleted literals are
now removed from the primary preconditions and added
explicitly as preconditions to all the other conditional
effects. This transformation yields an operator which
is equivalent in its effects on a state to the original,
although it can, in principle, be applied to a larger col-
lection of states (all states in which the deleted effects
are not true the effect of application is null). Analysis
of this new operator yields a conditional rule with the
correct structure, distinguishing the case where a prop-
erty is genuinely an enabling condition from the case
where it is actually a copy of the deleted condition in a
secondary effect.
Uniting transition rules In TIM the process of
uniting is that of combining the collections of properties
into a partition such that each transition rule refers, in
its start and end components, only to properties in a
single set within the partition. This ensures that the
construction of extensions of states in property spaces
works within a closed subset of the properties used in
the domain and that the initial state properties are
properly divided between the property spaces to seed
the extension process.
In the case of conditional rules, the properties which
change between the start and end of each conditional
component of each rule must be united into the same
subset of the partition, and properties within different
conditional components of the same rule are also com-
uniters((Ens Start E nd) + Subrules) =
(Start End)(End Start)
SrS ubrules
This form of uniting ensures that the property spaces
remain as small as possible, which improves the qual-
ity of the invariants that can be generated and also the
efficiency of the analysis. It does, however, impose ad-
ditional difficulties in the use of rules, since the same
rule can now affect the behaviour of objects in multiple
spaces (conditional elements might refer to properties
in entirely different spaces to the primary effects of the
rule). Each rule must be added to every space that it
applies to and considered during the extension of each
of those spaces separately.
A further change from the process of setting the ini-
tial collection of property spaces in STRIPS TIM is that
conditional rules can appear to contain attribute rules
when, in fact, they are half of a transition rule that is
completed by a second “attribute” rule in a conditional
effect. For example:
(:action B
:parameters (?x)
:precondition (p ?x)
:effect (and (not (p ?x))
(when (s ?x) (q ?x))
(when (not (s ?x)) (r ?x))))
This operator leads to the rule:
if s1null q1
if ¬s1null r1
which might suggest that p1,q1and r1should all be con-
sidered to be attributes and, consequently, have no use-
ful invariant behaviours. However, it would be better
to observe that the behaviour of these properties is ac-
tually equivalent to a pair of transitions: s1p1q1
and ¬s1p1r1(exploiting negative preconditions,
discussed below). Although it might be possible to con-
vert the rules automatically, it becomes much harder
to do this in the context of multiple rules referring to
other parameters. It is actually easier to manage the
rules during extension. The important thing, during
initial property space construction, is to avoid labelling
properties as attributes on the basis of the structure of
conditional rules. A decision about which properties to
label as attributes must be postponed to the extension
The fact that the properties in a property space can
be distributed between primary and conditional rules
creates a complication for uniting: it is not enough
to put together properties in the same rule. Proper-
ties must be combined when they appear in “attribute”
rules such as the previous example. It will be noted,
however, that the example relies on the form of the
conditions of the conditional effects and this feature is
further discussed later in the paper.
Extending the state spaces with the conditional
transitions Extension is the stage most impacted by
the introduction of conditional rules. Conditional rules
must be applied to each state in the property space
containing them in order to generate a set of reachable
states. Thus, the key to exploiting these rules is to un-
derstand how to apply the conditional rules to a state.
When a standard transition rule is applied the start
conditions are removed from the state and the end con-
ditions added to the result to yield the (single) new
state. Conditional rules are applied by removing the
primary start properties and then, for each conditional
rule, continuing expansion under the assumption that
the condition applies and under the assumption that it
does not apply. Therefore, there will be 2nnew states
generated for nconditional effects (subject to repeti-
tion of previously visited states). Although this is po-
tentially exponentially expensive, nis typically a very
small value, so that the cost is not a problem. Never-
theless, conditional effects represent a potential source
of considerable cost in the TIM analysis (just as they
can in planning itself). The hope is that we will have
saved significant cost by deferring this combinatorial
aspect to the latest possible time, and some redundant
processing has been avoided.
There are, in fact, several special cases that can be
used to reduce the number of combinations of condi-
tional rule elements that must be considered. Condi-
tional rules can only be applied if the start properties
are present in the state to which they are applied. Con-
ditions that are restricted to propositions concerning
only the variable that is affected by the transition can
usually be restricted by the enabling or start conditions
of the rule. Further, the observations of the next section
provide for an important collection of situations.
Having allowed possible attribute conditional rules
to be entered into property spaces it is extremely
important that the extension process monitors the
possible existence of increasing attributes in a property
space. This possibility also exists in the original TIM
analysis and is handled by checking to see whether
newly generated states are proper super-states of
previously generated states. In such cases, if there
is path of transition rules leading from the sub-state
to the super-state, the difference between the states
represents a collection of attribute properties and they
must be stripped from the property space and its rules
before extension can be continued. This process might
iterate several times before the space settles on a fixed
collection of properties. If this collection is actually
empty then the properties will, in fact, all be attributes
due to the effects of the conditional rules in the space.
Hidden exclusivity In some operators, conditional
effects are mutually exclusive because it is not possi-
ble for their preconditions to hold simultaneously. In
such cases the extension process described above will
generate permissive property spaces and weaker invari-
ants. In order to improve the generation process it is
necessary to avoid allowing rules to be applied simulta-
neously when their conditions will prevent it. Further
improvement can be made by observing that in many
cases the conditional effects are created to ensure that
precisely one effect of a collection will be triggered. For
(:action op1
:parameters (?y)
:precondition (a ?y)
:effect (and
(not (a ?y))
(b ?y)))
(:action op2
:parameters (?y)
:precondition (b ?y)
:effect (and
(not (b ?y))
(a ?y)))
(:action op3
:parameters (?x ?y)
:precondition (p ?x ?y)
:effect (and
(when (a ?y) (q ?x))
(when (b ?y) (r ?x))
(not (p ?x ?y)) ))
In this example, properties a1and b1may only be
exchanged for each other, as illustrated in Figure 1. If,
in the initial state, objects only have at most one of the
two properties, then the two when conditions in op3 are
mutually exclusive.
a1 b1
Figure 1: Property space and transitions for properties
a1and b1.
The generated transitions would be: a1b1,b1a1,
if null q1
if null r1
and p2null. Failure to observe that the conditional
effects are governed by preconditions of which precisely
one must be true will mean that no invariants can be
generated using the properties p1,q1and r1. In order
to discover these we need two pieces of information to
be available during extension: the fact that each condi-
tional effect is governed by a property that, in this case,
apply to another parameter and form part of another
property space and the fact that the properties govern-
ing these effects are the two alternative states in that
space. We therefore mark conditional rules with all of
the properties that govern their application. Enabling
conditions that are properties of other parameters are
called aliens. We enclose them in square brackets to dis-
tinguish them from enablers applying to the parameter
governed by the transition rule.
if [a1]null q1
if [b1]null r1
This provides the first piece of information. The second
piece is derived from an analysis of the property space
containing properties a1and b1. It is important that the
analysis makes the latter space available before the use
of the rule that depends upon it. Therefore, we perform
a dependency analysis to order the property spaces for
appropriate expansion order. Where one state space
depends on another, an order can be imposed between
them that would allow information from the first to be
used in the second. Space zdepends on space yif tran-
sitions belonging to space zhave enabling conditions
which belong to space y.
Circular dependency amongst state spaces must be
handled carefully. One way is to break the cycle arbi-
trarily and then follow the dependencies that remain.
The first space in the chain will then be expanded with
the more conservative assumption that no invariants
affect the conditions governing the application of con-
ditional effects, possible leading to weakened invariants.
Because these weakened invariants can propagate their
impact up the chain, it would obviously be best to break
the chain in such a way as to minimize the impact that
these weakened invariants might have. An alternative
solution to the problem of cyclic dependency is to carry
out extension on these property spaces in an interleaved
computation, leading to a fixed-point. The approach is
to apply conditional rules relative to the dependencies
on property spaces using the states that have been gen-
erated so far. The extension process must then iterate
around the cycle of interdependent spaces, adding new
states as new enabling states are added to the spaces on
which later spaces depend. This iterative computation
will have to be restarted if any of the properties in a
space is identified as an attribute, as described previ-
Managing combinations of subrules In this sec-
tion we give more detail about how to use informa-
tion from spaces for which the extension process is al-
ready completed, together with annotation of the sub-
rules with alien enablers, to restrict the combinations
in which subrules of a conditional rule can fire.
For a subrule to fire, we require that for each variable-
space combination occurring as an alien enabler in the
subrule, there is at least one state that satisfies the
enabling property.
The coupling between subrules is captured because
valid combinations of subrule firings are those in which
the enabling conditions can be simultaneously satisfied.
Enabling conditions are satisfied, if, for each variable,
and each space in which it occurs, there is a non-empty
set of satisfying states.
The approach adopted depends on amending the
TIM algorithm with the following steps
1. During rule construction, each subrule is anno-
tated with alien enablers, each consisting of a triple
aliens(subrule) is a set of hpr operty, space, vari,
where var is the variable from which the enabler was
generated in the planning operator.
2. A graph of dependencies between spaces is con-
structed from the alien enablers.
3. Spaces are constructed in order, according to topo-
logical sort of the dependency graph. Cycles must be
broken as discussed above.
Now we define the valid combinations of rule firings
by describing a set of variables, and constraints which
must hold between them.
For each variable-space combination in alien enablers,
we have a variable state(variable, space) whose domain
ranges over possible states of variable in space.
state(var, sp)states(sp)
For each property-variable-space combination in
alien enablers, we have a boolean constraint vari-
able, sat(property , variable, space), whose value indi-
cates whether the property is satisfied.
sat(prop, var, sp) {0,1}
For each subrule, we have a variable f(subrule),
whose domain is {0,1}, which records the whether or
not the subrule can fire. Note that since the possible
values remaining in the domain are attached to the vari-
able, we can describe never {0}, sometimes {0,1}, and
always {1}.
Now we attach constraints between these variables as
Between the sat(property, var iable, space) variables,
and the state(variable, space), we require that the
property is satisfied iff var is in a compatible state in
subrule subrules
∀hprop, var, spi aliens(subrule).
sat(prop, var, sp)has prop(state(v ar, sp), prop)
Between the f(subrule) variables and the
sat(property , variable, space) variables of its alien
enablers, we require that subrule fires iff the conjunc-
tion of its alien enablers is satisfied.
f(subrule)Vsat(prop, var, sp)
These constraints are used to determine which com-
binations of subrules may fire together.
Universally Quantified Effects
Since we are concerned with the transitions made by
individual objects, it is not necessary to expand the op-
erator in advance with every instantiation of the quan-
tified variable, as is done by (Gazen & Knoblock 1997).
(:action one_forall
:parameters (?a - t1)
:precondition (p ?a)
:effect (and (not (p ?a))
(q ?a)
(forall (?b - t2)
(when (r ?a ?b)
(and (not (r ?a ?b)) (s ?a ?b) )))))
The effect inside the quantifier may occur as many
times as there are instantiations for the quantified vari-
able ?b.
For ?b itself, we can generate a transition rule exactly
as if it was an ordinary parameter of the operator. The
number of objects making the transition is not relevant,
as any object belonging to this state space experiences
only a single transition. In the above example, analysis
for the variable ?b gives the transition r2s2.
Now consider the transitions for the variable ?a. Out-
side the quantifier, ?a undergoes a single transition
p1q1. Inside the quantifier, ?a undergoes a tran-
sition r1s1, but the number of times the transition
may occur depends on the number of instantiations the
quantified variable can take. This reasoning applies to
any variable occurring inside the scope of the quantifier,
which occurs in an effect together with the quantified
We must again resort to a new notation to describe
the resulting transition rules. We use to indicate that
the transition inside the quantifier may be performed
an unknown number of times.
For the variable ?a, we have:
In the extension process, the interpretation of the
starred rule is that the inner transition may occur any
number of times.
Observe that in this example, the transition inside
the quantifier is an exchange of properties. It may also
occur that the transition inside the quantifier involves
properties simply being gained or lost. Such properties
are considered to be attributes in the TIM system, and
are processed in a separate way. The presence of such
rules otherwise leads to non-termination of the exten-
sion process, as attributes may be added without limit.
Attribute rules are less useful for discovering invariants,
and it is unfortunate if properties are considered as at-
tributes unnecessarily. This is harmful to the TIM anal-
ysis because any property which becomes an attribute
also makes anything for which it can be exchanged into
an attribute.
It is our contention that properties will not be made
into attributes unnecessarily as a result of analysing
the quantified effect. Where properties are exchanged,
the whole exchange will normally take place inside the
quantifier, as in the example above.
An example where a quantified effect correctly gives
rise to attribute rules can be seen in the briefcase move
operator given above. There the at2properties are at-
tributes the portables at a location may be gained
and lost without exchange.
An awkward example can be found in the
Schedule domain, in which predicates of the form
(painted ?object ?paint) are typical. All operators
in the domain which mention painted include a dele-
tion which is universally quantified over possible paint
colours, as in the example operator shown below. Some
of the operators also add a single painted effect. Hence
all operators which touch an object’s painted1property
result in a state with either 0 or 1 instances of the prop-
erty for that object. If this holds also in the initial state,
it is an invariant.
(:action do-immersion-paint
:parameters (?x ?newpaint)
:precondition (and
(part ?x)
(has-paint immersion-painter ?newpaint)
(not (busy immersion-painter))
(not (scheduled ?x)))
:effect (and
(busy immersion-painter)
(scheduled ?x)
(painted ?x ?newpaint)
(when (not (objscheduled))
(forall (?oldpaint)
(when (painted ?x ?oldpaint)
(not (painted ?x ?oldpaint))))))
It is problematic that the quantified effect makes it
appear that painted1is a decreasing attribute. In ear-
lier versions of TIM, the appearance of decreasing at-
tribute transitions always led to the creation of a sepa-
rate attribute space. However, if the attribute may only
decrease, it can lead to only a finite number of states, so
it is safe to have rules of this kind in a property space.
It is important to take this approach, as invariants will
otherwise be lost.
Negative preconditions
Our treatment of negative preconditions is currently the
most restrictive described here. We use a similar tech-
nique to (Gazen & Knoblock 1997): for each predicate
that may appear as a negative precondition, we create a
new predicate to represent the negative version of that
precondition. This predicate must exactly complement
the positive use of the predicate and it replaces, in pre-
conditions, the use of the negative literal.
For those predicates which occur anywhere as a neg-
ative precondition, we must do the following to the ef-
fects of every operator:
Wherever the positive version of the predicate ap-
pears as a delete effect, the negative version must
appear as an add-effect.
Wherever the positive version of the predicate ap-
pears as an add effect, the negative version must ap-
pear as a deleted effect.
We complete the initial state of the problem descrip-
tion as follows: For each predicate and each object that
may instantiate the predicate, if there is no positively-
occurring fact, we add the negative version of the fact.
In the case of negatively-occurring predicates with
multiple arguments, the completion of initial state is
very expensive, and would, in any case, lead to a much
weaker domain analysis. For our processing we impose
the restriction that only predicates of a single argument
are handled. This also allows the transformation to be
performed, not on the operator itself, but to be pro-
cessed at the level of PRSs.
We believe that predicates with more than a single
argument could be handled efficiently using a represen-
tation in which properties which properties are counted,
but this remains an area of further investigation.
A prototype system has been implemented which suc-
cessfully produces the expected invariants for all the
cases considered in this paper, except those relying on
a full treatment of universal quantifiers. Work on the
handling of universal quantifiers is currently in progress.
Additional computational overheads for handling the
conditional effects are negligible.
In the example of hidden exclusivity between condi-
tional transitions, the system successfully detects that
exactly one of the subrules may fire, and thus extension
does not over-generate states or unnecessarily weaken
Figure 2: Property space and transitions for properties
p1,q1and r1.
the analysis by creating an attribute space. The result-
ing space for the properties p1,q1and r1is shown in
Fig. 2.
Directly from the state space, we get that states
in this space allow exactly one of the properties
{p1, q1, r1}, and from this the following invariants are
FORALL x:T1. (Exists y1:T0. p(x,y1) OR r(x) OR q(x))
FORALL x:T1. NOT (Exists y1:T0. p(x,y1) AND r(x))
FORALL x:T1. NOT (Exists y1:T0. p(x,y1) AND q(x))
FORALL x:T1. NOT (r(x) AND q(x))
Related work
Both the system of Rintanen (Rintanen 2000) and
Gerevini and Schubert’s DISCOPLAN (Gerevini &
Schubert 1998) rely on generating an initial set of can-
didate domain invariants. These are then tested against
the operators to see if they hold after the application of
the operator. Candidate invariants which are not pre-
served are either discarded or strengthened by adding
extra conditions and tested further. In both systems,
discovered invariants can be fed back, to help discover
further conditions.
The current version of DISCOPLAN (Gerevini &
Schubert 2000) has been extended to handle conditional
effects, types and negative preconditions, but does not
handle universal quantification.
An interesting question is whether DISCOPLAN can
detect and exploit the occurrence of mutually exclu-
sive secondary conditions. Our tests with the current
version of DISCOPLAN indicate that it cannot. The
account in (Gerevini & Schubert 2000) discusses the
feeding back of discovered invariants into the process,
by using this information to expand operator defini-
tions. It appears that currently, only the implicative
constraints are fed back in this way. To correctly re-
solve this problem would require XOR constraints to be
fed back into the processing of secondary conditions.
In this paper we have explored the extension of TIM to
handle a subset of ADL features. The features we have
not considered are those that allow fuller expressiveness
in the expression of preconditions: quantified variables
and arbitrary logical connectives. There are significant
difficulties in attempting to handle these features, since
the opportunity to identify the specific properties asso-
ciated with particular objects is obscured by the pos-
sibility for disjunctive preconditions combining proper-
ties of different objects, universally quantified variables
that allow reference to arbitrary objects, and nested
expressions that can involve exponential expansion if
conversion to disjunctive normal form is used. We have
also not considered a full treatment of equality and in-
equality propositions, nor of arbitrary negated literals.
The features that have been considered, and for
which there are extensions that allow TIM to extract in-
variants, include conditional effects, quantified effects,
types and a restricted form of negative preconditions.
These features form the core of those used in existing
ADL domain encodings, with the exception of the ADL
Miconics-10 domain used in the 2nd International Plan-
ning Competition in 2000. The most difficult feature
to handle is the use of conditional effects and we have
shown that there are a variety of possible approaches,
each with advantages and disadvantages. The most
powerful approach is the extension of the underlying
TIM machinery, rather than an attempt to preprocess
conditional effects out of the operators in order to reuse
the STRIPS TIM machinery. This extended machinery
complicates the entire sequence of analysis phases con-
ducted by TIM and we have described the effects that
are implied for each stage in turn.
The next stages of this work include completion of
a full implementation of all of the features described
in this paper, a further exploration of the treatment of
negative preconditions and experimentation with the
system on existing ADL domains.
The work was funded by EPSRC grant no. R090459.
Bacchus, F., and Kabanza, F. 2000. Using temporal
logics to express search control knowledge for plan-
ning. Artificial Intelligence 116.
Doherty, P., and Kvarnstrom, J. 1999. TALplanner:
An empirical investigation of a temporal logic-based
forward chaining planner. In Proceedings of the 6th
Int’l Workshop on the Temporal Representation and
Reasoning, Orlando, Fl. (TIME’99).
Fox, M., and Long, D. 1998. The automatic infer-
ence of state invariants in TIM. Journal of Artificial
Intelligence Research 9:367–421.
Fox, M., and Long, D. 2000. Utilizing automat-
ically inferred invariants in graph construction and
search. In International AI Planning Systems confer-
ence, AIPS 2000, Breckenridge, Colorado, USA.
Gazen, B. C., and Knoblock, C. A. 1997. Combin-
ing the expressivity of UCPOP with the efficiency of
graphplan. In ECP, 221–233.
Gerevini, A., and Schubert, L. K. 1998. Inferring
state constraints for domain-independent planning. In
AAAI/IAAI, 905–912.
Gerevini, A., and Schubert, L. 2000. Extending the
types of state constraints discovered by DISCOPLAN.
In Proceedings of the Workshop at AIPS on Analyzing
and Exploiting Domain Knowledge for Efficient Plan-
ning, 2000.
Kautz, H., and Selman, B. 1998. The role of domain-
specific knowledge in the planning-as-satisfiability
framework. In Proceedings of the 4th International
Conference on AI Planning Systems.
Lifschitz, E. 1986. On the semantics of STRIPS. In
Proceedings of 1986 Workshop: Reasoning about Ac-
tions and Plans.
Long, D., and Fox, M. 2000. Recognizing and ex-
ploiting generic types in planning domains. In Inter-
national AI Planning Systems conference, AIPS 2000,
Breckenridge, Colorado, USA.
Pednault, E. 1989. ADL: Exploring the middle ground
between strips and the situation calculus.
Porteous, J.; Sebastia, L.; and Hoffmann, J. 2001. On
the extraction, ordering, and usage of landmarks in
planning. In Proceedings of European Conference on
Rintanen, J. 2000. An iterative algorithm for synthe-
sizing invariants. In AAAI/IAAI, 806–811.
van Beek, P., and Chen, X. 1999. Cplan: A constraint
programming approach to planning. In Proceedings
of the 16th National Conference on Artificial Intelli-
gence, Orlando, Florida.
... For example, (controls ?p -person ?g -genie), defines the properties controls 1 and controls 2 , of type person and genie respectively. The analysis requires special treatment for negative preconditions [6]. Predicates that are used as negative preconditions (e.g., loves in the love-spell action in Fig. 2) are each paired with a new predicate that represents the negative of the predicate. ...
... These were selected because they had appeared in the literature, provided a range of narrative contexts and had been modelled independently by different narrative authors. These domains are: Aladdin [43], Crime Drama [21], Medical Drama [38], Red Riding Hood [40], Western [56] 6 . ...
Full-text available
Interactive Narrative is an emerging application of automated planning, in which a planning domain is used to generate a consistent chain of narrative actions that constitute a plot structure. The task of creating narrative planning domains has been identified as a bottleneck which is hampering further development of the field. This stems from the difficulties faced by humans authoring such planning domains due to the need to provide the range of alternative content, such as actions, which are required to support the important properties of diversity and robustness. Narrative planning domains must be capable of generating diverse sets of narratives to ensure system replayability, and they must also be able to respond robustly in the face of narrative execution failure due to user interaction. In this paper, we introduce a novel approach to the development of narrative planning domains based on the automatic expansion of a baseline planning domain through application of principled operations applied to both operators and predicates. We overview two such operations in this paper. The first of these, anton for antonymic operators, is based on the generation of contrary operators that can be invoked in the face of action failure, and whose structure is derived from a model of state transitions triggered by the original operator. Since the intention is for additional operators to be incorporated to the baseline, human-authored, domain model, the generated contents should be human-readable. This is achieved by using combined linguistic resources to access antonyms of predicates occurring inside operators, and parsing them from and into hyphenated units. The second operation, part of the same approach, referred to as thype, generates variants of operators by exploring type hierarchies for the main concepts associated with individual operators; the resulting concepts being fully integrated into a new operator’s structure. Our evaluation procedures are directly derived from the target properties of narrative planning domains, which are diversity and robustness, the former being measured through plot diversity and the latter, plot continuation following planned action execution failure. We used published narrative domains as datasets for these evaluations. Results demonstrated strong generative ability, and even more significant plan completion following action failure. Moreover, our evaluation demonstrates the synergic nature of anton and thype when applied simultaneously. Future work will focus on improving the integration of anton and thype operations through better balance between linguistic and conceptual hierarchies.
... @BULLET Edelkamp and Helmert's algorithm [14] proposed for the MIPS planner [16,15], @BULLET Scholz's algorithm for finding c-constraints [43], @BULLET Gerevini and Schubert's DISCOPLAN [24,25], @BULLET Rintanen's invariant synthesis algorithm [41], @BULLET Bonet and Geffner's algorithm for generating mutexes [4], and @BULLET Fox and Long's TIM [19,8]. Apart from the first algorithm in the list, all of these were developed independently from ours, although all but the last one follow very similar ideas. ...
... TIM was originally [19] limited to STRIPS and thus not directly usable for us. It has since been extended to handle some ADL constructs [8] , independently of the development of our invariant synthesis algorithm. ...
We introduce an efficient method for translating planning tasks specified in the standard PDDL formalism into a concise grounded representation that uses finite-domain state variables instead of the straight-forward propositional encoding.Translation is performed in four stages. Firstly, we transform the input task into an equivalent normal form expressed in a restricted fragment of PDDL. Secondly, we synthesize invariants of the planning task that identify groups of mutually exclusive propositions which can be represented by a single finite-domain variable. Thirdly, we perform an efficient relaxed reachability analysis using logic programming techniques to obtain a grounded representation of the input. Finally, we combine the results of the third and fourth stage to generate the final grounded finite-domain representation.The presented approach has originally been implemented as part of the Fast Downward planning system for the 4th International Planning Competition (IPC4). Since then, it has been used in a number of other contexts with considerable success, and the use of concise finite-domain representations has become a common feature of state-of-the-art planners.
... We believe that techniques such as simulation, visualization, and virtual prototyping, commonly used in other disciplines (Cecil and Kanchanapiboon, 2007), can help design teams identify requirements and inconsistencies in the model, as well understand their modeling decisions and the corresponding impact on plan generation and execution. It is worth mentioning that there exists a handful of specific domain analysis tools that help designers to spot malformed models (e.g., syntax checkers) and enhance the model (e.g., TIM Fox and Long, 1998; Cresswell et al., 2002). However, they have not addressed and studied the missing knowledge and requirement identification, and the re-modeling loop considering more realistic scenarios in which humans are in this loop. ...
The growth of industrial applications of artificial intelligence has raised the need for design tools to aid in the conception and implementation of such complex systems. The design of automated planning systems faces several engineering challenges including the proper modeling of the domain knowledge: the creation of a model that represents the problem to be solved, the world that surrounds the system, and the ways the system can interact with and change the world in order to solve the problem. Knowledge modeling in AI planning is a hard task that involves acquiring the system requirements and making design decisions that can determine the behavior and performance of the resulting system. In this paper we investigate how knowledge acquired during a post-design phase of modeling can be used to improve the prospective model. A post-design framework is introduced which combines a knowledge engineering tool and a virtual prototyping environment for the analysis and simulation of plans. This framework demonstrates that post-design analysis supports the discovery of missing requirements and can guide the model refinement cycle. We present three case studies using benchmark domains and eight state-of-the-art planners. Our results demonstrate that significant improvements in plan quality and an increase in planning speed of up to three orders of magnitude can be achieved through a careful post-design process. We argue that such a process is critical for the deployment of AI planning technology in real-world engineering applications.
... TIM is able to recognise the existence, in a domain, of finite renewable resources which can be consumed and released in units [31]. The analysis performed by TIM takes as input a standard STRIPS or, following recent extensions [8], an ADL description of a domain and problem. Some experiments have also been conducted with domains using numbers [17]. ...
Conference Paper
Full-text available
Reformulation of a problem is intended to make the problem more amenable to efficient solution. This is equally true in the special case of reformulating a planning problem. This paper considers various ways in which reformulation has been exploited in planning. In particular, it considers reformulation of planning problems to exploit structure within them by allowing deployment of specialised sub-solvers, capable of tackling sub-problems with greater efficiency than generic planning technologies. The relationship between this reformulation of planning problems and the reformulation of problems in general is briefly considered.
Full-text available
Domain-independent, or knowledge-sparse, planning has limited practical application because of the failure of brute-force search to scale to address real problems. However, requiring a domain engineer to take responsibility for directing the search behavior of a planner entails a heavy burden of representation and leads to systems that have no general application. An interesting compromise is to use domain analysis techniques to extract features from a domain description that can exploited to good effect by a planner. In this chapter we discuss the process by which generic patterns of behavior can be recognized in a domain, by automatic techniques, and appropriate specialized technologies recruited to assist a planner in efficient problem solving in that domain. We describe the integrated architecture of STAN5 and present results to demonstrate its potential on a variety of planning domains, including two that are currently beyond the problem-solving power of existing knowledge-sparse approaches.
Conference Paper
Full-text available
Constraint programming, a methodology for solving diffi- cult combinatorial problems by representing them as con- straint satisfaction problems, has shown that a general pur- pose search algorithm based on constraint propagation com- bined with an emphasis on modeling can solve large, prac- tical scheduling problems. Given the success of constraint programming on scheduling problems and the similarity of scheduling to planning, the question arises, would a con- straint programming approach work as well in planning? In thispaper,wepresentevidencethataconstraintprogramming approach to planning does indeed work well and has the ad- vantagein terms of time andspaceefficiencyover the current state-of-the-art planners.
Full-text available
As planning is applied to larger and richer domains the effort involved in constructing domain descriptions increases and becomes a significant burden on the human application designer. If general planners are to be applied successfully to large and complex domains it is necessary to provide the domain designer with some assistance in building correctly encoded domains. One way of doing this is to provide domain-independent techniques for extracting, from a domain description, knowledge that is implicit in that description and that can assist domain designers in debugging domain descriptions. This knowledge can also be exploited to improve the performance of planners: several researchers have explored the potential of state invariants in speeding up the performance of domain-independent planners. In this paper we describe a process by which state invariants can be extracted from the automatically inferred type structure of a domain. These techniques are being developed for exploitation by STAN, a Graphplan based planner that employs state analysis techniques to enhance its performance.
Conference Paper
Full-text available
We present a new forward chaining planner, TALplanner, based on ideas developed by Bacchus (1998) and Kabanza (1997), where domain-dependent search control knowledge represented as temporal formulas is used to effectively control forward chaining. Instead of using a linear modal tense logic as with Bacchus and Kabanza, we use TAL, a narrative-based linear temporal logic used for reasoning about action and change in incompletely specified dynamic environments. Two versions of TALplanner are considered, TALplan/modal which is based on the use of emulated modal formulas and a progression algorithm, and TALplan/non-modal which uses neither modal formulas nor a progression algorithm. For both versions of TALplanner and for all tested domains, TALplanner is shown to be considerably faster and requires less memory. The TAL versions also permit the representation of durative actions with internal state
Full-text available
SATPLAN is currently one of the fastest planning systems for domain-independent planning. In nearly all practical applications, however, there exists an abundance of domain-specific knowledge that can be used to improve the performance of a planning system. This knowledge is traditionally encoded as procedures or rules that are tied to the details of the planning engine. We present a way to encode domain knowledge in a purely declarative, algorithm independent manner. We demonstrate that the same heuristic knowledge can be used by completely different search engines, one systematic, the other using greedy local search. This approach greatly enhances the power of SATPLAN: solution times for some problems are reduced from days to seconds. Introduction Planning is a notoriously hard combinatorial search problem. In Kautz and Selman (1996) we considered domain-independent, state-space planning as a computational challenge. This style of planning is a core problem in AI; similar computati...
Full-text available
We describe some new preprocessing techniques that enable faster domain-independent planning. The first set of techniques is aimed at inferring state constraints from the structure of planning operators and the initial state. Our methods consist of generating hypothetical state constraints by inspection of operator effects and preconditions, and checking each hypothesis against all operators and the initial conditions. Another technique extracts (supersets of) predicate domains from sets of ground literals obtained by Graphplan-like forward propagation from the initial state. Our various techniques are implemented in a package called DISCOPLAN. We show preliminary results on the effectiveness of adding computed state constraints and predicate domains to the specification of problems for SAT-based planners such as SATPLAN or MEDIC. The results suggest that large speedups in planning can be obtained by such automated methods, potentially obviating the need for adding h...
Conference Paper
Full-text available
. There has been a great deal of recentwork on new approaches to efficiently generating plans in systems such as Graphplan and SATplan. However, these systems only provide an impoverished representation language compared to other planners, such as UCPOP,ADL, or Prodigy. This makes it difficult to represent planning problems using these new planners. This paper addresses this problem byproviding a completely automated set of transformations for converting a UCPOP domain representation into a Graphplan representation. The set of transformations extends the Graphplan representation language to include disjunctions, negations, universal quantification, conditional effects, and axioms. We tested the resulting planner on the 18 test domains and 41 problems that come with the UCPOP 4.0 distribution. Graphplan with the new preprocessor is able to solveevery problem in the test set and on the hard problems (i.e., those that require more than one second of CPU time) it can solve th...
Over the years increasingly sophisticated planning algorithms have been developed. These have made for more efficient planners, but unfortunately these planners still suffer from combinatorial complexity even in simple domains. Theoretical results demonstrate that planning is in the worst case intractable. Nevertheless, planning in particular domains can often be made tractable by utilizing additional domain structure. In fact, it has long been acknowledged that domain-independent planners need domain-dependent information to help them plan effectively. In this work we present an approach for representing and utilizing domain-specific control knowledge. In particular, we show how domain-dependent search control knowledge can be represented in a temporal logic, and then utilized to effectively control a forward-chaining planner. There are a number of advantages to our approach, including a declarative semantics for the search control knowledge; a high degree of modularity (new search control knowledge can be added without affecting previous control knowledge); and an independence of this knowledge from the details of the planning algorithm. We have implemented our ideas in the TLplan system, and have been able to demonstrate its remarkable effectiveness in a wide range of planning domains.