Planning Graph Heuristics for Scaling Up Conformant Planning Daniel Bryce & Subbarao Kambhampati Department of Computer Science and Engineering Arizona State University, Tempe AZ 85287-5406 fdan.bryce,
[email protected]
Abstract This paper describes a set of heuristics for efficiently solving conformant planning problems. Conformant planning, as described in this paper extends classical planning to problems where there is uncertainty in the initial state. The motivation for improved heuristic techniques stems from the observation that previous conformant planners used largely uninformed heuristics. We show that the reachability information captured in planning graphs provides a rich source for deriving powerful heuristics for conformant planning. We also show how multiple planning graphs capture the uncertainty of a conformant planning problem much better than single graphs. We evaluate the heuristics in the context of a new planner called C AltAlt. Empirical studies demonstrate that (C AltAlt) outperforms MBP, a state of the art conformant planner, in many scenarios.
1 Introduction Of late there has been significant interest in conformant planning. Ever since CGP [3] a series of planners have been developed for tackling conformant planning problems – including GPT[1] and MBP[5]. In comparing the current state of the art in conformant planning to that in classical and metric temporal planning problems, one is struck by two interesting differences. Conformant planners are currently evaluated on domains that are almost embarrassingly simplistic in comparison to the benchmark domains used for classical and temporal planning1. In contrast to classical and temporal planners, where much recent progress has come from the design of effective heuristics, heuristics used for conformant planning seem quite primitive. Currently MBP, GPT, and CGP are the best conformant planners [5],[1],[3]. The creators of MBP have shown by comparison to GPT and CGP that their approach is empirically superior. MBP exploits BDD structure to make belief state generation and representation very efficient. MBP can find a solution in a problem’s search space by generating many search 1 Indeed the prevalence of the (in)famous Bomb in the Toilet problem in more than one paper lead to the tongue in cheek refrain at AIPS-2002 that in 10 years since the first AIPS, planning has progressed all the way from stacking blocks to dunking bombs into the toilet.
nodes very quickly and compactly. While MBP’s search engine is quite sophisticated, surpisingly its heuristics are quite primitive. MBP’s search is guided by a “cardinality” heuristic, that counts the number of states consistent with a given belief state, to select the next belief state to expand. Cimatti et. al. [4] argue that this simplistic heuristic is more than sufficient in conformant planning. Their results in the Bomb in the Toilet (BiT ) domain seem to support their claim. At first glance, this is quite surprising given that cardinality heuristics are a severely limited version of reachability heuristics. They are similar to set difference heuristics, in that they consider all unachieved goals to be of uniform cost. Since such heuristics are easily defeated in domains where individual goals have different levels of difficulty, we started to wonder if the current empirical conclusions in conformant planning may have been unduly influenced by the simplistic nature of the domains that were considered. To test our speculation, we developed and experimented with conformant versions of Logistics, and Rovers domains. In contrast to BiT =BiT C , 2 the domains have goals that have differing degrees of difficulty both in the same world and across different worlds. We found that MBP was unable to solve even the simplest problem instances in these domains. Motivated by this discovery we set out to see if the performance of conformant planners can be improved by the use of more sophisticated heuristics based on reachability information. C AltAlt – a new conformant planner we developed as part of this investigation – demonstrates that planning graphbased reachability heuristics, similar to those employed in AltAlt [8], can indeed be gainfully extended and adapted to conformant planning. C AltAlt does regression search in the space of “clausal states” (which are disjunctive represenations for sets of states). The challenges in developing planning graph based heuristics to C AltAlt include: (i) handling the reachability cost of clauses instead of literals and (ii) handling uncertainty in the initial state by basing heuristics on multiple (rather than a single) planning graphs. We developed a series of sophisticated planning graph-based heuristics to control 2 For the uninitiated, here are the arcana of the Bomb in the Toilet family of problems: Bomb in the Toilet (BiT )–the problem includes two packages, one of which contains a bomb, and a toilet. The goal is to disarm the bomb and the only allowable actions are dunking a package in the toilet. The variation “bomb in the toilet with clogging” or BiTC says that the toilet will clog unless it is “flushed” after each “dunking” action.
C AltAlt’s regression search (see Figure 2). Our empirical results demonstrate that armed with these heuristics – C AltAlt is able to handily outperform MBP, the current state of the art conformant planner. We present our work by first explaining the state and action representation used within C AltAlt, then the set of heuristics used for search control, followed by implementation details, empirical evaluation, related work, and finally directions for future work. The state and action representation section shows how actions with conditional effects can be regressed over clausal states and why we take this approach. The heuristics section presents the major contribution of our work. The implementation details section gives an overview of our approach for designing a domain independent conformant planner (C AltAlt) that uses heuristic guidance. The empirical results section describes the problems and domains used to test the performance of C AltAlt, as well as the implications of the data collected. The related work section provides a description of competing approaches for conformant planning and the past work, on which our work is based. Lastly, the future work section outlines some avenues of research that we intend to pursue. 2 State and Action Representation State Representation As discussed in [1], conformant planning can be seen as a search in the space of belief states. A belief state is a union of multiple world states. We represent belief states as clausal states. A clausal state is a CNF representation of a belief state 3 . Clausal states lend themselves well to implementing Pednault’s description of regression of ADL actions in first order logic [9]. Definition: A clausal state S is a set of clauses Ci where each Ci is a disjunction of literals c j (propositions or their negations). A conjunctive clausal state S 0 is a set of unit clauses. A complete initial state I (found in classical planning) is a special case of conjunctive clausal state. Using the BiT C 4 problem as running example for this paper, the clausal state representation of BiT C ’s initial state, where an armed bomb is in either package 1 or package 2, and the toilet is not clogged is: I
= [arm; :clog; (inP 1 _ inP 2)]
Definition: A clausal state S is said to be satisfied by another clausal state I if every clause in S is satisfied by I . More specifically, S is satisfied by I if 8Cs 2S 9Ci 2I s.t. Ci Cs . For example, if I = [(inP 1 _ inP 2)], and S = [(:clog _ inP 1 _ inP 2)], then S is satisfied by I . Definition: A clausal state S is said to be inconsistent with another state I , if there is a clause C s 2 S s.t. :Cs is satisfied by I . For example, if I = [:arm; (:clog _ inP 1 _ inP 2)], and S = [clog; arm; (inP 1 _ inP 2)], then S is inconsistent with I because the negation of arm in S is satisfied by :arm in I . 3 Contrasting with MBP where the BDD structure uses a DNF representation. 4 Bomb in the Toilet with Clogging - BiT where dunking a package clogs the toilet and a flush action is needed to unclog the toilet.
Definition: The set of constituents (S ) of a state S are all minimal conjunctive clausal states s j that satisfy S . (S ) is equivalent to a DNF representation of a clausal state’s CNF representation. For example, BiT C ’s initial state I = [arm; :clog; (inP 1 _ inP 2)]; the set of constituents (I ) = f[arm; :clog; inP 1]; [arm; :clog; inP 2]g. Action Representation Without loss of generality, we can assume that an action A is described in terms of (1) an executability precondition e , and (2) several conditional effects of the form (' i : i ! "i ), where i and "i are, in general, clausal states. Each conditional effect is of the form [antecedent (precondition i ) ! consequent (effect " i )]. The executability precondition or antecedent of the individual effects can be empty. In the first case, the action has a defined outcome in any state; and in the second case, the corresponding effects occur in all worlds. The conditional effects ' i make up a set . The executability precondition e (a clausal state) of the action must hold for the action to be executable. As an example, the actions for BiT C are expressed as:
: :clog, 1 : inP 1 ! "1 : :arm, "2 : clog : :clog, 1 = inP 2 ! "1 : :arm, "2 : clog : = :clog 1: 2:
DunkP e DunkP e F lush "1
Regression Conformant planning by regression is just a search in the space of clausal states, starting with the goal state and regressing it nondeterministically over all relevant actions. Clausal states are regressed until finding a clausal state that is satisfied by the initial state. The main difference between regression search in conformant and classical planning is that because of disjunction in the initial state a conformant planner cannot split the disjunction in a regressed state 5 into the search space – and this has to handle disjunctive clausal states directly. Following Pednault [9], regressing a clausal state S over an action A involves taking the union of causation and preservation clauses of each C s 2 S w.r.t. each effect of A. Formally, the result S 0 of regressing the clausal state S over the action A is defined as: Regress(S; A) = 8Cs2S 8 i 2 e [ Ai (Cs ) [ Ai (Cs ) Executability clause (e ) is the executability precondition of A. This is what must hold in S 0 for A to have been applicable.
Causation clause for a clause C s w.r.t an effect i : i ! "i of an action A (denoted by Ai (Cs )) is defined as the weakest clause that must hold in the state before A such that i causes Cs . Formally Ai (Cs ) is defined as: fCs _ i j i : i ! "i 2 and "i satisfies Cs g.
Preservation clause of a clause C s w.r.t. an effect i : i ! Ai (Cs )) is defined as the weakest clause that must be true before A such that C s is not violated by the effect i of A. Formally Ai (Cs ) is defined as: f:i j i : i ! "i 2 and "i satisfies :Cs g. "i of an action A (denoted by
5 To see this, consider that we have a goal p _ q . Splitting the disjuncts into the search space treats the goal as p ^ q , which will not be satisfied if the initial state has p _ q
S 5 = Regress(S 3; DunkP 2) = [:clog; (inP 1 _ inP 2 _ :arm)] S 6 = Regress(S 3; DunkP 1) = [:clog; (inP 1 _ :arm)] S 7 = Regress(S 4; DunkP 1) = [:clog; (inP 1 _ inP 2 _ :arm)] S 8 = Regress(S 4; DunkP 2) = [:clog; (inP 2 _ :arm)] S 5 and S 7 are both satisfied by I because every clause in
G DunkP1
DunkP2
S1
the clausal states is satisfied by a clause in the initial state, so either is a terminal search node, and the path of actions leading to it is a conformant plan.
S2
Flush
Flush
S3
S4
DunkP2
DunkP1
S5
DunkP1
S6
S7
DunkP2
S8
Figure 1: Regression path for BiT C example. Example of Regression and Search Since clausal state regression is not commonly discussed in planning literature (at least since Pednault’s 1988 paper [9]), we will now give a complete example of clausal state regression search within BiT C . The search states are shown schematically in Figure 1. We start with initial and goal states:
=[ : = [: ] 1
(
1_
3 Heuristics for Conformant Planning
All of the heuristics (Figure 2) used in C AltAlt are within the context of HSP-R’s [2] greedy best first search, where the reachability cost of a state is f (S ) = g (S ) + w h(S ). The g (S ) term is the number of actions regressed from the goal state to reach S , w is the weight term 6 , and h(S ) is the heuristic estimate of how many actions are needed to reach the initial state from S . The search is guided by expanding the states with the lowest cost f (S ). Choosing accurate estimates for h(S ) allows the search to cut down the number of states generated, effectively reducing search time. Figure 2 shows a rough taxonomy of the set of heuristics that we present. Throughout this section, to illustrate the computation of each heuristic, we use an example from BiT C called CBiT C 7 , where a courteous package dunker has to disarm the bomb and leave the toilet unclogged. The inital state is I = [arm; :clog; (inP 1 _ inP 2)], and the goal is G = [:clog; :arm]. The optimal action sequence to reach G from I is: fDunkP 1 ! F lush ! DunkP 2 ! F lushg, or fDunkP 2 ! F lush ! DunkP 1 ! F lushg, thus the optimal heuristic estimate is h (G) = 4 because in either plan there are four actions.
2)]
I arm; clog; inP inP G arm DunkP and DunkP are applicable for regression at G because they both have arm as a conditional effect consequent. The regressed states S and S are constructed from
2 :
1
Reachability Information No Cardinality
2
the causation clause and the executability clause for the respective actions. S S
S S
hSum
1 = Regress(G; DunkP 1) = [:clog; (inP 1 _ :arm)] 2 = Regress(G; DunkP 2) = [:clog; (inP 2 _ :arm)]
Notice that in classical planning, we would have said here that Regress(G; DunkP 1) = [:clog; inP 1] since :arm is directly given by DunkP 1. However, the weakest preconditions for :arm to be true after DunkP 1 is (inP 1 _ :arm) rather than just :arm. F lush is applicable to both S 1 and S 2 because it has :clog as an effect. The regressed states S 3 and S 4 are constructed based on the executability clause, but the precondition is always true, so the only change is the removal of :clog .
3 = Regress(S 1; F lush) = [(inP 1 _ :arm)] 4 = Regress(S 2; F lush) = [(inP 2 _ :arm)]
Finally, both Dunk actions are applicable again for the same reason as the generation of S 1 and S 2. Choosing the unchosen Dunk action, given the search path, will lead to a state with new information. After regressing all applicable Dunk actions, we get S 5, S 6, S 7, and S 8.
Yes Single Graph
hLevel
hRP
Summation
Multiple Graph
hSumMax
hLevelMax
Level all satisfied
HRPMax HRPUnion
Relaxed Plan Length
Clause Combination Cost Measure
Figure 2: Diagram of heuristic classes based on reachability information, graph type, and clause combination techniques.
3.1
Cardinality of Clausal States (hcard )
The motivation for using the cardinality of a clausal state to guide search within C AltAlt is to give a control by which we can compare our approach to MBP. The advantage of using 6 7
w = 5, as is common in practice. Courteous BiTC
0
1
1
inP1
2
inP1
inP2
inP2 DunkP1
2 inP1 inP2
DunkP1 clog
DunkP2
clog DunkP2
~clog
~clog
~clog Flush
Flush arm
arm
~arm
~arm
arm
Figure 3: Planning graph for CBiT C , with facts used for hsum (G) circled, facts used for h level (G) in boxes, and actions for hRP (G) in ovals. hcard is its ease of computation. Although, it does not take
into account the number of actions that are needed to achieve a clausal state. Reachability is naively estimated with uniform cost for all goals. The hcard(S ) heuristic is computed by summing the values of each clause in S , where the value is 1 for unit clauses and 1 divided by the number of elements in the clause for nonunit clauses and taking the inverse so that higher cardinality states have a lower (better) heuristic value. Notice that this essentially makes the assumption that the reachability of all goals are uniformly 8 1. Formally: 9
1200 19.043/1546/9 >1200 19.043/1546/9 >1200 >1200 >1200 55.924/913/5 >1200 >1200 >1200
Sum 0.297/2/2 >1200 0.43/4/3 >1200 0.129/28/9 242.365/4765/15 >1200 >1200 >1200 0.659/45/7 >1200 >1200
Sum max 0.392/2/2 >1200 0.063/6/3 >1200 13.21/2618/9 >1200 >1200 >1200 4.293/913/5 261.175/12880/7 >1200 >1200
CGP 0.001/*/1 0.052/*/1 0.002/*/3 not found 0.064/*/8 1.323/*/11 0.168/*/10 4.559/*/14 0.307/*/5 2.272/*/7 >1200 >1200
Level max 0.44/2/2 >1200 0.033/3/3 >1200 0.144/9/9 3.245/73/15 0.193/14/11 24.873/200/18 0.148/5/5 0.206/9/7 1.171/83/10 2.044/114/13
GPT 0.041042/4/2 0.230247/20/10 seg fault seg fault >1200 -
Level 0.318/2/2 >1200 0.26/4/3 >1200 0.437/100/9 >1200 25.26/855/12 OoM 0.408/5/5 0.366/37/7 >1200 >1200 RP max 0.138/2/2 >1200 0.024/3/3 >1200 0.278/23/11 >1200 >1200 >1200 6.074/913/5 0.239/7/7 1.347/56/11 >1200
MBP 0.01/*/2 0.24/*/10 0.01/*/3 0.4/*/19 1.76/*/9 7.72/*/25 53.29/*/12 367.56/*/28 not found >10000 BS >10000 BS >10000 BS
RP 0.42/2/2 >1200 0.37/4/3 >1200 5.823/456/9 >1200 73.89/1506/12 >1200 0.548/5/5 0.456/37/7 >1200 >1200 RP union 0.475/2/2 >1200 0.043/3/3 0.958/19/19 0.337/41/9 >1200 0.548/17/11 >1200 1.828/203/5 0.244/7/7 0.407/12/11 >1200
Level max 0.44/2/2 >1200 0.033/3/3 >1200 0.144/9/9 3.245/73/15 0.193/14/11 24.873/200/18 0.148/5/5 0.206/9/7 1.171/83/10 2.044/114/13
RP union 0.475/2/2 >1200 0.043/3/3 0.958/19/19 0.337/41/9 >1200 0.548/17/11 >1200 1.828/203/5 0.244/7/7 0.407/12/11 >1200
Figure 5: Empirical Results. The first two tables compare the various planning graph heuristics on C AltAlt. The last one compares the performance with existing planners (with our two best heuristics repeated as reference). Legend – [Total time (s)/Search nodes expanded/Plan length], “OoM”: Out of Memory, “>10000 BS”: Exceeded belief state limit, “-”: Not attempted, “*”: Not given. The Rovers domain shows (Figure 6) that selective expansion of the search space is necessary when plans require many actions and the set of domain actions is quite large. Reachability heuristics help determine the most useful actions to insert in a plan by expanding a minimum amount of states. C AltAlt is the only planner that can solve the more difficult Rovers problems. MBP exceeds the self-imposed limit of 10000 belief states for the last three rovers problems, and cannot find a solution for the first. Likewise, CGP has difficulty solving Rovers problems that have plan lengths much greater that a few steps (i.e. it cannot solve rover3 and rover4). CGP is slow at constructing and searching the graphs for more difficult Rovers problems, and eventually is overwhelmed as the problem’s plan length increases.
C
In the Logistics domain (see Figure 7), AltAlt with the hlevelmax handily outperforms MBP, not only in terms of
search time, but also plan length. Interestingly, CGP, an approach all but given up for conformant planning because of being dominated by GPT and MBP in BiT domains, outperforms C AltAlt as well as MBP. This may be attributed to CGP’s sophisticated computation of mutex relations, whereas C AltAlt leaves much room for improvement in this area (see future work section). CGP and C AltAlt outperform MBP not only in terms of search time, but also plan length (CGP contains the same number of actions as C AltAlt but parallelizes them such that the plan length is lower). Lastly, GPT cannot even solve the first and easiest Logistics problem within 20 minutes11 . 11 Therefore, none of the other Logistics problems are attempted with GPT. Also, due to limitations on syntax Rovers is not attempted for GPT. We’ve contacted the author’s of GPT to obtain an explanation of these difficulties.
2.5
2
370
hLevelMax hRPunion CGP
320 270 220 Time (s)
Time (s)
1.5
hLevelMax MBP CGP
1
170 120
0.5
70 20
0 rover1
rover2
Problem
rover3
rover4
Figure 6: Results for Rovers domain, comparing CGP, hlevelmax and hRPunion Comparing the individual heuristics in C AltAlt, there are two that outperform the rest: h levelmax and hRPunion . The best heuristic for the Logistics domain is h levelmax (Figures 7 and 5). This is because the Logistics domain has a lot of actions that negatively interact and there are not a lot of actions that differ across graphs, making h RPunion less informed. hlevelmax also does well for Rovers (Figure 6). h RPunion doesn’t do quite as well on Rovers because its computation time is much higher than h levelmax . Yet, on BiT C (Figure 5), hRPunion does quite well, by actually solving BiT C 10 , because the combination of relaxed plans is fairly simplistic and proves to be more informed than any of the other heuristics.
6 Related Work Related work in domain independent conformant planning follows the chronology of CGP [3], GPT [1], then MBP [5]. Related work in domain independent heuristics for planning is also explored for classical planning by AltAlt [8]. CGP, the first conformant planner, is the conformant version of graph plan, where the graph search is conducted on several planning graphs, each constructed from each possible initial state. CGP’s inefficiency is that the search on multiple graphs proves to be slow on domains where reachability is not important. The advantage of CGP’s planning graph construction is that the multiple graphs are implicitly built, whereas in C AltAlt each graph is built explicitly. Thus CGP can represent uncertainty more compactly and C AltAlt can represent planning graphs with numerous levels more compactly. GPT uses dynamic programming to determine heuristic values for belief states while searching. This is more informed heuristic than MBP, but MBP’s search engine is so much faster that it overtakes GPT. In comparison to GPT, this work also assigns a high value to informed heuristic computation, but goes about computing it through planning graphs instead of dynamic programming. MBP, as previously discussed in the motivation section, is the most efficient conformant planner to date. MBP
-30
log1
log2
log3
log4
Problem
Figure 7: Results for Logistics domain, comparing h levelmax , MBP, and CGP. has efficient state representation and generation, making it a formidable search engine. Yet, MBP’s, lack of informed heuristic guidance prevents it from scaling to larger search spaces, where solutions can only be found through heuristic guidance. Lastly, AltAlt [8], although a classical STRIPS planner, provides several domain independent heuristic techniques based on planning graphs. C AltAlt generalizes many of these ideas to conformant planning.
7 Future Work Future work, based on this approach, will include improved control over the heuristic computation cost by trading accuracy for time, improved reasoning about relaxed plans for multiple graphs, compact representation of conformant planning graphs, consideration non-deterministic effects, and informed sensing to facilitate contingent planning. The heuristic computation cost can be reduced in several ways by sacrificing accuracy. First, for problems with a large amount of uncertainty, we can consider a representative subset of the possible worlds (i.e. only construct the best planning graphs). Second, when computing a heurstic that requires consideration of each s j 2 (S ), we can limit consideration to the best subset of (S ). The growth of the individual planning graphs themselves can be limited by a variety of heuristics such as those used in AltAlt. The reasoning about relaxed plans of multiple graphs can improve on the limitations of h RPunion . Recall that hRPunion unnecessarily overestimates the heuristic value by not accounting for the same action appearing in different steps of relaxed plans extracted from different planning graphs. Analyzing the similarities of the causal structure of the relaxed plans could reveal this overestimate error and properly adjust the heuristic value. Since hRPunion can become computationally expensive, doing further analysis of causal structure will only compound the heuristic computation cost; empirical tests will reveal if the trade-off for informedness proves beneficial.
Using multiple planning graphs is useful, but can become cumbersome with respect to memory consumption. Also, there happens to be quite a bit of common structure among the multiple graphs. There are two initial ideas for compacting the information contained in the multiple planning graphs. The first is to use a clausal planning graph (CPG, not to be confused with CGP). The idea is to redefine the fact layers of the planning graph as unions of clauses, instead of unions of propositions. This could facilitate the easy lookup of clauses in the graph without having to check all the individual constituents of a clausal state. The major overhead of this approach is the graph construction. Construction is complicated by a potential explosion in the number of clauses from level to level. The second idea is to use a single planning graph with propositions in the fact layers, but keep labels (logical formulae) on the propositions to indicate the worlds in which a particular proposition is supported 12. Then, in determining the cost of a proposition, it is infinite if the label is not consistent with every world. The approach for computing labels is straightforward in the absence of mutex relations, but is formidable since labels are not only needed on literals, but on mutexes too. Non-deterministic effects are a generalization that C AltAlt can handle by allowing weak regression. Weak regression of a clausal state S by an action A with non-deterministic effects will give a state S 0 with only those conditions in S that are not a result of applying the non-deterministic effects A to S 0 . Inclusion of non-deterministic effects will generalize the reach of conformant planning where uncertainty arises not only from the initial state, but also the effects of actions. Sensing actions are the addition to conformant planning that facilitates contingent planning. The effect of sensing is to reduce the amount of uncertainty in a belief state, but determining when to sense can be a difficult task. Planning graphs may be able to give estimates on when sensing is appropriate. For instance, if the union of the step i ’s across multiple graphs is much larger than any individual step i , then it may be a good time to sense.
8 Conclusion We have shown that heuristics extracted from planning graphs can greatly scale conformant planning to consider problems of the same domains as those undertaken by classical and metric-temporal planners in the International Planning Competition. We’ve also shown that approaches for conformant planning can benefit from informed heuristic guidance to estimate reachability of belief states. Also, many ideas in classical planning prove fruitful when generalized and adapted to conformant planning. Acknowledgements. We thank Minh B. Do, Romeo Sanchez, Terry Zimmermam, and Satish Kumar Thittamaranahalli for helpful discussions and feedback. We also thank David Smith and Piergiorgio Bertoli for help with the CGP and MBP planners. This research is supported in part by the NASA grants NAG2-1461 and NCC-1225, and the NSF grant IRI-9801676. 12 CGP does this, but labels only indicate which worlds a proposition is supported, not the properties of worlds that contribute to support.
References [1] Bonet, B. & Geffner, H. 2000. Planning with Incomplete Information as Heuristic Search in Belief Space. In Proc. of 17th National Conference on Artificial Intelligence (AAAI). [2] Bonet, B. & Geffner, H. 1999. Planning as heuristic search: New Results. In Proc. Fifth European Conference in Planning (ECP-99). [3] Smith, D. & Weld, D. 1998. Conformant Graphplan. In Proc. of 15th National Conference on Artificial Intelligence (AAAI). [4] Cimatti, A., and Roveri, M. 2001. Heuristic Search + Symbolic Model Checking = Efficient Conformant Planning. In Proc. of 17th International Joint Conference on Artificial Intelligence. [5] Bertoli, P., Cimatti, A., and Roveri, M. 2001. Conformant Planning via Symbolic Model Checking. In Journal of Artificial Intelligence Research, 13:305-338. [6] Koehler, J., Nebel, B., Hoffman, J., and Dimopoulos Y. 1997. Extending Planning Graphs to an ADL Subset. In Fourth European Conference in Planning (ECP-97). [7] Koehler, J. Handling of Conditional Effects and Negative Goals in IPP. Tech Report No. 128. [8] Nguyen, X., Kambhampati, S., and Nigenda, R. 2001. Planning Graph as the Basis for deriving Heuristics for Plan Synthesis by State Space and CSP Search. In Artificial Intelligence Journal. [9] Pednault, E. Synthesizing plans that contain actions with context-dependent effects. In Computational Intelligence, Volume 4, 1988. [10] Fox, M., Long, D. PDDL2.1 : An Extension to PDDL for Expressing Temporal Planning Domains http://www.dur.ac.uk/d.p.long/pddl2.ps.gz.
