Taming Numbers and Durations in the Model Checking Integrated Planning System

The Model Checking Integrated Planning System (MIPS) is a temporal least commitment heuristic search planner based on a flexible object-oriented workbench architecture. Its design clearly separates explicit and symbolic directed exploration algorithms from the set of on-line and off-line computed estimates and associated data structures. MIPS has shown distinguished performance in the last two international planning competitions. In the last event the description language was extended from pure propositional planning to include numerical state variables, action durations, and plan quality objective functions. Plans were no longer sequences of actions but time-stamped schedules. As a participant of the fully automated track of the competition, MIPS has proven to be a general system; in each track and every benchmark domain it efficiently computed plans of remarkable quality. This article introduces and analyzes the most important algorithmic novelties that were necessary to tackle the new layers of expressiveness in the benchmark problems and to achieve a high level of performance. The extensions include critical path analysis of sequentially generated plans to generate corresponding optimal parallel plans. The linear time algorithm to compute the parallel plan bypasses known NP hardness results for partial ordering by scheduling plans with respect to the set of actions and the imposed precedence relations. The efficiency of this algorithm also allows us to improve the exploration guidance: for each encountered planning state the corresponding approximate sequential plan is scheduled. One major strength of MIPS is its static analysis phase that grounds and simplifies parameterized predicates, functions and operators, that infers knowledge to minimize the state description length, and that detects domain object symmetries. The latter aspect is analyzed in detail. MIPS has been developed to serve as a complete and optimal state space planner, with admissible estimates, exploration engines and branching cuts. In the competition version, however, certain performance compromises had to be made, including floating point arithmetic, weighted heuristic search exploration according to an inadmissible estimate and parameterized optimization.


Introduction
The Model Checking Integrated Planning System MIPS has participated twice in the international planning competition: in the second planning competition at AIPS-2000 in Beckenridge (USA) and in the third planning competition at AIPS-2002 in Toulouse (France). As the name indicates, the MIPS project targets the integration of model checking techniques into a domainindependent action planner.
Model checking (Clarke, Grumberg, & Peled, 1999) is the automated process to verify if a formal model of a system satis es an speci ed temporal property or not. As an illustrative example, take an elevator control system together with a correctness property that requires an elevator to eventually stop on every call of a passenger or that guarantees that the door is closed, while the elevator is moving.
Although the success in checking correctness is limited, model checkers found many subtle errors in current hardware and software designs. Models often consists of many concurrent subsystems. Their combination is either synchronous, as often met in hardware design veri cation, or asynchronous, as frequently given in communication and security protocols, or in multithreaded programming languages like J a va.
Exploration of model checking domains spans very large spaces of all reachable system states. This e ect is usually denoted as the state explosion problem, e v en if the sets of generated states rather than the states themselves grow that quickly.
An error that shows a safety property violation, like a deadlock or a failed assertion, corresponds to one of a set of target nodes in the state space graph. Roughly speaking, something bad has occured. A l i v eness property violation refers to a (seeded) cycle in the graph. Roughly speaking, something good will never occur. For the case of the elevator example, eventually reaching a target state where a request button was pressed is a liveness property, while certifying closed doors refers to a safety property.
In this paper we refer to safety properties only, since goal achievement in traditional and competition planning problems have y et not been extended with temporal properties. However, temporally extended goals are of increasing research i n terests (Kabanza, Barbeau, & St-Denis, 1997Pistore & Traverso, 2001Lago, Pistore, & Traverso, 2002.
The two main validation processes in model checking are explicit and symbolic search. In explicit-state model checking each state refers to a xed memory location and the state space graph is implicitly generated by successive expansions of state.
In symbolic model checking (McMillan, 1993Clarke, McMillan, Dill, & Hwang, 1992, xed-length binary encodings of states are usually seen as mandatory, so that each state can be represented by its characteristic Boolean function. The function evaluates to true if and only if all state variables are assigned to according bit values. Sets of states are expressed by the disjunct of the individual characteristic functions. On the other hand satis ability a n d uniqueness of Boolean formulae is NP hard. The unique symbolic representation of sets of states as Boolean formulae through binary decision diagrams (BDDs) (Bryant, 1992) is often much smaller than the explicit one. BDDs are (ordered) read-once branching programs with nodes corresponding to variables, edges corresponding to variable outcomes, and each path corresponding to an assignment to the variables with the resulting evaluation at the leaves. One reason of the succinctness of BDDs is that directed acyclic graphs may express exponentially many paths. Since states are encoded in binary, the transition relation is de ned on two state variable sets. It evaluates to true, if and only if an operator exists that transforms a state into a valid successor. In some sense, BDDs exploit regularities of the state set and often appear better suited to regular hardware systems, in contrast to many software system that inherit a highly asynchronous and irregular structure, so that the straight use BDD with their xed variable ordering is probably not exible enough.
For symbolic exploration a set of states is combined with the transition relation to compute the set of all possible successor states, i.e. the image. Starting with the initial state, iteration of image computations eventually explores the entire reachable state space. To improve the e ciency of image computations, transition relations are often provided in partitioned form.
The correspondence of action planning and model checking can be roughly characterized as follows. Similar to model checkers, action planners implicitly generate large state spaces, and both exploration approaches base on applying parameterized operators to the current state. States in model checking and in planning problems are bothlabeled by (propositional state) predicates. The satisfaction of a speci ed property o n t h e one side and the arrival at a certain goal state on the other, leads to a slight di erence in the according search objective. With this respect, the goal in action planning is a safety error and the corresponding (error) trail is interpreted as a plan. In the elevator example, the goal of a planning task is to reach a state, in which the doors are open and the elevator is moving. For a formal treatment on the embedding of planning problems into model checking terminology, we refer the reader to (Giunchiglia & Traverso, 1999).
Model checkers perform either symbolic or explicit exploration. To the contrary MIPS features bothand allows to combines symbolic and explicit search planning. It applies heuristic search a search acceleration technique that has let to considerable gains in both communities. In the last few years, heuristic search planners frequently outperform other domain-independent planning approaches, e.g. (Ho mann & Nebel, 2001), and heuristic search model checkers turn out to signi cantly improve state-of-the-art, e.g. (Edelkamp, Leue, & Lluch-Lafuente, 2002).
Including resource variables (like the fuel level of a vehicle or the distance between locations) and action duration (i.e. the time passed during execution of the planning operator) are relatively new aspects for action planning, at least in form of an accepted domain description accessible for competitive planning (Fox & Long, 2001). The competition input format PDDL2.1 is not restricted to variables of nite domain, but also includes speci cation of rational ( oating-point) variables in both precondition and e ects. Similar to a set of atoms described by a propositional predicate, a set of numerical quantities can bedescribed by a set of parameters. Through the notation of PDDL2.1, we refer to parameterized numerical quantities as functions. For example, the fuel level might be parameterized by the vehicle that is present in the problem instance description.
In the 2002 competition, domains were provided in di erent tracks according to di erent layers of language expressiveness: i) pure propositional planning, ii) planning with numerical resources, iii) planning with numerical resources and constant action duration, iv) planning with numerical resources and variable action duration, and, in some cases, v) more complex problems usually combining time and numbers in more interesting ways. MIPS competed as a fully automated system and performed remarkably well in all ve tracks it solved a high number of problems and was the only system that produced solutions in each track o f e v ery benchmark domain.
In this paper the main algorithmic aspects to tame rational numbers,objective functions, and action duration are described. The article is structured as follows. First, we recall the development of the MIPS system and assert its main contributions to the planning community. Then we address the object-oriented heuristic search framework architecture of the system. Subsequently, w e x some terminology that allows to give a formal de nition of the syntax and the semantics of a grounded mixed numerical and propositional planning problem instance.
We then introduce the core contributions: critical path scheduling for concurrent plans, and e cient methods for detecting and using symmetry cuts. PERT scheduling produces optimal parallel plans given a sequence of operators and a precedence relation among them in linear time. The paper discusses pruning anomalies and handling of di erent optimization criteria. We analyze the correctness and e ciency of symmetry detection in detail. Afterwards, a TCP/IP client-server visualization system for sequential and temporal plans is presented. The article closes with related work and concluding remarks.

The Development of MIPS
The competing versions of MIPS refer to initial ndings  of heuristic symbolic exploration of planning domains with the cke model checker (Biere, 1997) that already lead to goodperformance in puzzle solving (Edelkamp & Re el, 1998) and in hardware veri cation . For general propositional planning, our concise BDD library StaticBdd 1 has been used.
During the implementation process we changed the BDD representation to improve performance mainly for small planning examples and chose the public domain c++ BDD package Buddy (Lind-Nielsen, 1999). In the beginning of the project the variable encodings were provided by hand, while the representation of all possible operator descriptions were established by enumerating all possible parameter instances. Once the encoding and transition relation were xed, symbolic exploration in form of a reachability analysis of the state-space could beexecuted. At that time, we w ere not aware of any other work in BDD-based planning like (Cimatti, Giunchiglia, Giunchiglia, & Traverso, 1997), which is probably the rst link to planning via (symbolic) model checking.
Since the above approach w as criticized not to be fully automated, we subsequently developed a parser and a static analyzer to cluster atoms into groups in order to minimize the length of the state encoding (Edelkamp & Helmert, 1999). The outcome of the analyzer allowed to specify states and transition functions in Boolean terms, which in turn were included in a bidirectional BDD exploration and solution extraction procedure. In the end, MIPS was the rst automated planning system based on symbolic model checking.
In the second international planning competition MIPS (Edelkamp & Helmert, 2001) could handle the STRIPS (Fikes & Nilsson, 1971) subset of the PDDL language (McDermott, 2000) and some additional features from ADL (Pednould, 1989), namely negative preconditions and (universal) conditional e ects. MIPS was one of ve planning systems to beawarded for \Distinguished Performance" in the fully automated track. The competition version (Edelkamp & Helmert, 2000) already included explicit heuristic search algorithms based on a bit-vector state representation and the relaxed planning heuristic (RPH) (Ho mann & Nebel, 2001) and symbolic heuristic search based on the HSP-Heuristic (Bonet & Ge ner, 2001) and a one-to-one atom RPH-derivate. However, at the end we used breadth-rst bi-directional symbolic search in each case the single state heuristic searcher got stuck in its exploration.
In between the planning competitions, explicit (Edelkamp, 2001c) and symbolic pattern databases (Edelkamp, 2002b) were proposed as o -line generated estimators referring to completely explored problem abstractions. Roughly speaking, pattern database abstractions slice the state vector of uent facts into pieces and adjusts the operators accordingly. The completly explored subspaces then serve as admissible estimate for the overall search and are competetive with the relaxed planning heuristic.
For the 2002's international planning competition new levels of the planning domain description language (Fox & Long, 2001) have been designed to specify problems that include actions with durations and resources. The agreed input language de nition is referred to as PDDL 2.1. While Level 1 considers pure propositional planning, Level 2 also includes numerical resources and objective functions to beminimized, and Level 3 additionally allows to specify actions with durations. Consequently, M I P S 2 has been extended to cope with these new forms of expressiveness.
In (Edelkamp, 2001b) rst results of MIPS in planning PDDL 2.1 problems are presented. The preliminary treatment exempli es the parsing process in two simple benchmark domains. Moreover, propositional heuristics and manual branching cuts were applied to accelerate sequential plan generation. This work was extended in (Edelkamp, 2002a), where two approximate exploration techniques to bound and to x numerical domains, rst results on symmetry detec-1 See http://www.informatik.uni-freiburg.de/~edelkamp/StaticBdd 2 A r e c e n t v ersion of MIPS is available in source code at www.informatik.uni-freiburg.de/~edelkamp tion based on fact groups and critical path scheduling, an any-time wrapper to produce optimal plans and a numerical extension to RPH were presented. Enumerating variable domains and the any-time wrapper were excluded from the competition version of MIPS because of their unpredictable impact on the planner performance.
Our approach to extend RPH with numerical information establishes plans even in challenging numerical domains like Settlers and was developed independently from Ho mann's work on his competing planner Metric-FF. Since his planner appears to bemore general in its parsing process to generate monotone numerical quantities for the relaxation, we omitted the algorithmic issues for this aspect from this manuscript. The reader is refered to (Ho mann, 2002a) for further information on this important issue of relaxed plan generation.
Although possible and plausible, in the competition, (S)PDBs estimates were nally not included for plan generation in MIPS, since the integration of numerical state facets and the retrieval of the corresponding relaxed plan operators had not been nished. Hence, the applied heuristic search engine at least in the competition version of MIPS relates to a numerical relaxed plan generator with important pre-and postprocessing aspects.
Hence, we selected the main contributions of this paper to include the following aspects: the formal de nition of grounded propositional and numerical planning and an index scheme for grounding predicate, functions, and actions the object-oriented framework architecture to choose and combine di erent heuristics with di erent s e a r c h algorithms and storage structures the static analyzer that applies e cient fact-space exploration to distinguish constant from variable atoms and resource variables, that clusters facts into groups and that infers static object symmetries di erent pruning methods, especially dynamic symmetry detection, hash and transposition cuts, and di erent strategies for optimizing objective functions and further implementation tricks that made the system e cient a throughout study of dynamic object symmetries, their time and space complexities and a possible trade-o as implemented in MIPS optimal temporal planning enumeration algorithms based on a precedence ralation and PERT scheduling of sequentially generated plans together with a concise analysis of correctness and optimality the integration of PERT scheduling already in the heuristic estimate to guide the search favoring states with smaller parallel plan length the intermediate format of grounded and simpli ed planning domain instances to serve a s an interface for other planners a client-server system for visualization including a wrapper for temporal plans to be presented in Gannt-chart format, and a domain-dependent frontend for executing sequential plans.

Terminology
Our running example is the following instance to of a simple PDDL 2.1 problem in Zeno-Travel and illustrated in Figure 1. The initial con guration is drawn to the left of the gure and the goal con guration to its right. Some global and local numerical variable assignment are not shown. In Figures 2 and 3 we p r o vide the according textual domain and problem speci cation 3 . The instance asks for a temporal plan to y passengers (dan, scott, a n d ernie) located somewhere on a small map (including the cities city-a, city-b, city-c, and city-d) with an aircraft (plane) to their respective target destinations. Boarding and debarking takes a constant amount of time. The plane has a determined capacity of fuel. Fuel and time are consumed according to the distances between the cities and with respect to two di erent travel speeds. Since fuel can be restored by refueling the aircraft, the total amount of fuel is also maintained as a numerical quantity.   For all sets we infer a suitable array embedding, indicated by a mapping from this set to a nite domain and vice versa. This embedding is important t o deal with unique identi ers of entities instead of their textual or internal representation. The arrays containing the corresponding information can then be accessed in constant time. Almost all planners that perform grounding prior to the search address instantiations by i d e n ti ers.
((a p 1 : : : p k(a) )) = (a) + k(a) X i=1 (p i )jOBJj i;1 : After static analysis has established a superset of all occurring uents F, operators O and variables V, in MIPS the index range is reduced to a minimum, thereby re ning to 0 . In the following we keep as a descriptor, and assume that (p) 2 f 1 : : : jPjg, (f) 2 f 1 : : : jVjg, and (a) 2 f 1 : : : jOjg.
In the following we rst give the formal description of a grounded planning problem and then turn to the static analyzer that infers the according and supplementary information.

Grounded Planning Problem Instances
As many other planners MIPS refers to grounded planning problem representations.
De nition 1 (Grounded Planning Instance) A grounded planning instance is a quadruple P = hS I O G i , where S is the set of planning states, I 2 S is the initial state, G S is the set of goal states. In mixed p r opositional and numerical planning problem the state space S is given by S 2 F IR jVj where 2 F is the power set of F. Therefore, a state S 2 S is a pair (S p S n ) with propositional part S p 2 2 F and numerical part S n 2 IR jVj .
For the sake o f b r e v i t y, w e assume the operators to be in normal form, b y means that propositional parts (preconditions and e ects) satisfy standard STRIPS notation (Fikes & Nilsson, 1971) and numerical parts are given in form of arithmetic trees t taken from the set of all trees T with arithmetic operations in the nodes and numerical variables and evaluated constants in the leaves. With LeafVariables(t), t 2 T, w e d e n o t e t h e s e t o f a l l l e a f v ariables in the tree t. However, there is no fundamental di erence to more general preconditions and e ects representations. The current implementation in MIPS takes a generic precondition tree, thereby including comparison symbols, logical operators (in the nodes) and arithmetic subtrees.
De nition 2 (Syntax of Grounded Planning Operator) An operator o 2 O in normal form o = ( ) has propositional preconditions F , propositional e ects = ( a d ) F 2 , numerical preconditions , and numerical e ects . A numerical precondition c 2 is a triple c = ( h c t c ), where h c 2 V , 2 f < = > g, and t c 2 T. A numerical e ect m 2 is a triple m = ( h m t m ), where h m 2 V , 2 f " #g and t m 2 T.
Obviously, 2 f < = > g represents the associated comparison relation, while denotes an assigment t o a v ariable, while " and # indicate a respective increase or decrease operation to it. This allows to formalize the application of planning operators to a given state.
De nition 3 (Semantics of Grounded Planning Operator Application) An o p erator o = ( ) 2 O applied to a state S = ( S p S n ), S p 2 2 F and S n 2 IR jVj , yields a successor state S 0 = ( S 0 p S 0 n ) 2 2 F IR jVj as follows.
We say that a vector S n = (S 1 : : : S jVj ) of numerical variables satis es a numerical constraint c = ( h c t c ) 2 if s (hc) eval(S n t c ) is true, where eval(S n t c ) 2 IR is obtained by substituting all v 2 V in t c by S (hc) followed by a simpli cation of t c . If S p and S n satis es all c 2 then S 0 p = S p a n d and the vector S n is updated for all m 2 . We say that the vector S n = ( S 1 : : : S jVj ) is updated to vector S 0 n = ( S 0 1 : : : S 0 jVj ) by modi er m = ( h m t m ) 2 , if S 0 (hm) = eval(S n t m ) for = , S 0 (hm) = S (hm) + eval(S n t m ) for = ", and S 0 (hm) = S (hm) ; eval(S n t m ) for = #.
The propositional update S 0 p = S p a n d is de ned as in standard STRIPS. The set of goal states G is often given as G = ( G p G n ) with a partial propositional state descrition G p F , and G n as a set of numererical preconditions c = ( h c t c ). Moreover, the arithmetic trees t c usually collaps to simple leaves labeled with numerical constants. Hence, we m i g h t assume that jG n j jVj.

Static Analysis
The static analyzer takes the domain and problem instance as an input, grounds its propositional state information and infers di erent forms of planner independent static information.
Parsing: Our simple Lisp parser generates a tree of Lisp entities. It reads the input les and recognizes the domain and problem name. To c o p e w i t h t yping we temporarily assert constant typed predicates to be removed together with other constant predicates in a further pre-compiling step. Thereby, w e infer a type hierarchy and an associated mapping of objects to types. Indexing: Based on the numberof counted objects, rst indices for the grounded predicates, functions and actions are devised. Since in our example problem we have eight objects and the predicates at and in have t wo parameters, we reserve 2 8 8 = 128 index positions. Similarly, the function distance consumes 64 indices, while fuel, slow-speed, fast-speed, slow-burn, fast-burn, capacity, a n d refuel-rate each reserve eight index positions. For the quantities total-fuel-used, boarding-time, debarking-time only a single fact identi er is needed. Last but not least we interpret duration as an additional quantity total-time. Flattening Temporal Identi ers: According to our assumption of nite branching in this phase we interpret each action as in integral entity, so that all timed propositional and numerical preconditions can bemerged. Similarly, a l l e ects are merged, independent o f their happening. Invariance conditions like (over all (at ?a ?c)) in the action board are included into the precondition set. We will discuss the rationale of this step in Section 5. Grounding Propositions: Fact-space exploration is a relaxed enumeration of the planning problem to determine a superset of all reachable facts. Algorithmically, a F I F O fact queue is comprised. Successively extracted facts at the front of the queue are matched to the operators. Each time all preconditions of an operator are ful lled, the resulting atoms according to the positive e ect (add) list are determined and enqueued. This allows to distinguish constant f r o m u e n t facts, since only the latter are reached by exploration. Grouping Atoms: For a concise encoding of the propositional part we group uent facts in sets of mutually exclusive groups, so that each state in the planning space can be expressed as a conjunct of (possibly trivial) facts drawn from each fact group (Edelkamp & Helmert, 1999). More formally, let #p i (o 1 : : : o i;1 o i+1 : : : o n ) be the number of objects o i for which the fact (p o 1 : : : o n ) is true. We establish a single-valued invariance at i if #p i (o 1 : : : o i;1 o i+1 : : : o n ) = 1 . All x object o j , j 6 = i, are representative of the invariance and label the group. To a l l o w for a better encoding, some predicates like at and in are merged. In the example three groups determine the unique position of the persons (one of ve) and one group determines the position of the plane (one of four). Therefore, 3 d log 5e + 1 d log 4e = 11 bits su ce to encode the encountered 19 uent facts.
Grounding Actions: Fact-space exploration also determines all grounded operators. Once all preconditions are met and grounded, the symbolic e ect lists are instantiated. In our case we determine 98 instantiated operators, which, by some further simpli cations that eliminate duplicates and void operators, are reduced to 43. Grounding Functions: Synchronous to fact space exploration of the propositional part of the problem all heads of the numerical formulae in the e ect lists are grounded. In the example case only three instantiated formulae are uent: fuel plane with initial value 750 as well as total-fuel-used and total-time both initialized with zero. All other numerical predicates are in fact constants that can be substituted in the formula-bodies. For example, the numerical e ect in board dan city-a reduces to (increase (total-time) 30), while zoom plane city-a city-b has the following numerical e ects: (increase (total-time) 150), (increase (total-fuel-used) 300)), and (decrease (fuel plane) 300). Refueling, however, does not reduce to a single rational number, e.g. the e ects in refuel plane city-a only simplify to (increase (total-time) (/ (-(750 (fuel plane)) / 12.5))) and (assign (fuel plane) 750). To evaluate the former assignment variable total-time has to beinstantiated on-the-y. This is due to the fact that the value of the quantity fuel plane is not constant and itself changes over time.
4 Architecture of MIPS Figure 4 depicts the main components of MIPS and the data ow from the input de nition of the domain and the problem instance to the resulting temporal plan in the output.
The planning process can be coarsely grouped into two stages, static analysis and (heuristic search) planning.
The intermediate textual format of the static analyzer in annotated grounded PDDL-like representation serves as an interface e.g. for other planners or model checkers and as an additional resource for plan visualization. Figures 5 and 6 depict an example output for the intermediate representation in the Zeno-Travel example.
The object-oriented framework design of MIPS allows di erent heuristic estimates to be combined with di erent search strategies, access data structures, and scheduling options. Relaxed planning heuristic (RPH): Approximation of the number of planning steps needed to solve the propositional planning problem with all delete e ects removed (Ho mann & Nebel, 2001). The heuristic is constructive, i.e. it returns the set of operators that appear in the relaxed plan. Numerical relaxed planning heuristic (numerical RPH): Our numerical extension to RPH is a combined propositional and numerical forward and backward approximation scheme, also allowing for multiple operator application. Our version for integrating numbers into the relaxed planning heuristic is sound, but not as general as Ho mann's contribution (Homann, 2002a): it restricts to variable-to-constant comparisons, and lacks the simpli cation of linear constraints. Pattern databases heuristic (explicit PDB heuristic): Explicit PDBs were already mentioned in the historical overview of MIPS. The di erent abstractions are found in a greedy best-t bin-packing manner, yielding a selection of large PDBs in form of perfect hash tables that t into main memory. If necessary, PDBs can be designed to be disjoint yielding an admissible estimate (Edelkamp, 2001c). Symbolic pattern database heuristic (symbolic PDB heuristic): Symbolic PDBs apply to both explicit and symbolic heuristic search engines. Due to the succinct BDD-representation of sets of states the averaged heuristic estimate can be increased while decreasing the numberofnodes to be explored in the overall search. Symbolic PDBs are often orders of (define (grounded zeno-travel-zeno-travel-1) (:fluents (at dan city-a) (at dan city-b) (at dan city-c) (at dan city-d) (at ernie city-a) (at ernie city-b) (at ernie city-c) (at ernie city-d) (at plane city-a) (at plane city-b) (at plane city-c) (at plane city-d) (at scott city-a) (at scott city-b) (at scott city-c) (at scott city-d) (in dan plane) (in ernie plane) (in scott plane)) (:variables (fuel plane) (total-fuel-used) (total-time)) (:init (at dan city-c) (at ernie city-c) (at plane city-a) (at scott city-a) (= (fuel plane) 750) (= (total-fuel-used) 0) (= (total-time) 0)) (:goal (at dan city-a) (at ernie city-d) (at scott city-d)) (:metric minimize (total-time) ) (:group dan (at dan city-a) (at dan city-b) (at dan city-c) (at dan city-d) (in dan plane)) (:group ernie (at ernie city-a) (at ernie city-b) (at ernie city-c) (at ernie city-d) (in ernie plane)) (:group plane (at plane city-a) (at plane city-b) (at plane city-c) (at plane city-d)) (:group scott (at scott city-a) (at scott city-b) (at scott city-c) (at scott city-d) (in scott plane)) magnitudes larger than explicit ones. Due to state conversion into a Boolean representation the retrieval of a heuristic estimate is slower than hashing, but still linear in the state description length (Edelkamp, 2002b), Scheduling relaxed plan heuristic (scheduling RPH, SRPH): Critical-path analysis by PERT s c heduling may also guide the plan nding phase. Di erent to the RPH heuristics, which computes the length of the greedily extracted plan, SRPH also takes the sequence of operators into account and searches for a good parallel arrangement. Adding PERTschedules for the path to a state and for the sequence of actions in the relaxed plan is not as accurate as the PERT-schedule of the combined paths. Therefore, the classical merit function of A*-like search engines f = g + h of generating path length g and heuristic estimate h is not immediate. We de ne the heuristic value of SRPH as the parallel plan length of the combined path minus the parallel plan length of the generating path. One suitable combination of the PDB heuristic and RPH heuristics that is also implemented in MIPS, compares the retrieved result of the PDBs with the set of operators in the plan graph that respect the abstraction. The intuition is to slice the relaxed plan graph. If in the backward exploration an add-e ect is selected the match will be assigned to its fact group. If the numberofmatches in an abstraction is smaller than the retrieved PDB value it will be increased by the lacking amount.
In the competition, except for numerical domains we chose pure RPH for sequential plan generation and scheduling PRH for temporal domains. Only in pure numerical problems we used numerical RPH. We have experimented with (symbolic)PDBs with mixed results. Since in our implementation PDBs are purely propositional and do not allow the retrieval of the corresponding operator sets of the optimal abstract plan, we have not included PDB search in the competition version of MIPS.

Exploration Algorithms
The algorithm portfolio includes: Weighted A* (weighted A*/A*): The A* algorithm (Hart, Nilsson, & Raphael, 1968) can becasted as a derivate of Dijkstra's SSSP exploration on a re-weighted graph. For lower bound heuristics, original A* can be shown to generate optimal plans (Pearl, 1985).
Weightening the in uence of the heuristic estimate may accelerate solution nding, but also a ects optimality ( P ohl, 1977). The set of horizon nodes are maintained in a priority queue Open, while the settled nodes are kept in Closed. In MIPS, Weighted A* is implemented with a Dial or a Weak-Heap priority queue data structure (Dial, 1969Edelkamp & Stiegeler, 2002. The former is used for propositional planning only, while the latter applies to general planning with scheduling estimates. Arrays have been implemented as a dynamic table that double their sizes if they become lled. MIPS stores all generated and expanded states in a hash table. An alternative, yet not implemented, but more exible storage structure is collection of persistent trees as in the TL planning system (Bacchus & Kabanza, 2000), one for each predicate. In the best case queries and update times to the structure are logarithmic in the numberof represented atoms. Weighted Iterative-Deepening A* ((W)IDA*): The memory-limited variant o f ( W eighted) A* is well-suited to large exploration problems with e cient e v aluation functions of small integer range (Korf, 1985). In MIPS, IDA* is extended with bit-state hashing (Edelkamp & Meyer, 2001) to improve duplicate detection with respect to ordinary transposition tables (Reinefeld & Marsland, 1994). This form of partial search e ectively trades statespace coverage for completeness. For a further compression of the planning state space, all variables that appear in the objective function are neglected from hash address calculations and state comparisons. Enforced Hill Climbing (EHC): The approach is another compromise between exploration and exploitation. EHC searches with an improved evaluation in breadth-rst manner and commits established decisions as nal (Ho mann, 2000). EHC is complete in undirected problem graphs and seems to have a slight a d v antage to Weighted A* when combined with RPH and other pruning cuts. On the other hand, it can bemisguided in unstructured planning domains and is likely to get lost in problem graphs with dead-ends. Bidirectional SymbolicBreadth-First-Search (BDD-BFS): The implementation performs bidirectional blind symbolic search, choosing the next search direction in favor to the faster executions of the previous iterations (Edelkamp & Helmert, 1999). Weak and Strong Planning: These two symbolic exploration algorithms suited to nondeterministic planning have been added to MIPS (Cimatti, Roveri, & Traverso, 1998), but due to the lack of an agreed standard for a domain description language, the implementation was only tested on deterministic samples in which the above symbolic algorithms clearly perform better. The encoding scheme directly transfers to the non-deterministic scenario, where plans were stored in a form of state-action tables.
In the competition we applied Weighted A* with weight 2, e.g. the merit for all states S 2 S was xed as f(S) = g(S) + 2 h(S), yielding good but not necessarily optimal plans. In temporal domains we introduced an additional parameter to scale the in uence between propositional estimates (f p (S) = g p (S) + 2 h p (S)) and scheduled ones (f s (S) = g s (S) + 2 h s (S)). More precisely, we altered the comparison function for the priority queue, so that a comparison of parallel length priorities was invoked if the propositional di erence of values was not larger than 2 IN 0 . A higher value of refers to a higher in uence of the SRPH, while = 0 indicates no scheduling at all. In the competition we produced data with = 0 (Pure MIPS), and = 2 (optimized MIPS).

Temporal Planning
PDDL 2.1 domain descriptions include temporal modi ers at start, over all, and at end, where label at start denotes the preconditions and e ects at invokation time of the action, over all refers to an invariance condition and at end to the nalization conditions and consequences of the action.

Temporal Model
In Figure 7 we show two di erent options to atten this information back to planning with preconditions and e ects to derive its semantic.
In the rst case (top right), the compound operator is split into three smaller parts, one for action invocation,one for invariance maintenance, and one for action termination. This is the semantic suggested by ( F ox & Long, 2001  As expected there are no e ects in the invariance pattern, i.e. B 0 = . Moreover, we found that in the benchmarks it is uncommon that new e ects in at-start are preconditioned for termination control or invariance maintenance, i.e. A 0 \ (B C) = .
Therefore, in MIPS the simpler second operator representation model was chosen (bottom right). The intermediate format of the example problem in Figures 5 and 6 implicitly assumed this simpler temporal model. At least for sequential plan nding we have not observed any de ciencies by assuming this temporal model, in which each action starts immediately after a previous one has terminated. This simple temporal model motivates the de nition of the rst plan objective: the sequential plan.
De nition 4 (Sequential Plan) A sequential plan s = ( O 1 : : : O k ) is an ordered sequence of operators O i 2 O , i 2 f 1 : : : k g, that transforms the initial state I into one of the goal states G 2 G , i.e., there exists a sequence of states S i 2 S , i 2 f 0 : : : k g, with S 0 = I, S k = G and S i is the outcome of applying O i to S i;1 , i 2 f 1 : : : k g.
Minimizing sequential plan length was the only objective in the rst and second planning competition. Since Graphplan-like planners (Blum & Furst, 1995) like IPP (Koehler, Nebel, & Dimopoulos, 1997) and STAN  already produced parallel plans, this was a indeed a limiting aspect to evaluate plan quality. The most important reason for this arti cial restriction was that total-ordered plans were easier accessible for automated validation, a necessity for evaluating correctness in a competitive scenario.

Operator Dependency
The formal de nition of operator dependency allows to avoid the transpositioned generation of independent actions and, more importantly, enables optimal schedules of sequential plans with respect to the generated action sequence and its causal structure. If all operators are dependent (or void with respect to the optimizer function), the problem is inherent sequential and no schedule leads to any improvement. in the condition of the other. This may be r eferred to as a direct con ict.
3. The head of the numerical modi er of one operator is contained in the formula body of the modi er of the other one, i.e., there exists a m = ( h m t m ) 2 and m 0 = ( h 0 m t 0 m ) 2 0 with h m 2 LeafVariables(t 0 m ) or h 0 m 2 LeafVariables(t m ). This may be referred to as an indirect con ict.
The dependence relation may bere ned according to the PDDL 2.1 guidelines for mutual exclusion (Fox & Long, 2001), but for our purposes for improving sequential plans this approach is su cient. In our implementation (at least for temporal and numerical planning) the dependence relation is computed beforehand and tabulated for constant time access. To improve the e ciency of pre-computation, the set of leaf variables is maintained in an array, once the grounded operator is constructed.
To detect domains for which a n y parallelization leads to no improvement, a planning domain is said to be inherently sequential if all operators in any sequential plan are dependent or instantaneous (i.e. with zero duration). The static analyzer checks this by testing each operator pair. While some benchmark domains like DesertRats and Jugs-and-Water are inherently sequential, others like ZenoTravel and Taxi are not. Precedence is not a partial ordering, since it is neither re exive nor transitive. By computing the transitive closure of the relation, however, precedence could be extended to a partial ordering.
A sequential plan O 1 : : : O k produces an acyclic set of precedence constraints O i d O j , 1 i < j k, on the set of operators. It is also important to observe, that the constraints are already topologically sorted according to d by taking the node ordering f1 : : : k g.   Many algorithms have been suggested to convert sequential plans into partial ordered ones (Pednault, 1986Regnier & Fade, 1991Veloso, P erez, & Carbonell, 1990). Most of them interpret a total ordered plan as a maximal constrained partial ordering = f(O 1 O j ) j 1 i < j kg and search for least constraint plans. However, the problem of minimum constraint \deordering" has also been proven to be NP-hard, except if the so-called validity c heck is polynomial (B ackstr om, 1998), where deordering maintains validity of the plan by lessening its constraintness, i.e. 0 for a new ordering 0 .
Since we have an explicit model of dependency and time, optimal parallel plans will not change the ordering relation d at all.

Critical Path Analysis
The Project Evaluation and Review Technique (PERT) is a critical path analysis algorithm usually applied to project management problems. The critical path is established, when the total time for activities on this path is greater than any other path of operators. A delay i n a n y tasks on the critical path leads to a delay in the project. The heart of PERT is a network of tasks needed to complete a project, showing the order in which the tasks need to be completed and their dependencies between them. As shown in Table 2, PERT scheduling reduces to a derivate of Dijkstra's single shortest path algorithm within acyclic graphs (Cormen, Leiserson, & R i v est, 1990).
In the algorithm, e(O i ) is the tentative earliest end time of operator O i , i 2 f 1 : : : k g, while the earliest starting times t i for all operators in the optimal plan are given by t i = e(O i );d(O i ).
Theorem 1 (PERT Scheduling) Given a sequence of operators O 1 : : : O k and a precedence ordering d an optimal parallel plan = ((O 1 t 1 ) : : : (O k t k )) can be computed in optimal time O(k + j d j).
Proof: The proof is done by induction on i 2 f1 : : : k g. The time and space complexities of the algorithm Critical-Path are clearly in O(k 2 ), where k is the length of the sequential plan. Using an adjacency list representation these e orts can be reduced to time and space proportional to the numberofvertices and edges in the dependence graph, which are of size O(k + j d j). The bound is optimal, since the input consists of (k) operators and (j d j) dependencies among them. 2

Graphplan Distances
In this section we restrict the planning model to valid STRIPS plans as in the original article of Graphplan (Blum & Furst, 1995), where the execution cost of each operator is 1 and the semantics of a parallel plan are as follows.
For each time step i, i 2 f 1 : : : l g, a state S i 2 S is generated by applying all operators with time stamp i ; 1 t o S i;1 , where S 0 = I. An optimal parallel plan is a parallel plan of minimal length l. The name dependency is borrowed from the notion of partial order reduction in explicitstate model checking (Clarke et al., 1999) A less restrictive notion of independence, in which several actions may occurat the same time even if one deletes an add-e ect of another is provided in (Knoblock, 1994).
All three models of valid plans are restrictive, since they assume that for each parallel plan there exist at least one corresponding total ordered plan. In general, however, this is not true. Consider the simple STRIPS planning problem domain with I = fBg, G = ffA Cgg, and O = f(fBg fAg fBg) (fBg fCg fBg)g. Obviously, bothoperators are needed for goal achievement, but there is no sequential plan of length 2, since B is deleted in both operators.
However, a parallel plan could be executed, since all precondition are ful lled at the rst time step.

Full Enumeration Algorithms
Even though full state-space enumaration is far from being practical they provide a basis for heurisitic search engines. In optimal parallel plans, each operator either starts or ends at the start or end time of another operator. Therefore, for a xed number of operators, we can assume a possibly exponential but nite number of possible parallel plans.
This immediately leads to the following plan enumeration algorithm ENUM-1. For all jOj i operator sequences of length i, i 2 IN, generate all possible partial orderings, check for each individual schedule if it transforms the initial state into one of the goals, and take the sequence with smallest parallel plan length. Since all parallelizations are computed we have established the following result.
Theorem 3 If the number of operators for an optimal parallel plan is bounded, ENUM-1 is complete and computes optimal parallel plans.
Note that the rst i with a matching solution does not necessarily yield an optimal parallel path, since longer operator sequences might rise better parallel solutions. ENUM-1 can also generate non-valid plans in the Graphplan model. For a better distinction between the objectives for parallel plans, we k eep the notion of validity in this section.
Assuming only valid plans implies that each parallel plan corresponds to at least one (possible many) sequential ones. Viewed from the opposite side, each partial-ordered plan can be established by generating a totally-ordered plan rst and then apply a scheduling algorithm to it to nd its best partial-order. Therefore, the next two e n umeration schemes produce valid plans only.
Enumeration algorithm ENUM-2 generates all feasible sequential plans of length i with increasing i 2 IN, and computes their optimal schedule with respect to the number of operators and dependency property. Since optimal parallelization of all valid operator sequences are computed we h a ve established the following theorem.
Theorem 4 If the number of operators for an optimal parallel plan is bounded, ENUM-2 is complete and computes a valid optimal parallel plan.
A complete enumeration scheme of all sequential plans that transform the initial state into one goal state is also still computationally expensive, but ruling out impossible operator applications drastically reduces the vast numberofjOj i operator sequences of length i. B ackstr om's result for deriving partial orders has shown, that given the sequence of operators in a sequential plan, to infer an optimized partial order that respects a set of mutexes is NP-hard, so that even for the second phase no polynomial-time algorithm is to beexpected. Therefore, at least for STRIPS we have restricted the PSPACE-hard planning task (Bylander, 1994) to an NP-hard problem for each generated sequential plan.
When the concept of mutual exclusion is extended to a precedence relation between operators, there exist at least one sequential plan that respects the set of operators and the set of precedence constraints. From the opposite point of view, for each sequential plan there exist at least one parallel plan that respects both the number of operators and the imposed set of precedence constraints. Algorithm ENUM-3 is a straight v ariant o f ENUM-2 that simply applies PERT s c heduling for nding the optimal parallel plan, with the main di erence that it additionally maintains the causal structure.
We have seen that ENUM-1 may generate parallel plans that ENUM-2 cannot produce. Are there also valid plans that ENUM-2 can produce, but ENUM-3 cannot? The answer is no. If ENUM-2 terminates with an optimal schedule, we generate a corresponding sequential plan while preserving the causal structure. Optimal PERT-scheduling of this plan with respect to the set of operators and the imposed precedence relation will yield back the optimal parallel plan. Since all sequential paths are eventually generated, the given partial will also be found by ENUM-3. This proves the following result.
Theorem 5 If the number of operators for an optimal parallel plan is bounded, ENUM-3 is complete and computes a valid optimal parallel plan.
In the following, we i n terpret optimized parallel plans as nodes in a weighted directed graph G = ( V E w). Edges correspond to possible extensions of the plans with an additional operator, which can befound by a sequentialization of the parallel plan followed by a PERT scheduling operation. The weight function denotes the di erence in parallel plan length. Since the set of operators and the precedence set is enlarged, all weights will be greater than or equal to 0. If only a nite numberof actions can beexecuted in parallel, then any in nite path in G has unboundedcost. Therefore, we can traverse G in shortest path ordering using Dijkstra's algorithm to nally yield an optimal parallel plan.
The argument for optimality is that Dijkstra's algorithm is complete, i.e., it cannot exit with failure, since if the horizon list becomes becomes empty there is no solution at all. If the horizon is not empty, there is at least one node on an optimal solution path, which has to beselected before any goal node with larger cost.
Theorem 6 If only a nite number of actions can be executed in parallel, Dijkstra's shortest path enumeration is complete and computes a valid optimal parallel plan.

Heuristic Search Enumeration
The enumeration algorithms in the previous section are sound, complete and optimal in theory. On the other hand enumeration schemes do not contradict known undecidability results in numerical planning (Helmert, 2002). If we have no additional information like a bound to the maximal number of actions in a plan or on the number of actions that can be executed in parallel, we cannot say i f t h e e n umeration will terminate or not.
The main drawback o f t h e a b o ve approaches is that they are seemingly too slow for practical planning. Heuristic search algorithms like A* and IDA* reorder the traversal of states in the planning problem, and an admissible estimate does not a ect completeness and optimality. The reason for completeness in nite graphs is that the number of acyclic paths in G is nite and with every node expansion, A* adds new links to its traversal tree. Each newly added link represents a new acyclic path, so that the reservoir of path must eventually be exhausted. The argument i s valid for any best-rst strategy that prunes cyclic paths, but by their move-committing nature, hill-climbing algorithms are not complete. (Pearl, 1985) has shown that A* is complete even on in nte graphs, demanding that the cost of every in nite path is unbounded. A d e e p e r i n vestigation shows that given an admissible estimate there must always beanode in the current search horizon with optimal priority. Actually to preserve this condition for admissible but not necessarily consistent estimates, already expanded node may h a ve to be reconsidered (re-opening). Hence, A* must also terminate with an optimal solution.
Theorem 7 If the cost of every in nite plan is unbounded, A* enumeration with an admissible parallel plan length estimate computes a valid optimal parallel plan. Note that the assumption of unbounded sequential plan costs is not true in all benchmark problems, since there may be an in nite sequence of instantaneous events that do not contribute to the plan objective. For example, loading and unloading tanks in DesertRats does not a ect total-fuel consumption, which i s t o be minimized in one benchmark instance.
As a matter of fact, informative admissible parallel plan length estimates are not easy to obtain. This was the reason in MIPS to chose sequential plan generation rst, because very e ective heuristics are known to generate sequential plans quickly. With the SRPH we c hoose a parallel plan length approximation, but since it extends PRH, it is known to be not admissible.

Pruning Anomalies
Other acceleration techniques like sequential plan hashing, symmetry and transposition cuts have t o b e c hosen carefully to maintain parallel plan length optimality.
Take for example sequential state memorization, i.e. the memorization of states in the sequential plan generation process. This approach does a ect parallel optimality, as the following example shows.
However, the PERT s c hedule for the rst sequence is shorter than the schedule for the second one, since in the previous case the time for boarding scott is compensated by the remaining two operators.
For small problems, such anomalies can be avoided by a voided duplicate pruning at all. As an example Figure 8 depicts a sequential plan for the example problem instance and its PERT schedule, which turns out to be the overall optimal parallel plan.
In order to generate sequential solutions for large planning problem instances, in the competition version of MIPS we h a ve i n troduced cuts that a ect optimality but reduce the number of expansions signi cantly.

Arbitrary Plan Objectives
In PDDL 2.1 di erent plan metrics can bedevised. In Figure 9 we depict two plans found by MIPS when modifying the objective function from minimizing total-time to minimize total-fuel-used, and to minimize the compound (+ (* 10 (total-time)) (* 1 (total-fuel-used))).
For the rst case we computed an optimal value of 1,333.33, while for the second case we established 7,666.67 as the optimized merit. When optimizing time, the ordering of board and zoom actions is important. When optimizing total-fuel we reduce speed to save fuel consumption to 333.33 per ight b u t w e m a y board the rst passenger immediately. We a l s o s a ve two refuel actions with respect to the rst case.
When increasing the importance of time we can trade refueling actions for time, so that both zooming and ight actions are chosen for the complex minimization criterion.
We rst thought, that we could simply substitute the plan objective in the PERT s c heduling process. However, the results did not match with the ones produced by t h e validator (Long & Fox, 2001a), in which t h e nal time is substituted in the objective function after the plan has been build.
The way we evaluate objective functions that include time is as follows. First we schedule the (relaxed or nal) sequential plan. Then we temporarily substitute the total-time value in the state with the parallel plan length and evaluate the formula to get the objective function value. To a void con icts in subsequent expansions, afterwards we set the value total-time back to the optimal one in the sequential plan.

Symmetry
An important feature of parameterized predicates, functions and action descriptions in the domain speci cation le is that actions are transparent to di erent bindings of parameters to objects. Disambiguating information is present in the problem instance le.
In case of typed domains, many planners, including MIPS, compile all type information into additional predicates, attach additional preconditions to actions and enrich the initial states by suitable object-to-type atoms.
As a consequence, a symmetry is viewed as a permutation of objects that is present in the current state, in the goal representation, and transparent to the set of operators.
There are n!, n = jOBJj, possible permutations of the set of objects. Taking into account all type information reduces the number of all possible permutation to n t 1 : : : t k ! = n! t 1 ! : : : t k ! : where t i is the number of objects with type i, i 2 f1 : : : k = jT YPESjg. In a moderate sized logistic domain with 10 cities, 10 trucks, 5 airplanes, and 15 packages, this results in 40!=(10! 10! 5! 15!) 10 20 permutations.
To reduce the number of potential symmetries to a tractable size we restrict symmetries to object transpositions, for which w e h a ve a t m o s t n(n;1)=2 2 O (n 2 ) candidates. Including type information this number further reduces to In the following, the set of typed object transpositions is denoted by S Y M M . For the example, we h a ve j S Y M M j= 45 + 45 + 10 + 105 = 205.

Static Symmetries
We generate a set of object pairs ( We summarize the complexity issues as follows.

Dynamic Symmetries
One problem is that symmetries that are present in the initial state may vanish or reappear during exploration. In the DesertRats domain, for example, the initial set of supply tanks is indistinguishable so that only one should beloaded into the truck. Once the fuel level of the supply tanks decrease or tanks are transported to another location, formerly existing symmetries are broken. However, when two tanks in one location are emptied they can once more be considered as being symmetric.
In a forward chaining planner goal conditions do not change over time, only the initial state I transforms to the current state C. Therefore, in a precompiling phase we re ne the set S Y M M To shorten notation, in the following we write ; 0 (C) for ;(S S Y M M 00 (C)) and 0 (C) for (S S Y M M 00 (C)). Determining ; 0 (C) can be performed in time O(j;(S)j), since nding O 0 = O o $ o 0 ] and the indices (O 0 ) a n d (O) are all available in constant t i m e . Theorem 10 Reducing the operator set ;(C) to ;(S S Y M M 00 (C)) during the exploration of planning problem P = hS O I Gipreserves completeness and sequential optimality for all expanded states C.
Proof: Suppose that for some expanded state C, reducing the operator set ;(C) to ; 0 (C) during the exploration of planning problem P = hS O I Gidoes not preserve completeness and sequential optimality. Furthermore, let C be the state with this property that is maximal in the exploration order.
Then there is a sequential plan = fO 1 : : : O k g in P = hS O C Giwith intermediate state sequence S 0 = C : : : S k G. Obviously, O i 2 ;(S i;1 ), i 2 f 1 : : : k g. By the choice of C we have O 1 6 2 ; 0 (S 0 ). Since O 1 6 2 ; 0 (S 0 ) but O 1 2 ;(S 0 ) w e h a ve that O 1 2 (S 0 S Y M M 00 (S 0 )). If the plan objective is de ned on instantiated predicates and objects, it can besymmetry breaking and to preserve optimality should be checked as an additional requirement similar to G and I.

Symmetry Reduction in MIPS
The main purpose of the re ned implementation in MIPS is to reduce the time for dynamic symmetry detection from O(jSYMM 0 j (jC p j+jVj)) to time O(jC p j+jS Y M M 0 j j V j ) b y loosing some but not all structural properties.
The key observation is that symmetries are also present in fact groups according to their object representatives. Fact groups G i F, i 2 f1 : : : l g implicitly de ne projections P j i of the (propositional) planning space P by P j i = hSj i Oj i I j i Gj i i, with S j i = G i , I j i = I \ G i , Gj i = S G2G G \G i , and Oj i = f( a b ) 2 O j ( a b ) \ S j i 6 = g. By construction for all S 2 S we have exactly one fact in each group true, such that S can bepartitioned into fS 1 : : : S l g, with S i 2 S j i , i 2 f 1 : : : l g. Let  S Y M M= f(i j) j 1 i < j l : R i o $ o 0 ] = R j g: Many objects, e.g. the objects of type city in ZenoTravel, w ere not selected as representatives for a single attribute invariance to build a group. These were neglected in MIPS, since we expect no symmetry on them. This reduces the set of objects OBJ that MIPS considers to a considerably smaller subset OBJ 0 = S f1 i lg R i . In the example problem jOBJj= 7, and jOBJ 0 j = 4 .
It may also happen that more than one group has a representative o 2OBJ 0 . However, if all uent predicates p have arity k(p) 2, which is frequently met in the benchmark domains, all jR i j were equal to one for all i, so for all objects we get a nite partitioning into representatives, i.e. OBJ 0 = _ S i2f1 ::: lg R i .
MIPS takes this conservative assumption and may leave other symmetries uncaught. It computes S Y M Mby analyzing the subproblem structures P j i , i 2 f1 : : : l g instead of P itself. In case of an object symmetry R i $ R j ] the groups G i and G j necessarily have to beisomorphic, and we can establish a bijective mapping : P j i ! P j j with subcomponents S : S j i ! S j j and O : Oj i ! O j j .
As above, static symmetries based on non-matching goal predicates were excluded, yielding a

Visualization
For visualization of plans we extended an existing animation system for our purposes. Vega (Hipke, 2000) is implemented as a Client-Server architecture that runs a annotated algorithm on the server side to be visualized on the client s i d e i n a Java frontend. Annotation are visualization requests that (minorly) extend the existing source code by (simple) commands like send point(x y) o r send circle(x y r). In the system visualization objects can be associated with hierarchical structured identi ers. The client is used bothas the user front-end and the visualization engine. Thus, it allows server and algorithm selection, input of data, running and stopping algorithms, and customization of the visualization.
It can beused to i) manipulate scenes with hierarchically named objects | either in the view or in an object browser that displays the object tree, ii) view algorithm lists at the server and display algorithm information, iii) apply algorithms to selected data in a view, control the algorithm execution using a VCR-like panel or the execution browser, iv) adjust view attributes directly or using the object browser, show s e v eral algorithms simultaneously in multiple scenes and open di erent views for a single scene, and v) load and save single scenes, complete runs, and attribute lists, export scenes in x g or gif format.
Vega allows on-line and o -line presentations. The main purpose of the server is to make algorithms accessible through TCP/IP. The server is able to receive commands from multiple clients at the same time. It allows the client t o choose from the list of available algorithms, to retrieve information about the algorithm, to specify input data, to start it and to receive output data. The server maintains a list of installed algorithms. This list may b e c hanged without the need of stopping and restarting the server.
We have extended Vega with two respects, and call it Vepa for Visualization of E cient Planning Algorithms to emphasize the planning aspect. It can be run as an interactive applet available at www.informatik.uni-freiburg.de/~mmips/visualization.
The rst program that we added is VepaServer which wraps plan execution and visualizes Gannt Charts of plans (cf. Figure 10). Gannt Charts are a well known representation for schedules in which a horizontal open oblong is drawn against each activity indicating estimated duration. The tool can beadapted to any planner that writes plans in planning competition format to standard I/O. The user may choose the planner, the domain, and the problem le. Hence, the algorithm is fully planner independent. To a void security con icts in our web presentation of the visualizer we have incorporated a slightly di erent call panel that allows to select the planner in a pull-down menu and to include domain and problem by cut and paste. The second program (suite) is VepaDomain for domain-dependent visualization of sequential plans. Figure 10 shows an example for the Settlers domain. VepaDomain includes instance independent visualizations for all competition domains all with less than 100 lines of code. The gures for the objects were collected with an image web search engine. We used Google (cf. www.google.de) in the advanced setting to search for small GIFs. VepaDomain works in cooperation with the MIPS system as follows. The planner writes propositional and numeric state facets and (unscheduled) action sequences into a le, which in turn is read by the domain dependent visualizer. Therefore, it is not di cult to adapt other planners to the domain visualizer.

Related Work
Solving planning problems with numerical preconditions and e ects as allowed in Level 2 and Level 3 problems is undecidable in general (Helmert, 2002). However, the structures of the provided benchmark problems are simpler than the general problem class, so that these problems are in fact solvable.

Problem Classes and Methods
According to the PDDL-hierarchy w e indicate three problem classes: 1. Propositional Planning. STRIPS problems have been tackled with di erent planning techniques, most notably by SAT-planning, e.g. (Kautz & Selman, 1996), IP-planning, Figure 11: Visualization of a Planning Problem Instance of Settlers.
If numerical e ects do not bound integral values, in nite state spaces are likely to be generated. However, by assuming nitely many i n teresting events the problem class becomes tractable and is e ectively dealt by schedulers that usually minimize the make-span of concurrent actions. 3. Numerical Preconditions. We distinguish nite and in nite branching problems. Withnite branching, execution time of an action is not parameterized, while with in nite branching, an in nite numberof actions can beapplied. These problems have ever since been confronted to model checking. Some subclasses of in nite branching problems like timed automata exhibit a nite partitioning through a symbolic representation of states (Pettersson, 1999). By the technique of shortest-path reduction a unique and reduced normal form can be obtained. We h a ve implemented this constraint n e t work data structure, since this is the main data structure when exploring timed automata as done by the model checker Uppaal (Pettersson, 1999). For this to work, all constraints must have the form x i ;x j c or x i c. For example, the set of constraints x 4 ; x 0 ;1, x 3 ; x 1 2, x 0 ; x 1 1, x 5 ; x 2 ; 8, x 1 ; x 2 2, x 4 ; x 3 3, x 0 ; x 3 ; 4, x 1 ; x 4 7, x 2 ; x 5 10, and x 1 ; x 5 5 has the shortest-path reduction x 4 ; x 0 ;1, x 3 ; x 1 2, x 5 ; x 2 ; 8, x 0 ; x 3 ;4, x 1 ; x 4 7, x 2 ; x 5 10, and x 1 ; x 5 5. If the constraint set is over-constraint, the algorithm will determine unsolvability, otherwise a feasible solution is returned. The absence of partitioning is current research ( W olper & Boigelot, 1998). Critical path analysis for timed precedence networks is one of the simpler cases for scheduling. We h a ve a c hieved a simpli cation by solving the sequential path problem rst. Several scheduling techniques apply the presented critical path analyses as a subcomponent (Syslo, Deo, & Kowalik, 1983).
Most previously achieved results in symmetry reduction, e.g. (Gu er e & Alami, 2001), neglect the combinatorial explosion problem and tend to assume that the information on existing symmetries in the domain is supplied by the user. Our approach shares similarities with the approach of (Fox & Long, 1999, 2002 in inferring symmetry information automatically, which bases on the TIM inference module . Since no additional information on the current symmetry level in form of matrix is stored, our approach consumes less space per state. Moreover, we can give correctness proofs and e ciency guarantees.

Competing Planners
The on-line presentation of IPC-3 4 provides aspects of the input language, domains, results and other resources, e.g links to competing planners and the history of the event. In the following we brie y present the successful approaches at AIPS-2002. In AIPS-1998 most successful planners besides HSP (Bonet & Ge ner, 2001) and Satplan (Kautz & Selman, 1996) were Graphplan derivates, e.g. IPP (Koehler et al., 1997) and STAN . In 2000, the eld was dominated by the success of heuristic search planning as in FF (Ho mann & Nebel, 2001), HSP-2 (Haslum & Ge ner, 2000), and in some hybrids, like STAN4 (Long & F ox, 2001b), and MIPS. System R (Lin, 2001) used backward regression.
Metric-FF (Ho mann, 2002a) extends FF (Ho mann & Nebel, 2001) and is a forward chaining heuristic state space planner. It performed bestin the numerical track and was the only system besides MIPS that solved instances to Settlers. The main heuristic of relaxed plans bases on the HSP-heuristic (Bonet & Ge ner, 2001). Metric-FF deals with PDDL 2.1 level 2, combined with ADL. The key di erence is the de nition of the relaxation. In STRIPS, the task is relaxed by ignoring all delete lists. However, numerical constraints are not monotonic: while one constraint (e.g. x > 2) might prefer higher values of a variable x, another constraint (e.g. x < 2) might prefer lower values. Opposed to that, the conditions in the purely logical case all prefer higher values of the propositional variables: negative conditions are compiled away as a pre-process, and thus it is always preferable to have more propositional facts true. The observation exploited in Metric-FF is that the same methodology can beapplied in the numerical setting, at least in a subset of the language. The task is pre-processed such t h a t all numerical constraints are monotonic, i.e., for any constraint c, if c is true in a state S then c is true in any state S 0 where, for all variables x, x(S 0 ) x(S). The relaxation is then simply to ignore all e ects that decrease the value of the a ected variable, and the relaxed task can be solved in Graphplan-style. To a c hieve the monotonicity property, one needs, in the numerical constraints and e ects, expressions that are monotonic in all variables. In the current implementation, Numerical-FF restricts to linear expressions which o b viously have this property.
LPG (Local search for Planning Graphs) (Gerevini & Serina, 2002) is the only planner that was competitive with MIPS at AIPS-2002 in the temporal domains. It bases on local search and planning graphs that handles PDDL 2.1 domains involving numerical quantities and durations. The system can solve bothplan generation and plan adaptation problems. The basic search scheme of LPG was inspired by Walksat, an e cient procedure to solve SAT-problems. The search space of LPG consists of action graphs (Gerevini & Serina, 1999), particular subgraphs of the planning graph representing partial plans. The search steps are certain graph modi cations transforming an action graph into another one. LPG exploits a compact representation of the planning graph to de ne the search n e i g h borhood and to evaluate its elements using a parametrized function, where the parameters weight di erent t ypes of inconsistencies in the current partial plan, and are dynamically evaluated during search using discrete Lagrange multipliers. The evaluation function uses some heuristics for estimate the search cost and the execution cost of achieving a (possibly numeric) precondition. Action durations and numerical quantities (e.g., fuel consumption) are represented in the actions graphs, and are modeled in the evaluation function. In temporal domains, actions are ordered using a precedence graph that is maintained during search, and that took into account the mutex relations of the planning graph.
TP4 (Haslum & Ge ner, 2001) is in fact a scheduling system based on grounded problem instances. For these cases all formula trees in numerical conditions and assignments reduce to constants. Utilizing admissible heuristics TP4 minimize the plan objective of optimal parallel plan length. Our planner has some distinctive a d v antages: it handles numerical preconditions, instantiates numerical conditions on the y and can cope with complex objective functions. Besides input restriction, in the competition, TP4 was somewhat limited by is focus to produce optimal solutions only.
SAPA (Do & Kambhampati, 2001) is a domain-independent time and resource planner that can cope with metrics and concurrent actions. It adapts the forward chaining algorithm of (Bacchus & Ady, 2001). Both planning approaches instantiate actions on the y and can, therefore, in principle be adapted to at least mixed propositional and numerical planning problems. The search algorithm of SAPA extends partial concurrent plans. It uses a relaxed temporal planning graph for the yet unplanned events for di erent heuristic evaluation functions. In the competition SAPA w as the only system besides MIPS that produced plans for the complex domains, which w as the only one it submitted solutions to.

SymbolicModel Checking based Planners
In the 2000 competition, two other symbolic planner took part: PropPlan (Fourman, 2000), and BDDPlan (H olldobler & St or, 2000). Although they were not awarded for performance, they show i n teresting properties. PropPlan performs symbolic forward breadth rst search to explore propositional planning problems with propositions for generalized action preconditions and generalized action e ects. It performed well in the full ADL Micsonic-10 elevator domain (Koehler, 2000). ProbPlan is written in the Poly/ML implementation of SML and the standart C-BDD library 5 . BDD-Plan bases on solving the entailment problem in the uent calculus with BDDs. At t h a t time the authors acknowledged that a concise domain encoding and symbolic heuristic search as found in MIPS provides a large space for improvements.
In the Model-Based Planner, MBP 6 , the paradigm of planning as symbolic model checking (Giunchiglia & Traverso, 1999) has beenimplemented for non-deterministic planning domains (Cimatti et al., 1998), which classi es in weak, strong, and strong-cyclic planning, with plans that are represented as complete state-action tables. For partial observable planning, exploration faces the space of belief states the power set of the original planning space. Therefore, in contrast to the successor set generation based on action application, observations introduce \And" nodes into the search tree (Bertoli, Cimatti, Roveri, & Traverso, 2001b). Since the approach is a hybrid of symbolic representation of beliefstates and explicit search within the \And"-\Or" search tree, simple heuristic have been applied to guide the search. The need for heuristics that trade information gain for exploration e ort is also apparent need in conformant planning (Bertoli, Cimatti, & Roveri, 2001a). Recent work (Bertoli & Cimatti, 2002) proposes improved heuristic for belief space planning. MBP has not yet participated in a planning competition, but plan to do in 2004.
The UMOP system parses a non-deterministic agent domain language that explicitly de nes a controllable system in an uncontrollable environment (Jensen & Veloso, 2000). The planner also applies BDD re nement t e c hniques such as automated transition function partitioning. New result for the UMOP system extends the setting of weak, strong and strong cyclic planning to adversarial planning, in which the environment actively in uences the outcome of actions. In fact, the proposed algorithm joins aspects of bothsymbolic search and game playing. UMOP has not participated yet in a planning competition.
More recent d e v elopments in symbolic exploration are expected to in uence automated planning in near future. With SetA*, (Jensen, Bryant, & Veloso, 2002) provide an improved imple-mentation of the symbolicheuristic search algorithm BDDA* (Edelkamp & Re el, 1998) and Weighted BDDA* (Edelkamp, 2001a). One major surplus is to maintain a ner granularity of the sets of states in the search horizon kept in a matrix according to matching gand hv alues. This contrasts the plain bucket representation of the priority queue based on f-values. The heuristic function is implicitly encoded with value di erences of grounded actions. Since sets of states are to beevaluated and some heuristics are state rather than operator dependent i t h a s still to be shown how general this approch i s . As above the considered planning benchmarks are seemingly simple for single-state heuristic search exploration (Ho mann, 2002bHelmert, 2001. (Hansen, Zhou, & Feng, 2002) also re-implemented BDDA* and suggest that symbolic search heuristics and exploration algorithms are probably better to be implemented with algebraic decision diagrams (ADDs), as available in Somenzi's CUDD package. Although the authors achieved no improvement t o ( E d e l k amp & Re el, 1998) to solve t h e ( n 2 ; 1)-Puzzle, the established generalization to guide a symbolicversion of the LAO* exploration algorithm (Hansen & Zilberstein, 2001) for probabilistic (MDP) planning, results in a remarkable improvement to the state-of-the-art .

Conclusions
With the competing planning system MIPS, we have contributed an object-oriented architecture for a forward chaining, heuristic explicit and symbolic search planner that nds plans in nite-branching numerical problems. The planner parses, pre-compiles, solves, and schedules all current benchmark problem instances include complex ones with duration, resource variables and di erent objective functions.
Model checking aspects have always been in uencing to the development of MIPS, e.g in the static analysis to minimize the state description length, in symbolic exploration and plan extraction, in the dependence relation for PERT schedules according to a given partial order, in bit-state hashing for IDA*, etc. The successes of planning with MIPS were also exported back to model checking, as the development of a heuristic search explicit-state model checker HSF-SPIN  indicates.
MIPS instantiates numerical pre-and postconditions on-the-y and produces optimized parallel plans. Essentially planning with numerical quantities and durative actions is planning with time and resources. The given framework of mixed propositional and numerical planning problems problems and the presented intermediate format can be seen as a normal form for temporal and metric planning.
For temporal planning, MIPS generates sequential (totally ordered) plans and e ciently schedules them with respect to the set of actions and the imposed causal structure, without falling into known NP-hardness traps for optimized partial-ordering of sequentially generated plan. For smaller problems the enumeration approach guarantees optimal solutions. To improve solution quality in approximate enumeration, the (numerical) estimate for the numberof operators was substituted by s c heduling the relaxed plan in each state.
Other contributions besides the new expressivity were re ned static analysis techniques to simplify propositionally grounded representation and to minimize state encoding, automated state-based dynamic symmetry detection, as well as e ective hashing and transposition cuts.
In the main part of paper we h a ve analyzed completeness and optimality of di erent forms of exploration and have given a troughout theoretical treatment of PERT s c heduling and symmetry detection, proving correctness results and studying run-time complexities.