Paper deep dive
Compiling Temporal Numeric Planning into Discrete PDDL+: Extended Version
Andrea Micheli, Enrico Scala, Alessandro Valentini
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 96%
Last extracted: 3/22/2026, 6:32:35 AM
Summary
The paper presents a practical, polynomial-time compilation method for transforming temporal planning problems with durative actions (PDDL 2.1) into PDDL+. The approach uses a combination of processes, events, and auxiliary state variables to enforce temporal semantics, including non-self-overlapping constraints and overall invariants, while maintaining sound and complete plan execution.
Entities (4)
Relation Signals (2)
Compilation → targets → PDDL+
confidence 95% · The target of our compilation is a PDDL+ problem
Compilation → transforms → PDDL 2.1
confidence 95% · compilation method that transforms a temporal planning problem specified in PDDL2.1 into an equivalent formulation in PDDL+
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Since the introduction of the PDDL+ modeling language, it was known that temporal planning with durative actions (as in PDDL 2.1) could be compiled into PDDL+. However, no practical compilation was presented in the literature ever since. We present a practical compilation from temporal planning with durative actions into PDDL+, fully capturing the semantics and only assuming the non-self-overlapping of actions. Our compilation is polynomial, retains the plan length up to a constant factor and is experimentally shown to be of practical relevance for hard temporal numeric problems.
Tags
Links
- Source: https://arxiv.org/abs/2603.12188v1
- Canonical: https://arxiv.org/abs/2603.12188v1
Trouble viewing inline? Open PDF directly →
Full Text
49,986 characters extracted from source content.
Expand or collapse full text
Compiling Temporal Numeric Planning into Discrete PDDL+: Extended Version111This paper is an extended version of the homonymous appearing in the ICAPS 2026 proceedings. This version provides the proofs and addidional explanations of the compilation. Andrea Micheli1, Enrico Scala2, Alessandro Valentini1 Abstract Since the introduction of the PDDL+ modeling language, it was known that temporal planning with durative actions (as in PDDL 2.1) could be compiled into PDDL+. However, no practical compilation was presented in the literature ever since. We present a practical compilation from temporal planning with durative actions into PDDL+, fully capturing the semantics and only assuming the non-self-overlapping of actions. Our compilation is polynomial, retains the plan length up to a constant factor and is experimentally shown to be of practical relevance for hard temporal numeric problems. Introduction Automated planning is the task of finding a course of actions to achieve a goal from an initial state given a model of the system specifying which actions are available, together with (i) their precondition, what needs to hold in order for an action to be applicable and (i) their effect, what needs to hold when such actions are applied. Temporal planning is the extension in which actions are assumed to last for some interval of time, and so we look for a plan that is schedulable too, i.e., actions need to be done in specific points over a potentially unbounded timeline, with conditions required to hold at the beginning, at the end and during the execution of the action. Temporal planning problems can be compactly represented in the PDDL 2.1 language (Fox and Long 2003). A number of solutions have been proposed to handle PDDL2.1 problems, ranging from forward heuristic search in the space of possible schedules (Coles et al. 2010; Benton et al. 2012; Valentini et al. 2020) to satisfiability-based bounded reductions (Cardellini and Giunchiglia 2025). Among these approaches, compilation-based techniques are particularly appealing, as they allow temporal reasoning to be delegated to more expressive or better-supported target languages. Building on this line of work, this paper studies a compilation method that transforms a temporal planning problem specified in PDDL2.1 into an equivalent formulation in PDDL+. PDDL+ is yet another extension of classical planning which provides a different take to the problem of representing timed and hybrid systems. Instead of having durative actions, in PDDL+ a system over time is modeled through a combination of processes, events and instantaneous actions. Processes model the system evolving over time through differential equations, and events dictate what needs to change instantaneously if some condition is satisfied. Our compilation is rooted in the known observation that a durative action can be compiled into a combination of processes and events/actions (Fox and Long 2006), but we contribute the first fully spelled-out formal account to approach this problem rigorously. Moreover, the expressiveness of PDDL+ makes it easier to extend the input problems with a number of features that are not well supported by many temporal planners, such as numeric state variables, delayed effects and timed initial literals. Our compilation provides a comprehensive account for the full semantics of temporal planning resulting in an encoding that is sound, complete and polynomial on the size of the input problem. To shed some light on the practical benefit of this compilation we run an experimental campaign on a number of temporal numeric domains. Surprisingly, PDDL+ planners prove competitive, and often superior, to state-of-the-art temporal planners on rich numeric temporal problems. This may inform a more precise understanding of the core difficulties in temporal planning. Background We start by defining a temporal planning problem, adapting the PDDL 2.1 level 3 language (Fox and Long 2003)222We speculate that our compilation could be easily adapted to PDDL 2.1 level 4, hence including continuous change, but for the sake of simplicity we restrict the paper presentation to level 3. . Definition 1. A temporal planning problem tP^t is a tuple (F,X,I,Ai,Ad,G)(F,X,I,A^i,A^d,G) where: • F is a finite set of boolean fluents (predicates); • X is a finite set of numeric rational fluents; • I:F∪X→∪ℚI:F∪ X is the initial state, assigning each fluent to its initial value; • AiA^i is a finite set of instantaneous actions; each a∈Aia∈ A^i has a precondition formula apre_a over F∪XF∪ X and a set of boolean and numeric effects aeff_a of the form f:=⊥,⊤f :=\ , \ if f∈Ff∈ F or f←ef← e with ←∈:=,+=←∈\ :=, +=\ and e being a numeric expression over X, if f∈Xf∈ X. • AdA^d is a finite set of durative actions; each a∈Ada∈ A^d has lower and upper duration bounds la≤ua∈ℚ>0l_a≤ u_a _>0, a pair of starting a⊢a_ and ending a⊣a_ instantaneous “snap” actions, and an overall invariant formula γa _a over F∪XF∪ X. • G is the goal expressed as a formula over F∪XF∪ X. We partition AdA^d into Afix⊔AvarA^fix A^var, with Afix=a∈Ad∣la=uaA^fix=\a∈ A^d l_a=u_a\ being the set of durative actions with a fixed duration (therefore, AvarA^var is the set of durative actions with variable duration). Moreover, given a (snap) instantaneous action a, we write: Va=def(a)V^pre_a =vars(pre_a) for the set of fluents occurring in apre_a; Var=defVa∪⋃(f←e)∈a(e)V^r_a =V^pre_a∪ _(f← e) _avars(e) for the fluents read by the precondition or by any effect of a; Va:==def⋃(f:=e)∈afV :=_a = _(f :=e) _a\f\ for the assigned fluents; Va+==def⋃(f+=e)∈afV +=_a = _(f +=e) _a\f\ for the increased fluents; and Vaw=defVa:=∪Va+=V^w_a =V :=_a∪ V +=_a for the effected (written) fluents. Definition 2. A temporal plan πtπ^tis a finite set of triples of the form (t,a,d)(t,a,d), where t∈ℚ≥0t _≥ 0 is the starting time, a∈Ai∪Ada∈ A^i∪ A^d is the action to execute and d∈ℚ≥0d _≥ 0 is the action duration, s.t. la≤d≤ual_a≤ d≤ u_a if a∈Ada∈ A^d, and d=0d=0 if a∈Aia∈ A^i. We present an adaptation of the non-self-overlapping semantics by Gigante et al. (2022). A state is a total assignment of values to fluents; given a formula e defined over F∪XF∪ X, we write s(e)s(e) for the value of e in s obtained by substitution and constant propagation. Given a state s and an instantaneous action a, a is applicable in s if s(a)s(pre_a) is true (s⊧as _a) and the successor state s′=defa(s)s =a(s) is such that s′(f)=s(e)s (f)=s(e) if f:=e∈af :=e _a, s′(f)=s(f)+s(e)s (f)=s(f)+s(e) if f+=e∈af +=e _a, s′(f)=s(f)s (f)=s(f) otherwise. Let πt=def(t1,a1,d1),…,(tn,an,dn)π^t =\(t_1,a_1,d_1),…,(t_n,a_n,d_n)\ be a temporal plan for a planning problem t=(F,X,I,Ai,Ad,G)P^t=(F,X,I,A^i,A^d,G). Let HπtH^π^t be the set of timed (snap) actions for πtπ^t defined as (ti,ai)∣ai∈Ai∪(ti,ai,⊢)∣ai∈Ad∪(ti+di,ai,⊣)∣ai∈Ad\(t_i,a_i) a_i∈ A^i\∪\(t_i,a_i, ) a_i∈ A^d\∪\(t_i+d_i,a_i, ) a_i∈ A^d\. Let t0s,t1s,…,tm−1s∈ℚt^s_0,t^s_1,…,t^s_m-1 be the times appearing in HπtH^π^t (that is, ∃(t,a)∈Hπt.tjs=t∃(t,a)∈ H^π^t.t^s_j=t) ordered s.t. tjs<tj+1st^s_j<t^s_j+1; moreover, we add an arbitrary final time: tms=deftm−1s+1t^s_m =t^s_m-1+1. We define the set of “happenings” at step j as the set Hj=a∣tjs=t and (a,t)∈HπtH_j=\a t^s_j=t and (a,t)∈ H^π^t\. We can now give the semantics of temporal planning: the plan πtπ^t is valid if there exists a sequence of states s0,…,sms_0,…,s_m such that: 1. s0=Is_0=I and sm⊧Gs_m G (initial state and goal constraints), 2. for each 0≤j<m0≤ j<m and each a∈Hja _j, sj⊧as_j _a (all conditions for happenings at step j are satisfied); 3. for each 0≤j<m0≤ j<m, sj+1=b0(b1(⋯bk(sj)))s_j+1=b_0(b_1(·s b_k(s_j))), with Hj=b0,b1,…,bkH_j=\b_0,b_1,…,b_k\ for an arbitrary ordering (a state is the result of applying all the effects of all happenings); 4. for each 1≤i≤n1≤ i≤ n with ai∈Ada_i∈ A^d, if tjs=tit^s_j=t_i and tks=ti+dit^s_k=t_i+d_i, sw⊧γ(ai)s_w γ(a_i) for all j<w≤kj<w≤ k (overall conditions); 5. for each 0≤j<m0≤ j<m and each pair of instantaneous actions a≠b∈Hja =b _j, Var∩Vbw=Vbr∩Vaw=Va:=∩Vb:==∅V^r_a∩ V^w_b=V^r_b∩ V^w_a=V :=_a∩ V :=_b= (no interfering actions at the same time); 6. For all j≠k∈[1,n]j =k∈[1,n], tj>tk+dkt_j>t_k+d_k or tk>tj+djt_k>t_j+d_j (no-self-overlapping constraint). The target of our compilation is a PDDL+ (Fox and Long 2006) problem, formalized below. Definition 3. A PDDL+ problem is modeled as a tuple (F,X,I,G,A,E,P)(F,X,I,G,A,E,P) where: • F is a finite set of boolean fluents (predicates); • X is a finite set of numeric rational fluents; • I:F∪X→∪ℚI:F∪ X is the initial state, assigning each fluent to its initial value; • G is a goal condition expressed as a formula over F∪XF∪ X. • A, E are two finite sets of instantaneous actions and events resp.; each action/event x is defined by a set of preconditions xpre_x and a set of effects xeff_x. • P is a set of processes each p∈Pp∈ P having a precondition formula ppre_p over F∪XF∪ X and a set of effects peff_p of the form dtf+=e ddtf +=e with f∈Xf∈ X and e is a formula over X. Definition 4. A PDDL+ plan is a pair (π+,te)(π^+,t_e), where te∈ℚt_e is the plan makespan and π+π^+ is a finite sequence of pairs (ti,ai)(t_i,a_i) with ti≤te∈ℚ≥0t_i≤ t_e _≥ 0. Following Percassi et al. (2025), we assume a discretization time quantum δ∈ℚδ . A plan is well-formed if tet_e and all times tit_i are multiples of δ. A plan (π+,te)(π^+,t_e) is valid for a PDDL+ problem (F,X,I,G,A,E,P)(F,X,I,G,A,E,P) if there exists a sequence of states (similarly to the temporal case) s¯0,…,s¯m¯ s_0,…, s_ m with s¯0=I s_0=I and m¯=teδ m= t_eδ defined as follows. Let t¯js=δ⋅j t^s_j=δ· j be the time of state s¯j s_j and let the sequence of “action happenings” HjaH_j^a at step j be the sequence of actions from π+π^+ happening at time t¯js t^s_j; i.e., Hja=(ai,…,ai+k)H_j^a=(a_i,…,a_i+k) where (ti,ai),…,(ti+k,ai+k)(t_i,a_i),…,(t_i+k,a_i+k) is a maximal sub-sequence of π+π^+ with ti=⋯=ti+k=t¯jst_i=·s=t_i+k= t^s_j. Given a state s¯ s, we inherit the definitions of action applicability from above and generalize them for events in the obvious way. We define the event completion of s¯ s (written s¯→ s^→) as the fixed-point state reached after applying any applicable event in s¯ s and then any other applicable event in the resulting state, until no event is applicable anymore. For each j, we define the final state at step j as s¯jend=defb0(b1(⋯(bk(s¯j→)→)→)→ s^end_j =b_0(b_1(·s(b_k( s_j^→)^→)^→)^→ with Hja=(b0,b1,…,bk)H_j^a=(b_0,b_1,…,b_k) (intuitively, we apply all actions ordered by π+π^+ to the event completion of s¯j s_j and after every action we perform an event completion). We can now define the state transition: for every 0≤j<m¯0≤ j< m, we define s¯j+1(f)=s¯jend(f) s_j+1(f)= s^end_j(f) for every f∈Ff∈ F, and for every x∈Xx∈ X: s¯j+1(x)=s¯jend(x)+∑p∈P,(x+=e)∈ps¯jend⊧ps¯jend(e)⋅δ s_j+1(x)= s^end_j(x)+ _ subarraycp∈ P,\>(x +=e) _p\\ s^end_j _p subarray s^end_j(e)·δ Intuitively, we set every predicate to its final value at step j and compute the value of the numeric fluents after some passage of time by applying a discretized step aggregating the contribution of every active process. Finally, the plan is valid if s¯m⊧G s_m G, and each ai∈Hjaa_i _j^a is applicable in s¯j→ s_j^→. Compile Temporal Planning into PDDL+ In this section, we formally define our compilation from temporal planning into PDDL+. Intuitively, we formulate a PDDL+ problem where each durative action is emulated by a triplet (action, process, event) for fixed duration actions, and (action, process, action) for flexible duration ones. To only encode valid temporal plans, we need all temporal points from 1-6 (see previous section) to hold. We introduce a number of auxiliary boolean and numeric state variables, and use them to constrain actions properly, and propagate processes and events when necessary. A key step is the introduction of lock preconditions-effects, a machinery employed to prevent interfering actions to happen at the same time. Below, we formalize the encoding. In the following, we assume a temporal planning problem Π=def(F,X,I,Ai,Ad,G) =(F,X,I,A^i,A^d,G) is given, and we define the compiled PDDL+ problem Π¯=def(F¯,X¯,I¯,G¯,A¯,E¯,P¯) =( F, X, I, G, A, E, P). Let FX=defF∪XFX =F∪ X; we start with the fluents definition. F¯ F =defF∪ra∣a∈Ad∪rlf,alf,ilf∣f∈FX =F∪\ok\∪\r_a a∈ A^d\∪\rl_f,al_f,il_f f∈ FX\ X¯ X =defX∪,∪ca∣a∈Ad =X∪\oc,gc\∪\c_a a∈ A^d\ In addition to the fluents of Π , we add a new ok predicate that will be required by every action in the compiled model and by the new goal, this will be used to “abort” a plan that violated some constraints. We also add two numeric fluents, oc and gc, to count the number of actions started but not terminated and to distinguish the time in consecutive steps, respectively. Moreover, for every durative action a, we add a predicate rar_a, which will be kept to true while a durative action is running, and a numeric fluent cac_a which will be used to measure the time since the start of a. Finally, for every fluent f we define three “lock” predicates, rlfrl_f, alfal_f and ilfil_f, that will be used to enforce mutual exclusion constraints. The initial state and goal condition are defined by simply augmenting the original initial state and goal as follows. I¯ I =def=⊤,==0∪ra=⊥,ca=0∣a∈Ad∪ =\ok\!=\! ,oc\!=\!gc\!=\!0\∪\r_a\!=\! ,c_a\!=\!0 a∈ A^d\\>∪ rlf=alf=ilf=⊤∣f∈FX∪I \>\>\rl_f\!=\!al_f\!=\!il_f\!=\! f∈ FX\∪ I G¯ G =defG∧=0 =G =0 Before defining the rest of the compilation, the following definition provides the key machinery for encoding the non-interference constraints. Definition 5. Given an instantaneous action a, we define the lock precondition λa _a as: ⋀f∈Var(alf∧ilf)∧⋀f∈Va:=(rlf∧ilf∧alf)∧⋀f∈Va+=(rlf∧alf). _f∈ V^r_a\!(al_f il_f) \!\!\! _f∈ V :=_a\!\!(rl_f il_f al_f) \!\!\! _f∈ V +=_a\!\!\!(rl_f al_f). Moreover, we define the lock effects LaL_a as the set: alf:=⊥∣f∈Va:=∪ilf:=⊥∣f∈Va+=∪ \al_f := f∈ V :=_a\∪\il_f := f∈ V +=_a\∪ rlf:=⊥∣f∈Var. \rl_f := f∈ V^r_a\. Intuitively, we will augment every happening associated with an instantaneous action or with the start or end of a durative action with its lock precondition and effects; if all locks are reset to ⊤ at every time step (see e¯↯ e below), no pair of interfering happenings can appear at the same time. We now define the core of the translation starting from actions: we introduce a PDDL+ action for every instantaneous action, start of durative action and termination of non-fixed durative action in the original problem: A¯=a¯i∣a∈Ai∪a¯⊢∣a∈Ad∪a¯⊣∣a∈Avar A=\ a^i a∈ A^i\∪\ a a∈ A^d\∪\ a a∈ A^var\ defined as follows. a¯i=def(a∧λa,a∪La) a^i =(pre_a _a,eff_a∪L_a) Instantaneous actions are simply augmented with the ok precondition (common to all other actions and events in the compilation) and with the lock preconditions and effects. Durative actions are split into their starting and ending timepoints; fixed-duration actions will be terminated by an event (e¯a⊣ e _a defined below), while variable-duration actions are terminated by the a¯⊣ a actions. a¯⊢=def( a =( a⊢∧λa⊢∧¬ra, _a_ _a_ r_a, a⊢∪La⊢∪ra:=⊤,ca:=0,+=1) _a_ ∪L_a_ ∪\r_a := ,c_a :=0,oc +=1\) The starting of every durative action a corresponds to the a⊢a_ snap action, we add the ¬ra r_a precondition to enforce non-self-overlapping and we set rar_a to true, we reset the clock cac_a because we are just starting the action, and we increase oc to signal that a new action started but has not finished yet. a¯⊣=def( a =( a⊣∧ra∧la≤ca≤ua∧λa⊣, _a_ r_a l_a≤ c_a≤ u_a _a_ , a⊣∪La⊣∪ra:=⊥,+=−1) _a_ ∪L_a_ ∪\r_a := ,oc +=-1\) To terminate a non-fixed durative action a, we require rar_a and that the duration constraint is satisfied with la≤ca≤ual_a≤ c_a≤ u_a; we then reset rar_a to false and decrement oc. We have two types of very simple processes in our compilation that are used to keep track of the time passing while an action is running and to continuously increase gc for the mutex construction we will describe below. The compilation processes are then P¯=p¯a∣a∈Ad∪p¯↯ P=\ p_a a∈ A^d\∪\ p \ with: p¯a=def(∧ra,dtca=1)p¯↯=def(,dt=1) p_a =(ok r_a,\ ddtc_a=1\) p =(ok,\ ddtgc=1\) In the compilation, events serve several purposes, each encoded in a different subset: E¯=defE¯↔∪E¯⊣fix∪E¯expire∪e¯↯ E = E ∪ E^fix_ ∪ E^expire∪\ e \. E¯⊣fix=defe¯a⊣∣a∈Afix E^fix_ =\ e_a a∈ A^fix\ encodes the termination of fixed-duration actions, E¯↔=defe¯a↔∣a∈Ad E =\ e_a a∈ A^d\ ensures that overall conditions of durative actions are not violated, E¯expire E^expire ensure that no plan prefix has variable duration actions that are not terminated within the duration upper bound and e¯↯ e resets all the lock variables immediately after a time-elapse. e¯a⊣=def( e_a =( a⊣∧ra∧ca=la∧λa⊣∧=0, _a_ r_a c_a=l_a _a_ =0, a⊣∪La⊣∪ra:=⊥,+=−1) _a_ ∪L_a_ ∪\r_a := ,oc +=-1\) The termination of fixed-duration actions is analogous to the variable duration ones, but is an event scheduled at the fixed duration (la=ual_a=u_a), measured by cac_a. We also require gc to be 0 to execute this event after e¯↯ e , as explained below. e¯a↔=def(∧ra∧¬γa,:=⊥) e_a =(ok r_a _a,\ok := \) Overall conditions are enforced through the ok predicate: if we reach a state where action a is running (rar_a is true) and its overall conditions are not satisfied, we set ok to false, making this prefix invalid, because ok can only be falsified, and never restored to true. Similarly, if a durative action with variable duration is not terminated within its duration upper bound (ra∧ca>ur_a c_a>u), we immediately set ok to false. (This is not strictly needed for correctness, as gc would never return to 0, but is useful for performance.) E¯expire=def E^expire =\ (∧ra∧ca>ua,:=⊥)∣a∈Avar (ok r_a c_a>u_a,\ok := \) a∈ A^var\ Finally, we have a single event that restores the locks to true whenever gc is positive as follows. e¯↯=def( e =( ∧>0,:=0∪ >0,\gc :=0\∪ rlx:=⊤,xwl:=⊤,ilx:=⊤∣x∈FX) \rl_x := ,x_wl := ,il_x := x∈ FX\) The idea of this “lock” construction is that in a certain time we start the chains of happenings with the event e¯↯ e that resets all the locks, then we can execute other actions or events, but every time we “read” a fluent f (either in a precondition or in the right-hand-side of an effect) we set rlfrl_f to false, every time we have an assignment or increment effect of f we set alfal_f or ilfil_f respectively to false. Thanks to the lock preconditions, we forbid reading a variable if it was previously (in the same “superdense” time) assigned or incremented, we forbid an assignment if it was previously assigned, increased or read, and we forbid increments if it was previously assigned or read. The whole trick is that gc will be continuously increased by a process, so in the subsequent times, the locks are automatically reset by the event e¯↯ e and the locks are released. This faithfully captures the semantics of non-interference we outlined for temporal planning. Given a plan (π¯+,te)( π^+,t_e) with π¯+=(t1,a1),…(tn,an) π^+=(t_1,a_1),…(t_n,a_n) for Π¯ , we define the temporal plan π~ π solving Π as: π~=def π = (t,a,0)∣(t,a¯i)∈π¯∪ \(t,a,0) (t, a^i)∈ π\∪ (t⊢,a,la)∣(t⊢,a⊢)∈π¯ and a∈Afix∪ \(t_ ,a,l_a) (t_ ,a )∈ π and a∈ A^fix\∪ (t⊢,a,t⊣−t⊢)∣(t⊢,a⊢),(t⊣,a⊣)∈π¯ and \(t_ ,a,t_ -t_ ) (t_ ,a ),(t_ ,a )∈ π and ∄t.t⊢<t′<t⊣,(t′,a⊢)∈π¯ ∃ t.t_ <t <t_ ,(t ,a )∈ π\ Additional intuition on the lock mechanism. The gc function is meant to keep track of a non zero passage of time, necessary to separate mutex actions. We highlight that >0gc>0 is true at the beginning of the sequence of happenings at any time t>0t>0. We recall that PDDL+ has a superdense model of time, so a fluent can change its value by means of contemporary happenings, without the time passing. In our construction, at each time t>0t>0 we start our sequence of contemporary happenings in a state where >0gc>0, because the process p¯↯ p increases it with a positive derivative (we chose 1 for simplicity, but any positive derivative would do); however, immediately at the second superdense step (at the same time) the event e¯↯ e triggers, resetting gc to 0. Visualizing the behavior of gcgc in the superdense time, we have the following: • (0,0)=0gc(0,0)=0, (0,1)=0gc(0,1)=0, …, (0,n0)=0gc(0,n_0)=0; • (δ,0)=δgc(δ,0)=δ, (δ,1)=0gc(δ,1)=0, …, (δ,n1)=0gc(δ,n_1)=0; • (2δ,0)=δgc(2δ,0)=δ, (2δ,1)=0gc(2δ,1)=0, …, (2δ,n2)=0gc(2δ,n_2)=0; • ⋯·s; • (t,0)=δgc(t,0)=δ, (t1)=0gc(t1)=0, …, (t,nt)=0gc(t,n_t)=0. Where (t,i)gc(t,i) indicates the value of gc at time t and superdense step i. Importantly, this construction motivates our choice of adopting a discrete time semantics for PDDL+. In fact, this construction works perfectly in discrete time (and is not very costly for the planner), but exhibits a Zeno behavior in continuous time, because the event e¯↯ e would trigger immediately after the previous happening imposing an infinite number of happenings in a finite amount of time. Finally, note that with an ϵε-separation semantics (Gigante et al. 2022), the system is essentially discrete, hence the construction will work. Below, we prove that the compilation is sound and complete. Indeed, if a plan (π¯+,te)( π^+,t_e) is found for Π¯ , so is π~ π for Π . This follows by proving that constraints 1-6 for the validity of a plan are all implied by the existence of a state sequence induced by (π¯+,te)( π^+,t_e). Completeness is more challenging: we prove that for every temporal plan, there exists a sufficiently small δ for which there is a corresponding valid PDDL+ plan for Π¯ . Finally, we highlight that the compilation is polynomial in size and the plan length is at most doubled. Theoretical Properties In this section, we formally prove the soundness and completeness of our compilation. Theorem 1 (Soundness). Let (π+¯,te)( π^+,t_e) be a valid plan for Π¯ , then π~ π is a valid plan for Π . Proof. Since (π+¯,te)( π^+,t_e) is a valid plan for a PDDL+ problem, let s¯0,…s¯m¯ s_0,… s_ m bet the states induced by the plan by the discrete semantics of PDDL+. We have to show that the six semantic conditions for π~ π outlined in the semantics explanation of temporal planning hold. First, we ensure the syntactical properties of π~ π. It is easy to see that every instantaneous action in the plan has a duration of 0 by definition; moreover, the duration dad_a of every durative action with fixed duration a∈Afixa∈ A^fix also trivially satisfies la≤da≤ual_a≤ d_a≤ u_a. For durative actions with non-fixed duration, we set the duration as the temporal distance between a consecutive pair of (a¯⊢,a¯⊢)( a , a ) in π+¯ π^+. This is guaranteed to be in the [la,ua][l_a,u_a] interval because: • a¯⊢ a requires ¬ra r_a and resets the counter cac_a to 0 and rar_a to true, while a¯⊢ a requires rar_a and la≤ca≤ual_a≤ c_a≤ u_a • The process pap_a starts when rar_a is set to true and increases cac_a with derivative 1 Hence, the temporal difference between a¯⊢ a and a¯⊢ a is equal to the value of cac_a in a¯⊢ a which is la≤ca≤ual_a≤ c_a≤ u_a by precondition. To prove the semantic conditions, let j¯=deftjsδ j = t^s_jδ and we define a sequence of states s0,…,sms_0,…,s_m defined as: sj=s¯j¯∣F∪Xs_j= s_ j F∪ X that is, the j-th temporal state is the PDDL+ state at step tjsδ t^s_jδ restricted to the original problem fluents. Note that this PDDL+ state exists because tjst^s_j is derived from times (or differences of times) in π¯+ π^+ which are integer multiples of δ by definition. Another preliminary consideration is that Hj=a⊢,b⊣∣a¯⊢,b¯⊣∈Hj¯a∪a⊣∣(t,a,la)∈π¯+,a∈Afix,tjs=t+laH_j=\a_ ,b_ a , b _ j^a\∪\a_ (t,a,l_a)∈ π^+,a∈ A^fix,t^s_j=t+l_a\. This is by definition of π~ π. We will now show that semantic conditions 1-6 hold for s0,…,sms_0,…,s_m. 1. s0=Is_0=I because also I⊆s¯0I s_0. Moreover, s0⊧Gs_0 G because tmsδ=m¯ t^s_mδ= m and s¯m¯⊧G¯ s_ m G and G¯→G G→ G. 2. For every j, the preconditions apre_a of all a∈Hja _j are trivially satisfied for the instantaneous actions, for all the starting snap actions and for a⊣a_ with a∈Avara∈ A^var, because apre_a is also part of the preconditions of the corresponding activities in A¯ A which are also in Hj¯aH_ j^a as noted above and thus true in s¯j¯ s_ j. The only case needing care is the termination of actions with fixed duration, which are encoded by means of the events e¯a⊣ e_a . It suffices to prove that for every a¯⊢∈Hk¯a a _ k^a with a∈Afixa∈ A^fix, there is an instance of event e¯a⊣ e_a guaranteed to be executable in sk¯+laδas_ k+ l_aδ^a, because this event also checks the preconditions of a. Suppose that one or more of these event instances is not applied, then the plan (π+¯,te)( π^+,t_e) cannot be valid for the PDDL+ semantics, because of the oc dynamics, which counts the difference in number of opening actions and closing actions or events. The only way to apply a closing action is paired with an opening, so if we skip a single instance of e¯a⊣ e_a , we will result in a final non-zero oc value. Moreover, such event must happen at step k¯+laδ k+ l_aδ because of the preconditions on cac_a (identical reasoning as per the variable action durations). 3. Comparing the two semantics, it is easy to see that for every j, s¯j¯end s_ j^end is computed analogously to sj+1s_j+1, noting again that ending events corresponding to ending snap actions in HjH_j must be executed in s¯j¯end s_ j^end. Hence, sj+1=s¯j+1¯∣F∪Xs_j+1= s_ j+1 F∪ X, because fluents in F∪XF∪ X are unaffected by processes. 4. Suppose, for the sake of contradiction, that there exists a state sw⊧̸γas_w _a with j<w≤kj<w≤ k and a starting in tjst^s_j and ending in tkst^s_k. Note that every PDDL+ state s¯i s_i with j¯<i≤k¯ j<i≤ k is such that s¯i(ra) s_i(r_a) is true because of the effects of the compiled snap actions as above. Hence, γa _a must be true in sws_w, otherwise ea↔e_a would trigger, making the plan invalid because of the :=⊥ok := effect that would make the goal unreachable. 5. Suppose, for the sake of contradiction, that there is a pair of actions a≠ba =b in HjH_j (for some j) violating the mutex constraint. Then, one of the following three cases must occur. • ∃f∈Var∩Vbw∃ f∈ V^r_a∩ V^w_b This is prevented by the preconditions and effects of the compiled actions or events corresponding to a and b (that we indicate with a¯ a and b¯ b). By corresponding we mean that if a is an instantaneous action, a¯=a¯i a= a^i; if a is a starting snap action, a¯=a¯⊢ a= a , if a is a ending snap action, either a¯=a¯⊣ a= a or a¯=e¯a⊣ a= e_a , and analogously for b. Now suppose a¯ a is before b¯ b in π¯+ π^+, rlfrl_f is required to be true by λb _b, but rlfrl_f is set to false by a¯ a, and cannot be set to true if not by letting time advance. If the order in π¯+ π^+ is reversed, both ilfil_f and alfal_f are required to be true by a¯ a, but either of them is set to false by the effects of b¯ b (because f is either assigned or incremented). Note that once alfal_f, ilfil_f or rlfrl_f is set to false, only e¯↯ e can reset them, but this cannot be done after either a¯ a or b¯ b are executed, because e¯↯ e requires gc to be positive, while both a¯ a and b¯ b require it to be 0 and only the process p¯↯ p can set gc to a positive value, but only in the subsequent step. (Practically, e¯↯ e is the first event of every step, because p¯↯ p resets to true its precondition when transitioning to anew step by letting time elapse). This leads to the contradiction. • ∃f∈Vbr∩Vaw∃ f∈ V^r_b∩ V^w_a This case is the symmetric of the previous one. • ∃f∈Va:=∩Vb:=∃ f∈ V :=_a∩ V :=_b Similarly to the previous case, the first happening sets alfal_f to false and both require it to be true, leading to the contradiction for the same reasoning as above. 6. Non self-overlapping is an immediate consequence of the rar_a dynamics: we forbid to start an action if rar_a is true and rar_a is kept true exactly during each action instance. ∎ Theorem 2 (Completeness). Let Π be a temporal planning problem admitting a valid plan πtπ^t, then there exists a δ under which there is a valid plan π¯ π for Π¯ . Proof. (Sketch) Let πt=(t1,a1),⋯,(tn,an)π^t=\(t_1,a_1),·s,(t_n,a_n)\ and let its induced sequence of states s0,…,sms_0,…,s_m with times t0s,…tmst^s_0,… t^s_m. We define the PDDL+ plan (π¯+,te)( π^+,t_e) as te=deftms+1t_e =t^s_m+1 and π¯+=def((tjs,h¯)∣h∈Hj,0≤j<m) π^+ =((t^s_j, h) h _j,0≤ j<m) with h¯=defa¯iif h∈Aia¯⊢if h=a⊢a¯⊣if h=a⊣ and a∈Avar h = cases a^i& if h∈ A^i\\ a & if h=a_ \\ a & if h=a_ and a∈ A^var cases (we assume π¯+ π^+ is sorted according to the time as per the semantics, and the order of simultaneous elements is arbitrary). Let δ be a rational such that for any 0≤j≤m0≤ j≤ m: tjsδ∈ℤ t^s_jδ (For example, we can define δ as the GCD of all numerators of the tjst^s_j’s divided by the LCM of their denominators, since we model timings as rational numbers. However, any choice of δ that makes the division yield an integer would work.) Given a time t∈ℚ≥0t _≥ 0, we define the index before , written ib(t)ib(t), as the largest j s.t. tjs≤t^s_j≤ t. We prove that (π¯+,te)( π^+,t_e) is a valid plan for Π¯ when using δ as discretization step. The plan is obviously well-formed, because each time is a multiple of δ. We define a sequence of states s¯0…,s¯m¯ s_0…, s_ m with m¯=defteδ m = t_eδ, where s¯0=I¯ s_0= I and for all 0<j<m¯0<j< m we define s¯j(x) s_j(x) per cases. • sib(jδ)(x)s_ib(jδ)(x) if x∈F∪Xx∈ F∪ X: original fluents values are aligned with the temporal trace. The j-th PDDL+ state corresponds to time δjδ j in the temporal trace. • s¯j()=def⊤ s_j(ok) = : ok is always true. • s¯j()=defδ s_j(gc) =δ: due to p¯↯ p , at the beginning of each step gc is set to δ, then e¯↯ e immediately sets it to 0. • The rar_a predicate is set to true while an action is running: s¯j(ra)=def⊤if ∃i.ti<jδ≤ti+di and ai=a⊥otherwise s_j(r_a) = cases & if ∃ i.t_i<jδ≤ t_i+d_i and a_i=a\\ & otherwise cases • Similarly, the oc fluent is set to the number of actions opened and not yet closed before time δjδ j: s¯j()=def∑k=0ib(δj)−1|a⊢∈Hk|−|a⊣∈Hk| s_j(oc) = _k=0^ib(δ j)-1|\a_ _k\|-|\a_ _k\| • The cac_a fluent evolves according to p¯a p_a, fluent, so we simply define: s¯j(ca)=defs¯j−1(ca)+δif s¯j(ra)s¯j−1(ca)otherwise s_j(c_a) = cases s_j-1(c_a)+δ& if s_j(r_a)\\ s_j-1(c_a)& otherwise cases • The lock predicates alfal_f, ilfil_f and rlfrl_f are set to false when there is an happening at index k that assigns, increases or reads f with tks=δjt^s_k=δ j: s¯j(alf)=def⊥if ∃k,a s.t. tks=δj,a∈Hk and f∈Va:=⊤otherwise s_j(al_f) = cases & if $∃ k,a$ s.t. t^s_k=δ j,a _k and f∈ V :=_a\\ & otherwise cases s¯j(ilf)=def⊥if ∃k,a s.t. tks=δj,a∈Hk and f∈Va+=⊤otherwise s_j(il_f) = cases & if $∃ k,a$ s.t. t^s_k=δ j,a _k and f∈ V +=_a\\ & otherwise cases s¯j(rlf)=def⊥if ∃k,a s.t. tks=δj,a∈Hk and f∈Var⊤otherwise s_j(rl_f) = cases & if $∃ k,a$ s.t. t^s_k=δ j,a _k and f∈ V^r_a\\ & otherwise cases The sequence of states s¯0…,s¯m¯ s_0…, s_ m constructed in this way satisfies all the PDDL+ semantic constraints for Π¯ . ∎ Domain ENHSP ENHSP ARIES OPTIC TAMER TFLAP Next- Patty LG WA FLAP MatchCellar 7 12 20 9 7 20 2 4 MaJSP 20 19 18 N/A 20 N/A N/A N/A T-Plant-Wat 20 16 15 20 12 0 0 13 T-Sailing 11 20 6 7 3 2 7 2 Total (80) 58 67 59 36 42 22 9 19 Table 1: Coverage analysis domain by domain, planner by planner. Bold for best, N/A for Not Applicable. Figure 1: Cactus (survival) plot (left) and run-time scatter plot for the planners with highest coverage (right). Experimental Evaluation We experimented with our compilation over a selection of temporal numeric domains. We focused our attention on problems requiring intertwined reasoning between numeric and temporal aspects, where the concurrency of the durative actions is necessary to solve the instances. As representative of temporally interesting domains, we took the classic Matchcellar IPC domain and MAJSP from (Micheli and Scala 2019). Then we introduce two new domains, T-Sailing, and T-Plant-Watering. T-Sailing extends Sailing (Scala et al. 2016) by requiring a boat not only to rescue the persons in some specific area of the cartesian space, but also to do so under a specific deadline. If the boat arrives too late, the person cannot be saved anymore. T-Plant-Watering extends Plant-Watering (Francès and Geffner 2015) by imposing temporal constraints between pouring and opening the tap. The task becomes a collaborative activity involving two distinct agents: one carries the pump used to water the plants, but can begin watering only when the other agent simultaneously performs the task of opening the tap. All benchmarks are available at https://github.com/hstairs/time2processes. For each domain we have 20 instances, mostly scaling with the number of objects. Our analysis focuses on coverage (number of solved instances per domain) and run-time. ENHSP is used as the PDDL+ planner, run with two different engines, i.e., lazy greedy best-first search (ENHSP-LG) and WA∗ (ENHSP-WA), both with the hmrph^mrp heuristic (Scala et al. 2020). In LG, we used focus search as in Scala and Bonassi (2025); in WA∗ we use w=4w=4. The compiler is implemented within the unified_planning library (Micheli et al. 2025), and also supports delayed effects and timed initial literals; roughly, we emulate them with events triggered at the proper time (we omit the formal description due to space constraints). We compare the compilation with native state-of-the-art temporal planners, i.e., ARIES (Bit-Monnot 2023), NextFLAP and TFLAP (Sapena et al. 2024), OPTIC (Benton et al. 2012), TAMER (Valentini et al. 2020) and Patty (Cardellini and Giunchiglia 2025). Experiments were run on an AMD EPYC 7413; 1800s timeout, 20 GB memory limit. Results. Figure 1 shows per-domain coverage. ENHSP-WA got the highest coverage. (Some planners do not support MAJSP for lack of delayed effects support.) For purely temporal domains, temporal planners are faster, yet both ENHSP engines proved competitive, especially in MAJSP. Over temporal numeric domains, ENHSP-WA provided superior performance overall. Figure 1 (right) shows a pairwise analysis on run-time for the two best performing planners ARIES and ENHSP-WA. ARIES scales better in Matchcellar, ENHSP-WA better over the temporal numeric domains, highlighting a great deal of complementarity. Finally, Figure 1 (left) shows the number of instances solved over time, confirming the strength of our compilation. Conclusion In this paper we presented a compilation from PDDL 2.1 level 3 into PDDL+, proving its soundness and completeness. It was commonly known that PDDL+ could express durative actions, but in thi spaper we provide the first formal account of this fact, providing mechanisms to deal with the subtleties of the PDDL semantics. In particular, we provide a mechanism to faithfully impose durative conditions and the “no-moving-target rule” presented in the PDDL 2.1 paper (Fox and Long 2003). Our compilation is not only of theoretical interest, but it is also shown to be useful on complex temporal numeric planning problems. As future work, we would like to extend the compilation to PDDL 2.1. level 4, hence including continuous change. Moreover, we would like to study an alternative compilation targeting PDDL+ with a continuous time semantics. Acknowledgments Andrea Micheli and Alessandro Valentini have been partially supported by the STEP-RL project funded by the European Research Council under GA n. 101115870. Enrico Scala has been supported by the Italian Ministry of University and Research within the PRIMA 2024 programme project ”Optimizing Water Resources in Coastal Areas using Artificial Intelligence” (AI4WATER – D53C25000510006) References J. Benton, A. J. Coles, and A. Coles (2012) Temporal planning with preferences and time-dependent continuous costs. In Proceedings International Conference on Automated Planning and Scheduling, ICAPS 2012, Cited by: Introduction, Experimental Evaluation. A. Bit-Monnot (2023) Enhancing hybrid CP-SAT search for disjunctive scheduling. In ECAI 2023 - 26th European Conference on Artificial Intelligence, K. Gal, A. Nowé, G. J. Nalepa, R. Fairstein, and R. Radulescu (Eds.), p. 255–262. External Links: Link, Document Cited by: Experimental Evaluation. M. Cardellini and E. Giunchiglia (2025) Temporal numeric planning with patterns. In AAAI-25 Conference on Artificial Intelligence, p. 26481–26489. External Links: Link, Document Cited by: Introduction, Experimental Evaluation. A. J. Coles, A. Coles, M. Fox, and D. Long (2010) Forward-chaining partial-order planning. In Proceedings International Conference on Automated Planning and Scheduling, ICAPS 2010, Cited by: Introduction. M. Fox and D. Long (2003) PDDL2.1: an extension to PDDL for expressing temporal planning domains. Journal of artificial intelligence research. Cited by: Introduction, Background, Conclusion. M. Fox and D. Long (2006) Modelling mixed discrete-continuous domains for planning. Journal of Artificial Intelligence Research. Cited by: Introduction, Background. G. Francès and H. Geffner (2015) Modeling and computation in planning: better heuristics from more expressive languages. In Proceedings of the Twenty-Fifth International Conference on Automated Planning and Scheduling, ICAPS 2015, R. I. Brafman, C. Domshlak, P. Haslum, and S. Zilberstein (Eds.), p. 70–78. External Links: Link Cited by: Experimental Evaluation. N. Gigante, A. Micheli, A. Montanari, and E. Scala (2022) Decidability and complexity of action-based temporal planning over dense time. Artif. Intell. 307, p. 103686. External Links: Link, Document Cited by: Background, Additional intuition on the lock mechanism.. A. Micheli, A. Bit-Monnot, G. Röger, E. Scala, A. Valentini, L. Framba, A. Rovetta, A. Trapasso, L. Bonassi, A. E. Gerevini, L. Iocchi, F. Ingrand, U. Köckemann, F. Patrizi, A. Saetti, I. Serina, and S. Stock (2025) Unified planning: modeling, manipulating and solving AI planning problems in python. SoftwareX 29, p. 102012. External Links: Link, Document Cited by: Experimental Evaluation. A. Micheli and E. Scala (2019) Temporal planning with temporal metric trajectory constraints. In The Thirty-Third AAAI Conference on Artificial Intelligence, AAAI 2019, p. 7675–7682. External Links: Link, Document Cited by: Experimental Evaluation. F. Percassi, E. Scala, and M. Vallati (2025) On the Notion of Plan Quality for PDDL+. In Proceedings of the International Conference on Automated Planning and Scheduling, Vol. 35, p. 102–111. External Links: Link, Document Cited by: Background. Ó. Sapena, E. Onaindia, and E. Marzal (2024) A hybrid approach for expressive numeric and temporal planning with control parameters. Expert Syst. Appl. 242, p. 122820. External Links: Link, Document Cited by: Experimental Evaluation. E. Scala and L. Bonassi (2025) On using lazy greedy best-first search with subgoaling relaxation in numeric planning problems. In Proceedings International Conference on Automated Planning and Scheduling, ICAPS 2025, p. 245 – 249. External Links: Document Cited by: Experimental Evaluation. E. Scala, P. Haslum, and S. Thiébaux (2016) Heuristics for numeric planning via subgoaling. In Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI 2016, S. Kambhampati (Ed.), p. 3228–3234. External Links: Link Cited by: Experimental Evaluation. E. Scala, A. Saetti, I. Serina, and A. E. Gerevini (2020) Search-guidance mechanisms for numeric planning through subgoaling relaxation. In Proceedings International Conference on Automated Planning and Scheduling, ICAPS 2020, p. 226–234. Cited by: Experimental Evaluation. A. Valentini, A. Micheli, and A. Cimatti (2020) Temporal planning with intermediate conditions and effects. In AAAI-20 Conference on Artificial Intelligence, Cited by: Introduction, Experimental Evaluation.