HEART: Using Abstract Plans as a Guarantee of Downward Refinement
in Decompositional Planning
Antoine Gréa, Samir Aknine and Laetitia Matignon
Univ Lyon, Université Lyon 1, CNRS, LIRIS, UMR5205, F-69621, Lyon, France
Keywords:
Hierarchical Planning, HTN, Partial Order Causal Link, POCL, Partial Order Planning, POP, Planning
Algorithms.
Abstract:
In recent years the ubiquity of artificial intelligence raised concerns among the uninitiated. The misunderstanding
is further increased since most advances do not have explainable results. For automated planning, the research
often targets speed, quality, or expressivity. Most existing solutions focus on one criteria while not addressing
the others. However, human-related applications require a complex combination of all those criteria at different
levels. We present a new method to compromise on these aspects while staying explainable. We aim to leave the
range of potential applications as wide as possible but our main targets are human intent recognition and assistive
robotics. We propose the HEART planner, a real-time decompositional planner based on a hierarchical version
of Partial Order Causal Link (POCL). It cyclically explores the plan space while making sure that intermediary
high level plans are valid and will return them as approximate solutions when interrupted. These plans are
proven to be a guarantee of solvability. This paper aims to evaluate that process and its results compared to
classical approaches in terms of efficiency and quality.
1 INTRODUCTION
Since the early days of automated planning, a wide
variety of approaches have been considered to solve di-
verse types of problems. They all range in expressivity,
speed, and reliability but often aim to excel in one of
these domains. This leads to a polarization of the solu-
tions toward more specialized methods to tackle each
problem. All of these approaches have been compared
and discussed extensively in the books of Ghallab et
al. (Ghallab et al., 2004; Ghallab et al., 2016). Par-
tially ordered approaches are popular for their least
commitment aspect, flexibility and ability to modify
plans to use refinement operations (Weld, 1994). These
approaches are often used in applications in robotics
and multi-agent planning (Lemai and Ingrand, 2004;
Dvorak et al., 2014). One of the most flexible partially
ordered approaches is called Partial Order Causal Link
planning (POCL) (Young and Moore, 1994). It works
by refining partial plans consisting of steps and causal
links into a solution by solving all flaws compromising
the validity of the plan. Another approach is Hier-
archical Task Networks (HTN) (Sacerdoti, 1974) that
is meant to tackle the problem using composite ac-
tions in order to define hierarchical tasks within the
plan. Hierarchical domains are considered easier to
conceive and maintain by experts mainly because they
seem closer to the way we think about these problems
(Sacerdoti, 1975). In our work, we aim to combine
HTN planning and POCL planning in such a manner
as to generate intermediary high-level plans during the
planning process. Combining these two approaches
is not new (Young and Moore, 1994; Kambhampati
et al., 1998; Biundo and Schattenberg, 2001). Our
work is based on Hierarchical Partial Order Planning
(HiPOP) by Bechon et al. (Bechon et al., 2014). The
idea is to expand the classical POCL algorithm with
new flaws in order to make it compatible with HTN
problems and allowing the production of abstract plans.
To do so, we present an upgraded planning framework
that aims to simplify and factorize all notions to their
minimal forms. We also propose some domain com-
pilation techniques to reduce the work of the expert
conceiving the domain. In all these works, only the
final solution to the input problem is considered. That
is a good approach to classical planning except when
no solutions can be found (or when none exists). Our
work focuses on the case when the solution could not
be found in time or when high-level explanations are
preferable to the complete implementation detail of the
plan. This is done by focusing the planning effort to-
ward finding intermediary abstract plans along the path
to the complete solution. In the rest of the paper, we
514
Gréa, A., Aknine, S. and Matignon, L.
HEART: Using Abstract Plans as a Guarantee of Downward Refinement in Decompositional Planning.
DOI: 10.5220/0007342905140522
In Proceedings of the 11th International Conference on Agents and Artificial Intelligence (ICAART 2019), pages 514-522
ISBN: 978-989-758-350-6
Copyright
c
 2019 by SCITEPRESS – Science and Technology Publications, Lda. All rights reserved

detail how the HiErarchical Abstraction for Real-Time
(HEART) planner creates abstract intermediary plans
that can be used for various applications. First, we
discuss the motivations and related works to detail the
choices behind our design process. Then we present
the way we modeled our own planning framework fit-
ting our needs and then we explain our method and
prove its properties to finally discuss the experimental
results.
Several reasons can cause a problem to be unsolv-
able. The most obvious case is that no solution exists
that meets the requirements of the problem. This has
already been addressed by Göbelbecker et al. (Göbel-
becker et al., 2010) where “excuses” are being investi-
gated as potential explanations for when a problem has
no solution. Our approach deals with problems that
are too difficult to solve within tight time constraints.
For example, in robotics, systems often need to be run
within refresh rates of several Hertz giving the process
only fractions of a second to give an updated result.
Since planning is at least EXPSPACE-hard for HTN us-
ing complex representation (Erol et al., 1994), comput-
ing only the first plan level of a hierarchical domain is
much easier in relation to the complete problem. While
abstract plans are not complete solutions, they still dis-
play a useful set of properties for various applications.
The most immediate application is for explainable plan-
ning (Fox et al., 2017; Seegebarth et al., 2012). Indeed
a high-level plan is more concise and does not contain
unnecessary implementation details that would con-
fuse a non-expert. Recent works focus on matching the
domain to a separate human model (Sreedharan et al.,
2018a; Sreedharan et al., 2018b). This requires the cre-
ation and maintenance of expansive human domains
that are mostly used as dictionaries to explain technical
details. Our method will give coherent high level plans
that are more concise and simpler than any classical
plans. Another potential application for such plans is
relative to domains that work with approximative data.
Our main example here is intent recognition which is
the original motivation for this work. Planners are not
meant to solve intent recognition problems. However,
several works extended what is called in psychology
the theory of mind. That theory is the equivalent of
asking “what would I do if I was them ?” when ob-
serving the behavior of other agents. This leads to
new ways to use inverted planning as an inference
tool. One of the first to propose that idea was Baker
et al. (Baker et al., 2007) that use Bayesian planning
to infer intentions. Ramirez and Geffner (Ramırez and
Geffner, 2009) found an elegant way to transform a
plan recognition problem into classical planning. This
is done simply by encoding temporal constraints in
the planning domain in a similar way as Baioletti et al.
(Baioletti et al., 1998) describe it to match the observed
action sequence. A cost comparison will then give a
probability of the goal to be pursued given the obser-
vations. Chen et al. (Chen et al., 2013) extended this
with multi-goal recognition. A new method, proposed
by Sohrabi et al. (Sohrabi et al., 2016), makes the
recognition fluent centric. It assigns costs to missing
or noisy observed fluents, which allows finer details
and less preprocessing work than action-based recogni-
tion. This method also uses a meta-goal that combines
each possible goal and is realized when at least one
of these goals is satisfied. Sohrabi et al. state that the
quality of the recognition is directly linked to the qual-
ity and domain coverage of the generated plans. Thus
guided diverse planning
1
was preferred along with the
ability to infer several probable goals at once.
2 RELATED WORKS
HTN is often combined with classical approaches since
it allows for a more natural expression of domains mak-
ing expert knowledge easier to encode. These kinds of
planners are named decompositional planners when
no initial plan is provided (Fox, 1997). Most of the
time the integration of HTN simply consists in call-
ing another algorithm when introducing a composite
operator during the planning process. The DUET plan-
ner by Gerevini et al. (Gerevini et al., 2008) does
so by calling an instance of a HTN planner based on
task insertion called SHOP2 (Nau et al., 2003) to de-
compose composite actions. Some planners take the
integration further by making the decomposition of
composite actions into a special step in their refine-
ment process. Such works include the discourse gen-
eration oriented DPOCL (Young and Moore, 1994)
and the work of Kambhampati et al. (Kambhampati
et al., 1998) generalizing the practice for decompo-
sitional planners. In our case, we chose a class of
hierarchical planners based on Plan-Space Planning
(PSP) algorithms (Bechon et al., 2014; Dvorak et al.,
2014; Bercher et al., 2014) as a reference approach.
The main difference here is that the decomposition is
integrated into the classical POCL algorithm by only
adding new types of flaws. This allows keeping all the
flexibility and properties of POCL while adding the
expressivity and abstraction capabilities of HTN. We
also made an improved planning framework based on
the one used by HiPOP to reduce further the number
of changes needed to handle composite actions and to
increase the efficiency of the resulting implementation.
As stated previously, our goal is to obtain intermediary
1
Diverse planning aims to find a set of 𝑚 plans that are
distant of 𝑑 from one another.
HEART: Using Abstract Plans as a Guarantee of Downward Refinement in Decompositional Planning
515

Table 1: Our notations are adapted from Ghallab et al. (Ghal-
lab et al., 2004). The symbol ± shows when the notation has
signed variants.
Symbol Description
,  Planning domain and problem.
𝑝𝑟𝑒(𝑎), 𝑒𝑓 𝑓 (𝑎) Preconditions and effects of the action 𝑎.
𝑚𝑒𝑡ℎ𝑜𝑑𝑠(𝑎) Methods of the action 𝑎.
𝜙
±
(𝑙) Signed incidence function:
𝜙
−
gives the source and 𝜙
+
the target step of 𝑙.
No sign gives a pair corresponding to link 𝑙.
𝐿
±
(𝑎) Set of incoming (𝐿
−
) and
outgoing (𝐿
+
) links of step 𝑎.
No sign gives all adjacent links.
𝑎
𝑠
𝑐
←←←←←←→ 𝑎
𝑡
Link with source 𝑎
𝑠
, target 𝑎
𝑡
and cause 𝑐.
𝑐𝑎𝑢𝑠𝑒𝑠(𝑙) Gives the causes of a causal link 𝑙.
𝑎
𝑎
≻ 𝑎
𝑠
A step 𝑎
𝑎
is anterior to the step 𝑎
𝑠
.
𝐴
𝑛
𝑥
Proper actions set of 𝑥 down 𝑛 levels.
𝑙𝑣(𝑥) Abstraction level of the entity 𝑥.
𝑎 ⊳
±
𝑎
′
Transpose the links of action 𝑎 onto 𝑎
′
.
𝑙 ↓ 𝑎 Link 𝑙 partially supports step 𝑎.
𝜋 ⇓ 𝑎 Plan 𝜋 fully supports 𝑎.
⤈
𝑓
𝑎 Subgoal: fluent 𝑓 not supported in step 𝑎.
𝑎
𝑏
⦻𝑙 Threat: action 𝑎
𝑏
threatens causal link 𝑙.
𝑎⊕
𝑚
Decomposition of action 𝑎 using method 𝑚.
𝑣𝑎𝑟 ∶ 𝑒𝑥𝑝 The colon is to be read as “such that”.
[𝑒𝑥𝑝] Iverson’s brackets:
0 if 𝑒𝑥𝑝 is false, 1 otherwise.
abstract plans and to evaluate their properties. Another
work has already been done on another aspect of those
types of plans. The Angelic algorithm by Marthi et al.
(Marthi et al., 2007) exploited such plans in the plan-
ning process itself and used them as a heuristic guide.
They also proved that, for a given fluent semantics, it is
guaranteed that such abstract solutions can be refined
into actual solutions. However, the Angelic planner
does not address the inherent properties of such ab-
stract plans as approximate solutions and uses a more
restrictive totally ordered framework.
3 DEFINITIONS
In order to make the notations used in the paper more
understandable, we gathered them in table 1. For do-
main and problem representation, we use a custom
knowledge description language that is inspired from
RDF Turtle (Beckett and Berners-Lee, 2011) and is
based on triples and propositional logic. In that lan-
guage quantifiers are used to quantify variables *(x)
(forall x) but can also be simplified with an implicit
form: lost(~) meaning " nothing is lost“. For refer-
ence, the exclusive quantifier we introduced (noted ~ )
is used for the negation (e.g. ~(lost(_)) for ” some-
thing is not lost") as well as the symbol for nil. All
symbols are defined as they are first used. If a symbol
is used as a parameter and is referenced again in the
same statement, it becomes a variable.
The domain specifies the allowed operators that
can be used to plan and all the fluents they use as
preconditions and effects.
Definition 1 (Domain) . A domain is a triplet  =
𝐸

, 𝑅, 𝐴

where:
• 𝐸

is the set of domain entities.
• 𝑅 is the set of relations over 𝐸
𝑛

. These relations
are akin to n-ary predicates in first order logic.
• 𝐴

is the set of operators which are fully lifted
actions.
Example: The example domain in listing 1 is in-
spired from the kitchen domain of Ramirez and Geffner
(Ramırez and Geffner, 2010).
1 tak e ( i tem ) pre ( t ak e n (~) , ?( ite m ) ) ;
//?(item) is used to make item
into a variable.
2 tak e ( i tem ) eff ( tak en ( ite m ) ) ;
3 hea t ( th in g ) pre (~( hot ( thi ng )) ,
ta k en ( th ing )) ;
4 hea t ( th in g ) eff ( h o t ( t hi n g ) ) ;
5 pou r ( thin g , in to ) pre ( t hin g ~( in )
int o , ta ken ( t hin g ) );
6 pou r ( thin g , in to ) eff ( t hin g in
int o ) ;
7 put ( ut en s il ) pre
(~( p l ac ed ( ut en si l ) ) ,
ta k en ( u t en si l ) ) ;
8 put ( ut en s il ) eff ( p la ce d ( u te ns il ) ,
~( tak e n ( ut ens il )) ) ;
9
10 in fu s e :: Action;
11 mak e :: Action;
Listing 1: Domain file used in our planner.
Definition 2 (Fluent) . A fluent 𝑓 is a parameterized
statement 𝑟(𝑎𝑟𝑔
1
, 𝑎𝑟𝑔
2
, . . . , 𝑎𝑟𝑔
𝑛
) where:
• 𝑟 ∈ 𝑅 is a relation/function holding a property of
the world.
• 𝑎𝑟𝑔
𝑖∈[1,𝑛]
∈ 𝐸

are the arguments (possibly quan-
tified).
• 𝑛 = 𝑟is the arity of 𝑟.
Fluents are signed. Negative fluents are noted ¬𝑓
and behave as a logical complement. The quantifiers
are affected by the sign of the fluents. We do not use
the closed world hypothesis: fluents are only satisfied
when another compatible fluent is provided. Sets of
fluents have a boolean value that equals the conjunction
of all its fluents.
Example: To describe an item not being held, we
use the fluent ¬𝑡𝑎𝑘𝑒𝑛(𝑖𝑡𝑒𝑚) . If the cup contains water,
𝑖𝑛(𝑤𝑎𝑡𝑒𝑟, 𝑐𝑢𝑝) is true.
ICAART 2019 - 11th International Conference on Agents and Artificial Intelligence
516

Definition 3 (Partial Plan / Method) . A partially or-
dered plan is an acyclic directed graph 𝜋 = (𝑆, 𝐿) , with:
• 𝑆 the set of steps of the plan as vertices. A step is
an action belonging in the plan. 𝑆 must contain an
initial step 𝐼
𝜋
and goal step 𝐺
𝜋
.
• 𝐿 the set of causal links of the plan as edges. We
note 𝑙 = 𝑎
𝑠
𝑐
←←←←←←→ 𝑎
𝑡
the link between its source 𝑎
𝑠
and
its target 𝑎
𝑡
caused by the set of fluents 𝑐 . If 𝑐 = ∅
then the link is used as an ordering constraint.
In our framework, ordering constraints are defined
as the transitive cover of causal links over the set of
steps. We note ordering constraints: 𝑎
𝑎
≻ 𝑎
𝑠
, with 𝑎
𝑎
being anterior to its successor 𝑎
𝑠
. Ordering constraints
cannot form cycles, meaning that the steps must be dif-
ferent and that the successor cannot also be anterior
to its anterior steps: 𝑎
𝑎
≠ 𝑎
𝑠
∧ 𝑎
𝑠
⊁ 𝑎
𝑎
. In all plans,
the initial and goal steps have their order guaranteed:
𝐼
𝜋
≻ 𝐺𝜋 ∧∄𝑎
𝑥
∈ 𝑆
𝜋
∶ 𝑎
𝑥
≻ 𝐼
𝜋
∨𝐺
𝜋
≻ 𝑎
𝑥
. If we need to
enforce order, we simply add a link without specifying
a cause. The use of graphs and implicit order con-
straints help to simplify the model while maintaining
its properties.
The central notion of planning is operators. In-
stantiated operators are usually called actions. In our
framework, actions can be partially instantiated. We
use the term action for both lifted and grounded opera-
tors.
Definition 4 (Action) . An action is a parametrized
tuple 𝑎(𝑎𝑟𝑔𝑠) = 𝑛𝑎𝑚𝑒, 𝑝𝑟𝑒,𝑒𝑓 𝑓 ,𝑚𝑒𝑡ℎ𝑜𝑑𝑠where:
• 𝑛𝑎𝑚𝑒 is the name of the action.
• 𝑝𝑟𝑒 and 𝑒𝑓 𝑓 are sets of fluents that are respectively
the preconditions and the effects of the action.
• 𝑚𝑒𝑡ℎ𝑜𝑑𝑠 is a set of methods (partial order plans)
that decompose the action into smaller ones. Meth-
ods, and the methods of their enclosed actions, can-
not contain the parent action.
Example: The precondition of the operator
𝑡𝑎𝑘𝑒(𝑖𝑡𝑒𝑚) is simply a single negative fluent noted
¬𝑡𝑎𝑘𝑒𝑛(𝑖𝑡𝑒𝑚) ensuring the variable 𝑖𝑡𝑒𝑚 is not already
taken.
Composite actions are represented using methods.
An action without methods is called atomic. It is of
interest to note the divergence with classical HTN rep-
resentation here since normally composite actions do
not have preconditions nor effects. In our case, we
insert them into abstract plans.
In order to simplify the input of the domain, the
causes of the causal links in the methods are optional.
If omitted, the causes are inferred by unifying the
preconditions and effects with the same mechanism
as in the subgoal resolution in our POCL algorithm.
Since we want to guarantee the validity of abstract
plans, we need to ensure that user provided plans
are solvable. We use the following formula to com-
pute the final preconditions and effects of any com-
posite action 𝑎 : 𝑝𝑟𝑒(𝑎) =

𝑚∈𝑚𝑒𝑡ℎ𝑜𝑑𝑠(𝑎)
𝑙∈𝐿
+
(𝐼
𝑚
)
𝑐𝑎𝑢𝑠𝑒𝑠(𝑙) and
𝑒𝑓 𝑓(𝑎) =

𝑚∈𝑚𝑒𝑡ℎ𝑜𝑑𝑠(𝑎)
𝑙∈𝐿
−
(𝐺
𝑚
))
𝑐𝑎𝑢𝑠𝑒𝑠(𝑙) . An instance of the
classical POCL algorithm is then run on the problem

𝑎
= , 𝐶

, 𝑎 to ensure its coherence. The domain
compilation fails if POCL cannot be completed. Since
our decomposition hierarchy is acyclic ( 𝑎 ∉ 𝐴
𝑎
, see def-
inition 10) nested methods cannot contain their parent
action as a step.
Problem instances are often most simply described
by two components: the initial state and the goal.
Definition 5 (Problem) . The planning problem is de-
fined as a tuple  = ,𝐶

, 𝑎
0
where:
•  is a planning domain.
• 𝐶

is the set of problem constants disjoint from
the domain constants.
• 𝑎
0
is the root operator of the problem which meth-
ods are potential solutions of the problem.
Example: We use a simple problem for our exam-
ple domain. The initial state provides that nothing is
ready, taken or hot and all containers are empty (all
using quantifiers). The goal is to have tea made. For
reference, listing 2 contains the problem instance we
use as an example.
1 ini t eff ( hot (~) , ta ken (~) ,
pl ace d (~) , ~ in ~) ;
2 goa l pre ( hot ( wat e r ) , te a in cup ,
wa t er in cup , pl ac e d ( sp o on ) ,
pl ace d ( cu p )) ;
Listing 2: Example of a problem instance for the kitchen
domain.
The root operator is initialized to 𝑎
0
=
 ““ , 𝑠
0
, 𝑠
∗
, {𝜋
𝑙𝑣(𝑎
0
)
} , with 𝑠
0
being the initial
state and 𝑠
∗
the goal specification. The method
𝜋
𝑙𝑣(𝑎
0
)
is a partial order plan with the initial and
goal steps linked together via 𝑎
0
. The initial partial
order plan is 𝜋
𝑙𝑣(𝑎
0
)
= ({𝐼, 𝐺}, {𝐼
𝑠
0
←←←←←←←←←→ 𝑎
0
𝑠
∗
←←←←←←←←←→ 𝐺}) , with
𝐼 = “init“,∅, 𝑠
0
, ∅and 𝐺 = “goal“, 𝑠
∗
, ∅, ∅.
Our method is based on the classical POCL
algorithm. It works by refining a partial plan into a
solution by recursively removing all of its flaws.
HEART: Using Abstract Plans as a Guarantee of Downward Refinement in Decompositional Planning
517

Definition 6 (Flaws) . Flaws have a proper fluent 𝑓
and a causing step often called the needer 𝑎
𝑛
. Flaws
in a partial plan are either:
• Subgoals , open conditions that are yet to be sup-
ported by another step 𝑎
𝑛
often called provider. We
note subgoals ⤈
𝑓
𝑎
𝑛
.
• Threats , caused by steps that can break a causal
link with their effects. They are called breakers of
the threatened link. A step 𝑎
𝑏
threatens a causal link
𝑙
𝑡
= 𝑎
𝑝
𝑓
←←←←←←←→ 𝑎
𝑛
if and only if ¬𝑓 ∈ 𝑒𝑓 𝑓 (𝑎
𝑏
) ∧ 𝑎
𝑏
⊁
𝑎
𝑝
∧𝑎
𝑛
⊁ 𝑎
𝑏
. Said otherwise, the breaker can cancel
an effect of a providing step 𝑎
𝑝
, before it gets used
by its needer 𝑎
𝑛
. We note threats 𝑎
𝑏
⦻𝑙
𝑡
.
Example: Our initial plan contains two unsup-
ported subgoals: one to make the tea ready and another
to put sugar in it. In this case, the needer is the goal
step and the proper fluents are each of its preconditions.
These flaws need to be fixed in order for the plan to
be valid. In POCL it is done by finding their resolvers.
Definition 7 (Resolvers) . Classical resolvers are addi-
tional causal links that aim to fix a flaw.
• For subgoals, the resolvers are a set of potential
causal links containing the proper fluent 𝑓 in their
causes while taking the needer step 𝑎
𝑛
as their target
and a provider step 𝑎
𝑝
as their source.
• For threats, we usually consider only two resolvers:
demotion ( 𝑎
𝑏
≻ 𝑎
𝑝
) and promotion ( 𝑎
𝑛
≻ 𝑎
𝑏
) of
the breaker relative to the threatened link. We call
the added causeless causal link a guarding link.
Negative resolvers are resolvers that will delete
causal links to fix a flaw. These are needed for decom-
position definition 12.
Example: The subgoal for 𝑖𝑛(𝑤𝑎𝑡𝑒𝑟, 𝑐𝑢𝑝) , in
our example, can be solved by using the action
𝑝𝑜𝑢𝑟(𝑤𝑎𝑡𝑒𝑟, 𝑐𝑢𝑝) as the source of a causal link carrying
the proper fluent as its only cause.
The application of a resolver does not necessarily
mean progress. It can have consequences that may
require reverting its application in order to respect the
backtracking of the POCL algorithm.
Definition 8 (Side effects) . Flaws that are caused by
the application of a resolver are called related flaws.
They are inserted into the agenda
2
with each applica-
tion of a resolver:
2
An agenda is a flaw container used for the flaw selection
of POCL.
• Related subgoals are all the new open conditions
inserted by new steps.
• Related threats are the causal links threatened by
the insertion of a new step or the deletion of a
guarding link.
Flaws can also become irrelevant when a resolver
is applied. It is always the case for the targeted flaw,
but this can also affect other flaws. Those invalidated
flaws are removed from the agenda upon detection:
• Invalidated subgoals are subgoals satisfied by the
new causal links or the removal of their needer.
• Invalidated threats happen when the breaker no
longer threatens the causal link because the order
guards the threatened causal link or either of them
has been removed.
Example: Adding the action 𝑝𝑜𝑢𝑟(𝑤𝑎𝑡𝑒𝑟, 𝑐𝑢𝑝)
causes a related subgoal for each of the preconditions
of the action which are: the cup and the water must be
taken and water must not already be in the cup.
In definition 7, we mentioned effects that aren’t
present in classical POCL, namely negative resolvers.
All classical resolvers only add steps and causal links
to the partial plan. Our method needs to remove com-
posite steps and their adjacent links when expanding
them.
4 THE HEART OF THE METHOD
In this section, we explain how our method combines
POCL with HTN planning and how they are used
to generate intermediary abstract plans. In order to
properly introduce the changes made for using HTN
domains in POCL, we need to define a few notions.
Transposition is needed to define decomposition.
Definition 9 (Transposition) . In order to transpose the
causal links of an action 𝑎
′
with the ones of an existing
step 𝑎 in a plan 𝜋, we use the following operation:
𝑎 ⊳
−
𝜋
𝑎
′
=

𝜙
−
(𝑙)
𝑐𝑎𝑢𝑠𝑒𝑠(𝑙)
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←→ 𝑎
′
∶ 𝑙 ∈ 𝐿
−
𝜋
(𝑎)

It is the same with 𝑎
′
𝑐𝑎𝑢𝑠𝑒𝑠(𝑙)
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←→ 𝜙
+
(𝑙) and 𝐿
+
for
𝑎 ⊳
+
𝑎
′
. This supposes that the respective precondi-
tions and effects of 𝑎 and 𝑎
′
are equivalent. When
not signed, the transposition is generalized: 𝑎 ⊳ 𝑎
′
=
𝑎 ⊳
−
𝑎
′
∪ 𝑎 ⊳
+
𝑎
′
.
Example: 𝑎⊳
−
𝑎
′
gives all incoming links of 𝑎 with
the 𝑎 replaced by 𝑎
′
.
ICAART 2019 - 11th International Conference on Agents and Artificial Intelligence
518

Definition 10 (Proper Actions) . Proper actions are
actions that are “contained” within an entity (either
a domain, plan or action). We note this notion 𝐴
𝑎
=
𝐴
𝑙𝑣(𝑎)
𝑎
for an action 𝑎 . It can be applied to various
concepts:
• For a domain or a problem, 𝐴

= 𝐴

.
• For a plan, it is 𝐴
0
𝜋
= 𝑆
𝜋
.
• For an action, it is 𝐴
0
𝑎
=

𝑚∈𝑚𝑒𝑡ℎ𝑜𝑑𝑠(𝑎)
𝑆
𝑚
. Re-
cursively: 𝐴
𝑛
𝑎
=

𝑏∈𝐴
0
𝑎
𝐴
𝑛−1
𝑏
. For atomic actions,
𝐴
𝑎
= ∅.
Example: The proper actions of 𝑚𝑎𝑘𝑒(𝑑𝑟𝑖𝑛𝑘)
are the actions contained within its methods. The
set of extended proper actions adds all proper
actions of its single proper composite action
𝑖𝑛𝑓 𝑢𝑠𝑒(𝑑𝑟𝑖𝑛𝑘, 𝑤𝑎𝑡𝑒𝑟, 𝑐𝑢𝑝).
Definition 11 (Abstraction Level) . This is a measure
of the maximum amount of abstraction an entity can
express, defined recursively by:
3
𝑙𝑣(𝑥) =

max
𝑎∈𝐴
𝑥
(𝑙𝑣(𝑎)) + 1

[𝐴
𝑥
≠ ∅]
Example: The abstraction level of any atomic
action is 0 while it is 2 for the composite action
𝑚𝑎𝑘𝑒(𝑑𝑟𝑖𝑛𝑘) . The example domain (in listing 1) has
an abstraction level of 3.
The most straightforward way to handle abstrac-
tion in regular planners is illustrated by Duet (Gerevini
et al., 2008) by managing hierarchical actions sepa-
rately from a task insertion planner. We chose to add ab-
straction in POCL in a manner inspired by the work of
Bechon et al. (Bechon et al., 2014) on a planner called
HiPOP. The difference between the original HiPOP
and our implementation of it is that we focus on the ex-
pressivity and the ways flaw selection can be exploited
for partial resolution. Our version is lifted at runtime
while the original is grounded for optimizations. All
mechanisms we have implemented use POCL but with
different management of flaws and resolvers.
One of those changes is that resolver selection
needs to be altered for subgoals. Indeed, as stated
by the authors of HiPOP: the planner must ensure the
selection of high-level operators in order to benefit
from the hierarchical aspect of the domain. Otherwise,
adding operators only increases the branching factor.
Composite actions are not usually meant to stay in a fin-
ished plan and must be decomposed into atomic steps
from one of their methods.
3
We use Iverson brackets here, see notations in table 1.
Definition 12 (Decomposition Flaws) . They occur
when a partial plan contains a non-atomic step. This
step is the needer 𝑎
𝑛
of the flaw. We note its decompo-
sition 𝑎
𝑛
⊕.
• Resolvers: A decomposition flaw is solved with a
decomposition resolver . The resolver will replace
the needer with one of its instantiated methods
𝑚 ∈ 𝑚𝑒𝑡ℎ𝑜𝑑𝑠(𝑎
𝑛
) in the plan 𝜋 . This is done by
using transposition such that: 𝑎
𝑛
⊕
𝑚
𝜋
= 𝑆
𝑚
∪ (𝑆
𝜋
⧵
{𝑎}), 𝑎
𝑛
⊳
−
𝐼
𝑚
∪ 𝑎
𝑛
⊳
+
𝐺
𝑚
∪ (𝐿
𝜋
⧵ 𝐿
𝜋
(𝑎
𝑛
)).
• Side effects: A decomposition flaw can be created
by the insertion of a composite action in the plan
by any resolver and invalidated by its removal:
𝑓 ∈𝑝𝑟𝑒(𝑎
𝑚
)

𝑎
𝑚
∈𝑆
𝑚
𝜋
′
⤈
𝑓
𝑎
𝑚
𝑙∈𝐿
𝜋
′

𝑎
𝑏
∈𝑆
𝜋
′
𝑎
𝑏
⦻𝑙
𝑙𝑣(𝑎
𝑐
)≠0

𝑎
𝑐
∈𝑆
𝑚
𝑎
𝑐
⊕
Example: When adding the step 𝑚𝑎𝑘𝑒(𝑡𝑒𝑎) in the
plan to solve the subgoal that needs tea being made, we
also introduce a decomposition flaw that will need this
composite step replaced by its method using a decom-
position resolver. In order to decompose a composite
action into a plan, all existing links are transposed to
the initial and goal step of the selected method, while
the composite action and its links are removed from
the plan. The main differences between HiPOP and
HEART in our implementations are the functions of
flaw selection and the handling of the results (one plan
for HiPOP and a plan per cycle for HEART). In HiPOP,
the flaw selection is made by prioritizing the decom-
position flaws. Bechon et al. (Bechon et al., 2014)
state that it makes the full resolution faster. However,
it also loses opportunities to obtain abstract plans in
the process.
Ω
hot(water), tea in cup, water in cup,
placed(spoon), placed(cup)
placed (~), taken (~),
hot (~), * ~(in) *
make(tea)
I G
pour(water, cup)
take(spoon)
take(cup)
I
i
G
i
I
m
G
m
infuse(tea, water, cup)
heat(water)
taken(~)
put(spoon)
put(cup)
~(taken(spoon)) placed(spoon)
take(tea)
take(water)
pour(tea, cup)
placed(cup)
2
0
1
Level 3
…
…
…
Figure 1: Illustration of how the cyclical approach is applied
on the example domain. Atomic actions that are copied from
a cycle to the next are omitted.
The main focus of our work is toward obtaining ab-
stract plans which are plans that are completed while
still containing composite actions. In order to do that
the flaw selection function will enforce cycles in the
planning process.
Definition 13 (Cycle) . A cycle is a planning phase
defined as a triplet 𝑐 = 𝑙𝑣(𝑐), 𝑎𝑔𝑒𝑛𝑑𝑎, 𝜋
𝑙𝑣(𝑐)
 where:
HEART: Using Abstract Plans as a Guarantee of Downward Refinement in Decompositional Planning
519

𝑙𝑣(𝑐) is the maximum abstraction level allowed for flaw
selection in the 𝑎𝑔𝑒𝑛𝑑𝑎 of remaining flaws in partial
plan 𝜋
𝑙𝑣(𝑐)
. The resolvers of subgoals are therefore
constrained by the following: 𝑎
𝑝
↓
𝑓
𝑎
𝑛
∶ 𝑙𝑣(𝑎
𝑝
) ≤ 𝑙𝑣(𝑐) .
During a cycle all decomposition flaws are delayed.
Once no more flaws other than decomposition flaws
are present in the agenda, the current plan is saved
and all remaining decomposition flaws are solved at
once before the abstraction level is lowered for the next
cycle: 𝑙𝑣(𝑐
′
) = 𝑙𝑣(𝑐) − 1 . Each cycle produces a more
detailed abstract plan than the one before.
Abstract plans allow the planner to do an approxi-
mate form of anytime execution. At any given time the
planner is able to return a fully supported plan. Before
the first cycle, the plan returned is 𝜋
𝑙𝑣(𝑎
0
)
.
Example: In our case using the method of intent
recognition of Sohrabi et al. (Sohrabi et al., 2016), we
can already use 𝜋
𝑙𝑣(𝑎
0
)
to find a likely goal explaining
an observation (a set of temporally ordered fluents).
That can make an early assessment of the probability
of each goal of the recognition problem.
For each cycle 𝑐 , a new plan 𝜋
𝑙𝑣(𝑐)
is created as a
new method of the root operator 𝑎
0
. These intermedi-
ary plans are not solutions of the problem, nor do they
mean that the problem is solvable. In order to find a
solution, the HEART planner needs to reach the final
cycle 𝑐
0
with an abstraction level 𝑙𝑣(𝑐
0
) = 0 . However,
these plans can be used to derive meaning from the po-
tential solution of the current problem and give a good
approximation of the final result before its completion.
Example: In the figure 1, we illustrate the way our
problem instance is progressively solved. Before the
first cycle 𝑐
2
, all we have is the root operator and its
plan 𝜋
3
. Then within the first cycle, we select the com-
posite action 𝑚𝑎𝑘𝑒(𝑡𝑒𝑎) instantiated from the operator
𝑚𝑎𝑘𝑒(𝑑𝑟𝑖𝑛𝑘) along with its methods. All related flaws
are fixed until all that is left in the agenda is the abstract
flaws. We save the partial plan 𝜋
2
for this cycle and
expand 𝑚𝑎𝑘𝑒(𝑡𝑒𝑎) into a copy of the current plan 𝜋
1
for the next cycle. The solution of the problem will be
stored in 𝜋
0
once found.
5 RESULTS
The completeness and soundness of POCL has been
proven in (Penberthy et al., 1992). An interesting prop-
erty of POCL algorithms is that flaw selection strate-
gies do not impact these properties. Since the only
modification of the algorithm is the extension of the
classical flaws with a decomposition flaw, all we need
to explore, to update the proofs, is the impact of the
new resolver. By definition, the resolvers of decompo-
sition flaws will take into account all flaws introduced
by its resolution into the refined plan. It can also revert
its application properly.
Lemma (Decomposing preserves acyclicity) . The de-
composition of a composite action with a valid method
in an acyclic plan will result in an acyclic plan.
Formely, ∀𝑎
𝑠
∈ 𝑆
𝜋
∶ 𝑎
𝑠
⊁
𝜋
𝑎
𝑠
⟹ ∀𝑎
′
𝑠
∈ 𝑆
𝑎⊕
𝑚
𝜋
∶
𝑎
′
𝑠
⊁
𝑎⊕
𝑚
𝜋
𝑎
′
𝑠
.
Proof. When decomposing a composite action 𝑎 with
a method 𝑚 in an existing plan 𝜋 , we add all steps 𝑆
𝑚
in the refined plan. Both 𝜋 and 𝑚 are guaranteed to
be cycle free by definition. We can note that ∀𝑎
𝑠
∈
𝑆
𝑚
∶

∄𝑎
𝑡
∈ 𝑆
𝑚
∶ 𝑎
𝑠
≻ 𝑎
𝑡
∧ ¬𝑓 ∈ 𝑒𝑓 𝑓(𝑎
𝑡
)

⟹ 𝑓 ∈
𝑒𝑓 𝑓(𝑎) . Said otherwise, if an action 𝑎
𝑠
can participate
a fluent 𝑓 to the goal step of the method 𝑚 then it is
necessarily present in the effects of 𝑎 . Since higher
level actions are preferred during the resolver selec-
tion, no actions in the methods are already used in the
plan when the decomposition happens. This can be
noted ∃𝑎 ∈ 𝜋 ⟹ 𝑆
𝑚
⊍ 𝑆
𝜋
meaning that in the graph
formed both partial plans 𝑚 and 𝜋 cannot contain the
same edges therefore their acyclicity is preserved when
inserting one into the other.
Lemma (Solved decomposition flaws cannot reoccur) .
The application of a decomposition resolver on a plan
𝜋 , guarantees that 𝑎 ∉ 𝑆
𝜋
′
for any partial plan refined
from 𝜋 without reverting the application of the resolver.
Proof. As stated in the definition of the methods defini-
tion 4: 𝑎 ∉ 𝐴
𝑎
. This means that 𝑎 cannot be introduced
in the plan by its decomposition or the decomposition
of its proper actions. Indeed, once 𝑎 is expanded, the
level of the following cycle 𝑐
𝑙𝑣(𝑎)−1
prevents 𝑎 to be
selected by subgoal resolvers. It cannot either be con-
tained in the methods of another action that are selected
afterward because otherwise following definition 11
its level would be at least 𝑙𝑣(𝑎) + 1.
Lemma (Decomposing to abstraction level 0 guaran-
tees solvability) . Finding a partial plan that contains
only decomposition flaws with actions of abstraction
level 1, guarantees a solution to the problem.
Proof. Any method 𝑚 of a composite action 𝑎 ∶
𝑙𝑣(𝑎) = 1 is by definition a solution of the problem

𝑎
= , 𝐶

, 𝑎 . By definition, 𝑎 ∉ 𝐴
𝑎
, and 𝑎 ∉ 𝐴
𝑎⊕
𝑚
𝜋
(meaning that 𝑎 cannot reoccur after being decom-
posed). It is also given by definition that the instan-
tiation of the action and its methods are coherent re-
garding variable constraints (everything is instantiated
ICAART 2019 - 11th International Conference on Agents and Artificial Intelligence
520

before selection by the resolvers). Since the plan 𝜋
only has decomposition flaws and all flaws within 𝑚
are guaranteed to be solvable, and both are guaranteed
to be acyclical by the application of any decomposition
𝑎⊕
𝑚
𝜋
, the plan is solvable.
Lemma (Abstract plans guarantee solvability) . Find-
ing a partial plan 𝜋 that contains only decomposition
flaws, guarantees a solution to the problem.
Proof. Recursively, if we apply the previous proof on
higher level plans we note that decomposing at level 2
guarantees a solution since the method of the composite
actions are guaranteed to be solvable.
6 CONCLUSION
In this paper, we have presented a new planner called
HEART based on POCL. An updated planning frame-
work fitting the need for such a new approach was pro-
posed. While the abstract plans generated during the
planning process are not complete solutions, they are
exponentially faster to generate while retaining signifi-
cant quality over the final plans. They are also proofs
of solvability of the problem. By using these plans,
it is possible to generate explanations of intractable
problems within tight time constraints.
The source code of HEART along with an extended
version of this paper is available at genn.io/heart.
REFERENCES
Baioletti, M., Marcugini, S., and Milani, A. (1998). En-
coding planning constraints into partial order planning
domains. In International Conference on Principles
of Knowledge Representation and Reasoning, pages
608–616. Morgan Kaufmann Publishers Inc. 00013.
Baker, C. L., Tenenbaum, J. B., and Saxe, R. R. (2007).
Goal inference as inverse planning. In Proceedings of
the Annual Meeting of the Cognitive Science Society,
volume 29. 00064.
Bechon, P., Barbier, M., Infantes, G., Lesire, C., and Vidal, V.
(2014). HiPOP: Hierarchical Partial-Order Planning. In
European Starting AI Researcher Symposium, volume
264, pages 51–60. IOS Press.
Beckett, D. and Berners-Lee, T. (2011). Turtle - Terse RDF
Triple Language. W3C Team Submission, W3C.
Bercher, P., Keen, S., and Biundo, S. (2014). Hybrid plan-
ning heuristics based on task decomposition graphs. In
Seventh Annual Symposium on Combinatorial Search.
Biundo, S. and Schattenberg, B. (2001). From abstract crisis
to concrete relief — A preliminary report on flexible
integration on nonlinear and hierarchical planning. In
Proceedings of the European Conference on Planning.
Chen, J., Chen, Y., Xu, Y., Huang, R., and Chen, Z. (2013).
A Planning Approach to the Recognition of Multiple
Goals. International Journal of Intelligent Systems,
28(3):203–216. 00003.
Dvorak, F., Bit-Monnot, A., Ingrand, F., and Ghallab,
M. (2014). A flexible ANML actor and planner in
robotics. In Planning and Robotics (PlanRob) Work-
shop (ICAPS).
Erol, K., Hendler, J., and Nau, D. S. (1994). HTN planning:
Complexity and expressivity. In AAAI, volume 94,
pages 1123–1128.
Fox, M. (1997). Natural hierarchical planning using operator
decomposition. In European Conference on Planning,
pages 195–207. Springer.
Fox, M., Long, D., and Magazzeni, D. (2017). Explain-
able Planning. In Proceedings of IJCAI Workshop on
Explainable AI, Melbourne, Australia.
Gerevini, A., Kuter, U., Nau, D. S., Saetti, A., and Waisbrot,
N. (2008). Combining Domain-Independent Planning
and HTN Planning: The Duet Planner. In Proceedings
of the European Conference on Artificial Intelligence,
volume 18, pages 573–577. 00025.
Ghallab, M., Nau, D., and Traverso, P. (2004). Automated
Planning: Theory & Practice. Elsevier. 00002.
Ghallab, M., Nau, D., and Traverso, P. (2016). Automated
Planning and Acting. Cambridge University Press.
00058.
Göbelbecker, M., Keller, T., Eyerich, P., Brenner, M., and
Nebel, B. (2010). Coming Up With Good Excuses:
What to do When no Plan Can be Found. In Pro-
ceedings of the International Conference on Automated
Planning and Scheduling, volume 20, pages 81–88.
AAAI Press. 00036.
Kambhampati, S., Mali, A., and Srivastava, B. (1998). Hy-
brid planning for partially hierarchical domains. In
AAAI/IAAI, pages 882–888.
Lemai, S. and Ingrand, F. (2004). Interleaving temporal
planning and execution in robotics domains. In AAAI,
volume 4, pages 617–622. 00117.
Marthi, B., Russell, S. J., and Wolfe, J. A. (2007). Angelic
Semantics for High-Level Actions. In ICAPS, pages
232–239.
Nau, D. S., Au, T.-C., Ilghami, O., Kuter, U., Murdock, J. W.,
Wu, D., and Yaman, F. (2003). SHOP2: An HTN
planning system. J. Artif. Intell. Res.(JAIR), 20:379–
404. 00891.
Penberthy, J. S., Weld, D. S., and others (1992). UCPOP: A
Sound, Complete, Partial Order Planner for ADL. Kr,
92:103–114. 00000.
Ramırez, M. and Geffner, H. (2009). Plan recognition as plan-
ning. In Proceedings of the International Conference
on International Conference on Automated Planning
and Scheduling, volume 19, pages 1778–1783. AAAI
Press. 00093.
Ramırez, M. and Geffner, H. (2010). Probabilistic plan
recognition using off-the-shelf classical planners. In
Proceedings of the Conference of the Association for
the Advancement of Artificial Intelligence, volume 24,
pages 1121–1126. 00099.
HEART: Using Abstract Plans as a Guarantee of Downward Refinement in Decompositional Planning
521

Sacerdoti, E. D. (1974). Planning in a hierarchy of abstraction
spaces. Artificial intelligence, 5(2):115–135.
Sacerdoti, E. D. (1975). The nonlinear nature of plans. Tech-
nical report, STANFORD RESEARCH INST MENLO
PARK CA.
Seegebarth, B., Müller, F., Schattenberg, B., and Biundo,
S. (2012). Making hybrid plans more clear to human
users—a formal approach for generating sound expla-
nations. In Proceedings of the Twenty-Second Inter-
national Conference on International Conference on
Automated Planning and Scheduling, pages 225–233.
AAAI Press. 00019.
Sohrabi, S., Riabov, A. V., and Udrea, O. (2016). Plan Recog-
nition as Planning Revisited. In Proceedings of the In-
ternational Joint Conference on Artificial Intelligence,
volume 25. 00004.
Sreedharan, S., Chakraborti, T., and Kambhampati, S.
(2018a). Handling Model Uncertainty and Multiplic-
ity in Explanations via Model Reconciliation. In In-
ternational Conference on Automated Planning and
Scheduling.
Sreedharan, S., Srivastava, S., and Kambhampati, S. (2018b).
Hierarchical Expertise-Level Modeling for User Spe-
cific Robot-Behavior Explanations. In International
Joint Conference on Artificial Intelligence.
Weld, D. S. (1994). An introduction to least commitment
planning. AI magazine, 15(4):27. 00775.
Young, R. M. and Moore, J. D. (1994). DPOCL: A principled
approach to discourse planning. In Proceedings of the
Seventh International Workshop on Natural Language
Generation, pages 13–20. Association for Computa-
tional Linguistics.
ICAART 2019 - 11th International Conference on Agents and Artificial Intelligence
522