Parameterized Complexity Results for Plan Reuse

07/16/2013 ∙ by Ronald de Haan, et al. ∙ Free University of Bozen-Bolzano TU Wien 0

Planning is a notoriously difficult computational problem of high worst-case complexity. Researchers have been investing significant efforts to develop heuristics or restrictions to make planning practically feasible. Case-based planning is a heuristic approach where one tries to reuse previous experience when solving similar problems in order to avoid some of the planning effort. Plan reuse may offer an interesting alternative to plan generation in some settings. We provide theoretical results that identify situations in which plan reuse is provably tractable. We perform our analysis in the framework of parameterized complexity, which supports a rigorous worst-case complexity analysis that takes structural properties of the input into account in terms of parameters. A central notion of parameterized complexity is fixed-parameter tractability which extends the classical notion of polynomial-time tractability by utilizing the effect of structural properties of the problem input. We draw a detailed map of the parameterized complexity landscape of several variants of problems that arise in the context of case-based planning. In particular, we consider the problem of reusing an existing plan, imposing various restrictions in terms of parameters, such as the number of steps that can be added to the existing plan to turn it into a solution of the planning instance at hand.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.


Planning is one of the central problems of AI with a wide range of applications from industry to academics (Ghallab, Nau, and Traverso 2004). Planning gives rise to challenging computational problems. For instance, deciding whether there exists a plan for a given planning instance is PSPACE-complete, and the problem remains at least NP-hard under various restrictions (Bylander 1994). To overcome this high worst-case complexity, various heuristics, restrictions, and relaxations of planning problems have been developed that work surprisingly well in practical settings (Hoffmann 2001; Helmert 2006). Among the heuristic approaches is case-based planning, which proceeds from the idea that significant planning efforts may be saved by reusing previous solutions (Kambhampati and Hendler 1992; Veloso 1994). This approach is based on the assumption that planning tasks tend to recur and that if the tasks are similar, then so are their solutions. Empirical evidence suggests that this assumption holds in many settings, and that the case-based approach works particularly well if the planning tasks require complex solutions while the modifications required on the known plans are considerably small.

So far the research on the worst-case complexity of case-based planning did not take into account the essential assumption that similar planning tasks require similar solutions. Indeed, as shown by Liberatore (2005), if none of the known solutions are helpful, then the case-based system needs to invest an effort comparable to generating the solution from scratch, and hence does not benefit from the previous experience. There is no way to benefit from the knowledge of an unrelated solution. However, the result disregards the case-based assumptions which are meant to avoid such worst cases. It seems that the classical complexity framework is not well-suited for taking such assumptions into account.

New Contribution

In this paper we provide theoretical results that identify situations in which the plan reuse of the case-based approach is provably tractable. We perform our analysis in the framework of parameterized complexity, which supports a rigorous worst-case complexity analysis that takes structural properties of the input into account (Downey, Fellows, and Stege 1999; Niedermeier 2006; Gottlob and Szeider 2006). These structural properties are captured in terms of parameters, which are integer numbers that are small compared to the size of the total problem input. The theoretical analysis now considers the impact of these parameters on the worst-case complexity of the considered problems. A central notion of parameterized complexity is fixed-parameter tractability, which extends the classical notion of polynomial-time tractability by utilising the impact of parameters. Parameterized complexity also provides a hardness theory that, similar to the theory of NP-completeness, provides strong evidence that certain parameterized problems are not fixed-parameter tractable (fixed-parameter intractable).

In the problems we study we are given a planning task together with a stored solution for a different planning task, where this solution consists of a plan and an initial state the plan is applied to. The question is to modify the existing solution to obtain a solution for the new planning task. By means of various parameters we control the modifications applied to the stored solution. For instance, we can require that the number of additional planning steps added to fit the stored solution to the new planning task is small compared to the length of the stored solution.

In order to evaluate the impact of structural properties on the overall complexity we use parameters based on the following four restrictions, each restriction is associated with one of the four symbols L, A, V, and D.

  • [itemsep=0pt]

  • bounds on the number of added planning steps

  • bounds on the size of a specified set of actions from which the added planning steps are built (each action from the set can be added several times)

  • bounds on the size of a specified set of variables that may be mentioned by the added planning steps

  • bounds on the size of a specified set of values that may be mentioned by the added planning steps



















W[]-hard for all



Figure 1: Overview of the fixed-parameter (in)tractability results for all combinations of restrictions .

We show that parameterized by L the problem is fixed-parameter intractable even if the additional steps may only be added to the beginning and end of the plan. Parameterized by A the problem is fixed-parameter tractable. Parameterized either by V or D, the problem is fixed-parameter intractable; however, if we combine these two parameters, we achieve fixed-parameter tractability. Combining the restriction L with either V or D is not enough to achieve fixed-parameter tractability.

We obtain a full classification as shown in Figure 1. In addition, we show that the same results hold even if we reuse only some “infix” of the stored solution, i.e., if it is allowed to discard any number of actions from the beginning and end of the stored solution before the modification takes place. Finally, we prove that in more general settings where we reuse only the syntactical sequence of actions as represented by the stored solution (disregarding the actual states of the stored solution), all the combinations of parameters considered yield fixed-parameter intractability.


In this section we introduce basic notions and notation related to (case-based) planning and parameterized complexity, which are used further in the paper.


In this study, we use the SAS+ planning framework (Bäckström and Nebel 1996) in the notational variant of Chen and Giménez (2010): An instance of the planning problem, or a planning instance, is a tuple , whose components are described as follows.

  • [itemsep=0pt,leftmargin=*]

  • is a finite set of variables, where each has an associated finite domain . A state is a mapping defined on a set of variables such that for each . A partial state is a mapping defined on a subset vars of such that for all it holds that . We sometimes denote a partial state by a set of explicit mappings .

  • is a state called the initial state.

  • is a partial state called the goal.

  • is a set of actions; each action is of the form , where is a partial state called precondition, and is a partial state called postcondition.

For a (partial) state and a subset , we let be the (partial) state resulting from restricting to . We say that a (partial) state is a goal state, or that satisfies the goal, if . A plan (for an instance ) is a sequence of actions . The application of a plan on a state yields a state , which is defined inductively as follows. The application of an empty plan () does not change the state (). For a non-empty plan , we define based on the inductively defined state , where .

  • [itemsep=0pt,leftmargin=*]

  • If then , i.e., if the precondition of does not hold in , the action is not applicable and does not change the state.

  • Otherwise, is applicable and is the state equal to on variables , and equal to on .

A plan is a solution plan if is a goal state.

If for each , then we have a Boolean (or binary) instance, which in fact gives us a notational variant of the STRIPS planning framework (Bylander 1994).

Consider the following example instance, that we will use as a running example in the remainder of this paper.

Example 1.

We let be the planning instance defined below. A solution plan for would be .

Case-Based Planning

Case-based planning (CBP) is a type of case-based reasoning that involves the use of stored experiences (called cases) of solving analogous problems. Often, a case is composed of a planning instance and a solution plan of . The plan can be replaced by some other information related to the search for a solution to , e.g., a set of justifications (Kambhampati and Hendler 1992; Veloso 1994; Hanks and Weld 1995). A plan library, or a case base, is a collection of such cases, constituting the experience of the planner. For more detailed explanation of implementation choices of specific planners we refer to the survey of Spalazzi (2001).

Example 2.

Consider the case , where the planning instance coincides with the instance defined in Example 1 on , and where and . The solution plan can be reused to find the solution given in Example 1.

When faced with a new problem, the case-based planner follows a sequence of steps common in case-based reasoning (Aamodt and Plaza 1994). First, it queries the library to retrieve cases suitable for reuse. The reuse step modifies the retrieved solution(s) to solve the new problem and such a new solution is validated in the revision phase by execution, simulated execution, etc. The verified solution may be eventually stored in the case base during a retention process.

In this paper, we focus on theoretical properties of plan reuse and therefore we skip the retrieval, we simply assume that together with the problem to solve we are also given a case which contains a suitable solution for reuse. In other words, we assume that the instance to be solved coincides on the sets with the instance provided in the case.

Parameterized Complexity

Here we introduce the relevant concepts of parameterized complexity theory. For more details, we refer to the works of Downey and Fellows (1999), Downey, Fellows, and Stege (1999), Flum and Grohe (2006), Niedermeier (2006), and Gottlob and Szeider (2006).

In the traditional setting of considering the complexity of a problem, the input size

of the instance is the only measure available. Parameterized complexity is a two-dimensional framework to classify the complexity of problems based on their input size

and some additional parameter . An instance of a parameterized problem is a pair where is the main part of the instance, and is the parameter. A parameterized problem is fixed-parameter tractable if it can be solved by a fixed-parameter algorithm, i.e., if instances can be solved in time , where is a computable function of , is a constant, and is the size of . FPT denotes the class of all fixed-parameter tractable decision problems. Many problems that are classified as intractable in the classical setting can be shown to be fixed-parameter tractable.

Parameterized complexity also offers a completeness theory, similar to the theory of NP-completeness. This allows the accumulation of strong theoretical evidence that a parameterized problem is not fixed-parameter tractable. Hardness for parameterized complexity classes is based on fpt-reductions, which are many-one reductions where the parameter of one problem maps into the parameter for the other. A parameterized problem is fpt-reducible to another parameterized problem if there is a mapping from instances of to instances of such that (i) if and only if , (ii) for a computable function , and (iii) can be computed in time for a computable function and a constant , where is the size of .

Central to the completeness theory is the hierarchy of parameterized complexity classes , where all inclusions are believed to be strict. Each of the classes W[] for and W[P] contains all parameterized problems that can be reduced to a certain parameterized satisfiability problem under fpt-reductions. For instance, for W[2], the corresponding satisfiability problem asks whether a given CNF formula has a satisfying assignment that sets exactly variables to true. A sufficient condition for a problem to be hard for the class para-PSPACE is that the problem is PSPACE-hard for a single value of the parameter (Flum and Grohe 2003). There is strong evidence that a parameterized problem that is hard for any of these intractability classes is not in FPT.

We use the following problems to prove some fixed-parameter intractability results.

Partitioned-Clique is a W[1]-complete problem (Fellows et al. 2009). The instances are tuples , where is a finite set of vertices partitioned into subsets , is a simple graph, and is a parameter. The question is whether there exists a -clique in that contains a vertex in each .

Hitting-Set is a W[2]-complete problem (Downey and Fellows 1995). The instances are tuples , where is a finite set of nodes, is a collection of subsets of , and is a parameter. The question is whether there exists a hitting set such that and for all .

-WSat(CIRC) (weighted circuit satisfiability) is a W[P]-complete problem (Downey and Fellows 1995). The instances are pairs , where is a Boolean circuit, and is a parameter. The question is whether there exists a satisfying assignment of that sets at most input nodes to true.

Longest-Common-Subsequence-I is a parameterized problem that is W[]-hard for all (Bodlaender et al. 1995). As input, it takes strings over an alphabet , and a positive integer . The parameter is . The question is whether there is a string of length at least that is a subsequence of for all .

Related Work

The first paper providing a complexity-theoretical study of plan reuse (Nebel and Koehler 1995) considered so-called conservative plan reuse. Conservative plan reuse maximizes the unchanged part of the known solution. The authors showed that such a plan reuse is not provably more efficient than plan generation. Moreover, they show that identifying what is the maximal reusable part of the stored solution is an additional source of hardness.

Liberatore (2005) studied the problem of plan reuse in a different fashion, interpreting the case (or the case base) as a “hint” that makes the search for the solution plan more informed. The complexity results he provides do not improve over the complexity of uninformed plan generation. He does however give a tractable compilation result for planning instances that differ from the stored instances only in a constant number of valuations from the initial state and goal.

The parameterized complexity of planning was first studied by Downey, Fellows, and Stege (1999) and, more recently, by Bäckström et al. (2012, 2013), using the solution length as the parameter. The analysis by Bäckström et al. reveals that the planning problem is W[2]-complete and there exist fragments that are W[1]-complete and other fragments that are fixed-parameter tractable. More specifically, they provide a full classification of SAS+ planning under all combinations of the P, U, B and S restrictions introduced by Bäckström and Klein (1991), and they provide a full classification of STRIPS planning under the syntactical restrictions studied by Bylander (1994).

Parameterized Complexity of Plan Reuse

In this paper, we study the parameterized complexity of reusing a plan. However, as this work is motivated by plan reuse in the context of case-based planning, we exploit assumptions common in the case-based approaches to ensure that there is a solution at hand that can be reused. Also, we consider a more specific form of a plan reuse (case reuse) and generalizations thereof.

Reusing the Case

In its general form, the classical complexity of plan reuse is not better than the one of plan generation. Liberatore (2005) has shown it to be PSPACE-complete. However, the case-based approach assumes that similar problems have similar solutions (Leake 1996). This means that cases can either be used to yield a solution by applying only a limited number of modifications or will not be helpful at all in finding a solution. When considering the complexity of plan reuse in the classical setting, we cannot exclude the worst case in which the case provides no guidance and where an uninformed search similar to the traditional plan generation is needed. When using the framework of parameterized complexity instead, we can capture the computational complexity of reusing a case in those settings where it can be used to get a solution plan with only a limited amount of modification.

We consider a case useful for solving an instance if can be modified to a solution plan for by means of limited modification. We define the following template CaseMod for the decision problems, intended to find such useful cases.

Instance: a planning instance ; a case consisting of an instance 111In the remainder of the paper, we will often specify an instance in the definition above only by its value of . Since and coincide on and , and the choice of is not relevant for answering the question, this will suffice for most purposes. and its solution plan ; a subset of actions ; and an integer .
Question: Does there exist a sequence of actions for some , and does there exist some , such that is a solution plan for and ?

The sequence in the definition above can be thought of as the “glue” that enables the reuse of the plan by connecting the new initial state to the beginning of the case , using the plan to reach its goal and connecting it to the goal required by instance . In the following, we will often refer to these action occurrences (or steps) as glue steps. Though such a reuse may seem naive, CaseMod is in fact implemented and used by CBP system FarOff (Tonidandel and Rillo 2002).

Example 3.

Let be the planning instance from Example 1 and the case from Example 2. Consider the instance for CaseMod, given by , where and . This is a positive instance, since the solution plan can be constructed from by adding the sequence of actions from , and .

We will consider a number of different parameterizations for CaseMod, where in each case the parameter is intended to capture the assumption that the plan given in the case is similar to the solution we are looking for. In order to define these variants, we define the problems , for any subset of . The choice of the parameterization depends on this set of restrictions.

  • [itemsep=0pt,leftmargin=*]

  • If includes L, we add to the parameterization the allowed maximum length of the glue sequence .

  • If includes V, we add to the parameterization the number of variables mentioned in the actions in .

  • If includes D, we add to the parameterization the number of values mentioned in the actions in .

  • If includes A, we add to the parameterization the number of actions in .

For instance, the parameter in the problem is , where is the maximum length allowed for the sequence of glue steps and .

In order to establish the parameterized complexity landscape for various combinations of these restrictions as sketched in Figure 1, we need to prove the following results. We show that is fixed-parameter tractable for , that it is W[1]-complete for , that it is W[2]-complete for , that it is W[]-hard for all , for , and that it is para-PSPACE-complete for . These results are summarized in Table 1.

FPT (Thm 1)
FPT (Cor 1)
W[1]-complete (Thm 4)
W[2]-complete (Prop 1)
W[2]-complete (Cor 2)
W[]-hard for all    (Thm 2)
para-PSPACE-complete (Thm 3)
Table 1: Map of parameterized complexity results.

The modification of a plan (or a case) concerns addition of actions to the plan stored in the case. One intuitive way to restrict the amount of modification that is allowed in order to reuse the case is to restrict the number of allowed additional steps, resulting in the L restriction. It is believed (Kambhampati and Hendler 1992) that the presence of a similar solution, or rather the fact that only actions need to be added to the stored plan in order to find the plan , will make the decision problem of existence of (and also its generation) easier than if no suitable solution is available. Unfortunately, the following result shows that the corresponding problem remains hard.

Proposition 1.

is W[2]-complete.

Proof 1.

The result follows from the W[2]-completeness proof of finding a solution plan of at most action occurrences (the -step planning problem) given by Bäckström et al. (2012). They proved that W[2]-hardness already holds for complete goal states. Now, by letting , the -step planning problem directly reduces to .

To show W[2]-membership, we sketch the following reduction to the -step planning problem. We introduce an additional operator , where is a fresh variable. Furthermore, we let and , and we let . It is straightforward to verify that this reduces to the -step planning problem.

Intuitively, the reason of such a result is that the large number of different actions to choose from is a source of hardness. Bäckström et al. showed that for the -step planning problem, complexity results can be improved by considering only planning instances whose actions satisfy the condition of post-uniqueness. Similarly, we can require the set of actions , from which glue steps can be taken, to be post-unique (Bäckström et al. 2012). This parameterized problem is in fact fixed-parameter tractable (this result follows from Theorem 5 in Bäckström et al. (2012)).

In a similar way, parameterizing directly by the cardinality of also provides fixed-parameter tractability:

Theorem 1.

is in FPT.

Proof 2.

We have that . Then the number of states reachable from any state by actions from is bounded by a function of and can be enumerated in fixed-parameter tractable time. Similar bounds hold for all the states reachable from for each such . Overall, checking if any of these states satisfies the goal state can thus be done in fixed-parameter tractable time.

As a consequence of Theorem 1, we get another fixed-parameter tractability result.

Corollary 1.

is in FPT.

Proof 3.

If the set of actions refers to at most variables and at most values, then the number of different actions that can possibly contain is bounded by . The result then follows from Theorem 1.

The fact that the above results are the only fixed-parameter tractable results under the considered restrictions suggests that plan reuse is not the answer to the high computational complexity of planning in general. However, we can use these results to identify settings in which plan reuse is likely to perform well. For example, Theorem 1 suggests that replanning in case of an execution failure is tractable to implement as plan reuse, provided that the number of applicable actions is limited due to, e.g., limited resources.

These results for plan reuse as implemented in case-based planning are quite unpleasant as in such settings usually . Additionally, tends to be quite high, as the set of actions is obtained by grounding a set of (few) operators (propositional implication rules) over a set of potentially many objects, giving a rise to a rich set of actions which only very rarely satisfies the condition of post-uniqueness to make fixed-parameter tractable. Nevertheless, these claims suggest that, besides identifying where to apply the glue steps, a case-based planning system needs to employ heuristics to identify which glue steps may be useful. Even though is in FPT, parameterizing only on the number of variables occurring in actions in , or only on the number of values occurring in actions in , yields fixed-parameter intractability.

Theorem 2.

is W[]-hard for all .

Proof 4.

We prove the result by giving an fpt-reduction from Longest-Common-Subsequence-I, which is W[]-hard for all . Let the strings over the alphabet and the integer constitute an instance of Longest-Common-Subsequence-I. For a string of length we write . For each we let . We construct an instance of specified by , , and . We let , and be a sufficiently large number (that is, ). Also, we define:

Note that .

The idea behind the reduction is that any solution plan that results in an assignment of variable to any corresponds to a witness that the strings have a common subsequence of length . The variables correspond to the position of reading heads on the strings that can only move from left to right, and the variables are used to read symbols in the string on the position of the reading heads. The variables are used to ensure that each symbol is read at most once (each symbol is either read by using an action in or skipped by using an action in ). Then the variable can only be increased if in all strings the same symbol is read (by using an action in ). The actions are used to be able to enforce a complete goal state.

It is now straightforward to verify that there exists a common subsequence for of length if and only if the constructed instance is a yes-instance.

As mentioned above in the preliminaries, if we restrict the planning instances to Boolean values, we get a framework corresponding to the STRIPS planning framework. By the fact that is fixed-parameter tractable, we get that for STRIPS instances is also fixed-parameter tractable.

By naively keeping track of all states reachable from the initial state (which are at most many, for and ) we get that can be solved in polynomial time for each constant value of . As a consequence, the following theorem shows that is of higher complexity than (unless ).

Theorem 3.

is para-PSPACE-complete.

Proof 5.

The para-PSPACE-membership result follows from the fact that , when unparameterized, is in PSPACE (Bäckström and Nebel 1996).

For the hardness result, consider the case where the number of values allowed in the set of actions is . The problem then reduces to the problem of finding a solution plan for the Boolean planning instance , in case we let . Bäckström and Nebel (1996) showed that finding a solution plan for Boolean planning instances (even for complete goal states) is PSPACE-hard. Since this hardness result holds already for a single value of , the para-PSPACE-hardness result follows (Flum and Grohe 2003).

Parameterizing on the combination of the number of allowed additional steps together with either the number of variables or the number of values occurring in actions in is not enough to ensure fixed-parameter tractability.

Theorem 4.

is W[1]-complete.

Proof 6.

W[1]-membership can be proven analogously to the W[1]-membership proof given by Bäckström et al. (2012, Theorem 4) for the -step planning problem restricted to actions with one postcondition. In this proof the problem is reduced to a certain first-order model checking problem.

For the hardness result, we reduce from the W[1]-complete problem Partitioned-Clique. Let be an instance of Partitioned-Clique, where is partitioned into . We define the instance of as follows: , is specified by its initial state , , and . We define:

The intuition behind the reduction is as follows. The budget of actions allows for guessing steps, to set the variables using actions ; verification steps, to set the variables to using actions ; and cleanup steps, to reset the variables using actions . The only way to achieve the goal state is by guessing a -clique.

It is now straightforward to verify that the graph has a -clique if and only if there exist plans of total length such that and satisfies .

Corollary 2.

is W[2]-complete.

Proof 7.

The claim follows directly from the proof of Proposition 1, since -step planning is W[2]-complete already for Boolean planning instances (Bäckström et al. 2012).

The above results together give us the complete parameterized complexity characterization as depicted in Figure 1.

Reusing an infix of the case

As a slight generalization of the CaseMod problem, we consider the problem CaseMod. In this problem, we require not that the full plan from the case is being reused together with its initial state , but that any infix of the plan (i.e., any subplan resulting from removing any prefix and postfix from ) is reused with its corresponding initial state . Formally, the question becomes whether there exists a sequence of actions for some , and whether there exists some and some such that solves the new planning instance and , where .

The following results show that this generalization does not change the parameterized complexity results that we obtained in the previous section.

Observation 1.

Whenever is in FPT, then also is in FPT.

Proof 8.

Let . There are only different ways of selecting subplans to consider, for . For each of these, we can compute the initial state in linear time. Simply trying all these possibilities using the algorithm for results in an fixed-parameter tractable algorithm for .

Theorem 5.

The completeness results in Proposition 1, Theorems 23 and 4 and Corollary 2 also hold for the corresponding variants for .

Proof 9 (sketch).

For the hardness results, it suffices to note that the hardness proofs of these theorems use a case containing the empty plan .

For the membership results, we note that the problem can be solved by answering the disjunction of polynomially many (independent) instances. The W[]-membership results can then be proved by encoding the instances as instances of certain first-order model checking problems (Bäckström et al. 2012), and combining these into one model checking problem instance that is equivalent to the disjunction of the separate instances. For the para-PSPACE-membership result, we can straightforwardly evaluate the disjunction of the instances in polynomial space.

Generalized infix reuse

The problem of CaseMod can be generalized even further by reusing an infix of the stored solution plan from any state that satisfies the preconditions of the plan infix. For this problem, the instances coincide with those of CaseMod, but the question is:

Question: Does there exist a sequence of actions for some , and does there exist and such that is a solution plan for and for all we have that action is applicable in ?

This generalization does not change the parameterized complexity results stated in Table 1. In all cases where is fixed-parameter tractable, we can obtain a fixed-parameter tractable algorithm to solve the above problem, since in those cases we can enumerate all states reachable from a given state in fixed-parameter tractable time. For the fixed-parameter intractability results, the hardness follows straightforwardly from the hardness proofs for the corresponding problems.

Reusing a sequence of actions

In principle, there is no need to require anything from the state to which the stored plan is applied. Therefore we will consider the following generalization of the CaseMod problems discussed above. In this problem, denoted by PlanMod, we remove the requirement that the additional steps added before the plan result in the initial state or some other state that satisfies the preconditions of (the infix of) the plan . Also, we allow the insertion of additional steps in the middle of the plan . Formally, the question then becomes whether there exists some , a sequence of actions , and some sequence of actions such that is a solution plan of and can be divided into two subsequences and , i.e., interleaving and yields . In other words, the additional steps can be used anywhere before, after or in the middle of the plan . Since we do not restrict ourselves to any particular state being visited in our solution plan, the actions in the glue sequence can be used anywhere before, after or in the middle of the plan . Similarly to the case for CaseMod, we define the variants , and . In the following, we show that all variants of PlanMod are fixed-parameter intractable.

Theorem 6.

is W[P]-complete.

Proof 10 (sketch).

For W[P]-membership, we sketch how to reduce

to the problem of determining whether a nondeterministic Turing machine

accepts the empty string within a bounded number of steps using at most nondeterministic steps (parameterized by ). Since this parameterized halting problem is in W[P] (Cesati 2003), this suffices to show W[P]-membership. First guesses pairs , for and . Pair corresponds to the application of the first actions from the given plan , followed by the application of action . Similarly, for each , pair corresponds to the application of the next actions from the given plan , followed by the application of action . Then (deterministically) verifies whether applying the plan corresponding to is a solution plan.

To prove W[P]-hardness, we reduce from -WSat(CIRC). Let be a circuit for which we want to check whether there exists a satisfying assignment of weight at most . Let be the input nodes, the internal nodes, and the output node of , together denoted . We assume without loss of generality that contains only and and negation nodes. Since is acyclic, we let the sequence denote the nodes of in any order such that for each we have that for all input nodes of . We construct an instance of consisting of a planning instance , a plan , and an integer . We let , and we define:

We define for each as follows. If is a negation node with input , we let . If is an and node with inputs , we let .

It is now straightforward to verify that is a yes-instance of if and only if the circuit has a satisfying assignment of weight .

Note that the proof of the above theorem suffices to show fixed-parameter intractability of all variants of the PlanMod and problems. We also point out that this fixed-parameter intractability result holds even when the problem is restricted to instances for which the entire set of actions satisfies post-uniqueness.


We provided theoretical results, using the framework of parameterized complexity, to identify situations in which plan reuse is provably tractable. We drew a detailed map of the parameterized complexity landscape of several variants of problems that arise in the context of case-based planning. In particular, we considered the problem of reusing an existing plan, imposing various restrictions in terms of parameters, such as the number of steps that can be added to the existing plan to turn it into a solution of the planning instance at hand.

The results show that contrary to the common belief, the fact that the number of modifying actions is small does not guarantee tractability on its own. We additionally need to restrict the set of actions that can participate in the modifications. This indicates the need for a good heuristic function that identifies a limited set of actions used for modifications.

In the future, these results may be extended to richer planning formalisms, e.g., considering variables of different types or using predicates to express certain properties related to a planning domain rather than planning instance.


  • Aamodt and Plaza (1994) Aamodt, A., and Plaza, E. 1994. Case-based reasoning: foundational issues, methodological variations, and system approaches. AI Communications 7(1):39–59.
  • Bäckström and Klein (1991) Bäckström, C., and Klein, I. 1991. Planning in polynomial time: the SAS-PUBS class. Computational Intelligence 7:181–197.
  • Bäckström and Nebel (1996) Bäckström, C., and Nebel, B. 1996. Complexity results for SAS+ planning. Computational Intelligence 11:625–655.
  • Bäckström et al. (2012) Bäckström, C.; Chen, Y.; Jonsson, P.; Ordyniak, S.; and Szeider, S. 2012. The complexity of planning revisited - a parameterized analysis. In

    Twenty-Sixth AAAI Conference on Artificial Intelligence

  • Bäckström et al. (2013) Bäckström, C.; Jonsson, P.; Ordyniak, S.; and Szeider, S. 2013. Parameterized complexity and kernel bounds for hard planning problems. In Spirakis, P., and Serna, M., eds., Algorithms and Complexity (CIAC 2013), volume 7878 of Lecture Notes in Computer Science.
  • Bodlaender et al. (1995) Bodlaender, H. L.; Downey, R. G.; Fellows, M. R.; and Wareham, H. T. 1995. The parameterized complexity of sequence alignment and consensus. Theoretical Computer Science 147:31–54.
  • Bylander (1994) Bylander, T. 1994. The computational complexity of propositional STRIPS planning. Artificial Intelligence 69:165–204.
  • Cesati (2003) Cesati, M. 2003. The Turing way to parameterized complexity. Journal of Computer and System Sciences 67:654–685.
  • Chen and Giménez (2010) Chen, H., and Giménez, O. 2010. Causal graphs and structurally restricted planning. Journal of Computer and System Sciences 76(7):579–592.
  • Downey and Fellows (1995) Downey, R. G., and Fellows, M. R. 1995. Fixed-parameter tractability and completeness I: Basic results. SIAM J. Comput. 24(4):873–921.
  • Downey and Fellows (1999) Downey, R. G., and Fellows, M. R. 1999. Parameterized Complexity. Monographs in Computer Science. New York: Springer Verlag.
  • Downey, Fellows, and Stege (1999) Downey, R.; Fellows, M. R.; and Stege, U. 1999. Parameterized complexity: A framework for systematically confronting computational intractability. In Contemporary Trends in Discrete Mathematics: From DIMACS and DIMATIA to the Future, volume 49 of AMS-DIMACS, 49–99. American Mathematical Society.
  • Fellows et al. (2009) Fellows, M. R.; Hermelin, D.; Rosamond, F. A.; and Vialette, S. 2009. On the parameterized complexity of multiple-interval graph problems. Theoretical Computer Science 410(1):53–61.
  • Flum and Grohe (2003) Flum, J., and Grohe, M. 2003. Describing parameterized complexity classes. Information and Computation 187(2):291–319.
  • Flum and Grohe (2006) Flum, J., and Grohe, M. 2006. Parameterized Complexity Theory, volume XIV of Texts in Theoretical Computer Science. An EATCS Series. Berlin: Springer Verlag.
  • Ghallab, Nau, and Traverso (2004) Ghallab, M.; Nau, D.; and Traverso, P. 2004. Automated Planning: Theory & Practice. Morgan Kaufmann.
  • Gottlob and Szeider (2006) Gottlob, G., and Szeider, S. 2006. Fixed-parameter algorithms for artificial intelligence, constraint satisfaction, and database problems. The Computer Journal 51(3):303–325. Survey paper.
  • Hanks and Weld (1995) Hanks, S., and Weld, D. 1995. A domain-independent algorithm for plan adaptation. Journal of Artificial Intelligence Research (JAIR) 2:319–360.
  • Helmert (2006) Helmert, M. 2006. The fast downward planning system. Journal of Artificial Intelligence Research 26(1):191–246.
  • Hoffmann (2001) Hoffmann, J. 2001. Ff: The fast-forward planning system. AI magazine 22(3):57.
  • Kambhampati and Hendler (1992) Kambhampati, S., and Hendler, J. A. 1992. A validation-structure-based theory of plan modification and reuse. Artificial Intelligence 55:193–258.
  • Leake (1996) Leake, D. B., ed. 1996. Case-Based Reasoning. Cambridge, Massachusetts: The MIT Press.
  • Liberatore (2005) Liberatore, P. 2005. On the complexity of case-based planning. Journal of Experimental & Theoretical Artificial Intelligence 17(3):283–295.
  • Nebel and Koehler (1995) Nebel, B., and Koehler, J. 1995. Plan reuse versus plan generation: A complexity-theoretic perspective. Artificial Intelligence- Special Issue on Planning and Scheduling 76:427–454.
  • Niedermeier (2006) Niedermeier, R. 2006. Invitation to Fixed-Parameter Algorithms. Oxford Lecture Series in Mathematics and its Applications. Oxford: Oxford University Press.
  • Spalazzi (2001) Spalazzi, L. 2001. A survey on case-based planning. Artificial Intelligence Review 16(1):3–36.
  • Tonidandel and Rillo (2002) Tonidandel, F., and Rillo, M. 2002. The FAR-OFF system: A heuristic search case-based planning. In Ghallab, M.; Hertzberg, J.; and Traverso, P., eds., AIPS, 302–311. AAAI.
  • Veloso (1994) Veloso, M. 1994. Planning and Learning by Analogical Reasoning, volume 886 of Lecture Notes in Artificial Intelligence and Lecture Notes in Computer Science. New York, USA: Springer-Verlag Inc.