Computing Infinite Plans for LTL Goals Using a Classical Planner

1 Motivation

Classical planning has been concerned with the synthesis of finite plans to achieve final states where given propositional goals hold. These are usually called "reachability" problems. In the last few years temporally extended goals, expressed in temporal logics such as LTL, have been increasingly used to capture a richer class of finite plans, where restrictions over the whole sequence of states must be satisfied as well [Gerevini and Long, 2005]. A (temporally) extended goal may state, for example, that any borrowed tool should be kept clean until returning it; a constraint that does not apply to states but, rather, to state sequences. Yet almost all work in planning for LTL goals has been focused on finite plans [Bacchus and Kabanza, 1998; Cresswell and Coddington, 2004; Edelkamp, 2006; Baier and McIlraith, 2006; Baier et al., 2009], while general LTL goals may require infinite plans (see [Bauer and Haslum, 2010]). For instance, in order to monitor a set of rooms, an extended LTL goal may require the agent to always return to each of the rooms, a goal that cannot be achieved by a finite plan.

In this work, we take the next step in the integration of LTL goals in planning and consider the computation of infinite plans for achieving arbitrary LTL goals. It is well known that such infinite plans can be finitely characterized as "lassos": sequences of actions π1, mapping the initial state of a Giuseppe De Giacomo Sapienza Univ. di Roma Rome, Italy degiacomo@dis.uniroma1.it Hector Geffner ICREA & UPF Barcelona, Spain first.last@upf.edu composite system into some state s, followed by a second action sequence π2 that maps s into itself, and that is repeated infinitely often [Vardi, 1996]. The composite system is the product of the planning domain and the B¨uchi automaton representing the goal [De Giacomo and Vardi, 1999]. In this paper we show that such infinite plans can efficiently be constructed by calling a classical planner once over a classical planning problem Pϕ, which is obtained from the PDDL description P of the planning domain, and the B¨uchi automaton Aϕ representing the goal ϕ.

The crux of our technique is a quite natural observation: since we are looking for lasso sequences, when we reach an accepting state of the B¨uchi automaton, we can nondeterministically elect the current configuration formed by the state of the automaton and the state of the domain as a "start looping" configuration, and then try to reach the exact same configuration a second time. If we do, we have found an accepting automaton state that repeats infinitely often, satisfying the B¨uchi condition, i.e., we have found the lasso. In this way we reduce fair reachability (the lassos sequences) to plain reachability (finite sequences). Such an observation has been made already in the model-checking literature. In particular [Schuppan and Biere, 2004] use this observation to reduce checking of liveness properties ("something good eventually happens"), and, more generally, arbitrary LTL formulas via B¨uchi automata nonemptiness, to checking of safety properties ("something bad never happens").

Planning technologies have been used before for tackling LTL goals, starting with the pioneer work by Edelkamp [2003]. Also, an earlier computational model for planning with arbitrary LTL goals was developed in [Kabanza and Thi´ebaux, 2005], where no direct translation into classical planning was present, but a classical planner was invoked to solve a series of subproblems, inside a backtracking search. Strictly related to our approach is the work reported in Albarghouthi, Baier, and McIlraith [2009], where the authors map the model-checking problem over deterministic and nondeterministic transition systems into classical planning problems. They directly exploit the reduction schema devised in [Schuppan and Biere, 2004] to handle the B¨uchi acceptance condition with the generality required by arbitrary LTL formulas, while adopting specific techniques for safety and liveness properties, demonstrated by promising experiments over the Philosophers domain.

Here we propose instead a direct translation of LTL goals (or better arbitrary B¨uchi automata goals) into classical planning specifically well cut to exploit state-of-the art planners capabilities, and test it over a variety of domains and goals.

The paper is organized as follows. First, we review the background material: planning domains, LTL, and B¨uchi automata (Section 2), and the definition of the problem of achieving arbitrary LTL goals ϕ over planning domains P (Section 3). We then map this problem into the classical planning problem Pϕ (Section 4) and test the compilation over various domains and goals (Section 5).

2 Preliminaries

We review the models associated with classical planning, LTL, and B¨uchi automata.

2.1 Planning Domains

A (classical) planning domain is a tuple D = (Act,Prop, S, s0, f) where: (i) Act is the finite set of domain actions; (ii) Prop is the set of domain propositions; (iii) S ⊆ 2Prop is the set of domain states; (iv) s0 ∈ S is the initial state of the domain; and (v) f : A × S → S is a (partial) state transition function.

Planning languages such as STRIPS or ADL, all accommodated in the PDDL standard, are commonly used to specify the states and transitions in compact form.

A trace on a planning domain is a possibly infinite sequence of states s0, s1, s2, . . . where si+1 = f(si, a) for some a ∈ Act s.t. f(si, a) ̸= ⊥. A goal is a specification of the desired traces on D. In particular, classical reachability goals, which require reaching a state s where a certain propositional formula ϕ over Prop holds, are expressed as selecting all those finite traces t = s0s1 · · · sn, such that sn |= ϕ. Using infinite traces allows us to consider a richer set of goals, suitably expressed through arbitrary LTL formulas.

2.2 Linear Temporal Logic (LTL)

LTL was originally proposed as a specification language for concurrent programs [Pnueli, 1977]. Formulas of LTL are built from a set Prop of propositional symbols and are closed under the boolean operators, the unary temporal operators ◦, ✸, and ✷, and the binary temporal operator U. 1 Intuitively, ◦ϕ says that ϕ holds at the next instant, ✸ϕ says that ϕ will eventually hold at some future instant, ✷ϕ says that from the current instant on ϕ will always hold, and ϕU ψ says that at some future instant ψ will hold and until that point ϕ holds. We also use the standard boolean connectives ∨, ∧, and →.

The semantics of LTL is given in terms of interpretations over a linear structure. For simplicity, we use IN as the linear structure: for an instant i ∈ IN, the successive instant is i+1. An interpretation is a function π : IN → 2Prop assigning to each element of Prop a truth value at each instant i ∈ IN. For an interpretation π, we inductively define when an LTL formula ϕ is true at an instant i ∈ IN (written π, i |= ϕ):

• π, i |= p, for p ∈ Prop iff p ∈ π(i).
• π, i |= ¬ϕ iff not π, i |= ϕ.

1 In fact, all operators can be defined in terms of ◦ and U.

• π, i |= ϕ∧ϕ′ iff π, i |= ϕ and π, i |= ϕ′ .
• π, i |= ◦ϕ iff π, i+1 |= ϕ.
• π, i |= ϕU ϕ′ iff for some j ≥ i, we have that π, j |= ϕ′ and for all k, i ≤ k < j, we have that π, k |= ϕ.

A formula ϕ is true in π (written π |= ϕ) if π, 0 |= ϕ. Given a planning domain (or more generally a transition system), its traces s0, s1, s2, . . . can be seen as LTL interpretations π such that π, i |= p iff si |= p.

2.3 LTL and B¨uchi Automata

There is a tight relation between LTL and B¨uchi automata on infinite words, see e.g., [Vardi, 1996]. A B¨uchi automaton (on infinite words) [Thomas, 1990] is a tuple A = (Σ,Q,Q0, ρ, F) where: (i) Σ is the input alphabet of the automaton; (ii) Q is the finite set of automaton states; (iii) Q0 ⊆ Q is the set of initial states of the automaton; (iv) ρ : Q × Σ → 2Q is the automaton transition function (the automaton does not need to be deterministic); and (v) F ⊆ Q is the set of accepting states. The input words of A are infinite words σ0σ1 · · · ∈ Σω . A run of A on an infinite word σ0σ1 · · · is an infinite sequence of states q0q1 · · · ∈ Qω s.t. q0 ∈ Q0 and qi+1 ∈ ρ(qi, σi). A run r is accepting iff lim(r) ∩ F ̸= ∅, where lim(r) is the set of states that occur in r infinitely often. In other words, a run is accepting if it gets into F infinitely many times, which means, being F finite, that there is at least one state qf ∈ F visited infinitely often. The language accepted by A, denoted by L(A), is the set of (infinite) words for which there is an accepting run.

The nonemptiness problem for an automaton A is to decide whether L(A) ̸= ∅, i.e., whether the automaton accepts at least one word. The problem is NLOGSPACE-complete [Vardi and Wolper, 1994], and the nonemptiness algorithm in [Vardi and Wolper, 1994] actually returns a witness for nonemptiness, which is a finite prefix followed by a cycle.

The relevance of the nonemptiness problem for LTL follows from the correspondence obtained by setting the automaton alphabet to the propositional interpretations, i.e., Σ = 2Prop . Then, an infinite word over the alphabet 2Prop represents an interpretation of an LTL formula over Prop.

Theorem 1 [Vardi andWolper, 1994] For every LTL formula ϕ one can effectively construct a B¨uchi automaton Aϕ whose number of states is at most exponential in the length of ϕ and such that L(Aϕ) is the set of models of ϕ.

Typically, formulas are used to compactly represent subsets of Σ = 2Prop . We extend the transition function of a B¨uchi automaton to propositional formulas over Prop as: ρ(q,W) .= {q′ | ∃s s.t. s |=W ∧ q′ ∈ ρ(q, s)}.

3 The Problem

A plan π over a planning domain D = (Act , Prop, S, s0, f) is an infinite sequence of actions a0, a1, a2, . . . ∈ Act ω . The trace of π (starting from the initial state s0) is the infinite sequence of states tr(π, s0) = s0, s1, . . . ∈ Sω s.t. si+1 = f(si, ai) (and hence f(si, a) ̸= ⊥). A plan π achieves an LTL formula ϕ iff tr(π, s0) ∈ L(Aϕ), where Aϕ = (2Prop ,Q,Q0, ρ, F) is the automaton that accepts exactly the interpretations that satisfy ϕ.

How can we synthesize such a plan? We can check for nonemptiness the B¨uchi automaton AD,ϕ = (ΣD,QD,QD0, ρD, FD) that represents the product between the domain D and the automaton Aϕ, where: (i) ΣD = Act ; (ii) QD = Q × S; (iii) QD0 = Q0 × {s0}; (iv) (qj, sj) ∈ ρD((qi, si), a) iff sj = f(si, a) and qj ∈ ρ(qi,W), with si |= W; and (v) FD = F × S. It can be shown that the above construction is sound and complete:

Theorem 2 [De Giacomo and Vardi, 1999] A plan π for the planning domain D achieves the LTL goal ϕ iff π ∈ L(AD,ϕ) for the automaton AD,ϕ.

It is also easy to see that if a plan π is accepted by the B¨uchi automaton AD,ϕ, and hence π achieves the LTL goal ϕ over D, then π can be seen as forming a lasso, namely: an action sequence π1 followed by a loop involving an action sequence π2. This is because π must generate a run over the automaton AD,ϕ that includes some accepting state (qi, si) an infinite number of times. It follows from this that:

Theorem 3 The goal ϕ is achievable in a planning domain D iff there is a plan π made up of an action sequence π1 followed by the action sequence π2 repeated an infinite number of times, such that π achieves ϕ in D.

4 Compilation Into Classical Planning

Theorem 3 says that the plans to achieve an arbitrary LTL goal have all the same form: a sequence π1 mapping the initial state of the product automaton AD,ϕ into an accepting state, followed by another sequence π2 that maps this state into itself, that is repeated for ever. This observation is a direct consequence of well known results. What we want to do now is to take advantage of the factored representation P of the planning domain D afforded by standard planning languages, for transforming the problem of finding the sequences π1 and π2 for an arbitrary LTL goal ϕ, into the problem of finding a standard finite plan for a classical problem Pϕ, where Pϕ is obtained from P and the automaton Aϕ (that accepts the interpretations that satisfy ϕ). Such classical plans, that can be obtained using an off-the-shelf classical planner, will all have the form π′1 , loop(q), π′2 , where π′1 and π′2 are the action sequences π1 and π2 extended with auxiliary actions, and loop(q) is an auxiliary action to be executed exactly once in any plan for Pϕ, with q representing an accepting state of Aϕ. The loop(q) action marks the current state over the problem Pϕ, as the first state of the lasso. This is accomplished by making the loop(q) action dynamically set the goal of the problem Pϕ to the pair (q, s) (extended with a suitable boolean flag) if s represents the state of the literals over Prop when the loop(q) was done. That is, the action sequence π′2 that follows the loop(q) action, starts with the fluents encoding the state (q, s) true, and ends when these fluents have been true once again, thus capturing the loop.

The basis of the classical planning problem Pϕ is the intermediate description P ′ , an encoding that captures simple reachability in the product automaton AD. If P = 〈Prop, s0, Act〉 is the PDDL description of the planning domain, and Aϕ = 〈2P rop , Q, Q0, ρ, F 〉 is the B¨uchi automaton accepting the interpretations that satisfy ϕ, then P ′ is the tuple 〈P rop′ , s′0 , Act′ 〉 where:

• Prop′ = P rop ∪ {pq, nq | q ∈ Q} ∪ {f0, f1, f2},
• s′0 = s0 ∪ {pq | q ∈ Q0} ∪ {f1},
• Act′ = Act ∪ {mv1, mv2},

where the actions in Act′ that come from P, i.e. those in Act, have the literal f0 as an extra precondition, and the literals ¬f0 and f1 as extra effects. The booleans fi are flags that force infinite plans a0, a1, a2, . . . in P ′ to be s.t. a0 is an action from P, and if ai is an action from P, ai+1 = mv1, ai+2 = mv2, and ai+3 is an action from P again. That is, plans for P ′ are made of sequences of three actions, the first from P , followed by mv1 and mv2. For this, mv1 has precondition f1 and effects f2 and ¬f1, and mv2 has precondition f2 and effects f0 and ¬f2.

The actions mv1 and mv2 keep track of the fluents pq that encode the states q of the automaton Aϕ. Basically, if state q′ may follow q upon input formula W in Aϕ, then action mv1 will have the conditional effects

and mv2 will have the conditional effects

for all the states q in Aϕ. So that if pq and W are true right before mv1, then pq′ will be true after the sequence mv1, mv2 iff q′ ∈ ρ(q,W) for the transition function ρ of Aϕ. It can be shown then that:

Theorem 4 Let P = 〈Prop, s0,Act〉 be the PDDL description of the planning domain D, and Aϕ = 〈2Prop ,Q,Q0, ρ, F〉 be the B¨uchi automaton accepting the interpretations that satisfy ϕ. The sequence π = a0, a1, a2, . . . , ai∗3+2 non-deterministically leads the product automaton AD,ϕ to the state (q, s) iff in the planning domain description P ′ , π achieves the literal pq and the literals L over Prop iff L is true in s.

P ′ thus captures simple reachability in the automaton AD that is the product of the planning domain described by P and the automaton Aϕ representing the goal ϕ. The classical planning problem Pϕ that captures the plans for ϕ over P is defined as an extension of P ′ . The extension enforces a correspondence between the 'loopy' plans π for ϕ over P of the form 'π1 followed by loop π2', and the finite plans for the classical problem Pϕ of the form 'π′1 , loop(q), π′2 ', where π1 and π2 are the action sequences before and after the loop(q) action with the auxiliary actions removed. The encoding Pϕ achieves this correspondence by including in the goal the literal pq encoding the state q of the Aϕ as well as all the literals L over Prop that were true when the action loop(q) was done. This is accomplished by making a copy of the latter literals in the atoms req(L). More precisely, if P = 〈Prop, s0,Act〉 and P ′ = 〈Prop′ , s′0 ,Act′ 〉, Pϕ is the tuple P ′′ = 〈P rop′′ , s′′ 0 , Act′′ , Goal′′ 〉 where:

• Prop′′ = P rop′ ∪ {req(L) | L ∈ Prop} ∪ {Ls, Lf }
• s′′ 0 = s′0
• Act′′ = Act′ ∪ {loop(q) | q ∈ F}
• G′′ = {Lf} ∪ {L ≡ req(L) | L ∈ Prop}.

Here L ∈ Prop refers to the literals defined over the Prop variables, and the new fluents req(L), Ls, and Lf stand for 'L required to be true at the end of the loop', 'loop started', and 'loop possibly finished' respectively. In addition, the new loop(q) actions have preconditions pq, f0, ¬Ls, and effects Ls and

for all literals L over Prop, along with the effects pq → ¬pq′ for all the automaton states q′ different than q. The effects L → req(L) 'copy' the literals L that are true when the action loop(q) was done, into the atoms req(L) that cannot be changed again. As a result, the goals L ≡ req(L) in G′′ capture the equivalence between the truth value of L when the loop(q) action was done, and when the goal state of Pϕ is achieved.

The effects pq → ¬pq′ , on the other hand, express a commitment to the automaton state q associated with the loop(q) action, setting the fluents representing all other states q′ to false. In addition, all the non-auxiliary actions in Act′′ , namely those from P , are extended with the effect Ls → Lf that along with the goal Lf ensures that some action from P must be done as part of the loop. Without the Lf fluent ('loop possibly finished') in the goal and these conditional effects, the plans for Pϕ would finish right after the loop(q) action without capturing a true loop.

From the goal G′′ above that includes both Lf and

for all literals L over Prop, this all means that a loop(q) action must be done in any plan for Pϕ, after an initial action sequence π′1 , and before a second action sequence π′2 containing an action from Act. The sequence π′2 closes the 'lasso'; namely, it reproduces the state of the product automaton where the action loop(q) was done. 2

Theorem 5 (Main) π is a plan for the LTL goal ϕ over the planning domain described by P iff π is of the form 'π1 followed by the loop π2', where π1 and π2 are the action sequences from P, before and after the loop(q) action in any classical plan for Pϕ.

5 Use of the Classical Planner

Theorem 5 states that the plans for an arbitrary LTL goal ϕ over a domain description P can be obtained from the plans for the classical planning problem Pϕ. The goal of Pϕ is a classical goal that includes the literal Lf and the equivalences L ≡ req(L) for L ∈ Prop. Classical planners usually deal with precondition, conditions, and goals that are conjunctions of literals, eliminating other formulas. For this, they apply standard transformations as a preprocessing step [Gazen and Knoblock, 1997]. In our use of planners, we have found useful to compile the equivalences L ≡ req(L) away from the goal by including extra actions and fluents. In particular, a new action End? is introduced that can be applied at most once as the last action of a plan (this is managed by an extra boolean flag). The precondition of End? is Lf and its effects are

2 The theorem below doesn't require the presence of a NO-OP action in P, yet many LTL goals require such an action (e.g., the goal 'eventually always hold block A'). Also, the finite plans π that can be used to achieve some type of LTL goals (e.g., 'eventually hold block A'), map then into the infinite plans where π is followed by a NO-OP loop.

over all L over Prop, where end(L) are new atoms. It is easy to see that π is a classical plan for the original encoding Pϕ iff π followed by the End? action is a classical plan in the revised encoding where the equivalences L ≡ req(L) in the goal have been replaced by the atoms end(L). This transformation is general and planner independent.

The second transformation that we have found useful to improve performance involves changes in the planner itself. We made three changes in the state-of-the-art FF planner [Hoffmann and Nebel, 2001] so that the sequences made up of a normal domain action followed by the auxiliary actions mv1 and mv2, that are part of all plans for the compiled problems Pϕ, are executed as if the 3-action sequence was just one "primitive" action. For this, every time a normal action a is applied in the search, the whole sequence a,mv1,mv2 is applied instead. In addition, the two auxiliary actions mv1 and mv2 that are used to capture the ramifications of the normal actions over the B¨uchi automata, are not counted in the evaluation of the heuristic (that counts the number of actions in the relaxed plans), and the precondition flag f1 of the action mv1 appearing in the relaxed plans is not taken into account in the identification of the "helpful actions", as all the actions applicable when f1 is false and f0 is true, add f1 Finally, we have found critical to disable the goal agenda mechanism, as the compiled problems contain too many goals: as many as literals. Without these changes FF runs much slower over the compiled problems. In principle, these problems could be avoided with planners able to deal properly with "action macros" or "ramifications", but we have found such planners to be less robust than FF.

6 Experiments

Let us describe through a sample domain what LTL goals can actually capture. In this domain, a robotic 'animat' lives on a n × n grid, whose cells may host a food station, a drink station, the animat's lair, and the animat's (beloved) partner. In our instances the partner is at the lair. The animat status is described in terms of levels of power (p), hunger (h), and thirst (t). The animat can move one cell up, down, right, and left, can drink (resp. eat), when in a drink (food) station, and can sleep, when at the lair. Each action affects (p, h, t), as follows: move:(-1, +1, +1), drink:(-1, +1, 0), eat:(-1, 0,+1), and sleep:(max,+1,+1). The value max is a parameter adjusted depending on the grid size n. Initially, (p, h, t) = (max, 0, 0).

The objective of the animat is not to reach a particular goal as in classical planning but to carry on a happy life. The animat is happy if it is not (too) hungry, thirsty or weak, and, importantly, if it can get back to its lair and see its partner, every now and then, and do something different as well. Its life is happy if this condition is always verified. Formally, animat's happiness is expressed by the following LTL formula: ✷((h ̸= max) ∧ (t ̸= max) ∧ (p ̸= 0))∧✷✸(with partner)∧✷✸(¬with partner), which requires an infinite plan such that: (i) h, t and p are guaranteed to never reach their max/min values; (ii) the animat visits its partner infinitely often; and (iii) the animat does something else than visiting its partner infinitely often.

As a first set of experiments 3 , we tested the performance of FF (with the modifications previously discussed) in solving animat instances. Specifically, we increased the grid size from 3 to 9, and max from 15 (for n = 3) to 27 (for n = 9), adding 2 units each time n was increased by 1. As for the goal formula, we used exactly the same as seen above, by just setting the value of max depending on n. This problem is challenging for FF because it requires building a non-trivial lasso for which the EHC search fails. In Table 1 we show the results, with times expressed in seconds, and plan lengths including the auxiliary actions (number of domain actions is approx. 1/3). In this domain, the failure of the more focused EHC triggers a greedy best first search that runs out of memory over the largest domains. Still, this search produces nontrivial working 'loopy' plans, including almost 40 actions in the largest instance solved.

We carried out two additional classes of experiments on standard planning domains. In the first class, we test the overhead of the translation for purely classical problems, and hence reachability goals, with the NO-OP action added. For this we compare the performance of FF over the classical planning problems P ′ with goal G with the performance of FF over the translation Pϕ where P is P ′ but with the goal G removed, and ϕ is the LTL formula ✸G. Results are shown in Table 2. As it can be seen from the table, there is a performance penalty that comes in part from the extra number of actions and fluents in the compiled problems (columns OP and FL). Still, the number of nodes expanded in the compiled problems remains close to that of nodes expanded in the original problems, and while times are higher, coverage over the set of instances does not change significantly (columns S). The scalability of FF over classical problems vs. their equivalent compiled LTL problems is shown in Fig. 1 for Gripper, as the number of balls is increased. While the times grow for the latter, the degradation appears to be polynomial as the number of expanded nodes is roughly preserved.

In the second class, we tested our approach on three classical problems (Blocksworld, Gripper and Logistics) using more complex LTL goals. Such experiments aim at evaluating the effectiveness of our approach wrt the general problem of finding infinite plans that satisfy generic LTL goals. We used five different classes of LTL formulas as goals:

3 Experiments run on a dual-processor Xeon 'Woodcrest', 2.66 GHz CPU, 8 GB of RAM, with a process timeout of 30 minutes and memory limit of 2 GB).

• (Type 1) ∧ni=1 ✸pi;
• (Type 2) ✸(p1 ∧◦✸(p2 ∧ . . . ∧◦✸(pn) . . .));
• (Type 3) ∧ni=1 ✷✸pi;
• (Type 4) (. . . (p1 U p2)U . . .)U pn;
• (Type 5) (✷✸p1 → ✷✸p2) ∧ . . . ∧ (✷✸pn-1 → ✷✸pn).

Types 1, 3 and 4, appear among those proposed in [Rozier and Vardi, 2010] for model-checkers' performance comparison; type 2 is a type-1 variant, which forces the planner to plan for sequential goals; and type 5 formulas are built from strong fairness formulas ✷✸p → ✷✸q, so as to generate large B¨uchi automata.

For all domains and classes of formulas above, we generated a set of instances, obtained by increasing several parameters. For Blocksworld, we increased the number of blocks, for Gripper the number of balls, and for Logistics the number of packages, airplanes and locations within each city, fixing the number of cities to 4. In addition to these, for each problem, we increased the LTL formula length, i.e., the number of boolean subformulas occurring in the LTL formula. Then, we compiled such instances into classical planning problems, according to the schema above, and solved them using FF. The results are shown in Table 3.

We tried to solve these collections of instances using the well-known symbolic model checker NuSMV [Cimatti et al., 2002], so as to compare our approach with a state-of-the-art model checker [Rozier and Vardi, 2010]. In order to do so, we translated the LTL goals (before compilation into classical planning) into LTL model-checking ones, using a very natural schema, where ground predicates are mapped into boolean variables, and ground actions act as values for a variable. The model checker, however, runs out of memory on even the simplest instances of Blocksworld and Logistics with classical goals, and on most of the Gripper instances, and had even more problems when non-classical goals were used instead. The sheer size of these problems appears thus to pose a much larger challenge to model checkers than to classical planners.

7 Conclusion

We have introduced a general scheme for compiling away arbitrary LTL goals in planning, and have tested it empirically over a number of domains and goals. The transformation allows us to obtain infinite 'loopy' plans for an extended goal ϕ over a domain description P, from the finite plans that can be obtained with any classical planner from a problem Pϕ. The result is relevant to both planning and modelchecking: to planning, because it enables classical planners to produce a richer class of plans for a richer class of goals; to model-checking, because it enables the use of classical planning to model-check arbitrary LTL formulas over deterministic and non-deterministic domains. We have experimentally shown indeed that state-of-the-art model-checkers do not appear to scale up remotely as well as state-of-the-art planners that search with automatically derived heuristics and helpful actions. In the future, we want to test the use of the Pϕ translation for model-checking rather than planning, and extend these ideas to planning settings where actions have nondeterministic effects, taking advantage of recent translations developed for conformant and contingent problems.

Acknowledgements

This work was partially supported by grants TIN2009-10232, MICINN, Spain, EC-7PM-SpaceBook, and EU Programme FP7/2007-2013, 257593 (ACSI).