Title: Zero-Shot Trajectory Planning for Signal Temporal Logic Tasks
Venue: NeurIPS 2025
Accepted: yes
Keywords: signal temporal logic

diffusion model

trajectory planning
Abstract: Signal Temporal Logic (STL) is a powerful specification language for describing complex temporal behaviors of continuous signals, making it well-suited for high-level robotic task descriptions. However, generating executable plans for STL tasks is challenging, as it requires consideration of the coupling between the task specification and the system dynamics. Existing approaches either follow a model-based setting that explicitly requires knowledge of the system dynamics or adopt a task-oriented data-driven approach to learn plans for specific tasks. In this work, we address the problem of generating executable STL plans for systems with unknown dynamics. We propose a  hierarchical planning framework that enables zero-shot generalization to new STL tasks by leveraging only task-agnostic trajectory data during offline training. The framework consists of three key components: (i) decomposing the STL specification into several progresses and time constraints, (ii) searching for timed waypoints that satisfy all progresses under time constraints, and (iii) generating trajectory segments using a pre-trained diffusion model and stitching them into complete trajectories. We formally prove that our method guarantees STL satisfaction, and simulation results demonstrate its effectiveness in generating dynamically feasible trajectories across diverse long-horizon STL tasks. Project Page: https://cps-sjtu.github.io/Zero-Shot-STL/

Zero-Shot Trajectory Planning for Signal Temporal Logic Tasks

Abstract

Signal Temporal Logic (STL) is a powerful specification language for describing complex temporal behaviors of continuous signals, making it well-suited for highlevel robotic task descriptions. However, generating executable plans for STL tasks is challenging, as it requires consideration of the coupling between the task specification and the system dynamics. Existing approaches either follow a modelbased setting that explicitly requires knowledge of the system dynamics or adopt a task-oriented data-driven approach to learn plans for specific tasks. In this work, we address the problem of generating executable STL plans for systems with unknown dynamics. We propose a hierarchical planning framework that enables zero-shot generalization to new STL tasks by leveraging only task-agnostic trajectory data during offline training. The framework consists of three key components: (i) decomposing the STL specification into several progresses and time constraints, (ii) searching for timed waypoints that satisfy all progresses under time constraints, and (iii) generating trajectory segments using a pre-trained diffusion model and stitching them into complete trajectories. We formally prove that our method guarantees STL satisfaction, and simulation results demonstrate its effectiveness in generating dynamically feasible trajectories across diverse long-horizon STL tasks. Project Page: https://cps-sjtu.github.io/Zero-Shot-STL/

1 Introduction

Signal Temporal Logic (STL) is a formal specification language used to describe the temporal behavior of continuous signals. It has become widely adopted for specifying high-level robotic behaviors due to its expressiveness and the availability of both Boolean and quantitative evaluation measures. Controlling robots under STL task constraints, however, is a challenging problem, as it requires balancing both the satisfaction of the task and the feasibility of the system dynamics. In cases where the environment and system dynamics are fully known, several representative methods have been developed, including optimization-based approaches [1, 2, 3], gradient-based techniques [4, 5], and sampling-based methods [6]. However, these methods are often difficult to apply in practical scenarios, where the system dynamics and environment are either unknown or difficult to model.

To address the challenge of unknown dynamics, several learning-based approaches have been proposed. One typical method is reinforcement learning (RL) [7, 8, 9, 10, 11, 12], where an appropriate reward function is designed to approximate the satisfaction of the STL task. However, these methods

often struggle with long-horizon STL tasks and lack generalization capabilities across different tasks. Another approach involves first learning a system model and then integrating it with model-based planning methods. For example, in [13], the authors trained a neural network to approximate the system dynamics and combined it with an optimization-based approach. However, this method is limited to simple short-horizon STL tasks due to its high computational cost. In [14], the authors used goal-conditioned RL to train multiple goal-conditioned policies, referred to as 'skills," to accomplish specific objectives. They then applied a search algorithm to determine the optimal sequence of 'skills" needed to satisfy the given STL tasks. While this approach enables a certain degree of task generalizations, these tasks must be based on pre-defined objectives associated with the skills.

More recently, generative models, such as diffusion models [15], have emerged as a new approach for generating trajectories for systems with unknown dynamics [16, 17, 18, 19, 20], gaining popularity across various applications. Compared to traditional model-based reinforcement learning methods, these generative approaches are better suited for long-horizon decision-making and offer greater test-time flexibility [16], making them particularly effective for complex tasks. For example, for finite Linear Temporal Logic (LTL f ) tasks, [21] introduced a classifier-based guidance approach to steer the sampling of diffusion models, ensuring that generated trajectories satisfy LTL f requirements. Similarly, [22] proposed a hierarchical framework that decomposes co-safe LTL tasks into subtasks using hierarchical reinforcement learning. This framework employs a diffusion model with a determinant-based sampling strategy to generate diverse low-level trajectories, improving both planning success rates and task generalization.

In the context of STL trajectory planning, the use of generative models has also been explored recently. For example, [23] proposed a classifier-based guidance approach that leverages robustness gradients to guide diffusion model sampling, enabling the generation of vehicle trajectories that adhere to traffic rules specified by STL. Building on this, [24] introduced a data augmentation method to enhance trajectory diversity and improve rule satisfaction rates. However, these approaches are still limited to simpler STL tasks, primarily due to the complexity of optimizing robustness values and the inherent trade-off between maximizing reward objectives and maintaining the feasibility of the generated trajectories [25].

In this paper, considering that trajectories satisfying complex STL specifications are typically difficult to collect in real-world scenarios, we focus on composing such trajectories by stitching together short trajectory chunks. The main challenge lies in determining appropriate ways to combine these chunks such that the resulting trajectory satisfies the global STL specification while maintaining dynamic consistency and feasibility. Inspired by recent advances in decomposition-based STL planning[26], we propose a novel hierarchical framework that integrates task decomposition, search algorithms, and generative models. First, complex STL tasks are decomposed into a set of time-aware reach-avoid progresses. Next, a search algorithm, heuristically guided by the trajectory data, is employed to allocate these progresses and generate a sequence of waypoints with corresponding timestamps. Finally, a pre-trained diffusion model, trained on task-agnostic data, is used to sequentially generate trajectory chunks that connect adjacent timed waypoints. All trajectory chunks are then stitched together to form the complete trajectory.

To the best of our knowledge, our algorithm is the first data-driven approach with zero-shot generalization capability for complex STL tasks. We have formally proven the soundness of our STL decomposition and planning algorithm, which guarantees that the generated trajectories satisfy any given STL specification. Furthermore, we empirically evaluate the dynamic consistency and feasibility of the planned trajectories through simulation experiments. Simulation results demonstrate that our method achieves a high execution success rate across diverse long-horizon STL tasks, where the diffusion-based baseline fails. Moreover, it outperforms both the diffusion-based baseline and a standard non-data-driven method in planning efficiency.

2 Preliminaries

2.1 System Model

We consider a discrete time system with unknown dynamics

where x t ∈ R n and a t ∈ R m are the state and the action at time instant t , respectively. Given an initial state x 0 and a sequence of actions a 0 a 1 . . . a T -1 , the resulting trajectory of the system is τ = x 0 a 0 x 1 a 1 . . . a T -1 x T , where T is the horizon. The signal of the trajectory is referred to as the state sequence s = x 0 x 1 . . . x T and we denote by s t = x t x t +1 . . . x T the sub-signal starting from time step t .

2.2 Signal Temporal Logic

We use signal temporal logic (STL) to describe the formal task imposed on the generated state sequence [27]. Specifically, we consider STL formula in the Positive Normal Form (PNF) [28] whose syntax is as follows:

where ⊤ is the true predicate and µ is an atomic predicate associated with an evaluation function h µ : R n → R , i.e., predicate µ is true at state x t iff h µ ( x t ) ≥ 0 . Furthermore, ∧ and ∨ are logic operators 'conjunction" and 'disjunction", respectively; U [ a,b ] , F [ a,b ] and G [ a,b ] are temporal operators 'until", 'eventually" and 'always", respectively; [ a, b ] is a time interval such that a, b ∈ Z , 0 ≤ a ≤ b < ∞ . Note that, negation is not used in the PNF. However, as shown in [28], this does not result in any loss of generality as one can always redefine atomic predicates to account for the presence of negations, allowing any general STL formula to be expressed in PNF. In our work, we impose an additional restriction on the Prenex Normal Form of formulas. Specifically, for any formula of the form φ 1 U [ a,b ] φ 2 , φ 1 can only involve temporal operator 'always'. This restriction is introduced for technical reasons, as it facilitates the decomposition of the overall formula into a set of progresses. For any signal s = x 0 x 1 . . . x T , we denote by s t ⊨ φ if s satisfies STL formula φ at time t , and we denote by s ⊨ φ if s 0 ⊨ φ . This is formally defined by the Boolean semantics of STL formulae as shown in Appendix C.1 .

2.3 Planning with Unknown Dynamics

In the context of STL planning, the objective is to determine an action sequence such that the resulting signal satisfies the specified STL formula. When the system dynamics are perfectly known, this problem can be solved using model-based optimization approaches (e.g., see [1, 2, 3]). In contrast, our work addresses a setting with unknown dynamics. Specifically, we assume the mapping f : R n × R m → R n is unknown,but a dataset of historical operational trajectories, consistent with the underlying unknown system dynamics, is available. Note that each trajectory in the dataset is collected from the previous task-agnostic operations and may vary in length. Our goal is to leverage these task-agnostic trajectories to generate new trajectories that satisfy any given STL formula, thereby achieving zero-shot task generalization at test time.

Problem 1. Given a set of trajectories from the unknown system (1) and a STL formula φ in the desired form, find a sequence of actions a 0 a 1 . . . a T such that the resulting signal s satisfies the STL formula, i.e., s ⊨ φ .

3 Our Method

3.1 Overall Framework

First, we provide an overview of our proposed planning framework, whose overall structure is illustrated in Figure 1. Our method consists of three key components. The first is semanticsbased task decomposition , in which the given STL formula is decomposed into a set of spatialtemporal progresses P = P R ˙ ∪ P I , where P R denotes the set of reachability progresses and P I the set of invariance progresses . These progresses must be satisfied under a set of time constraints T defined over time variables Λ . The second component is dynamics-aware progress allocation . While the above decomposition is task-centric, ensuring that the progresses can be satisfied in the correct temporal order requires considering the system's underlying dynamics. To this end, we use a pre-trained Time Predictor , learned from task-agnostic trajectory data, to estimate the time required to transition between waypoints. A search-based algorithm then determines a sequence of timed waypoints (˜ x 0 , t 0 ) , (˜ x 1 , t 1 ) , . . . , (˜ x n , t n ) such that each waypoint satisfies a corresponding reachability progress in P R and complies with all invariance progresses in P I .

The third component is trajectory generation . Given the sequence of timed waypoints, we generate an executable trajectory that ensures each waypoint is visited at the correct time while satisfying all invariance progresses by stitching together shorter trajectory segments. We instantiate this using existing constrained sampling frameworks (e.g., SafeDiffuser [29]), which leverage diffusion models pre-trained on trajectory data to produce dynamically feasible, constraint-compliant trajectories through constrained sampling. Next, we provide the technical details of each component.

3.2 Decompositions of STL Formulae

Eliminating Disjunctions. For the given STL task φ , our first step is to covert it into the dis- junctive normal form (DNF) ˜ φ = φ 1 ∨ φ 2 ∨ · · · ∨ φ n , where each subformula φ i involves no 'disjunction". Formally, for any STL formula, one can obtain its disjunctive normal form (DNF) by recursively applying the following replacements: (i) replace F [ a,b ] ( φ 1 ∨ φ 2 ) with F [ a,b ] φ 1 ∨ F [ a,b ] φ 2 ; (ii) replace G [ a,b ] ( φ 1 ∨ φ 2 ) with G [ a,b ] φ 1 ∨ G [ a,b ] φ 2 ; and (iii) replace ( ϕ 1 ∨ ϕ 2 )U [ a,b ] ( φ 1 ∨ φ 2 ) with ∨ i,j ∈{ 1 , 2 } ϕ i U [ a,b ] φ j . Note that the last two replacements are not equivalent, making the resulting DNF ˜ φ stronger than the original formula φ ; i.e., ˜ φ ⇒ φ but not conversely, adding conservativeness while preserving soundness. Furthermore, to achieve the task defined by ˜ φ , it suffices to satisfy one of the subformulas φ i . Without loss of generality, we will assume henceforth that the DNF contains only a single subformula, as the STL planning problem can be addressed for each subformula individually. In other words, moving forward, we will focus on STL formulae, denoted directly by φ , without negations (due to the PNF) and without disjunctions (due to the DNF). Similar simplifications and assumptions are common in STL planning or control synthesis literature [30].

Progresses. We encode the STL task φ by a finite set of progresses together with a set of timevariable constraints . For a signal fragment s t = x t x t +1 . . . x T , we use two canonical progress types:

Reachability progress R ( a Λ + t, b Λ + t, µ ) : there exists t ′ ∈ [ a Λ + t, b Λ + t ] such that x t ′ ⊨ µ .

Invariance progress I ( a Λ + t, b Λ + t, µ ) : for all t ′ ∈ [ a Λ + t, b Λ + t ] it holds that x t ′ ⊨ µ .

Unless stated otherwise we take t = 0 and write simply R ( a Λ , b Λ , µ ) and I ( a Λ , b Λ , µ ) .

Time Variables and Constraints. The subscript ' Λ ' indicates that the interval endpoints may depend on a finite set of time variables Λ φ = { λ 1 , . . . , λ | Λ | } . A concrete assignment is a vector λ = [ λ 1 , . . . , λ | Λ | ] ∈ Z | Λ | + . Throughout our decomposition (see Appendix D), each endpoint is an affine 0 -1 combination of these variables (plus constants), hence we view a Λ , b Λ : Z | Λ | + → Z + . All time constraints are unary interval bounds of the form λ i ∈ [ a i , b i ] ; we collect them in a set T φ .

Feasible Assignment Set. The feasible set induced by T φ is

where λ ⊨ ( λ i ∈ [ a i , b i ]) iff the i -th component of λ lies in the specified interval. Because constraints are unary, F φ factorizes coordinatewise.

Satisfaction of Progresses under an Assignment. Given λ ∈ F φ , we abbreviate s 0 ⊨ P ( λ ) for the satisfaction of P ( a Λ ( λ ) , b Λ ( λ ) , µ ) , where P ∈ {R , I} :

The full recursive decomposition procedure is detailed in Appendix D . To establish the soundness of the decomposition process with respect to the original STL specification, we propose the following lemma and the proof is provided in Appendix G .

Progresses

STL

Decomposition

and

Task

DO

iConstraints

Time

Progress

Predictor

Allocation

Trajectory

Diffusion

Waypoints

Data

Model

Sequence

n

Trajectory

→Task-Compliant

Generation

Trajectory

Lemma 1 (Soundness of Semantics-based STL Decomposition) . Let φ be an STL formula in positive normal form (PNF) without disjunctions, and let ( P φ , T φ ) along with the time-variable set Λ φ be the result of the recursive decomposition. Let F φ denote the set of feasible assignments that satisfy all time constraints. Then, for any signal s 0 ,

In particular, if Λ φ = ∅ , i.e., no time variables appear in the decomposition procedure, the condition reduces to s 0 ⊨ φ ⇐⇒ ∀P ∈ P φ : s 0 ⊨ P .

3.3 Progress Allocation

Basic Idea. By Lemma 1, when system dynamics are ignored, STL planning reduces to a constraintsatisfaction problem over the decomposed progresses and time constraints ( P φ , T φ ) . Concretely, s 0 ⊨ φ holds iff there exists a feasible time-variable assignment λ ∈ F φ such that every progress in P φ is satisfied. This reformulation is advantageous for signal construction: instead of reasoning directly with temporal quantifiers in the original formula, it suffices to (i) ensure the existence of a feasible λ , and (ii) construct a signal that satisfies all progresses under that assignment. We refer to this process as progress allocation .

However, unknown system dynamics pose additional challenges, as arbitrary allocation may result in dynamically infeasible plans. To address this, we adopt a search-based allocation algorithm, where the feasibility of each assignment is evaluated using a model (Time Predictor) learned from trajectory data, which implicitly captures the system dynamics.

Preprocessing. To perform the search-based allocation process, we further split the progresses P φ as follows. For each invariance progress I ( a Λ , b Λ , µ ) ∈ P φ , we decompose it into a reachability progress R ( a Λ , a Λ , µ ) and an invariance progress I ( a Λ +1 , b Λ , µ ) . For simplicity, we will denote the further decomposed progresses as ( P , T ) without subscripts, where P = P R ˙ ∪ P I . Due to this further decomposition, each invariance progress follows a unique reachability progress.

Main Allocation Algorithm. The main algorithm for progress allocation is presented in Algorithm 1. Note that the pseudo-code presents the search with an explicit stack for readability, whereas our reference implementation executes the same logic recursively.

The algorithm employs a depth-first search (DFS) to sequentially assign satisfaction times and waypoints for each reachability progress in P R . When the algorithm terminates, it returns a sequence of waypoints with associated timestamps of form (˜ x 0 , t 0 )(˜ x 1 , t 1 ) . . . (˜ x n , t n ) such that each waypoint corresponds to the satisfaction of a reachability progress in P R . During the search process, we maintain the current state x , the current time step t , the set of remaining reachability progresses P R , the set of all time constraints T , and the searched sequence of waypoints with associated timestamps ˜ s .

At each step, we select a remained reachability progress R ( a Λ , b Λ , µ ) from P R as the next target progress from the current state ( x , t ) . Specifically, to achieve progress R ( a Λ , b Λ , µ ) , function SampleState is used to determine a satisfaction time t ′ and a corresponding new state x ′ such that x ′ | = µ . Then the searched waypoint ( x ′ , t ′ ) is appended to ˜ s and we remove progress R ( a Λ , b Λ , µ ) from P R . Furthermore, the time con-

Algorithm 1 Main-Allocation

Input: Initial state x 0 , reachability progresses P R , invariance progresses P I , time variable constraints T

̸

straints T are updated based on the assigned state x ′ and time t ′ according to function

UpdateConstraint . Finally, the algorithm proceeds to the next iteration. If P R becomes empty, it indicates that all reachability progresses have been successfully assigned a satisfaction time. If no feasible assignment can be made, the algorithm backtracks to explore alternative assignments.

Dynamic Maintenance of Time Variable Constraints. During allocation, we dynamically maintain the set of time variable constraints T . Once the satisfaction time of a reachability progress is determined, additional constraints are added accordingly. This enables the planner to query T at any point to determine potential ranges of a Λ and b Λ (we denote by [ a min Λ , T , a max Λ , T ] , [ b min Λ , T , b max Λ , T ] ) in a progress P ( a Λ , b Λ , µ ) by solving integer linear programs (ILP), while ensuring consistency with previously assigned progresses. For example, to obtain a min Λ , T , we minimize a Λ ( λ ) subject to all constraints in T .

Note that only the constraints are updated during planning; the time variable set Λ remains fixed. As new constraints are introduced, the feasible assignment set F becomes increasingly restricted. If F becomes empty-i.e., no assignment λ satisfies all constraints-the current allocation is deemed infeasible, and backtracking is triggered to revise earlier decisions.

Heuristic Order. In the DFS of Algorithm 1, reachability progresses from P R are selected based on a heuristic order: progresses with earlier potential deadlines b min Λ , T are prioritized; if multiple candidates share the same deadline, the one with the earlier potential start time a min Λ , T is preferred.

Constraint Update. Let R ( a Λ , b Λ , µ ) be the selected progress and ( x ′ , t ′ ) the assigned waypoint with time. We then add the following time constraints to T :

These constraints ensure that the progress can be satisfied at time t ′ . Recall that in our decomposition, each original invariance progress I ( a Λ , b Λ , µ ) is split into a reachability progress R ( a Λ , a Λ , µ ) and a residual invariance progress I ( a Λ +1 , b Λ , µ ) . Thus, if constraints (5) are added for a reachability progress of the form R ( a Λ , a Λ , µ ) , the value of a Λ is fixed to t ′ . Let P I det denote the set of invariance progresses whose starting times have been determined. For any I ( c, d Λ , µ ) ∈ P I det , if x ′ ⊭ µ , we add an additional constraint d Λ < t ′ to ensure that the invariance progress terminates before t ′ , thereby avoiding conflicts with the assigned waypoint.

Sample Timed Waypoints. When a reachability progress R ( a Λ , b Λ , µ ) is selected, we use function SampleState to determine a valid satisfaction time and waypoint state for this progress while ensuring compliance with invariance progresses.

The pseudocode of this function is shown in Algorithm 2. The process starts by computing the largest possible time interval [ t min , t max ] for the reachability progress. Then the algorithm attempts to sample a candidate state x ′ with the satisfication region of µ up to N max times. For each attempt, we first calculate the minimum possible conflict time interval, denoted by O , during which x ′ conflicts with the invariance progresses.

Once the conflict time interval O is computed, we further use function TimePredict to predict the arrival time t ′ from the current state x to the sample state x ′ . Particularly, if (i) t ′ > t max ; or (ii) the feasible interval [max( t ′ , t min ) , t max ] is fully occupied by conflicting intervals in O , then it means that the sample state x ′ is not feasible and we proceed to the next attempt. Otherwise, the earliest available time t new in the feasible interval is assigned as the satisfaction time, and the algorithm returns t new along with the sampled state x ′ .

Remark 1. When calculating the conflict time interval O , we only consider invariance progresses whose starting times are determined. This is because, in the preprocessing process, we make each invariance progress follows a 'preceding" reachability progress. If the starting time of an invariance progress is not determined, then it implies that its 'preceding" reachability progress has not yet been satisfied and will only be satisfied strictly later than the current reachability progress. Consequently, this invariance progress will also start strictly later.

Prediction of Reachability Time. In Algorithm 2, model TimePredict is used to estimates the time step (trajectory length) needed to transition from the current state x to the new state x ′ . This model is trained on the same trajectory data, that will be used to train the Diffusion model. It assumes that the trajectory length between two states follows a Gaussian distribution. A simple multilayer perceptron (MLP) is used as the backbone of TimePredict model, and it is trained to predict the mean and variance of the trajectory length using a negative log-likelihood loss function. To account for tasks with avoidance requirements, which may require longer trajectories, a scaling factor γ is applied to the predicted mean trajectory length. This factor allows control over the algorithm's conservativeness by adjusting the predicted trajectory length as needed.

Soundness of the Progress Allocation Algorithm. We establish the soundness of the progress allocation algorithm in Lemma 2, with proof provided in Appendix G .

Lemma 2 (Soundness of Progress Allocation Algorithm) . Let ( x 0 , P R , P I , T ) be the input to Algorithm 1. Assume the depth-first allocation terminates with a waypoint sequence ˜ s = (˜ x 0 , t 0 ) (˜ x 1 , t 1 ) . . . (˜ x n , t n ) , 0 = t 0 ≤ t 1 ≤ · · · ≤ t n , and let T f be the final set of time-variable constraints with feasible assignment space F f .

̸

Then F f = ∅ , and for any signal s 0 = x 0 x 1 . . . x T with T ≥ t n and x t i = ˜ x i for 0 ≤ i ≤ n , there exists λ ∈ F f such that

In other words, by interpreting the returned waypoints as key states within the signal s 0 , the algorithm guarantees that, under some feasible assignment of time variables, all reachability progresses are satisfied and no invariance progress is violated at any selected waypoint.

3.4 Trajectory Generation

Lemma 2 ensures that the signal constructed from the waypoints returned by the Progress Allocation algorithm satisfies all reachability progresses and does not violate any invariance progress at the selected time steps. We now address the problem of completing the full system trajectory so that the entire signal satisfies all progress conditions. Suppose the Progress Allocation algorithm returns a waypoint sequence ˜ s = (˜ x 0 , t 0 ) (˜ x 1 , t 1 ) . . . (˜ x n , t n ) , 0 = t 0 ≤ t 1 ≤ ·· · ≤ t n . Our goal is to generate a system trajectory τ = x 0 a 0 x 1 a 1 . . . a T -1 x T under system dynamics (1), whose corresponding signal s 0 = x 0 x 1 . . . x T satisfies:

Note that the time intervals of all invariance progresses are now fixed by selecting a specific feasible assignment λ ⋆ ∈ F f . Aspecial case arises when certain invariance progresses have not yet terminated at time t n . In this situation, we simply wait at ˜ x n until all invariance progresses end, since according to Lemma 2, ˜ x n satisfies all predicates corresponding to the active invariance progresses at that time.

To solve this conditional trajectory generation problem, we employ a diffusion model trained on taskagnostic trajectory data, which enables the generation of dynamically feasible trajectories. Moreover, by incorporating constraints into the sampling process, the generated trajectories can be aligned with additional task requirements. However, directly generating long trajectories is challenging, as they often deviate from the training distribution. To mitigate this, we adopt a trajectory stitching strategy, generating individual segments τ i between each pair of adjacent waypoints ( x i , t i ) and ( x i +1 , t i +1 ) , and concatenating them to form the final trajectory τ . Specially, each segment must

satisfy the following conditions: (i) the length is t i +1 -t i +1 , (ii) it starts at state x i and ends at state x i +1 , and (iii) it satisfies all invariance progresses active within the time interval [ t i , t i +1 ] .

The diffusion model implementation is detailed in Appendix E . Briefly, the trajectory length is controlled via the length of initial noise, leveraging architectural properties of the backbone network [16]. Endpoint conditions are handled as an inpainting problem [16], by fixing the start and end states at every denoising step. To enforce invariance progresses, each I ( a, b, µ i ) is translated into a set of pointwise state constraints h µ i ( x t ) ≥ 0 for t = a, . . . , b , commonly referred to as safety constraints . These constraints can be handled using various existing constrained sampling methods for diffusion models [31, 29, 32, 33, 34, 35]. We employ SafeDiffuser [29], which integrates control barrier functions (CBFs) [36] to enforce these constraints within the sampling process, providing formal guarantees under mild conditions.

Soundness Analysis. We establish the soundness of the overall framework in the following theorem. The proof is provided in Appendix G .

Theorem 1 (Soundness of the Overall Planner) . Let φ be an STL formula satisfying all assumptions in Sections 2.2 and 3.2. Assume that the Semantics-based Decomposition terminates with a finite set of progresses and constraints, the Progress Allocation algorithm returns a sequence of timed waypoints and a non-empty feasible assignment set, and the Trajectory Generation module produces a trajectory τ whose signal s 0 visits all timed waypoints and satisfies all active invariance progresses. Then the resulting signal satisfies the STL specification: s 0 ⊨ φ .

3.5 Action Sequence and Control Protocol

Following mainstream diffusion-planner practice, we use the diffusion model solely to generate the state sequence; since action sequences are high-frequency and less smooth [17], we recover them via an learned inverse dynamics model [37] or with controllers that track the generated state sequence during execution. To guarantee strict adherence to the temporal windows imposed by STL tasks, we adopt a time-synchronous control protocol : each planning step is aligned with a fixed number k of control steps, where k is specified at task definition time to relate the planning horizon to the control frequency. At each planning step, the controller or inverse dynamics model therefore outputs exactly k actions and executes k control updates, ensuring that the temporal structure of the trajectory is preserved at runtime; unless otherwise stated, we set k = 1 , so each planning step corresponds to precisely one control step.

4 Case Study

To illustrate the workflow of our algorithm, we consider a sequential visit and region avoidance task in the Maze2D (Large) environment [38]. In this scenario, the agent starts at the yellow point shown in Figure 2 and aims to complete the following STL task: F [0 , 35] ( µ 1 ∧ (F [35 , 45] ( µ 2 ∧ F [10 , 30] µ 3 ))) ∧ G [0 , 110] ( ¬ µ 4 ∧ ¬ µ 5 ) , where the predicate µ i represents 'reach region µ i ,' and ¬ µ i denotes 'avoid region µ i '. Intuitively, this STL task requires the agent

to sequentially visit circular regions µ 1 , µ 2 , and µ 3 within specific time intervals while avoiding regions µ 4 and µ 5 throughout the entire episode.

The environment layout and target regions are depicted in Figure 2. Our method leverages only an STL task-agnostic trajectory dataset to train the diffusion model, without prior knowledge of the map or system dynamics. The decomposed progresses and time constraints are summarized in Table 1. The planning algorithm then assigns completion times to each reachability progress, as indicated by the numbers next to start point and regions µ 1 , µ 2 , and µ 3 in Figure 2, resulting in a sequence of waypoints with corresponding times. The diffusion model is then used to sequentially generate trajectories between adjacent waypoints while ensuring all invariance progresses are satisfied. The final generated trajectory is shown in the left subfigure of Figure 2. To evaluate the feasibility of the planned trajectory, we employ a simple PD controller to track it as described in Section 3.5.

The resulting execution trajectory is shown in the right subfigure of Figure 2. Using the open-source library stlpy [2], we calculate the robustness values for both the planned and actual execution trajectories as 0.180 and 0.115, respectively. Since both values are positive, the trajectories satisfy the STL task requirements.

5 Experiments

Although Theorem 1 guarantees the STL satisfaction of the trajectory, the use of a diffusion model to generate trajectories for systems with unknown dynamics means we cannot guarantee dynamic feasibility. Furthermore, our algorithm is not complete and exhibits some conservatism. Therefore, in our experiments, we primarily focus on evaluating the dynamic feasibility of the trajectories and the conservatism of the planning algorithm. To this end, we design several experiments to test these two aspects. All experiments were run on a PC with an Intel i7-13700K CPU and Nvidia 4090 GPU.

5.1 Experiment in Maze2D Environment

Experimental Settings. We evaluate our algorithm in three Maze2D environments (U-Maze, Medium, and Large) to assess its zero-shot generalization capability on randomly generated STL tasks. The agent, starting from a random position, must complete the STL task by reaching the target regions within specified time intervals. To generate random STL tasks, we design nine templates (Table F.1) and randomly generate time intervals and atomic predicate regions for each template, resulting in 150 randomized tasks per environment. We compare our method with the Robustness Guided Diffuser (RGD) [23], which uses a diffusion model with robustness value gradient guidance to optimize the robustness value of trajectory. Both algorithms use diffusion models trained on the D4RL dataset [38] to generate trajectories and a PD controller for trajectory execution.

Evaluation Metrics. We evaluate both methods using Execution Success Rate (SR) , Average Robustness Value (RV) , and Total Planning Time (T0) to assess the task satisfaction of the actually executed trajectories and the overall planning efficiency. Additionally, we record the Trajectory Generation Time (T1) to analyze the computational efficiency of the trajectory generation module of our algorithm. More details about these evaluation metrics and experiment settings are provided in Appendix F.3 .

Results and Analysis. Due to page limitations, we present a subset of the experimental results in Table 2, with the full results available in Table F.2. The results indicate that RGD works only on simple tasks (Types 1-3) and struggles with more complex tasks, as it cannot guarantee STL satisfaction and faces challenges balancing robustness optimization with dynamic feasibility for the entire long trajectories. In contrast, our method guarantees STL satisfaction and focuses the challenge on ensuring dynamic feasibility of short trajectory segments. In simpler environments, such as

1

2

3

4

5

0

34

69

97

1

2

3

4

5

U-Maze, our method achieves over 80% execution success rate across all task types, and maintains at least 69% success in the more complex Large environment. Moreover, the average robustness values of the actually executed trajectories using our method are consistently higher, further demonstrating its advantage in task satisfaction performance. Our approach is also more efficient, outperforming RGD by over 10 × in planning time. By comparing Trajectory Generation Time (T1) and Total Planning Time (T0) , we identify trajectory generation as the primary bottleneck in our algorithm. This is primarily due to the additional runtime introduced by SafeDiffuser , which uses complex quadratic programming for safety constraints enforcement. We plan to accelerate the trajectory generation module in future work by incorporating advanced sampling acceleration techniques for diffusion models [39, 40, 41].

5.2 Experiments under More Complex Dynamics

We further evaluate the generality of our framework on two dynamics-rich domains from OGBench [42]: Cube (6-DoF UR5e manipulator) and AntMaze (8-DoF Ant). Training uses only task-agnostic trajectory datasets provided by OGBench; at evaluation time we replace the original goal-conditioned objectives with STL specifications. In Cube we plan and track end-effector trajectories in Cartesian space, and in AntMaze we plan in the workspace and execute with a learned inverse-dynamics controller. Across nine STL templates per environment, the framework attains high execution success rate in Cube (over 84% ) and robust performance in AntMaze (over 60% ), with planning times that remain practical despite the increased dynamical complexity (Table F.3). These results indicate that the proposed decomposition-allocation-generation pipeline transfers beyond simple scenarios to higher-dimensional settings. Full experimental settings, metrics, and analyses are provided in Appendix F.4 .

5.3 Comparative Experiment with Optimization-based Method

In the previous experiments, due to the lack of access to precise system dynamics in the simulation environment, we could not use sound-and-complete methods to verify the feasibility of randomly generated STL tasks. Instead, task feasibility was determined by our progress allocation module, which may lead to a slightly optimistic estimation of the overall success rate, as it overlooks the conservativeness of our approach. To more accurately assess this conservativeness, we conduct additional experiments in a custom-built environment with full access to both the environment and system dynamics. In this setting, we adopt a sound and complete optimization-based method [4], which utilizes full model information to rigorously verify the feasibility of STL formulas. Our algorithm is then evaluated on those verified feasible cases. Results show that the progress allocation module achieves a success rate exceeding 80% across various task scenarios, highlighting its strong capability to identify feasible solutions. Full experimental details are provided in Appendix F.5 .

6 Conclusion

We presented a data-driven hierarchical framework for planning trajectories that satisfy complex Signal Temporal Logic (STL) tasks under unknown dynamics using only task-agnostic offline trajectories. The approach semantically decomposes an STL formula into time-aware progresses, allocates timed waypoints via a dynamics-aware search guided by a learned reachability heuristic, and synthesizes short constrained trajectory segments with a diffusion-based generator; these segments are then stitched into complete trajectories. We established formal soundness of the planning pipeline for STL satisfaction, and validated the method extensively. On Maze2D, the framework attains high execution success rate on long-horizon tasks while delivering over 10 × speedups relative to a robustness-guided diffusion baseline and higher robustness values with smaller variance. On dynamics-rich domains (Cube and AntMaze), it maintains strong success rates with practical planning times, and in a custom environment with known dynamics the progress-allocation module achieves > 80% feasibility on rigorously certified instances, underscoring completeness in practice. Overall, the results indicate that unifying logic-level task decomposition with data-driven trajectory synthesis yields a scalable and general solution for zero-shot STL planning; future work will pursue stronger time-prediction and control modules, verification enhancements, and accelerated diffusion sampling for even longer horizons.

References

V. Raman, M. Maasoumy, and A. Donzé, 'Model predictive control from signal temporal logic specifications: A case study,' in Proceedings of the 4th ACM SIGBED International Workshop on Design, Modeling, and Evaluation of Cyber-Physical Systems , 2014, pp. 52-55.

V. Kurtz and H. Lin, 'Mixed-integer programming for signal temporal logic with fewer binary variables,' IEEE Control Systems Letters , vol. 6, pp. 2635-2640, 2022.

D. Sun, J. Chen, S. Mitra, and C. Fan, 'Multi-agent motion planning from signal temporal logic specifications,' IEEE Robotics and Automation Letters , vol. 7, no. 2, pp. 3451-3458, 2022.

Y. Gilpin, V. Kurtz, and H. Lin, 'A smooth robustness measure of signal temporal logic for symbolic control,' IEEE Control Systems Letters , vol. 5, no. 1, pp. 241-246, 2020.

C. Dawson and C. Fan, 'Robust counterexample-guided optimization for planning from differentiable temporal logic,' in 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2022, pp. 7205-7212.

R. B. Ilyes, Q. H. Ho, and M. Lahijanian, 'Stochastic robustness interval for motion planning with signal temporal logic,' in 2023 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 2023, pp. 5716-5722.

D. Aksaray, A. Jones, Z. Kong, M. Schwager, and C. Belta, 'Q-learning for robust satisfaction of signal temporal logic specifications,' in 2016 IEEE 55th Conference on Decision and Control (CDC) . IEEE, 2016, pp. 6565-6570.

A. Balakrishnan and J. V. Deshmukh, 'Structured reward functions using stl,' in Proceedings of the 22nd ACM International Conference on Hybrid Systems: Computation and Control , 2019, pp. 270-271.

K. C. Kalagarla, R. Jain, and P. Nuzzo, 'Model-free reinforcement learning for optimal control of markov decision processes under signal temporal logic specifications,' in 2021 60th IEEE Conference on Decision and Control (CDC) . IEEE, 2021, pp. 2252-2257.

H. Venkataraman, D. Aksaray, and P. Seiler, 'Tractable reinforcement learning of signal temporal logic objectives,' in Learning for Dynamics and Control . PMLR, 2020, pp. 308-317.

J. Ikemoto and T. Ushio, 'Deep reinforcement learning under signal temporal logic constraints using lagrangian relaxation,' IEEE Access , vol. 10, pp. 114 814-114 828, 2022.

S. Wang, S. Li, L. Yin, and X. Yin, 'Synthesis of temporally-robust policies for signal temporal logic tasks using reinforcement learning,' in 2024 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 2024, pp. 10 503-10 509.

P. Kapoor, A. Balakrishnan, and J. V. Deshmukh, 'Model-based reinforcement learning from signal temporal logic specifications,' arXiv preprint arXiv:2011.04950 , 2020.

Y. He, P. Liu, and Y. Ji, 'Scalable signal temporal logic guided reinforcement learning via value function space optimization,' arXiv preprint arXiv:2408.01923 , 2024.

J. Ho, A. Jain, and P. Abbeel, 'Denoising diffusion probabilistic models,' Advances in neural information processing systems , vol. 33, pp. 6840-6851, 2020.

M. Janner, Y. Du, J. Tenenbaum, and S. Levine, 'Planning with diffusion for flexible behavior synthesis,' in International Conference on Machine Learning . PMLR, 2022, pp. 9902-9915.

A. Ajay, Y. Du, A. Gupta, J. Tenenbaum, T. Jaakkola, and P. Agrawal, 'Is conditional generative modeling all you need for decision-making?' arXiv preprint arXiv:2211.15657 , 2022.

C. Chi, Z. Xu, S. Feng, E. Cousineau, Y. Du, B. Burchfiel, R. Tedrake, and S. Song, 'Diffusion policy: Visuomotor policy learning via action diffusion,' The International Journal of Robotics Research , p. 02783649241273668, 2023.

J. Carvalho, A. T. Le, M. Baierl, D. Koert, and J. Peters, 'Motion planning diffusion: Learning and planning of robot motions with diffusion models,' in 2023 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2023, pp. 1916-1923.

R. Huang, Y. Pei, G. Wang, Y. Zhang, Y. Yang, P. Wang, and H. Shen, 'Diffusion models as optimizers for efficient planning in offline rl,' in European Conference on Computer Vision . Springer, 2025, pp. 1-17.

Z. Feng, H. Luan, P. Goyal, and H. Soh, 'Ltldog: Satisfying temporally-extended symbolic constraints for safe diffusion-based planning,' IEEE Robotics and Automation Letters , 2024.

Z. Feng, H. Luan, K. Y. Ma, and H. Soh, 'Diffusion meets options: Hierarchical generative skill composition for temporally-extended tasks,' in 2025 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 2025, pp. 10 854-10 860.

Z. Zhong, D. Rempe, D. Xu, Y. Chen, S. Veer, T. Che, B. Ray, and M. Pavone, 'Guided conditional diffusion for controllable traffic simulation,' in 2023 IEEE International Conference on Robotics and Automation (ICRA) . IEEE, 2023, pp. 3560-3566.

Y. Meng and C. Fan, 'Diverse controllable diffusion policy with signal temporal logic,' IEEE Robotics and Automation Letters , 2024.

X. Li, Y. Zhao, C. Wang, G. Scalia, G. Eraslan, S. Nair, T. Biancalani, A. Regev, S. Levine, and M. Uehara, 'Derivative-free guidance in continuous and discrete diffusion models with soft value-based decoding,' CoRR , 2024.

P. Kapoor, E. Kang, and R. Meira-Góes, 'Safe planning through incremental decomposition of signal temporal logic specifications,' in NASA Formal Methods Symposium . Springer, 2024, pp. 377-396.

O. Maler and D. Nickovic, 'Monitoring temporal properties of continuous signals,' in International Symposium on Formal Techniques in Real-Time and Fault-Tolerant Systems . Springer, 2004, pp. 152-166.

S. Sadraddini and C. Belta, 'Robust temporal logic model predictive control,' in 2015 53rd Annual Allerton Conference on Communication, Control, and Computing (Allerton) . IEEE, 2015, pp. 772-779.

W. Xiao, T.-H. Wang, C. Gan, R. Hasani, M. Lechner, and D. Rus, 'Safediffuser: Safe planning with diffusion probabilistic models,' in International Conference on Learning Representations , 2025.

P. Yu, X. Tan, and D. V. Dimarogonas, 'Continuous-time control synthesis under nested signal temporal logic specifications,' IEEE Transactions on Robotics , vol. 40, pp. 2272-2286, 2024.

J. Zhang, L. Zhao, A. Papachristodoulou, and J. Umenberger, 'Constrained diffusers for safe planning and control,' arXiv preprint arXiv:2506.12544 , 2025.

N. Botteghi, F. Califano, M. Poel, and C. Brune, 'Trajectory generation, control, and safety with denoising diffusion probabilistic models,' arXiv preprint arXiv:2306.15512 , 2023.

K. Mizuta and K. Leung, 'Cobl-diffusion: Diffusion-based conditional robot planning in dynamic environments using control barrier and lyapunov functions,' in 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE, 2024, pp. 13 801-13 808.

Y. Zheng, J. Li, D. Yu, Y. Yang, S. E. Li, X. Zhan, and J. Liu, 'Safe offline reinforcement learning with feasibility-guided diffusion model,' arXiv preprint arXiv:2401.10700 , 2024.

J. K. Christopher, S. Baek, and F. Fioretto, 'Constrained synthesis with projected diffusion models,' in The Thirty-eighth Annual Conference on Neural Information Processing Systems , 2024.

Q. Nguyen and K. Sreenath, 'Exponential control barrier functions for enforcing high relativedegree safety-critical constraints,' in 2016 American Control Conference (ACC) . IEEE, 2016, pp. 322-328.

P. Agrawal, A. V. Nair, P. Abbeel, J. Malik, and S. Levine, 'Learning to poke by poking: Experiential learning of intuitive physics,' Advances in neural information processing systems , vol. 29, 2016.

J. Fu, A. Kumar, O. Nachum, G. Tucker, and S. Levine, 'D4rl: Datasets for deep data-driven reinforcement learning,' arXiv preprint arXiv:2004.07219 , 2020.

J. Song, C. Meng, and S. Ermon, 'Denoising diffusion implicit models,' arXiv preprint arXiv:2010.02502 , 2020.

Z. Xiao, K. Kreis, and A. Vahdat, 'Tackling the generative learning trilemma with denoising diffusion gans,' arXiv preprint arXiv:2112.07804 , 2021.

W. Zhou, Z. Dou, Z. Cao, Z. Liao, J. Wang, W. Wang, Y. Liu, T. Komura, W. Wang, and L. Liu, 'Emdm: Efficient motion diffusion model for fast and high-quality motion generation,' in European Conference on Computer Vision . Springer, 2025, pp. 18-38.

S. Park, K. Frans, B. Eysenbach, and S. Levine, 'OGBench: Benchmarking offline goalconditioned RL,' in The Thirteenth International Conference on Learning Representations (ICLR) , 2025.

K. Leahy, M. Mann, and C.-I. Vasile, 'Rewrite-based decomposition of signal temporal logic specifications,' in NASA Formal Methods Symposium . Springer, 2023, pp. 224-240.

X. Yu, C. Wang, D. Yuan, S. Li, and X. Yin, 'Model predictive control for signal temporal logic specifications with time interval decomposition,' in 2023 62nd IEEE Conference on Decision and Control (CDC) . IEEE, 2023, pp. 7849-7855.

G. Li, Y. Shan, Z. Zhu, T. Long, and W. Zhang, 'Diffstitch: Boosting offline reinforcement learning with diffusion-based trajectory stitching,' in International Conference on Machine Learning . PMLR, 2024, pp. 28 597-28 609.

S. Kim, Y. Choi, D. E. Matsunaga, and K.-E. Kim, 'Stitching sub-trajectories with conditional diffusion model for goal-conditioned offline rl,' in Proceedings of the AAAI Conference on Artificial Intelligence , vol. 38, no. 12, 2024, pp. 13 160-13 167.

Y. Luo, U. A. Mishra, Y. Du, and D. Xu, 'Generative trajectory stitching through diffusion composition,' arXiv preprint arXiv:2503.05153 , 2025.

L. Yuan, Y. Bian, L. Li, Z. Zhang, C. Guan, and Y. Yu, 'Efficient multi-agent offline coordination via diffusion-based trajectory stitching,' in The Thirteenth International Conference on Learning Representations , 2025.

P. Yu, Y. Gao, F. J. Jiang, K. H. Johansson, and D. V. Dimarogonas, 'Online control synthesis for uncertain systems under signal temporal logic specifications,' The international journal of robotics research , vol. 43, no. 6, pp. 765-790, 2024.

Z. Gu, Y. Zhao, Y. Chen, R. Guo, J. K. Leestma, G. S. Sawicki, and Y. Zhao, 'Robustlocomotion-by-logic: Perturbation-resilient bipedal locomotion via signal temporal logic guided model predictive control,' IEEE Transactions on Robotics , 2025.

T. Wang, A. Torralba, P. Isola, and A. Zhang, 'Optimal goal-reaching reinforcement learning via quasimetric learning,' in International Conference on Machine Learning . PMLR, 2023, pp. 36 411-36 430.

V. Myers, B. C. Zheng, B. Eysenbach, and S. Levine, 'Offline goal-conditioned reinforcement learning with quasimetric representations,' arXiv preprint arXiv:2509.20478 , 2025.

R. Liu, A. Hou, S. Li, and X. Yin, 'Vh-diffuser: Variable horizon diffusion planner for timeaware goal-conditioned trajectory planning,' arXiv preprint arXiv:2509.11930 , 2025.

E. Bartocci, J. Deshmukh, A. Donzé, G. Fainekos, O. Maler, D. Niˇ ckovi´ c, and S. Sankaranarayanan, 'Specification-based monitoring of cyber-physical systems: a survey on theory, tools and applications,' Lectures on Runtime Verification: Introductory and Advanced Topics , pp. 135-175, 2018.

K. Leung, N. Aréchiga, and M. Pavone, 'Backpropagation through signal temporal logic specifications: Infusing logical structure into gradient-based methods,' The International Journal of Robotics Research , vol. 42, no. 6, pp. 356-370, 2023.

G. Zhou, S. Swaminathan, R. V. Raju, J. S. Guntupalli, W. Lehrach, J. Ortiz, A. Dedieu, M. Lázaro-Gredilla, and K. Murphy, 'Diffusion model predictive control,' arXiv preprint arXiv:2410.05364 , 2024.

S. Zhou, Y. Du, S. Zhang, M. Xu, Y. Shen, W. Xiao, D.-Y. Yeung, and C. Gan, 'Adaptive online replanning with diffusion models,' Advances in Neural Information Processing Systems , vol. 36, 2024.

E. Opryshko, J. Quan, C. Voelcker, Y. Du, and I. Gilitschenski, 'Test-time graph search for goal-conditioned reinforcement learning,' arXiv preprint arXiv:2510.07257 , 2025.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: The abstract and introduction sections clearly state the main contributions and scope of the paper.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: We discuss main limitations of our work in Appendix B .

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory assumptions and proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: The full proofs of all theoretical results presented in the paper are included in Appendix G .

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental result reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: We provide detailed implementation descriptions and key experimental settings in both the main text and the appendix. In addition, we have included the experimental code in the supplementary materials. We also commit to open-sourcing the code and will add the corresponding link in the paper upon publication.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: We will include the link to the code repository on the project page.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental setting/details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Full details will be provided with the code.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment statistical significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: The results are accompanied by error bars.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments compute resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: We describe our computer resources in Section 5.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code of ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: The research in the paper conform with the Code of Ethics.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [NA]

Justification: This work focuses primarily on the theoretical aspects of task planning and does not pose any foreseeable societal impact.

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: the paper poses no such risks.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: we cite the original paper that produced the code package or dataset.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [Yes]

Justification: We will provide a document alongside our code.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and research with human subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: the paper does not involve crowdsourcing nor research with human subjects.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional review board (IRB) approvals or equivalent for research with human subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: the paper does not involve crowdsourcing nor research with human subjects.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

16. Declaration of LLM usage

Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.

Answer: [NA]

Justification: the core method development in this research does not involve LLMs as any important, original, or non-standard components.

Guidelines:

The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non-standard components.

Please refer to our LLM policy ( https://neurips.cc/Conferences/2025/ LLM ) for what should or should not be described.

A Related Works

A.1 STL Decomposition

To address the high complexity of STL control synthesis problems, several decomposition-based methods have been proposed [43, 44, 26]. In [43], the authors proposed a formula transformationbased method for multi-agent STL planning. This approach jointly decomposes an STL specification and team of agents. In [44], the authors decompose STL tasks into several subtasks with nonoverlapping time intervals using time interval decomposition and sequentially apply the shrinking horizon Model Predictive Control (MPC) algorithm to each short-time-interval subtask. However, this method is limited to handling STL fragments that do not include nested temporal logic operators.

The work most similar to our STL decomposition framework is [26]. This work first decomposes STL tasks into several spatio-temporal subtasks with time variable constraints. Then, through time variable simplification, partial ordering, and slicing, the subtasks are segmented into several time intervals. Finally, a planning algorithm is subsequently used to sequentially solve the atomic tasks within each time interval. Our algorithm similarly begins by decomposing the STL task into several spatio-temporal progresses and time variable constraints. However, we adopt a search-based approach to determine the completion times and corresponding states to achieve each progress. During the search process, our method dynamically maintains the time variable constraints on-the-fly according to the completion of progresses. By incorporating the search mechanism, our algorithm achieves greater completeness compared to the incremental planning approach used in [26]. Additionally, the dynamic maintenance of time variable constraints enables a more natural handling of relationships between subtasks and extends the applicability of our approach to more complex STL task fragments that allows 'until' operator.

A.2 Planning with Diffusion Model

Recent advancements in diffusion-based planning methods highlight their remarkable flexibility, as they rely exclusively on offline trajectory datasets and do not require direct interaction with or access to the environment. By leveraging guided sampling, these methods can address a wide range of objectives without the need for retraining. This approach has been widely applied to long-horizon task planning and decision-making, facilitating the generation of states or actions for control purposes [16, 17, 18].

In the domain of diffusion-based planning for temporal logic tasks, several significant studies have been conducted [23, 24, 21, 22]. For instance, [21] proposed a classifier-based guidance approach to direct the sampling process of the diffusion model, enabling the generation of trajectories that fulfill finite Linear Temporal Logic (LTL f ) tasks. Similarly, [22] introduced a data-driven hierarchical framework that decomposes co-safe LTL tasks into sub-tasks using hierarchical reinforcement learning. This framework integrates a diffusion model with a determinant-based sampling technique to efficiently produce diverse low-level trajectories, enhancing both planning success rates and task generalization capabilities.

For diffusion-based Signal Temporal Logic (STL) planning, [23] employed a classifier-based guidance method that leverages the gradient of robustness values to guide the sampling process of a diffusion model. This method enabled the generation of vehicle trajectories compliant with STL-specified traffic rules. Expanding on this work, [24] introduced a data augmentation process to further improve trajectory diversity and increase the satisfaction rate of specified rules. However, these approaches remain constrained to relatively simple STL tasks due to the inherent complexity of optimizing robustness values, as well as the trade-off between maximizing reward objectives and preserving the feasibility of generated trajectories [25].

We compare our algorithm with the method proposed in [23] in the experiments. The results demonstrate that our algorithm can handle complex and long-horizon STL tasks that the method in [23] cannot address, while also exhibiting significant advantages in runtime efficiency.

A.3 Trajectory Stitching

In practical applications of diffusion-based trajectory planning, the training data for diffusion models typically consist of short and simple trajectories. As a result, the learned models struggle to capture the

distribution of more complex behaviors, making it difficult to generate trajectories that satisfy intricate task specifications through guided sampling. To address this limitation, recent studies [45, 46, 47, 48] leverage trajectory stitching methods. The core idea is to construct long-horizon trajectories by stitching together shorter trajectory segments, thereby enabling the satisfaction of more challenging tasks. Current research on trajectory stitching mainly focuses on data augmentation [45, 48] or enabling diffusion models, trained on simple sub-optimal trajectories, to perform relatively complex long-horizon goal-reaching tasks [46, 47].

In contrast to these works, we focus on using trajectory stitching to generate trajectories that satisfy complex, long-horizon STL tasks by leveraging a diffusion model trained on task-agnostic, simple trajectory data. We address the challenge of generating trajectories that satisfy complex STL specifications by decomposing the global task into simpler local sub-tasks using an hierarchical STL-decomposition and planning framework. For each sub-task, a diffusion model is employed to generate a locally feasible trajectory segment, and the final trajectory is obtained by stitching these segments together. The key difficulty lies in ensuring that the decomposition and stitching process preserves satisfaction of the original global STL specification.

B Limitations

B.1 Algorithmic Incompleteness

The main limitation of the proposed framework lies in its incompleteness -the planner may fail to find a solution even when one exists-due to three inherent sources of conservativeness:

(i) Specification strengthening. Eliminating disjunctions transforms the original formula φ into a logically stronger formula ˜ φ . While this may exclude some feasible solutions, such transformation is typical in STL planning [30].

(ii) Heuristic allocation. The depth-first, heuristic-based progress allocation (Algorithm 1) relies on approximate time-to-reach estimations and greedy ordering, which may prematurely prune feasible branches. This can be partially mitigated by treating the first feasible solution as a candidate rather than terminating immediately. Exploring more candidates improves solution quality but increases planning time.

(iii) Data-driven synthesis. The diffusion model can only generate trajectories that resemble its training distribution. When the task requires behaviors beyond this distribution, the model may fail to synthesize valid segments.

In fact, the incompleteness is inevitable in any sound, data-driven planner under this scenario. Achieving completeness would require full knowledge of the true system dynamics f , contradicting the core assumption of the problem. Therefore, pursuing absolute completeness is neither meaningful nor practical. Instead, a sound yet statistically conservative framework offers greater value in real-world applications.

We outline some directions that can reduce (though never eliminate) the conservativeness:

Adaptive progress allocation. Replacing the greedy allocation with a beam search or widening strategy, and integrating uncertainty-aware arrival-time predictors (e.g., conformal prediction bounds), can diminish the risk of pruning viable branches.

Hybrid model refinement. When limited model knowledge is available (e.g., a coarse dynamics model or learned residual), incorporating it as a constraint inside trajectory generator may shrink the realism gap and enhance synthesis coverage.

Data Augmentation for Synthesis Coverage. Enhance the diffusion prior and Time Predictor using stitching-based data augmentation [45], which increases the coverage of rare transitions and long detours. This augmentation mitigates the sensitivity of data-driven synthesis to dataset sparsity and distribution shift.

We leave these possible improvements for future work.

B.2 Optimality

Our current objective prioritizes task correctness and dynamic feasibility under unknown dynamics. The optimization of secondary criteria such as makespan, temporal slack, energy, or risk remains outside our present scope and is particularly challenging in our setting.

Nevertheless, incorporating optimality represents a promising research direction. A practical approach is to replace the current 'first-feasible' strategy with an anytime allocator that continues to explore the search space after finding an initial solution, thereby trading additional computation for improved objectives such as reduced makespan or increased slack within invariance windows. This approach can be combined with (i) multi-objective scoring that integrates feasibility and soft cost terms, (ii) admissible pruning based on uncertainty-aware time-to-reach bounds, and (iii) post-allocation local refinements such as waypoint re-timing under STL windows while maintaining soundness.

It is important to emphasize that any extension toward optimality must still preserve dynamic feasibility. Overemphasizing cost minimization may increase dynamic infeasibility during downstream synthesis or execution. Systematically balancing these trade-offs through anytime search, Pareto-front maintenance, or constrained optimization over progress schedules is an important direction for future work.

B.3 Scenario Limitations

As a planning framework, our method currently performs planning in a relatively low-dimensional task space rather than directly in the high-dimensional configuration space. During execution, control is still handled by a low-level controller or an learned inverse dynamics model, as described in Section 3.5. This design choice may limit the planner's ability to fully account for low-level dynamic feasibility when generating trajectories, resulting in a potential gap between the planned and the executed trajectories. Nevertheless, our experiments evaluate the success rate based on the actually executed trajectories, and the results show that even in challenging environments with complex low-level dynamics, such as AntMaze, our method still achieves satisfactory performance.

In addition, our current experiments primarily focus on navigation-style STL tasks, in which the atomic predicates typically specify reaching certain regions, and the overall task requires sequentially visiting designated goals within specified time windows. This follows the mainstream setting adopted in most studies on temporal logic task planning and control synthesis [12, 21, 22, 30, 49, 26]. However, temporal logic can also describe other types of behaviors, such as safety constraints and maintenance conditions [24, 50]. These scenarios usually involve relatively simple temporal logic specifications, whereas our focus is on planning under long-horizon and complex temporal logic tasks. Therefore, we restrict our experiments to navigation-style tasks and leave other types of STL scenarios for future exploration.

B.4 Time Predictor Limitations

The Time Predictor (TP) uses offline trajectories to estimate time-to-reach between states, thereby injecting a notion of dynamical feasibility into allocation. This data-driven design has inherent limitations. When datasets are sparse or misaligned with the evaluation distribution, the TP can overfit local transition patterns or extrapolate poorly to pairs of states that do not appear in the data. This issue becomes more pronounced when avoidance constraints require long detours. Coverage requirements also increase with the dimensionality of the planning space, and without sufficient cross-episode transitions the predictions can become biased or insufficiently dispersed, which may lead to unreachable schedules.

Effectiveness within our regime. In the data regimes considered here, where abundant taskagnostic trajectories are available, the TP works in concert with the generator and the controller. The TP proposes a horizon, the diffusion-based generator synthesizes a segment of the corresponding length, and the time-synchronous controller executes it. The predictor-generator-controller pipeline achieves high execution reliability in practice (as shown in Section F.6). These results indicate that moderate TP accuracy is often sufficient when combined with segment-level generation and closed-loop tracking in our framework.

Mitigations and modular improvements. Within our modular framework, several upgrades can reduce TP-induced failures while preserving soundness:

Stronger time-prediction models. Replace the lightweight TP with more expressive predictors that can better capture long detours and heterogeneous dynamics. Options include models with calibrated uncertainty as well as recent approaches that learn temporal-distance or hitting-time style quantities [51, 52, 53]. These predictors can be paired with slack-aware scheduling to translate predictions into more robust waypoint times.

Data augmentation for coverage. Increase support for rare transitions through stitching-based augmentation [45], which composes cross-episode segments to create longer feasible paths and improves coverage in sparsely sampled regions.

We leave these possible improvements for future work.

C Semantics of Signal Temporal Logic

C.1 Boolean Semantics

The Boolean semantics of a STL formula φ with respect to a signal s t starting at time t are defined inductively as follows [54]:

⊨

φ

1

U

[

a,b

]

φ

2

⇔∃

t

′

∈

[

t

+

a, t

+

b

]

s

t

′

⊨

φ

2

For simplicity, we slightly abuse the notation x t ⊨ µ to denote h µ ( x t ) ≥ 0 , and thus, we have

s

t

C.2 Quantitative Semantics

Besides the Boolean semantics, STL also incorporates a concept of robustness value [54], which refers to its quantitative semantics used to measure the degree to which a signal satisfies or violates a formula. Positive robustness values signify satisfaction, while negative values indicate violation. The quantitative semantics of a STL formula φ with respect to a signal s t starting at time t are defined as follows:

D Semantic-Based STL Decomposition

The decomposition procedure is defined recursively as follows:

If φ = F [ a,b ] µ , then we have P φ = {R ( λ i , λ i , µ ) } and T φ = { λ i ∈ [ a, b ] } , Λ φ = { λ i } , where λ i is a new time variable.

If φ = G [ a,b ] µ , then we have P φ = {I ( a, b, µ ) } and T φ = ∅ , Λ φ = ∅ .

If φ = µ 1 U [ a,b ] µ 2 , then we have P φ = {I (0 , λ i , µ 1 ) , R ( λ i , λ i , µ 2 ) } and T φ = { λ i ∈ [ a, b ] } , Λ φ = { λ i } , where λ i is a new time variable.

If φ = φ 1 ∧ φ 2 , then we merge the progresses and time constraints, i.e., P φ = P φ 1 ⊎ P φ 2 and T φ = T φ 1 ⊎ T φ 2 , Λ φ = Λ φ 1 ⊎ Λ φ 2 . We use ' ⊎ ' to emphasize that the two merged sets contain no duplicate elements.

If φ ′ = F [ a,b ] φ , then we (i) introduce a new time variable λ i , i.e., Λ φ ′ = Λ φ ⊎ { λ i } ; (ii) add a new time constraint T φ ′ = T φ ⊎ { λ i ∈ [ a, b ] } ; (iii) increase each time indices in each progress by λ i , i.e., P φ ′ = {P ( c Λ + λ i , d Λ + λ i , µ ) | P ( c Λ , d Λ , µ ) ∈ P φ } . Specifically, if φ ′ = F [ a,a ] φ , then we do not introduce a new time variable. In this case, we set Λ φ ′ = Λ φ , T φ ′ = T φ , P φ ′ = {P ( c Λ + a, d Λ + a, µ ) | P ( c Λ , d Λ , µ ) ∈ P φ } .

If φ ′ = G [ a,b ] φ , we treat it as φ ′ = ∧ k ∈ [ a,b ] F [ k,k ] φ . Each subformula F [ k,k ] φ corresponds to a separate copy of progresses P ( k ) φ , time variables Λ ( k ) φ and the associated constraints T ( k ) φ . Therefore, Λ φ ′ = ⊎ k ∈ [ a,b ] Λ ( k ) φ , T φ ′ = ⊎ k ∈ [ a,b ] T ( k ) φ , P φ ′ = ⋃ k ∈ [ a,b ] {P ( c Λ + k, d Λ + k, µ ) | P ( c Λ , d Λ , µ ) ∈ P ( k ) φ } .

Specifically, for an invariance progress in P φ of the form I ( c, d, µ ) that does not contain any time variables, applying the operation F [ k,k ] φ on its copy in P ( k ) φ yields I ( c + k, d + k, µ ) . We then merge all such copies I ( c + k, d + k, µ ) for k ∈ [ a, b ] into a single progress I ( c + a, d + b, µ ) .

If φ ′ = ϕ U [ a,b ] φ , then (i) introduce a new time variable λ i ,i.e., Λ φ ′ = Λ φ ⊎ { λ i } ; and (ii) add a new time constraint, i.e., T φ ′ = T φ ⊎ { λ i ∈ [ a, b ] } ; and (iii) increase each time indices in each progress in P φ by λ i and modify each invariance progress I ( c, d, µ ) ∈ P ϕ to I ( c, d + λ i , µ ) , i.e., P φ ′ = {P ( c Λ + λ i , d Λ + λ i , µ ) | P ( c Λ , d Λ , µ ) ∈ P φ } ∪ {I ( c, d + λ i , µ ) | I ( c, d, µ ) ∈ P ϕ } .

Remark 2. Since we require that, for any subformula of the form φ 1 U [ a,b ] φ 2 , the subformula φ 1 does not contain the operators F or U , it follows that in the case of φ ′ = ϕ U [ a,b ] φ , no time variables or reachability progresses are introduced by the operations within ϕ . Therefore, we have Λ ϕ = ∅ , T ϕ = ∅ , and P ϕ = {I ( c, d, µ ) } .

The decomposition process is shown in Figure D.1, where the progress and time constraints are constructed incrementally from the bottom to the top. The top node represents the overall decomposed ( P φ , T φ ) for the STL formula φ .

E Trajectory Generation

E.1 Diffusion Models for Trajectory Planning

The core concept of diffusion-model-based trajectory planning[16, 17] is to employ the diffusion model to learn the distribution of pre-collected trajectories q ( τ 0 ) in the current environment under the system dynamics, thereby transforming planning or control synthesis problems into conditional trajectory generation.

Diffusion models consist of two processes: the diffusion process and the denoising process .

The diffusion process gradually adds Gaussian noise to a trajectory τ 0 , transforming it into noise. At each timestep i , the noisy trajectory is given by:

where β i controls the noise scale, and N is the total number of diffusion steps. The noisy trajectory τ i at any step can be directly computed as:

with ¯ α i = ∏ i j =1 (1 -β j ) .

The denoising process reverses the diffusion by iteratively recovering the trajectory from Gaussian noise. The reverse distribution is approximated as:

where µ θ ( τ i , i ) is parameterized by the model, and Σ i is typically fixed. Instead of learning µ θ directly, the model typically predicts the noise ε θ ( τ i , i ) and gets µ θ ( τ i , i ) according to the relationship[15]:

The model is trained by minimizing a simplified loss function:

In this paper, superscripts denote the diffusion time step, while subscripts indicate the trajectory time step. For example, τ i t represents the state at trajectory time step t during diffusion time step i . For noise-free trajectories, τ 0 , we omit the superscript when there is no ambiguity.

E.2 Trajectory Stitching

Directly generating an entire long-horizon trajectory that meets all STL constraints is challenging, since the resulting trajectories may fall far outside the training distribution, which typically consists of shorter demonstrations. Inspired by recent work on trajectory stitching [45, 47], we decompose the problem into segment-wise generation. Specifically, between two adjacent way-points ( x i , t i ) and ( x i +1 , t i +1 ) , we generate a segment τ i that:

has length t i +1 -t i +1 ;

starts at x i and ends at x i +1 ;

satisfies all invariance progresses active in [ t i , t i +1 ] .

The complete trajectory τ is then formed by concatenating all segments τ i . This design balances tractability with expressiveness, ensuring that long-horizon STL tasks can be addressed while maintaining consistency with the learned trajectory distribution.

E.3 Constrained Generation Mechanisms

To enforce the above conditions, we incorporate several mechanisms into the generation process:

Length control. As noted in [16], the planning horizon of a diffusion model is not fixed by its architecture but dynamically adapts based on the input noise size. This allows for variable-length plans during the denoising process at test time. In this work, we leverage this adaptability by directly adjusting the input noise size to generate trajectories of the desired length. During experiments, we observe that models trained with longer planning horizons generalize better to different trajectory lengths during testing. In contrast, models trained with shorter planning horizons exhibit weaker generalization. To address this, one can employ multiple models trained with different horizons, each responsible for generating trajectories whose lengths are close to their respective training horizons. Alternatively, one can train one diffusion model using trajectory segments of varying lengths, which has been shown to improve the generalization ability of diffusion models for generating trajectories of different lengths [53].

Waypoint inpainting. To respect waypoint constraints, we treat generation as an inpainting problem as [16], where the start and end states of each segment are replaced with ( x i , x i +1 ) after every denoising step.

Safety constraints. Each invariance progress I ( a, b, µ ) is decomposed into constraints of the form h µ i ( x t ) ≥ 0 for t = a, a +1 , . . . , b , which can be handled by many existing methods [29, 32, 33, 34, 35]. We adopt SafeDiffuser [29], which integrates control barrier functions (CBFs) [36] into the denoising dynamics. At each diffusion step, a quadratic program (QP) is solved to minimally adjust the update direction while ensuring all CBF constraints are satisfied, thereby providing finite-time invariance guarantees during trajectory generation.

F Details of Experiments

F.1 Environments

We evaluate our proposed framework across a diverse set of environments that encompass both navigation and robotic manipulation domains, as well as a custom-built environment designed for controlled comparisons. These environments differ significantly in their underlying dynamics and control dimensionality, thereby providing a comprehensive test of the generality and robustness of our approach. Importantly, in all experiments we only utilize the environments and their associated STL task-agnostic trajectory datasets provided by the original benchmarks. We explicitly discard the original task definitions and evaluation protocols, and instead redefine all tasks as Signal Temporal Logic (STL) specifications, allowing us to unify the evaluation across domains. Visualizations of all environments are shown in Figure F.1.

D4RL Maze2D [38] ( U-Maze , Medium , Large ) . This environment features a point-mass agent navigating within two-dimensional maze layouts of increasing complexity. The original benchmark tasks are goal-reaching problems defined by start and goal locations. In our experiments, these tasks are reformulated as STL specifications that require the agent to sequentially reach multiple target regions in the maze, enforcing both temporal ordering and spatial reachability constraints.

OGBench AntMaze [42] . In this environment, an 8-DoF quadruped 'ant' robot must traverse a large two-dimensional maze. Compared to Maze2D, the AntMaze environment introduces substantially more complex locomotion dynamics. While the original benchmark evaluates performance by whether the ant reaches a single goal region, we instead define STL tasks that require visiting multiple spatial regions in a prescribed temporal order.

OGBench Cube [42] . This environment involves a 6-DoF UR5e robotic arm performing cube manipulation on a tabletop. The original benchmark tasks assess goal-conditioned manipulation success using predefined demonstrations. For our evaluation, we abstract away from the physical cubes and focus on the Cartesian-space motion of the robot's end-effector. We define STL tasks that constrain the end-effector to visit a sequence of spatial waypoints within specified temporal windows, thereby converting the manipulation process into a structured STL-constrained trajectory planning problem. This abstraction allows large-scale and systematic testing of our framework.

Custom-built Environment . To further evaluate the reliability of the Progress Allocation module in our framework, we construct a custom simulation environment consisting of a bounded two-

1

2

3

4

1

2

3

4

1

2

3

4

dimensional square arena with a circular obstacle. The agent follows double-integrator dynamics and is required to accomplish randomly generated STL tasks by reaching designated regions within specified time intervals. Unlike the benchmark environments, this setting provides full access to the system model and environment information, which are relatively simple, thereby enabling direct comparison with sound and complete optimization-based baselines that require full knowledge of system dynamics and environment layout.

F.2 STL Task Generation

To generate random STL tasks, we design nine STL task templates, as illustrated in Table F.1. For each template, we randomly sample time intervals as well as the positions and sizes of the regions corresponding to the atomic predicates, thereby producing diverse randomized STL tasks. The feasibility of each generated STL task is verified using the Progress Allocation module of our method in all experiments, except for the custom-built environment experiment, where feasibility is instead verified using the sound-and-complete baseline algorithm.

F.3 Details of Experiment in Maze2d Environment

Baseline Algorithm. We compare our algorithm with the method proposed in [23], which adopts classifier-based guidance and directly leverages the gradient of the trajectory's robustness value to guide the sampling process of the diffusion model, thereby optimizing the robustness of the generated trajectory. The gradient of robustness is calculated by the STLCG method proposed in [55]. In the following text, we refer to this algorithm as the Robustness Guided Diffuser (RGD).

Experimental Settings. The diffusion models used in both RGD and our algorithm are trained following the procedure in [16] using the D4RL dataset [38]. A simple multilayer perceptron (MLP) with four fully connected layers is used as the TimePredict model in our algorithm and it is also trained using the same dataset. In our experiments, we employ diffusion model to generate only the state sequence of the trajectory and use a simple PD controller to follow the state sequence during running to get the actual execution trajectory as described in Section 3.5.

Evaluation Metrics. For each pair of Maze2D environment (U-Maze, Medium, Large) and task template listed in Table F.1, we generate 150 feasible random STL formulae as testing cases and test RGD and our algorithm on them and record the following metrics:

Execution Success Rate (SR): The proportion of cases where the actual execution trajectory achieve non-negative robustness values.

Average Robustness Value (RV): The average robustness value of the executed trajectories, after discarding the top and bottom 5% to mitigate the effect of outliers.

Total Planning Time (T0): The average total running time (in seconds) to plan a trajectory per case.

In addition, we also record the average Trajectory Generation Time (T1) , which is the average time spent by the Trajectory Generation module of our algorithm per case. By recording this metric, we analyze the proportion of runtime contributed by each module in our algorithm.

For total planning time, we report both the mean and standard deviation in our results. For success rate, we compute the proportion of successful cases over the total number of test cases.

Full Results. The full experimental results are presented in Table F.2.

More Cases. We visualized some of the experimental results. The actual execution trajectories for some successful cases (where the STL tasks were satisfied by the execution trajectories) are shown in Figure F.2 to Figure F.4. For some failed cases (where the STL tasks were not satisfied), the trajectories planned by our algorithm are shown in Figure F.5.

Failure-case Analysis. Notably, by analyzing the failure-cases, we identified that the primary reason for execution failure is that the trajectories generated by the diffusion model significantly violated system dynamics, such as colliding with obstacles in the environment or having excessively large distances between consecutive states. To further enhance the actual execution success rate, our method can be integrated with some receding horizon control methods [56] or online replanning strategies [57]. This extension will be explored in our future work.

F.4 Details of Experiments under More Complex Dynamics

To further evaluate the generality and robustness of our framework, we conduct experiments on two dynamics-rich domains from the offline goal-conditioned RL benchmark OGBench [42]: cube-singleplay ('Cube') and antmaze-medium-navigate ('AntMaze').

Experimental Settings. The Cube environment involves a 6-DoF UR5e robotic arm manipulating a cube, while AntMaze features an 8-DoF quadruped ant navigating through a complex maze. In both environments, training relies solely on STL task-agnostic trajectory datasets provided by the benchmark; during evaluation, we replace the original goal-conditioned objectives with randomly generated STL tasks that encode multi-stage temporal and spatial constraints.

For AntMaze, we adopt the STL formulation described in Section 5.1: the agent must visit designated regions in a specific temporal order to satisfy the task specification. Planning is performed in the two-dimensional x -y workspace, while execution uses an inverse dynamics controller that maps a 29-dimensional observation and the next x -y target to an 8-dimensional action at each control step as

1

2

1

2

1

2

1

2

1

2

1

2

1

2

1

2

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

3

4

1

2

1

2

3

4

1

2

3

4

1

2

1

2

3

4

1

2

3

4

1

2

3

4

1

2

in [47]. Given the higher dynamic complexity of this domain, we set k = 2 , such that each planning timestep corresponds to two control steps, as described in Section 3.5.

For the Cube environment, we focus on the end-effector's Cartesian motion rather than the physical manipulation of objects. Trajectories are generated in x -y -z space and tracked via a PD controller, as in Section 3.5. This abstraction ensures methodological consistency with other experiments while still capturing the essential planning characteristics of high-dimensional robotic control.

Evaluation Metrics. For each environment and STL task template (as defined in Table F.1), we randomly generate 100 feasible STL formulae as test cases. We report two quantitative metrics: Execution Success Rate (SR) and Total Planning Time (T0) .

Results. The complete results are summarized in Table F.3. Our framework achieves high success rates across both environments, with moderate computational cost despite the distinct dynamic structures of the two systems.

Analysis. In the Cube environment, our method achieves consistently strong performance, with execution success rates exceeding 90% on most task templates. The low planning time (typically below 2 seconds) indicates that the framework efficiently handles the dynamics of the 6-DoF manipulator. Performance degradation is observed only in more complex templates (Types 4 and 9), which involve long-horizon temporal dependencies and nested STL tasks. These cases require more extensive search and multiple calls to the trajectory generator, slightly increasing the planning time while reducing the success rate due to accumulated modeling uncertainty. Nevertheless, the overall high success rate demonstrates that our framework generalizes well to this manipulation-like domains.

In contrast, the AntMaze environment presents a substantially greater challenge due to its highdimensional locomotion dynamics and strong coupling between joint configurations and global motion. Here, the average success rate remains around 80-90% for moderate templates but drops to around 60% for the most complex ones (Types 5, 6, and 9). A closer examination reveals that these harder tasks often involve stringent temporal nesting and 'avoid' constraints, which are more sensitive to execution noise and controller-induced deviation. The higher planning times-especially for longhorizon templates (e.g., Type 5 and 6)-reflect the reduced efficiency of the trajectory generation module in scenarios requiring longer trajectories due to more complex dynamics. Nevertheless, our method is still able to produce feasible trajectories in most cases within an acceptable time frame.

Overall, these results confirm that the proposed framework scales effectively from smooth, fully actuated manipulation systems to complex locomotion environments. The modular combination of decomposition, allocation, and diffusion-based trajectory generation allows efficient reasoning over

STL objectives, maintaining both computational efficiency and high task success rates across diverse dynamical regimes.

F.5 Details of Comparative Experiment with Optimization-based Method

To further evaluate the success rate of the progress allocation module in our algorithm, we compare it against a widely-used optimization-based algorithm [4] in a custom-built simulation environment. The baseline algorithm is employed as a sound and complete solution to accurately assess the feasibility of randomly generated test cases.

Experimental Settings. The experiment is conducted within a bounded 10 × 10 square 2D plane containing a circular obstacle. The underlying system dynamics are modeled using a double integrator. The agent starts from a randomly generated position and must complete the randomly generated STL tasks by reaching the target region within the specified time interval.

In this experiment, the baseline algorithm is implemented using the open-source library stlpy [2] and has full knowledge of the environmental information and system dynamics, while our algorithm only has access to the trajectory dataset.

To generate the trajectory dataset, we randomly sample start and end points in the environment and use the baseline algorithm to solve reach-avoid tasks. This process produces 200,000 collision-free trajectories that satisfy the system dynamics, which are then used to train the diffusion model and the Time Predictor.

To further enhance the trajectory generator's ability to produce trajectories of varying lengths, we train two diffusion models with different horizons: one dedicated to generating shorter trajectories and the other specialized for longer trajectories. The first model is trained on trajectory segments of length 16 for shorter trajectories, while the second model uses segments of length 32 to improve generalization to longer trajectories.

We generate 200 feasible STL tasks for each template, as described in Section F.2. The deterministic baseline algorithm is used to ensure the feasibility of these tasks. However, for templates 4 and 5, which involve multi-layer nesting of temporal operators, the baseline algorithm fails to find solutions within an acceptable time. In these cases, we still employ our algorithm's progress allocation module to verify feasibility.

Evaluation Metrics. In addition to the Execution Success Rate (SR) and Total Planning Time (T0) metrics described in Section 5, we introduce an additional evaluation metric:

Progress Allocation Success Rate (SR0): The proportion of cases where the progress allocation module successfully identifies a sequence of waypoints. This metric specifically measures the reliability of the progress allocation module in our algorithm.

Analysis. The experimental results are summarized in Table F.4. Since the optimization-based baseline is used as an expert solver to certify the feasibility of randomly generated STL tasks, its execution success rate ( SR ) is naturally 100% and thus omitted from Table F.4. Our algorithm achieves

consistently high success rates across test cases generated from diverse task templates. Notably, the Execution Success Rate (SR) exceeds 69% in all scenarios, demonstrating the algorithm's strong generalization capability for STL tasks.

For all templates except 4 and 5, the Progress Allocation Success Rate (SR0) exceeds 80% , indicating that the progress allocation module is generally reliable, albeit slightly conservative.

Finally, by comparing the Total Planning Time , our algorithm significantly outperforms the optimization-based baseline algorithm, highlighting the efficiency of the task decomposition and planning framework employed in our approach. Notably, for templates 4 and 5, which involve multilayered nested STL tasks, the baseline algorithm fails to find feasible solutions within a reasonable time. In contrast, our algorithm demonstrates both high success rates and high efficiency, even in these complex scenarios.

F.6 Analysis of the Predictor-Generator-Controller Framework

In our framework, the Time Predictor serves as a crucial component that provides heuristic guidance on system reachability during progress allocation. By estimating the time required for transitions between states, it allows the allocation process to consider not only the logical satisfaction of STL constraints but also the underlying dynamical feasibility between consecutive waypoints, thereby creating favorable conditions for subsequent trajectory generation. The Time Predictor operates in close collaboration with the diffusion-based trajectory generator. Specifically, the predictor estimates the expected travel time between two states, and the generator then produces a trajectory of the corresponding length. Although the true time-to-reach can vary considerably due to stochasticity and unmodeled dynamics, a generator trained on trajectory segments of diverse lengths demonstrates strong generalization. In practice, even a moderately accurate statistical estimate from the predictor typically suffices to produce a dynamically feasible trajectory. Moreover, the feedback control layer further compensates for residual prediction errors, ensuring consistent execution despite model approximation. To empirically validate the effectiveness of this collaboration, we conducted an additional experiment in both Maze2D and AntMaze environments.

Experimental Settings. For each environment, we randomly sampled 1000 start-goal pairs (with goal region radii ranging from 3% to 6% of the arena size). For each case, the Time Predictor estimated the required trajectory length from the start position to the center of the goal region; the trajectory generator then produced a trajectory of that length, which was subsequently executed using a PD controller (in Maze2D) or an inverse dynamics model (in AntMaze) under the strict time-synchronous control protocol described in Section 3.5 (with k = 1 in Maze2D and k = 2 in AntMaze). All modules were employed exactly as implemented in our main framework, without additional tuning.

Results and Analysis. The resulting execution success rates, summarized in Table F.5, demonstrate that even in the more challenging AntMaze setting, the current predictor-generator-controller pipeline achieves high overall reliability. These results underscore the effectiveness of modular integration among prediction, generation, and control within our framework. Given this modular design, each component can be further improved independently-for example, by incorporating more accurate time prediction models [51, 52, 58] or more expressive trajectory generators-to handle increasingly complex dynamical systems. We leave such extensions as promising directions for future work.

F.7 Implementation Details of Experiments

F.7.1 Calculation of the Robustness Value

In our experiments, we compute the robustness values of execution trajectories using the opensource library stlpy [2], which implements quantitative semantics for Signal Temporal Logic

(STL). However, in environments such as Maze2D, AntMaze, and Cube, transitions between states often require relatively long trajectories. As a result, the corresponding STL task intervals become lengthy, leading to a substantial computational burden when evaluating robustness directly on the full-resolution trajectories-often exceeding the available computational resources.

To mitigate this issue, we introduce a temporal sampling factor η , which defines the mapping between the time scale of the STL task and the resolution of the system trajectory used for evaluation. Specifically, one discrete time step in the STL task corresponds to η time steps in the system trajectory. When computing robustness, we sample one state every η steps to obtain a down-sampled trajectory , and then evaluate robustness on this sampled sequence. Importantly, the STL formula used for evaluation is also temporally rescaled, with all time intervals divided by η , so that the robustness value is computed with respect to a temporally consistent but shorter-horizon STL specification. This procedure effectively reduces computational overhead while preserving the temporal and logical structure of the original task.

It is worth emphasizing that the parameter η is conceptually distinct from the parameter k introduced in the control protocol (Section 3.5). While k determines the number of low-level control updates executed per planning step during runtime-thus linking planning and control frequenciesη only affects the post-hoc evaluation of robustness by defining how densely the executed trajectory is sampled for STL computation.

F.7.2 Experimental Parameter Settings

Some of the parameters involved in the experiments are listed below, and their specific values are shown in Table F.6:

Maximum Number of Attempts ( N max ) : The maximum number of attempts for new state sampling in Algorithm 2.

Horizon ( H ) : The planning horizon used during the training of the diffusion model.

Total Denoise Steps ( N ) : The total number of steps in the denoising process.

Scaling Factor ( γ ) : Applied to the predicted mean trajectory length, used to control the conservativeness of the Progress Allocation Module, as described in Section 3.3.

Sampling Factor ( η ) : Used when computing the robustness value of trajectories, as described in Section F.7.1.

Control Frequency ( k ) : The number of low-level control updates executed per planning step during runtime, as described in Section 3.5.

G Proofs

G.1 Proof of Lemma 1

Proof. We prove the statement by structural induction on φ . Throughout, we assume discrete time t ∈ Z ≥ 0 and use the shorthand s 0 ⊨ R ( a, b, µ ) ⇔∃ t ∈ [ a, b ] : x t ⊨ µ and s 0 ⊨ I ( a, b, µ ) ⇔∀ t ∈ [ a, b ] : x t ⊨ µ (cf. (3)-(4)).

Base cases.

(i) φ = F [ a,b ] µ . The decomposition yields P φ = {R ( λ, λ, µ ) } , T φ = { λ ∈ [ a, b ] } , Λ φ = { λ } . By the Boolean semantics of F (Eq. (C.4)),

which is exactly the desired form with λ = [ λ ] ∈ F φ .

(ii) φ = G [ a,b ] µ . The decomposition yields P φ = {I ( a, b, µ ) } and Λ φ = T φ = ∅ . By Eq. (C.5),

which matches the target equivalence (no time variables).

(iii) φ = µ 1 U [ a,b ] µ 2 . The decomposition yields P φ = {I (0 , λ, µ 1 ) , R ( λ, λ, µ 2 ) } , T φ = { λ ∈ [ a, b ] } , Λ φ = { λ } . By Eq. (C.6),

again yielding the target form with λ = [ λ ] ∈ F φ .

Inductive steps. For each constructor below we assume the lemma holds for the immediate subformula(e).

(1) Conjunction φ = φ 1 ∧ φ 2 . By semantics, s 0 ⊨ φ ⇔ ( s 0 ⊨ φ 1 ∧ s 0 ⊨ φ 2 ) . The decomposition uses disjoint unions P φ = P φ 1 ⊎ P φ 2 , T φ = T φ 1 ⊎ T φ 2 , Λ φ = Λ φ 1 ⊎ Λ φ 2 , implicitly α -renaming to avoid clashes. Since each constraint in T φ i involves a single variable, the feasible set factors: F φ = F φ 1 ×F φ 2 . By the IH on φ 1 , φ 2 and the fact that every progress in P φ depends only on its own component of λ = [ λ 1 , λ 2 ] , we obtain

(2) Outer finally φ ′ = F [ a,b ] φ . By Eq. (C.4), s 0 ⊨ φ ′ ⇔∃ λ ∈ [ a, b ] : s λ ⊨ φ. Time-shift identity. For any progress P ( c, d, µ ) and any k ∈ Z ≥ 0 ,

This is immediate from the definitions of R and I . The decomposition introduces a fresh λ ∈ [ a, b ] and shifts every progress of φ by + λ ; hence Λ φ ′ = Λ φ ⊎ { λ } and F φ ′ = { [ λ , λ ] | λ ∈ F φ , λ ∈ [ a, b ] } . Applying the IH to φ on the shifted signal s λ and then using (G.1) yields

(The special case F [ a,a ] is the same with a constant shift + a and no new variable.) (3) Outer always φ ′ = G [ a,b ] φ . In discrete time,

since s 0 ⊨ G [ a,b ] φ iff s k ⊨ φ for every integer k ∈ [ a, b ] . The decomposition makes an independent copy ( P ( k ) φ , T ( k ) φ , Λ ( k ) φ ) for each k and shifts every progress by + k , then merges all copies:

Applying item (2) to each F [ k,k ] factor and using (G.1) yields the target form. Merging constant invariances. If I ( c, d, µ ) ∈ P φ has constant endpoints, then its shifted copies {I ( c + k, d + k, µ ) } b k = a are equivalent to the single I ( c + a, d + b, µ ) because ⋃ b k = a [ c + k, d + k ] = [ c + a, d + b ] in discrete time; hence merging preserves truth.

(4) Outer until φ ′ = ϕ U [ a,b ] φ . By assumption, ϕ contains no F or U , thus its decomposition consists solely of invariance progresses with constant endpoints and Λ ϕ = T ϕ = ∅ . The decomposition

of φ ′ : introduce λ ∈ [ a, b ] , shift each progress of φ by + λ , and prolong every I ( c, d, µ ) ∈ P ϕ to I ( c, d + λ, µ ) . Formally,

By Eq. (C.6),

The first conjunct is handled by item (2) with the shift identity (G.1). For the second conjunct, note the following sliding-invariance identity : for any constant c ≤ d ,

because s τ ⊨ I ( c, d, µ ) means ∀ t ∈ [ c + τ, d + τ ] : x t ⊨ µ , and ⋃ λ τ =0 [ c + τ, d + τ ] = [ c, d + λ ] in discrete time. Since P ϕ is a conjunction of such invariances, applying (G.4) to each member yields the prolonged invariances in P φ ′ . Combining these observations with (G.3) gives

Conclusion. All constructors preserve the claimed equivalence. By structural induction, for any PNF STL formula without disjunctions,

G.2 Proof of Lemma 2

Proof. We argue by maintaining inductive invariants along the DFS. At each node of the search tree we keep a tuple ( x , t, P R rem , T , ˜ s ) , where ˜ s is the waypoint list accumulated so far and P R rem are the remaining reachability progresses.

Inductive invariants. After initialization and after every successful extension by Algorithm 2 and UpdateConstraint , the following hold:

(I1) Feasibility is preserved: the current constraint set T admits at least one assignment of time variables (i.e., the feasible set is nonempty).

(I2) Committed reachabilities are honored: for every reachability progress R ( a Λ , b Λ , µ ) that has been assigned a waypoint ( x ′ , t ′ ) and removed from P R rem , T contains the inequalities a Λ ≤ t ′ and b Λ ≥ t ′ . Hence any λ feasible for T satisfies t ′ ∈ [ a Λ ( λ ) , b Λ ( λ )] .

(I3) Waypoint-level invariance consistency: let I ( c, d Λ , µ ′ ) be any invariance progress whose start time has been determined (by preprocessing every I has a preceding R ( c, c, µ ′ ) ; once that R is assigned at time c = t ∗ , the start is fixed). Whenever a new waypoint ( x ′ , t ′ ) is appended with x ′ ⊭ µ ′ , Algorithm 2 computes a conflict interval O and UpdateConstraint adds d Λ < t ′ ; consequently, no feasible λ can make the interval [ c, d Λ ( λ )] cover t ′ , so I cannot be active at t ′ .

Initialization. At the start, ˜ s = [( x 0 , 0)] and T is the given constraint set; by assumption it is feasible, so (I1) holds. No progress has been assigned, so (I2) and (I3) are vacuous.

Preservation under one extension. Suppose the algorithm chooses a remaining reachability R ( a Λ , b Λ , µ ) at ( x , t ) and calls Algorithm 2. By construction, the routine computes the largest currently feasible time window [ t min , t max ] consistent with T , and samples a candidate x ′ | = µ together with a predicted arrival time t ′ . If t ′ > t max or the residual feasible window is covered by conflicts, the attempt is discarded; otherwise the routine returns the earliest nonconflicting time t new ∈ [max { t ′ , t min } , t max ] \ O . Therefore, with t ∗ := t new , the augmented constraints a Λ ≤ t ∗ , b Λ ≥ t ∗ are consistent with the current T , establishing (I1) and (I2) at the child node. Moreover, for every invariance with determined start time that is violated by x ′ , UpdateConstraint inserts d Λ < t ∗ ; since Algorithm 2 avoided O and t ∗ lies strictly to the right of the current lower bound for d Λ , the new inequality is compatible with T . Hence (I3) holds as well.

̸

Termination case and witness construction. When the algorithm returns, P R rem = ∅ and the final constraints are T f with feasible set F f = ∅ by (I1). Pick any λ ∈ F f . By (I2), for every assigned reachability with waypoint time t i , we have t i ∈ [ a Λ ( λ ) , b Λ ( λ )] , hence s 0 | = R ( a Λ ( λ ) , b Λ ( λ ) , µ ) . For any invariance I ( a Λ , b Λ , µ ′ ) and any waypoint time t i that lies in its active window [ a Λ ( λ ) , b Λ ( λ )] , there are two possibilities: (i) ˜ x i | = µ ′ , in which case the waypoint trivially satisfies the invariance; or (ii) ˜ x i ⊭ µ ′ , in which case the start of this invariance has already been determined by its preceding reachability, and (I3) guarantees that t i cannot lie in the interval (because d Λ < t i was added). Either way, the stated waypoint-level invariance condition holds. This proves the lemma.

Remark 3 (Scope of the guarantee) . The lemma certifies that, under some feasible time-variable assignment, all reachability progresses are satisfied and no invariance progress is violated at the returned waypoint times. It does not claim invariance satisfaction at every intermediate time step between waypoints.

G.3 Proof of Theorem 1

Proof. Let ( P φ , T φ ) be the progress/constraint pair returned by the Semantics-based Decomposition, and let ˜ s = (˜ x 0 , t 0 ) (˜ x 1 , t 1 ) . . . (˜ x n , t n ) with 0 = t 0 ≤ · · · ≤ t n and final constraint set T f be the output of the Progress Allocation algorithm. By assumption, F f = ∅ . Fix any feasible assignment λ ⋆ ∈ F f and let s 0 = x 0 x 1 . . . x T ( T ≥ t n ) be the signal induced by the trajectory τ returned by the Trajectory Generation module, which (by assumption) satisfies: (i) x t i = ˜ x i for all i , and (ii) for every invariance I ( a Λ , b Λ , µ ) , ∀ t ∈ [ a Λ ( λ ⋆ ) , b Λ ( λ ⋆ )] we have x t | = µ .

̸

Reachability progresses. By construction of the allocation phase and by Lemma 2, for every R ( a Λ , b Λ , µ ) ∈ P φ there exists an index i such that (a) ˜ x i | = µ and (b) t i ∈ [ a Λ ( λ ⋆ ) , b Λ ( λ ⋆ )] , because T f contains the constraints a Λ ≤ t i and b Λ ≥ t i , which are satisfied by λ ⋆ . Since the generated signal visits all waypoints, x t i = ˜ x i , hence s 0 | = R ( a Λ ( λ ⋆ ) , b Λ ( λ ⋆ ) , µ ) .

Invariance progresses. By property (ii) of the generated trajectory, for every I ( a Λ , b Λ , µ ) ∈ P φ we have ∀ t ∈ [ a Λ ( λ ⋆ ) , b Λ ( λ ⋆ )] : x t | = µ , i.e., s 0 | = I ( a Λ ( λ ⋆ ) , b Λ ( λ ⋆ ) , µ ) .

Conclusion via decomposition soundness. We have shown that for the same feasible assignment λ ⋆ ,

Therefore, by Lemma 1, s 0 ⊨ φ . This proves the theorem.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper presents a novel, data-driven hierarchical framework for generating robot trajectories that satisfy complex Signal Temporal Logic (STL) tasks when the system dynamics are unknown. The proposed method decomposes the STL specification into simpler timed objectives, searches for waypoints to achieve them, and then uses a pre-trained diffusion model to generate and stitch together the final trajectory segments. This approach allows for zero-shot generalization to new tasks using only task-agnostic data and is formally proven to guarantee the satisfaction of the given STL specification if a solution is generated. Run-time execution performance is shown to be quicker than existing diffusion-based solutions with a higher overall success rate.\n\nSTRENGTHS AND WEAKNESSES:\n## Strengths:\n\n- **Novelty:** The algorithm, while being manually constructed and heuristic based, focuses on generating a valid solution to a given STL specification using Diffusion-based sampling. The approach is novel and cleverly avoids the problem of getting long range trajectories with diffusion models (by sampling between generated waypoints) as well as handling Invariance or Avoidance Predicates (by using $\\texttt{SafeDiffuser}$ that integrates Control Barrier Functions while sampling).\n- **Speed:** The algorithm is shown to be much faster than existing approaches and elegantly handles the slow inference time of diffusion models.\n\n## Weaknesses:\n\n- **Assumption of TimePredict:** The accuracy of $\\texttt{TimePredict}$ is important and is hard to guarantee in a general setting. For example, depending on the maze structure, the time between states may vary drastically. Some requirements on this function (such as assumed accuracy range) along with related experiments (in a given maze) would be helpful to understand the validity of the approach and how easy it would be to get this function. This is especially the case in environments with complex dynamics (e.g., instead of a point mass as in the experiments, if the agent was a quadruped or a differential drive robot).\n- **Solution Optimality:** The approach has several heuristics and assumptions that guide the solution generation yet may not be optimal in many scenarios. Consider Algorithm 1 L9 For each progress ordered by starting time $a_\\Lambda$ - this may cause poor solutions in terms of makespan, e.g. $\\phi = F_{[0,100]} {A}\\land F_{[1,100]}{B}$ where goal A is far away and goal B is near the starting state. This would yield a solution visiting the far goal A first and the coming back for goal B. I realize there are no mentions of solution optimality by the given algorithm, but this is just pointing out the fact that different solutions have distinct characteristics which are often of concern to the user.\n- **Metrics Beyond Success Rate:** On a related note, rather than success rate alone, a makespan equivalent metric or “time to complete” metric could help to give a better idea of solution quality rather than simply success rate.\n- **Writing:** Although the ideas proposed are interesting, the writing and organization could do with several refinements.\n    - **Organization of Section 3:** At over four pages, Section 3 is overly long, making it difficult to follow. Subsection 3.3, in particular, should be reorganized into distinct subsections for each primary module of the algorithm (e.g., Main-Allocation, $\\texttt{SampleState}$) to clearly delineate their functions.\n    - **Clarity of Notation:** I found the notation in L163-L174 somewhat unclear. While going through the appendix provided the necessary clarification, I suggest incorporating some of those details into the main body to improve readability.  For example, the definition of $\\Lambda$ (L163) being a set of time instance variables (clarified in L236) and the domain of $\\mathfrak{t}\\in\\mathbb{T}_\\varphi$ (L171) could be made more explicit in the main text.\n    - **Correction of References:** L 283 mentions “the above DFS” which erroneously points to Algorithm 2, while I believe this references Algorithm 1 (a reference could be inserted here). Additionally, this line could be in the suggested new Main-Allocation subsection which can be separate from the $\\texttt{SampleState}$ subsection.\n    - **Refinement of Figure 1:** The figure lacks clarity and consistency with the text. Labels in the diagram, such as \"Guided Sampling,\" should be updated to match section titles like \"Trajectory Generation.\" The diagram itself should also employ standard conventions, using different shapes to distinguish processes from outputs (e.g., \"Progress Allocation\" vs. \"Waypoints Sequence\").\n\nQUESTIONS:\n1. In Algorithm 2, L7, what is $d^{\\text{min}}_{det}$? On a related note, I find it difficult to understand the purpose of L5-9 in Algorithm 2, could I get an explanation please or a reference to where it is explained in detail?\n2. Would it be possible to include experiments with more complicated dynamics such as the Ant robot?\n3. In the Results section (L411-412), why is the performance of the method underplayed? It appears to have a greater than 90% and 79% overall success rate (vs 80 and 69 as mentioned). \n4. In Table G.1, why is the success rate of STLPY not mentioned?\n5. How does the approach manage discrepancies between planning times and execution delays (i.e., failure to reach a goal on time due to the controller)? How does this impact the success rate?\n6. Typos:\n    - L202: way-point → way-points\n    - L207: satisfication → satisfaction\n    - L252: fucntion → function\n    - L681: Sementic → Semantic\n\nLIMITATIONS:\n- Assumes a valid $\\texttt{TimePredict}$ function exists for the entire system, but this is not easy in many environments. For example, a setting where multiple robots are placed in a maze, predicting the time between global system states could be hard due to conflicts.\n- The algorithm heuristics may lead to sub-optimal solutions in terms of makespan which is not fully examined.\n- Delays during execution can cause the specification to not be satisfied and this does not appear formalized.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "CLARITY": 2, "IMPACT": 4, "ORIGINALITY": 3, "DATE": "2025-06-24"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose a method for satisfying STL specifications using a combination of spatio-temporal decomposition and trajectory generation using diffusion. Using previously collected trajectory data, the authors generate estimates for travel times between regions in space, in addition to training a diffusion model for generating short trajectories that can be stitched together. The decomposed STL specification is used to generate “progresses” that capture reachability and invariance properties implied by the STL specification. The time estimates assign times to these progresses to generate a sequence of timed waypoints, and the diffusion model is used to generate trajectories to reach those timed waypoints. Results are compared against a recent diffusion approach for STL satisfaction.\n\nSTRENGTHS AND WEAKNESSES:\nStrengths:\n- This paper covers an interesting and timely problem area. The method outperforms recent methods on the provided metrics.\n- The discussion of limitations is thorough and fair, and the authors even include examples of failure cases.\n- The paper is reasonably clear—for someone well-versed in this area, it is easy to gather the main ideas and most of the important details.\n\nWeaknesses:\n- The descriptions in sec. 3.3 should refer to line numbers in the algorithms. It seems like the backtracking element is not presented in the algorithm. Does this happen outside of Algorithm 1, or within it? In general, some more details about the algorithm would be appreciated – is it guaranteed to terminate? Obviously, the results suggest it is fast, but what is the complexity? If I’m not mistaken, there is an ILP in the algorithm that could cause bottlenecks depending on what variables impact its performance.\n- Unless I missed it, there is no comparison of robustness of RGD and the proposed method. Quantitative semantics are one of the key motivators for using STL, and it would be informative to see whether the methods perform comparably.\n\nMinor:\n- Line 110, missing space in “unknown,but”\n- Line 202, should “way-point” be “waypoints”?\n- Line 215 “remained” should be “remaining”\n- Line 252 “fucntion\"\n- Line 286 “estimates” should be “estimate”\n\nQUESTIONS:\nWas there a reason that alternatives to diffusion were not used as comparators? For example, one could imagine using RRT* or related methods to generate candidate trajectory segments. Since there needs to be some controller to track the diffusion trajectory anyway, it seems like you could apply the same controller to an RRT* generated trajectory.\n\nRelatedly, what were the dynamics used in the simulation results? This seems to have strong implications for how successful the method would be. I would expect it to be easier to learn a model for a single integrator than for more complex nonlinear dynamics. However, the latter is where a method such as this would probably be more useful.\n\nWhere do $a_{\\Lambda,\\mathbb{T}}^{min}$ and $b_{\\Lambda,\\mathbb{T}}^{max}$ come from? I was confused about the heuristic order, and it seems to hinge on how these are calculated.\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "CLARITY": 2, "IMPACT": 3, "ORIGINALITY": 3, "DATE": "2025-07-02"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper seeks to generate plans that satisfy signal temporal logic (STL) specifications without access to a transition model but assumes the state variables and their domain (values that can be assigned to them) are known. The algorithm decomposes an STL specification into a set of reachability and invariance progresses as well as time constraints. Based on this and a start state, a depth-first search is performed for a sequence of waypoints that satisfies the STL. At each node in the depth-first search, all possible unsatisfied progresses are examined and states that satisfy those progresses are sampled. After the waypoints are found a diffusion model trained on offline data is used to find the intermediate states and a sequence of actions that connects the state sequence is found via an inverse dynamics model. The algorithm was evaluated on 2D maze tasks.\n\nSTRENGTHS AND WEAKNESSES:\n**Strengths**\n\nThe approach can find a sequence of states that satisfies an STL specification without needing a model since the diffusion model is trained via an offline dataset. Decomposes and STL specification into progresses to better integrate with search for waypoints.\n\n**Weaknesses**\n\nIt appears the main innovation of this paper is satisfying STL constrains in a model-free manner. However, the algorithm to accomplish this finds waypoints via a depth-first search that does not use a domain-specific heuristic function (which could be learned). Therefore, I do not believe this algorithm will scale to larger search spaces.\n\nWhile there is preference given to next waypoints with a lower predicted time to be reached from the current waypoint, the manner in which these states are generated does not directly depend on the current waypoint. Therefore, very inefficient plans may be found.\n\nGiven the sequence of states, generating action sequences still depends on an inverse model. Therefore, I do not think that this method truly addresses the problem of satisfying STL plans with unknown dynamics.\n\nFor the evaluation, there are failure cases. However, it is not clear where the algorithm failed (i.e. at waypoint search, state trajectory generation with the diffusion model, or action generation).\n\nQUESTIONS:\nHow is sampling of x’ in Algorithm 2 performed such that x’ entails \\mu?\n\nLIMITATIONS:\nSearch for waypoints is based on a depth-first search, which will not scale to larger state spaces.\nSampling waypoints does not directly depend on the current waypoint, which can lead to inefficient plans.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 3, "CLARITY": 2, "IMPACT": 2, "ORIGINALITY": 2, "DATE": "2025-07-03"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper presents a planning algorithm for STL specifications. The proposed method first decomposes the STL formula into several basic formulations with reachability, invariance, and temporal constraints. Then a search-based algorithm is developed to generate waypoints that can satisfy this STL. The full trajectory is generated with a conditional diffusion model pre-trained on trajectory data.\n\nSTRENGTHS AND WEAKNESSES:\n## Strengths\n\n* The problem of planning for STL from offline trajectory data is interesting and meaningful.\n\n* The proposed decomposition and search algorithm can solve certain STL formulations.\n\n## Weaknesses\n\n* Major\n\n  * The major weakness is that the proposed search algorithm for waypoints generation did not take system dynamics into consideration. It seems that from STL decomposition to allocation, the proposed solution depends mainly on the STL formulation itself. Although there is a neural network based time predictor that can predict the time required to visit a future state from a current state, this predictor can overfit or generate unrealistic predictions. My understanding is that if two states are not in the same trajectory in the dataset, then according to the description of this training pipeline, the time predictor cannot learn state pairs outside individual episodes.\n  * Therefore:\n    * In state search/sample, it might not find new state that is actually possible by stitching together dataset trajectories;\n    * The generated waypoints, although can satisfy the STL, may not be achievable due to overfitting, as there does not exist a valid trajectory to satisfy the goal based on demonstration;\n    * Although scaling factors are added for time prediction, this does not align well with the actual trajectories, as the avoidance requirements may lead to much longer distance and time through detour path.\n  * The experimental environments used in this work are very toy example as they are all two dimensional navigation tasks for a point mass agent.\n\n* Minor\n\n  * The proposed framework depends on additional assumptions on the form of STL, for example, assuming operator “until” only has “always” temporal operator for its first operand, assuming DNF only has single subformula, and using replacement in DNF. The method only solves the resulting STL. Therefore, the solution is no longer optimal with respect to the original STL specification. And in the worst case, there might be no feasible solutions after these assumptions and transformation.\n\n  * The paper also implicitly assumes that the evaluation function is know to the planner if I am understanding correctly. I think this should be pointed out since it will make the method unrealistic in the environments where the atomic propositions of a state can only be observed once the agent really interacts that state.\n\nQUESTIONS:\nPlease see the weaknesses part.\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 3, "REVIEWER_CONFIDENCE": 3, "CLARITY": 3, "IMPACT": 1, "ORIGINALITY": 3, "DATE": "2025-07-03"}