Planning is an area of research in artificial intelligence that aims to achieve autonomous control of complex systems. Formally, the planning problem is to obtain a sequence of transformations for moving a system from an initial state to a goal state, given a description of possible transformations. Planning algorithms have been successfully used in a variety of applications, including robotics, process planning, information gathering, autonomous agents and spacecraft mission control. Research in planning has seen significant progress during the last ten years, in part due to the establishment of the International Planning Competition.
An important aspect of research in planning is to classify the complexity of solving planning problems. Being able to classify a planning problem according to complexity makes it possible to select the right tool for solving it. Researchers usually distinguish between two problems: plan generation, the problem of generating a sequence of transformations for achieving the goal, and plan existence, the problem of determining whether such a sequence exists. If the original STRIPS formalism is used, plan existence is undecidable in the first-order case[ChapmanChapman1987] and PSPACE-complete in the propositional case [BylanderBylander1994]. Using PDDL, the representation language used at the International Planning Competition, plan existence is EXPSPACE-complete [Erol, Nau, SubrahmanianErol et al.1995]. However, planning problems usually exhibit structure that makes them much easier to solve. Helmert03 showed that many of the benchmark problems used at the International Planning Competition are in fact in or .
A common type of structure that researchers have used to characterize planning problems is the so called causal graph [KnoblockKnoblock1994]. The causal graph of a planning problem is a graph that captures the degree of independence among the state variables of the problem, and is easily constructed given a description of the problem transformations. The independence between state variables can be exploited to devise algorithms for efficiently solving the planning problem. The causal graph has been used as a tool for describing tractable subclasses of planning problems [Brafman DomshlakBrafman Domshlak2003, Jonsson BäckströmJonsson Bäckström1998, Williams NayakWilliams Nayak1997], for decomposing planning problems into smaller problems [Brafman DomshlakBrafman Domshlak2006, JonssonJonsson2007, KnoblockKnoblock1994]
, and as the basis for domain-independent heuristics that guide the search for a valid plan[HelmertHelmert2006].
In the present work we explore the computational complexity of solving planning problems with simple causal graphs. We present new results for three classes of planning problems studied in the literature: the class 3S [Jonsson BäckströmJonsson Bäckström1998], the class [Domshlak DinitzDomshlak Dinitz2001], and the class of planning problems with polytree causal graphs [Brafman DomshlakBrafman Domshlak2003]. In brief, we show that plan generation for instances of the first class can be solved in polynomial time using macros, but that plan existence is not solvable in polynomial time for the remaining two classes, unless . This work first appeared in a conference paper [Giménez JonssonGiménez Jonsson2007]; the current paper provides more detail and additional insights as well as new sections on plan length and CP-nets.
A planning problem belongs to the class 3S if its causal graph is acyclic and all state variables are either static, symmetrically reversible or splitting (see Section 3 for a precise definition of these terms). The class 3S was introduced and studied by Jonsson98b as an example of a class for which plan existence is easy (there exists a polynomial-time algorithm that determines whether or not a particular planning problem of that class is solvable) but plan generation is hard (there exists no polynomial-time algorithm that generates a valid plan for every planning problem of the class). More precisely, Jonsson98b showed that there are planning problems of the class 3S for which every valid plan is exponentially long. This clearly prevents the existence of an efficient plan generation algorithm.
Our first contribution is to show that plan generation for 3S is in fact easy if we are allowed to express a valid plan using macros. A macro is simply a sequence of operators and other macros. We present a polynomial-time algorithm that produces valid plans of this form for planning problems of the class 3S. Namely, our algorithm outputs in polynomial time a system of macros that, when executed, produce the actual valid plan for the planning problem instance. The algorithm is sound and complete, that is, it generates a valid plan if and only if one exists. We contrast our algorithm to the incremental algorithm proposed by Jonsson98b, which is polynomial in the size of the output.
We also investigate the complexity of the class of planning problems with multi-valued state variables and chain causal graphs. In other words, the causal graph is just a directed path. Domshlak01 showed that there are solvable instances of this class that require exponentially long plans. However, as it is the case with the class 3S, there could exist an efficient procedure for generating valid plans for instances using macros or some other novel idea. We show that plan existence in is -hard, hence ruling out that such an efficient procedure exists, unless .
We also prove that plan existence for planning problems whose causal graph is a polytree (i.e., the underlying undirected graph is acyclic) is
-complete, even if we restrict to problems with binary variables. This result closes the complexity gap that appears in Brafman03 regarding planning problems with binary variables. The authors show that plan existence is-complete for planning problems with singly connected causal graphs, and that plan generation is polynomial for planning problems with polytree causal graphs of bounded indegree. We use the same reduction to prove that a similar problem on polytree CP-nets [Boutilier, Brafman, Domshlak, Hoos, PooleBoutilier et al.2004] is -complete.
1.1 Related Work
Several researchers have used the causal graph to devise algorithms for solving planning problems or to study the complexity of planning problems. Knoblock94 used the causal graph to decompose a planning problem into a hierarchy of increasingly abstract problems. Under certain conditions, solving the hierarchy of abstract problems is easier than solving the original problem. Williams97 introduced several restrictions on planning problems to ensure tractability, one of which is that the causal graph should be acyclic. Jonsson98b defined the class 3S of planning problems, which also requires the causal graphs to be acyclic, and showed that plan existence is polynomial for this class.
Domshlak01 analyzed the complexity of several classes of planning problems with acyclic causal graphs. Brafman03 designed a polynomial-time algorithm for solving planning problems with binary state variables and acyclic causal graph of bounded indegree. Brafman06 identified conditions under which it is possible to factorize a planning problem into several subproblems and solve the subproblems independently. They claimed that a planning problem is suitable for factorization if its causal graph has bounded tree-width.
The idea of using macros in planning is almost as old as planning itself [Fikes NilssonFikes Nilsson1971]. Minton85 developed an algorithm that measures the utility of plan fragments and stores them as macros if they are deemed useful. Korf87 showed that macros can exponentially reduce the search space size of a planning problem if chosen carefully. Vidal04 used relaxed plans generated while computing heuristics to produce macros that contribute to the solution of planning problems. Macro-FF [Botea, Enzenberger, Müller, SchaefferBotea et al.2005], an algorithm that identifies and caches macros, competed at the fourth International Planning Competition. The authors showed how macros can help reduce the search effort necessary to generate a valid plan.
Jonsson07 described an algorithm that uses macros to generate plans for planning problems with tree-reducible causal graphs. There exist planning problems for which the algorithm can generate exponentially long solutions in polynomial time, just like our algorithm for 3S. Unlike ours, the algorithm can handle multi-valued variables, which enables it to solve problems such as Towers of Hanoi. However, not all planning problems in 3S have tree-reducible causal graphs, so the algorithm cannot be used to show that plan generation for 3S is polynomial.
1.2 Hardness and Plan Length
A contribution of this paper is to show that plan generation may be polynomial even when planning problems have exponential length minimal solutions, provided that solutions may be expressed using a concise notation such as macros. We motivate this result below and discuss the consequences. Previously, it has been thought that plan generation for planning problems with exponential length minimal solutions is harder than , since it is not known whether problems in are intractable, but it is certain that we cannot generate exponential length output in polynomial time.
However, for a planning problem with exponential length minimal solution, it is not clear if plan generation is inherently hard, or if the difficulty just lies in the fact that the plan is long. Consider the two functional problems
where is a -CNF formula, is the number of clauses of , is a word containing copies of the symbol , and is if is satisfiable (i.e., is in 3Sat), and if it is not. In both cases, the problem consists in generating the correct word. Observe that both and are provably intractable, since their output is exponential in the size of the input.
Nevertheless, it is intuitive to regard problem as easier than problem . One way to formalize this intuition is to allow programs to produce the output in some succinct notation. For instance, if we allow programs to write “” instead of a string containing copies of the symbol , then problem becomes polynomial, but problem does not (unless ).
We wanted to investigate the following question: regarding the class 3S, is plan generation intractable because solution plans are long, like , or because the problem is intrinsically hard, like ? The answer is that plan generation for 3S can be solved in polynomial time, provided that one is allowed to give the solution in terms of macros, where a macro is a simple substitution scheme: a sequence of operators and/or other macros. To back up this claim, we present an algorithm that solves plan generation for 3S in polynomial time.
Other researchers have argued intractability using the fact that plans may have exponential length. Domshlak01 proved complexity results for several classes of planning problems with multi-valued state variables and simple causal graphs. They argued that the class of planning problems with chain causal graphs is intractable since plans may have exponential length. Brafman03 stated that plan generation for STRIPS planning problems with unary operators and acyclic causal graphs is intractable using the same reasoning. Our new result puts in question the argument used to prove the hardness of these problems. For this reason, we analyze the complexity of these problems and prove that they are hard by showing that the plan existence problem is -hard.
Let be a set of state variables, and let be the finite domain of state variable . We define a state as a function on that maps each state variable to a value in its domain. A partial state is a function on a subset of state variables that maps each state variable to . For a subset of state variables, is the partial state obtained by restricting the domain of to . Sometimes we use the notation to denote a partial state defined by and for each . We write to denote that .
Two partial states and match, which we denote , if and only if , i.e., for each , . We define a replacement operator such that if and are two partial states, is the partial state defined by , for each , and for each . Note that, in general, . A partial state subsumes a partial state , which we denote , if and only if and . We remark that if and , it follows that . The difference between two partial states and , which we denote , is the partial state defined by and for each .
A planning problem is a tuple , where is the set of variables, is an initial state, is a partial goal state, and is a set of operators. An operator consists of a partial state called the pre-condition and a partial state called the post-condition. Operator is applicable in any state such that , and applying operator in state results in the new state . A valid plan for is a sequence of operators that are sequentially applicable in state such that the resulting state satisfies .
The causal graph of a planning problem is a directed graph with state variables as nodes. There is an edge if and only if and there exists an operator such that and .
3 The Class 3s
Jonsson98b introduced the class 3S of planning problems to study the relative complexity of plan existence and plan generation. In this section, we introduce additional notation needed to describe the class 3S and illustrate some of the properties of 3S planning problems. We begin by defining the class 3S:
A planning problem belongs to the class 3S if its causal graph is acyclic and each state variable is binary and either static, symmetrically reversible, or splitting.
Below, we provide formal definitions of static, symmetrically reversible and splitting. Note that the fact that the causal graph is acyclic implies that operators are unary, i.e., for each operator , . Without loss of generality, we assume that 3S planning problems are in normal form, by which we mean the following:
For each state variable , and .
, , implies that .
To satisfy the first condition, we can relabel the values of in the initial and goal states as well as in the pre- and post-conditions of operators. To satisfy the second condition, for any operator with and , we either remove it if , or we let if previously undefined. The resulting planning problem is in normal form and is equivalent to the original one. This process can be done in time .
The following definitions describe the three categories of state variables in 3S:
A state variable is static if and only if one of the following holds:
There does not exist such that ,
and there does not exist such that .
A state variable is reversible if and only if for each such that , there exists such that . In addition, is symmetrically reversible if .
From the above definitions it follows that the value of a static state variable cannot or must not change, whereas the value of a symmetrically reversible state variable can change freely, as long as it is possible to satisfy the pre-conditions of operators that change its value. The third category of state variables is splitting. Informally, a splitting state variable splits the causal graph into three disjoint subgraphs, one which depends on the value , one which depends on , and one which is independent of . However, the precise definition is more involved, so we need some additional notation.
For , let be the subset of state variables, different from , whose value is changed by some operator that has as a pre-condition. Formally, . Define in the same way for . Let be the subgraph of whose edges exclude those between and . Formally, . Finally, let be the subset of state variables that are weakly connected to some state variable of in the graph . Define in the same way for .
A state variable is splitting if and only if and are disjoint.
Figure 1 illustrates the causal graph of a planning problem with two splitting state variables, and . The edge label indicates that there are operators for changing the value of that have as a pre-condition. In other words, , the graph excludes the two edges labeled , and includes all state state variables, since is weakly connected to and connects to the remaining state variables. The set is empty since there are no operators for changing the value of a state variable other than with as a pre-condition. Consequently, is empty as well. Figure 1(a) shows the resulting partition for .
In the case of , , excludes the edge labeled , and , since no other state variable is connected to when the edge is removed. Likewise, . We use to denote the set of remaining state variables that belong neither to nor to . Figure 1(b) shows the resulting partition for .
For any splitting state variable , if the two sets and are non-empty, belongs neither to nor to .
Proof By contradiction. Assume that belongs to . Then is weakly connected to some state variable of in the graph . But since does not exclude edges between and , any state variable in is weakly connected to the same state variable of in . Consequently, state variables in belong to both and , which contradicts that is splitting. The same reasoning holds to show that does not belong to .
The value of a splitting state variable never needs to change more than twice on a valid plan.
Proof Assume is a valid plan that changes the value of a splitting state variable at least three times. We show that we can reorder the operators of in such a way that the value of does not need to change more than twice. We need to address three cases: belongs to (cf. Figure 1(a)), belongs to , or belongs to (cf. Figure 1(b)).
If belongs to , it follows from Lemma 3.5 that is empty. Consequently, no operator in the plan requires as a pre-condition. Thus, we can safely remove all operators in that change the value of , except possibly the last, which is needed in case . If belongs to , it follows from Lemma 3.5 that is empty. Thus, no operator in the plan requires as a pre-condition. The first operator in that changes the value of is necessary to set to 1. After that, we can safely remove all operators in that change the value of , except the last in case . In both cases the resulting plan contains at most two operators changing the value of .
If belongs to , then the only edges between ,
, and are those from to and . Let , and be
the subsequences of operators in that affect state variables in
, and , respectively. Write , where is the last operator in
that changes the value of from to .
We claim that the reordering of plan is still valid. Indeed, the operators
of only require , which holds in the initial state, and
the operators of only require , which holds due to the
operator . Note that all operators changing the value of in
can be safely removed since the value is never
needed as a pre-condition to change the value of a state variable in
. The result is a valid plan that changes the value of at
most twice (its value may be reset to 0 by ).
The previous lemma, which holds for splitting state variables in general, provides some additional insight into how to solve a planning problem with a splitting state variable . First, try to achieve the goal state for state variables in while the value of is 0, as in the initial state. Then, set the value of to and try to achieve the goal state for state variables in . Finally, if , reset the value of to .
We illustrate the class 3S using an example planning problem. The set of state variables is . Since the planning problem is in normal form, the initial state is for each . The goal state is defined by , and the operators in are listed in Table 1. Figure 2 shows the causal graph of the planning problem. From the operators it is easy to verify that is static and that and are symmetrically reversible. For the planning problem to be in 3S, the remaining state variables have to be splitting. Table 1 lists the two sets and for each state variable to show that indeed, for each of the state variables in the set .
4 Plan Generation for 3s
In this section, we present a polynomial-time algorithm for plan generation in 3S. The algorithm produces a solution to any instance of 3S in the form of a system of macros. The idea is to construct unary macros that each change the value of a single state variable. The macros may change the values of other state variables during execution, but always reset them before terminating. Once the macros have been generated, the goal can be achieved one state variable at a time. We show that the algorithm generates a valid plan if and only if one exists.
We begin by defining macros as we use them in the paper. Next, we describe the algorithm in pseudo-code (Figures 3, 4, and 5) and prove its correctness. To facilitate reading we have moved a straightforward but involving proof to the appendix. Following the description of the algorithm we analyze the complexity of all steps involved. In what follows, we assume that 3S planning problems are in normal form as defined in the previous section.
A macro-operator, or macro for short, is an ordered sequence of operators viewed as a unit. Each operator in the sequence has to respect the pre-conditions of operators that follow it, so that no pre-condition of any operator in the sequence is violated. Applying a macro is equivalent to applying all operators in the sequence in the given order. Semantically, a macro is equivalent to a standard operator in that it has a pre-condition and a post-condition, unambiguously induced by the pre- and post-conditions of the operators in its sequence.
Since macros are functionally operators, the operator sequence associated with a macro can include other macros, as long as this does not create a circular definition. Consequently, it is possible to create hierarchies of macros in which the operator sequences of macros on one level include macros on the level below. The solution to a planning problem can itself be viewed as a macro which sits at the top of the hierarchy.
To define macros we first introduce the concept of induced pre- and post-conditions of operator sequences. If is an operator sequence, we write , , to denote the subsequence .
An operator sequence induces a pre-condition and a post-condition . In addition, the operator sequence is well-defined if and only if for each .
In what follows, we assume that is a planning problem such that for each operator , and that is an operator sequence.
For each planning problem of this type and each , .
Proof A direct consequence of the definitions and .
The operator sequence is applicable in state if and only if is well-defined and . The state resulting from the application of to is .
Proof By induction on . The result clearly holds for . For , note that , , and is well-defined if and only if is well-defined and .
By hypothesis of induction the state resulting from the application of to is . It follows that .
Assume is applicable in state . This means that is applicable in and that is applicable in . By hypothesis of induction, the former implies that and is well-defined, and the latter that . This last condition implies that if we use that , which is a consequence of and being a total state. Finally, we deduce from and , by using that . It follows that is well-defined and that .
Conversely, assume that is well-defined and . This implies that is well-defined and , so by hypothesis of induction, is applicable in state . It remains to show that is applicable in state , that is, . From it follows that . The fact that and completes the proof.
Since macros have induced pre- and post-conditions, Lemmas 4.2 and 4.3 trivially extend to the case for which the operator sequence includes macros. Now we are ready to introduce our definition of macros:
A macro is a sequence of operators and other macros that induces a pre-condition and a post-condition . The macro is well-defined if and only if no circular definitions occur and is well-defined.
To make macros consistent with standard operators, the induced post-condition should only include state variables whose values are indeed changed by the macro, which is achieved by computing the difference between and . In particular, it holds that for a 3S planning problem in normal form, derived macros satisfy the second condition of normal form, namely that , , implies .
Let be the set of ancestors of a state variable in a 3S planning problem. We define the partial state on as
if is splitting and ,
A macro is a 3S-macro if it is well-defined and, for , and .
The algorithm we present only generates 3S-macros. In fact, it generates at most one macro with for each state variable and value . To illustrate the idea of 3S-macros and give a flavor of the algorithm, Table 2 lists the macros generated by the algorithm in the example 3S planning problem from the previous section.
We claim that each macro is a 3S-macro. For example, the operator sequence induces a pre-condition and a post-condition . Thus, the macro induces a pre-condition and a post-condition . Since and are splitting and since and , it follows that , so .
The macros can be combined to produce a solution to the planning problem. The idea is to identify each state variable such that and append the macro to the solution plan. In the example, this results in the operator sequence . However, the pre-condition of specifies and , which makes it necessary to insert and before . In addition, the pre-condition of specifies , which makes it necessary to insert before , resulting in the final plan . Note that the order of the macros matter; requires to be 0 while requires to be 1. For a splitting state variable , the goal state should be achieved for state variables in before the value of is set to 1. We can expand the solution plan so that it consists solely of operators in . In our example, this results in the operator sequence . In this case, the algorithm generates an optimal plan, although this is not true in general.
4.2 Description of the Algorithm
We proceed by providing a detailed description of the algorithm for plan generation in 3S. We first describe the subroutine for generating a unary macro that sets the value of a state variable to . This algorithm, which we call GenerateMacro, is described in Figure 3. The algorithm takes as input a planning problem , a state variable , a value (either 0 or 1), and a set of macros for ’s ancestors in the causal graph. Prior to executing the algorithm, we perform a topological sort of the state variables. We assume that, for each and , contains at most one macro such that . In the algorithm, we use the notation to test whether or not contains .
|1||function GenerateMacro(, , , )|
|2||for each such that do|
|6||for each in increasing topological order do|
|7||if is static or then|
|9||else if is not splitting and and then|
For each operator that sets the value of to , the algorithm determines whether it is possible to satisfy its pre-condition starting from the initial state. To do this, the algorithm finds the set of state variables to which assigns 1 (the values of all other state variables already satisfy in the initial state). The algorithm constructs two sequences of operators, and , by going through the state variables of in increasing topological order. If is an operator sequence, we use as shorthand to denote an operator sequence of length consisting of all operators of followed by , which can be either an operator or a macro. If it is possible to satisfy the pre-condition of some operator , the algorithm returns the macro . Otherwise, it returns .
If is symmetrically reversible and GenerateMacro(, , 1, ) successfully generates a macro, so does GenerateMacro(, , 0, ).
Proof Assume that GenerateMacro(, , 1, ) successfully returns the macro for some operator such that . From the definition of symmetrically reversible it follows that there exists an operator such that and . Thus, the set is identical for and . As a consequence, the values of , , and are the same after the loop, which means that GenerateMacro(, , 0, ) returns the macro for . Note that GenerateMacro(, , 0, ) may return another macro if it goes through the operators of in a different order; however, it is guaranteed to successfully return a macro.
If the macros in are 3S-macros and GenerateMacro(, , , ) generates a macro , then is a 3S-macro.
|3||for each in increasing topological order do|
|4||GenerateMacro(, , 1, )|
|5||GenerateMacro(, , 0, )|
|6||if and then|
|8||else if and then|
|10||return GeneratePlan(, , )|
Next, we describe the algorithm for plan generation in 3S, which we call Macro-3S. Figure 4 shows pseudocode for Macro-3S. The algorithm goes through the state variables in increasing topological order and attempts to generate two macros for each state variable , and . If both macros are successfully generated, they are added to the current set of macros . If only is generated and the goal state does not assign 0 to , the algorithm adds to . Finally, the algorithm generates a plan using the subroutine GeneratePlan, which we describe later.
Let be a 3S planning problem and let be a state variable. If there exists a valid plan for solving that sets to 1, Macro-3S() adds the macro to . If, in addition, the plan resets to 0, Macro-3S() adds to .
Proof First note that if and are generated, Macro-3S() adds them both to . If is generated but not , Macro-3S() adds to unless . However, contradicts the fact that there is a valid plan for solving that sets to 1 without resetting it to 0. It remains to show that GenerateMacro(, , 1, ) always generates and that GenerateMacro(, , 0, ) always generates if the plan resets to 0.
A plan for solving that sets to 1 has to contain an operator such that . If the plan also resets to 0, it has to contain an operator such that . We show that GenerateMacro(, , 1, ) successfully generates if is the operator selected on line 2. Note that the algorithm may return another macro if it selects another operator before ; however, if it always generates a macro for , it is guaranteed to successfully return a macro . The same is true for and .
We prove the lemma by induction on state variables . If has no ancestors in the causal graph, the set is empty by default. Thus, is never set to false and GenerateMacro(, , 1, ) successfully returns the macro for . If exists, GenerateMacro(, , 0, ) successfully returns for .
If has ancestors in the causal graph, let . Since the plan contains it has to
set each to 1. By hypothesis of induction, Macro-3S() adds to for each . As a
consequence, is never set to false and thus, GenerateMacro(, , 1, ) successfully returns for .
If exists, let . If the plan contains , it has to set each to 1. By hypothesis of induction, Macro-3S()
adds to for each and consequently, GenerateMacro(, , 0, ) successfully returns for
|1||function GeneratePlan(, , )|
|4||first variable in topological order present in|
|5||if is splitting then|
|6||Generate-Plan(, , )|