TeLoGraF: Temporal Logic Planning via Graph-encoded Flow Matching
Authors: Yue Meng
Chuchu Fan
Venue: ICML 2025 poster (2025)
Keywords: Imitation Learning
Temporal Logic
Flow Matching
Graph Neural Networks
Primary area: applications->robotics
TL;DR: We utilize Graph Neural Networks (GNN) encoder and flow-matching to learn solutions for general signal temporal logic specifications.

Abstract: Learning to solve complex tasks with signal temporal logic (STL) specifications is crucial to many real-world applications. However, most previous works only consider fixed or parametrized STL specifications due to the lack of a diverse STL dataset and encoders to effectively extract temporal logic information for downstream tasks. In this paper, we propose TeLoGraF, Temporal Logic Graph-encoded Flow, which utilizes Graph Neural Networks (GNN) encoder and flow-matching to learn solutions for general STL specifications. We identify four commonly used STL templates and collect a total of 200K specifications with paired demonstrations. We conduct extensive experiments in five simulation environments ranging from simple dynamical models in the 2D space to high-dimensional 7DoF Franka Panda robot arm and Ant quadruped navigation. Results show that our method outperforms other baselines in the STL satisfaction rate. Compared to classical STL planning algorithms, our approach is 10-100X faster in inference and can work on any system dynamics. Besides, we show our graph-encoding method's capability to solve complex STLs and robustness to out-distribution STL specifications. Code is available at https://github.com/mengyuest/TeLoGraF

TeLoGraF:
Temporal Logic Planning via Graph-encoded Flow Matching
Yue Meng' Chuchu Fan
Abstract
stop before the stop sign and may proceed only if other cars have the right of way, etc. These cases require precise reasoning and planning to ensure safety, efficiency, and cor- rectness. Hence, it is of utmost importance to endow agents with the ability to tackle temporal logic constraints.
Learning to solve complex tasks with signal tem- poral logic (STL) specifications crucial to many real-world applications. However, most previous works only consider fixed parametrized STL specifications due to the lack of diverse STL dataset and encoders to effectively extract tempo- ral logic information for downstream tasks. In this paper, we propose TeLoGraF, Temporal Logic Graph-encoded Flow, which utilizes Graph Neu- Networks (GNN) encoder and flow-matching to learn solutions for general STL specifications. We identify four commonly used STT. templates and collect total of 200K specifications with paired demonstrations. We conduct extensive ex- periments in five simulation environments rang- ing from simple dynamical models the 2D space to high-dimensional 7DoF Franka Panda robot arm and Ant quadruped navigation. Re- sults show that our method outperforms other baselines in the STL satisfaction rate. Compared to classical STL planning algorithms, our ap- proach is 10-100X faster in inference and can work on any system dynamics. Besides, we show our graph-encoding method's capability to solve complex STLs and robustness out-distribution STL specifications. Code is available at ht https: // //github. www.e//meegeeeeeeeeeeotoo
Existing temporal logic specifications can be mainly cat- egorized into linear temporal logic (LTL) (Pnueli, 1977), computation tree logic (CTL) (Clarke & Emerson, 1981), metric temporal logic (MTL) (Koymans, 1990), and signal temporal logic (STL) (Donzé & Maler, 2010; Raman et al., 2015; He et al., 2022). LTL checks single system trace via logical operators and temporal operators, whereas CTL reasons for tree of possible futures. Extending from LTL, MTL introduces timed intervals for the temporal operators and STL further generalizes this by handling continuous- valued signals. In this work, we focus on STL since it offers the most expressive framework to handle wide range of requirements in robotics and cyber-physical systems.
However, it is challenging to plan paths under STL speci- fications, due to its non-Markovian nature and lack of effi- cient decomposition. Synthesis for STL satisfaction is NP- hard (Kurtz & Lin, 2022). Classical methods for solving STL include sampling- basedd methods (Vasile al., 2017; Kapoor et al., 2020), optimization-banl
methods (Sadrad- dini & Belta, 2015; Kurtz & Lin, 2022; Sun et al., 2022) and gradient- based methods (Dawson & Fan, 2022) but they cannot balance solution quality and computation efficiency for high dine-iinnsi systems or complex STLs.
There is growing trend to use learning- satisfy given STL (Li et al., 2017; Puranic et al., 2021; Liu et al., 2021; Guo et al., 2024) or family of parametrized STL (Leung & Pavone, 2022; Meng & Fan, 2024), but few of them can train one model to handle general STL.s. If new STL comes, they must retrain the neural network to learn the corresponding policy, resulting in inefficiency. Hashimoto et al. (2022) propose a model-based approach handle flexible STL forms but requires differentiable environments, While other works (Zhong et al., 2023; Feng et al., 2024) explored regularizing the pre-trained models with temporal logic guidance at test time, the generated trajectories are heavily constrained by the original data distribution. To the best of our knowledge, there is no existing model that can take general STL as input to produce satisfiable solutions.
methods
1. Introduction
Learning to plan for complex tasks with temporal depen- dency and logical constraints is critical to many real-world applications, such as navigation, autonomous vehicles, and industrial assembly lines. For example, robot might need to reach one of the destination regions in 10 seconds while avoiding obstacles, a robot arm will need pick the objects in specific sequence, vehicle should come a complete
Department Acronautics and Astronautics, MIT, Cambridge, USA. Correspondence to: Yue Meng <mengyue@@n (eaoyyue@miiteeee mii.
Proceedings of the ndnd International Conference Machine Learning. Vancouver, Canada. PMLR 267, 2025. Copyright 2025 by the author(s).

---

Signal Temporal Logic Planning via Graph-eneoded Flow Matching
Impeding the advance of STL-conditioned models are three critical challenges: (1) most of the papers either work simplified STLs that are not diverse enough or useful but heavily engineer-designet STLs (Maierhofer et al., 2022: Meng& & Fan, 2023) that are hard to generalize (2) there is no large-scale dataset available to provide paired demonstra- tions with diverse STL specifications and (3) unlike visual- conditioned or kunguage-conditione tasks, there lacks an analysis of the effective encoder design to embed the STL information to the downstream neural network.
to this survey (Urain et al., 2024) for full review. The general paradigm is to collect demonstrations from real- world (Chi et al., 2023; Zhong et al., 2023) off-the-shelf solvers (Yang et al., 2023; Carvalho et al., 2023; Huang et al., 2024), and then train the neural network to imitate the data. Based on the input modality, the related works can be summarized into state-based (Janner et al., 2022). 2D diffusion policy (Chi et al., 2023). 3D diffusion policy (Ze et al., 2024; Ke et al., 2024), and vision language action models (Team et al., 2024). Varied output forms have been proposed, such as configuration-basee based (Yang et al., 2023), cettion-based (Chi et al., 2023; Ze et al., 2024), trajectory- based (Carvalho et al., 2023; Meng & Fan, 2024), and hi- erarchical models (Li et al., 2023; Chen et al., 2024). Re- garding long-horizon task planning, compositional diffusion has been studied in GSC (Mishra et al., 2023) ChainedDif- fuser (Xian et al., 2023) and DiMSam (Fang al., 2024), where the task skeletons are usually fixed. More recently, flow-based methods (Chang et al., 2022: Chen et al., 2023; Prasad et al., 2024; Zhang et al., 2024) appear to have more stable training and faster sampling speed than diffusion models. Hence, we decide to use the linear flow discussed in (Liu et al., 2022) as our generative model backbone.
In this paper, we tackle all these points above and propose TeLoGraF (Temporal Logic Graph-encoded Flow), a graph- encoded flow matching model that can handle general STL syntax and produce satisfiable trajectories. We first identify four commonly used STL templates and collect over 200K diverse STL specifications. We obtain paired demonstra- tions using off-the-shelf solvers under each robot domain. Finally, we argue that GNN is suitable encoder to embed STL information for the downstream tasks and we system- atically compare different encoder architectures for STL encoding over varied tasks.
Extensive experiments have been conducted over five simu- lation environments, ranging from simple linear and Dubins car dynamics in the 2D space, to high-dimensional Franka Panda robot arm and Ant quadruped maze navigation tasks. Compared to other encoder architectures, our GNN-based encoder can produce the highest quality solutions. Our imitation
Signal Temporal Logic. Decades of efforts have been devoted to controlling robots under temporal and logical constraints (Fainekos et al., 2009; Wongpiromssrn et al., 2012). Unlike linear temporal logic (Finucane et al., 2010; Vaezipoor et al., 2021), STL is not equipped with well-formed automaton or progression mechanism (Bac- chus & Kabanza, 2000) hence special treatment is needed for planning. Previous works include sampling-base method (Vasile et al., 2017), mixed-integer programming (MILP) (Sadraddini & Belta, 2015; Sun et al., 2022), evo- lutionary algorithms (Kapoor et al., 2020), gradient-based method (Dawson & Fan, 2022; Leung et al., 2023), rein- forcement learning (Li et al., 2017) and model- based learn- ing (Liu et al., 2021; Meng & Fan, 2023; Eappen al., 2025). Temporal logic has been used to guide the diffusion models sampling in CTG (Zhong et al., 2023) for STL and in LTLDoG (Feng ct al., 2024) for LTL, but they do not incor- porate STL syntax during the training. Meng & Fan (2024) handles diverse STL in training but is limited to continu- ous parameters, whereas ours emphasizes handling general STL structures. The most similar to ours is Hashimoto et al. (2022), which studies different STL encoder architectures for model-based learning, but they work on shorter and simpler specifications without obstacles.
method also outperforms other guidance-basee learning methods such as CTG (Zhong et al., 2023) and LTL- DoG (Feng al., 2024), demonstrating the need to bring STL into the training phase. Compared to classical methods (gradient- igradient-based (Dawson & Fan, 2022), CEM (Kapoor et al., 2020)), our approach is faster in inference and can work on any system dynamics and STL formats. Additional re- sults also show our methods' capability in handling complex STLs and out-distribution specifications.
Our contributions are follows: (1) we the first to learn generative model for planning tasks conditioned on diverse STL specifications (2) we identify four key STL patterns and collect over 200K diverse STLs paired with demon- strations in five simulation environments (3) our proposed TeloorrFF demonstrates strong performance over other base- lines and encoder architectures, which supports the design of using graph-encoding to extract different STLs (4) all the code and the datasets will be open-sourced to promote the development of STL planning.
2. Related work
3. Preliminaries
Generative models for robotics. The rise of diffusion mod- els in computer vision (Ho et al., 2020) has drawn massive attention in the robotic community. We refer the readers
3.1. Signal Temporal Logic (STL)
Consider discrete-time system Fe+1 = fx1 u)) where 24 E R is the state, and u, I. is the control. Start-
2

---

s,t +,t 61U(aM102 e A1 E a,t++ 8,, - Φ2, Vi" E [0, 10,"",,,tt x,,tt Φ1. plain words, Φ1 U/U,000022 means "al- [a. Robustness Signal Temporal Logic Planning via Graph-encoded Flow Matching
Single-goal
II. Multi-gonl
III. Sequential
IV. Partial
Figure I: Four STL templates used in this paper. Single-goal: reach one goal under time constraints while avoiding obstacles. Multi-goal: reach one of the valid subsets of the goals. Sequential: All the goals needed to be reached in strict temporal order. Partial: Some goals must be reached first before reaching other goals (no global order is explicitly specified).
ing from an initial state To. a signal 8 = Io, Ii, Pr is generated via controls uo...., ur-1- STL specifies signal properties via the following rules (Donzé et al., 2013):
3.2. Diffusion models and flow matching
Diffusion models and flow matching learn distribution from data samples. They both contain a forward process (for training) and an inverse process (for generating sam- ples). For DDPM diffusion models (Ho et al., 2020), the data are diffused with Gaussian noise iteratively towards white noise, and a neural network is trained to predict the noise at different diffusion steps. In the denoising process (inverse process), the samples initialized from the white noise are recovered gradually by removing the "noise" pre- dicted by this neural net. For flow matching (Liu et al., 2022), in the forward process, the samples are continuously transformed into Gaussian noise by vector field, and the neural network learns predict the vector field. During the inverse process, new samples are generated by integrating the predicted vector field over over time, starting from noise and progressively refining the samples.
T (TT(p(z) 2 0 T or A dee Φ1 02.
Here the boolean-type operators split by "I" are the building blocks to compose STL: T means "true", a denotes function F" + I, and -, A. U, [a,b] are "not", "and", "until" and the time interval from a to b. Other operators are "or": éi VØs = -(-01 A "eventually": 1/. 1 and "always": [aa,1o = (0 We denote s, f } & if the signal s from time satisfies the STL formula (the evaluation of á returns True). For operators T, > 0, A and V, the evaluation checks for the signal state at time t. As for temporal operators (Maler & Nickovic, 2004):
s, - O/,,jo + Et' E [t a,t + b) s,t' + Φ; and
s. t = Dja,jo + Vt E t a, b] s = o; and
4. Methodology
4.1. Problem formulation
ways hold Φi true until d2 happens
score (Donzé & Maler, 2010) p(s, 1, 6) measures how well signal satisfies 6, where p 2 0 iff s, F d. The score is computed as:
Given set of demonstrations D == [(oi, where d; is the STL formula defined in Sec. 3.1, and (T.. is a batch of trajectories that satisfy the STL specification, Yk, TiA., O }= é.. our goal is to learn a condi- tional generative model po (r] Fo. Φ). so that given query STL specification & and an initial state no. the trajectories sampled from this learned distribution J ~ (o)))o,2)) can satisfy the STL specification, i.c., T, } δ.
p(8,4 1, p) = m(s(1) pls,t, -)) ())
p(s,t, A (2) = minfp(s, t, p(,,) 62))
0(8,t,0/.011 rE(a,b)
sup p(s,t + r.))
4.2. STL specification templates
(8,44, = inf p(s, + 0)
We aim to collect specifications that are both general and representative of the unique characteristies of the STL. Since our focus is primarily on addressing the complexity of STL rather than the skills required to perform each subtask, we restrict the set of atomic propositions semantics to "reach"
rE(a,
inf pls,t" (ii) min pls, 02), 12)), melein
sup re[t+a,t40)
3

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
STL Specification
Graph encoding
Conditional flow-matching module
Planned trajectory
rrentuallyreach 02 within time
Skip connections
[t f2] reach 02 within time [a], and always not reach O3-
GNN Encoder
Downsample
Og
(F14,400 v Fit,,,102) (0.)
Upsample
State Encoder
O₂
Temporal U-Net backbone
Start
Figure 2: System diagram for TeLoGraF. The STL specification is encoded as a graph structure data. The GNN extracted embedding and the state embedding are sent to the Temporal U-Net flow model to generate the planned trajectory (via ODE).
(an object/ / region) and "avoid" (an object a region), while excluding operations that involve dexterity or agility skills. We want to emphasize the "temporal" and the "logical" facets of the STI. specification, where the former includes both absolute time constraints or relative temporal ordering (dependencies), and the latter captures patterns to describe multi-choice and selections. this paper, we consider four types of STL templates: single-goal, multi-goal, sequential, and partial-order, denoted as Dsingler Omulti. @sequentials and Opartial in the following Backus-Naur Form (BNF) (similar to Sec. 3.1, the symbols on the left-hand side of "::=" can take any of the forms split by "I" shown on the
The template Osingle specifies the single-gos goale-goal---oo reaching with time constraints. The template @malti speci- fies subset of goals to reach. The third template & Psequential specifies multiple goals that must be reached in a specific order. And the last template @pantial specifies some ob- jects (Op.) need to be reached after other objects (O,,) are reached, and some objects needed be reached within time constraints (Or,). )- All the templates further paired with Pavoid reflect safety constraints.
Figure. 1.
4.3. Encoder design
To capture the information from an STL., we treat the STL as a syntax tree, and create graph node for every operator and atomic proposition node in the syntax tree. The graph nodes are connected based on the edges on the syntax tree, where for every connection, we use a directed edge pointing from the child node to its father node. Mathmatically, given an STL syntax tree, we represent it as directed graph == (V, F., H) G with nodes set V, edge set E and node features H (edges pointing from the child node to its father node), where each node feature h,, E Rdde contains all the attributes to characterize an STL operator or atomic proposition (AP), including the operator type Tyyee E Z, start time and end time start: lend E O,..., T (for operators and APs that do not have the time intervals, we use as the default value), object coordinates x, y, and radius (or side length, depending whether the object is cir- cle/sphere or square/cube). Besides, for the Until operator, we need to distinguish its left child with its right child as the order matters, so we use a separate binary variable to indicate whether it is the left child of the Until operator. In total, the node feature dimension is de = 8.
right-hand side of the expression):
Dreach (s)dss) Fieanss G(te.ta)
Davoid :: T Gio.11 -0
davoid,1 A Davoid,2
&reach, A (Dor.))
Dand
j=1
dor &reach, (Dand.))
1=1
Osingle Dreach A Davoid
Omantti Dand A Davoid Dor
& sequential Dreach
Ppa.ds) A @sequential A Daroid
Opartial
Op. 1u A Dreach.ry A Davoid
1=1
(3) where O₂ is the atomic proposition representing "reach the th object", and -O means "avoid the object". Øreach means "eventually reach the object at time interval [L,, (a,,4) 1o] (and stay there for the time interval [te + tc, to + ta] if Gitattll is specified)". davoid means "always avoid obstacles for all time (here [0, 7] denotes the full time horizon)".. Dond and for mean "reach subset of objects" (for example, 6reach.1 V (Øreach.2 A @reach.3) means "reach O or reach both O2 and ")
A multi-layer GNN Fo: :p:9 G - Rd operates on this graph data G to get dy-dimension embedding. It first iteratively updates the node representations through message passing, The initial node feature for the node is k(()) h, dis-
Here, we overload the symbol G previously used as the "al- ways" operator for consistency with the normal notation.
graphical illustration for the examples can be found in

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
door
key
goal
goal1
S
Linear
(b) Dubins
(c) PointMaze
(d) AntMaze
(e) Franka Panda
Figure 3: Simulation benchmarks. In Linear and Dubins, moving robot needs reach circular regions and avoid circular obstacles. In PointMaze and AntMaze, the agent needs to reach/avoid square tiles in maze. In Franka Panda, the robot arm needs to reach certain cubes on the table while not colliding with red balls.
cussed above. At each layer of the GNN, the node v's feature h is updated based on the message passing proce- dure with its neighbors (children) ((u):
as the graph for ø as mentioned in Sec. 4.3. To this end, we can formulate the Flow Matching loss:
CFM = Xt, H| (Fo ru, Xx) AX (5)
hg+11 =7 (1())
( (D)
(4)
which is used to update the neural network parameters and w in the training. The network Ha learns a velocity field (conditional on é and xp) which deter- mines a flow vi [0.1] (mmm)) + (Tx(m+))) (Fo(G), xo, t, ())
(EN((e)
here 7(.) and si are the nonlinear update and message func- tions to increase the expressiveness the GNN, and @ is the permutation eermutation-iivariant function (c.g., sum, mean, min, max). After L layers of message passing, the final representation ( E _2d= is read out using another aggregation function hg = + h! which will be used for the downstream Ev
depicted as XX) with initial condition X)) = X. Therefore, can generate the target sample by first randomly sam- pling X' ~ NO I). then solve the ODE with X X t = 0 until t = 1, and the target sample will be i = (1,1X'), To solve ODE numerically, we discretize the ODE time domain into N, steps, and sample I uni- formly from {0, N, N, ..., 1} training. In testing, from random sample X run Euler's 's method to solve ODE: (ttt, (L. ag., ((t,..))) where
trajectory generation task.
4.4. Expressiveness of GNN to encode STL
is crucial to verify theoretically that the GNN can distin- guish different STLs. The work (Xu et al., 2018) shows GNN has (at most) the same expressiveness as the 1- dimensional Weisfeiler Leman graph isomorphism test (WL- test). It has been shown in (Kiefer, 2020) that the WL-test is a complete test for trees, hence GNN can distinguish two STLs (syntax trees) if they are different on the graph level.
t N, for 0, O...,.,, -1 1.
5. Experiments
Implementation details. We consider five robot simulation environments, including ZoneEnv in Jackermeier Abate (2024) with Linear ionglle-nttegrator dynamics) and Du- bins (Car dynamics), PointMaze, AntMaze (Fu et al., 2020) and Franka Panda robot arm (Gaz al., 2019). The trajec- tory length is 512 for PointMaze and AntMaze and 64 for the other environments. For each robot domain, we start with the four STL templates discussed in Sec. 4.2, and for each template, we randomly generate 10000 STL specifications with 2 to 12 objects (regions) for goals and obstacles, and randomly initialize the agent location in each case. For sim- ulation environments like Linear/Dubins and Franka Panda, we use gradient-based solver to collect trajectories that maximize the STL robustness scores. For non non-differentiaall environments like PointMaze and AntMaze, we first plan for waypoints on the grids using A" search algorithm, then we use waypoint tracking controllers to generate the low-level
4.5. Conditional flow for trajectory generation
Given the STL embedding E dd for Φ and the initial state Jo E R", we aim to learn a conditional flow neural network Ha I xR xRI xR (m+n) -> T T (m++)) to generate the trajectory E (m+++)) that can satisfy the STL. each training step, we randomly draw a demonstration? X1 with its corresponding STL ø from the dataset (Io is the first state in 7) and randomly draw X, from the Gaussian distribution (/0., /) and denote AX = X; Xo- Then, we uniformly sample t ~ Uniform( (0, 1) and take the linear combination: X, LX1 + (1 - 1) Xo. We denote G
We use No to denote the samples from the source distribution, and X, for the samples from the target data distribution, while using x for the states the trajectory.
5

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
Grad-lite
Grad
CEM
CTG
LTLDoG
TeLoGraD
TeLoGraF
TeLoGraF (Fast)
STL satifactioon
0.6
1.0
1.0
0.75
0.4
0.50
0.50
0.2
0.25
0.00
0.0
0.0
0.0
0.00
6
30
15
15
Runtime
10
2
10
0
Linear
Dubins
Pointmaze
Antmaze
Franka panda
Figure 4: Main results. Our methods outperform both learning-basee methods (CTG and LTLDoG) and classical methods (Grad, CEM). In four out of the five benchmarks, TeLoGraD achieves the highest solution quality. TeLoGraF (Fast) achieves the best trade-off between solution quality and efficiency over all benchmarks, especially being 123.6X faster than Grad and 60.7X faster than CEM with higher satisfaction rate in the Franka Panda environment.
trajectories. For each STL, we generate 2 demonstrations, resulting in 80k trajectories under each robot domain. We 80% for training and 20% for validation. Our TeLoGraF uses GNN encoder with GCN layers (Kipf & Welling, 2016) with 4 hidden layers and 256 units in each layer, and ReLU activation (Nair & Hinton, 2010) is used for the intermediate layers. The output embedding dimension is 256. The backbone network follows the UNet architecture used in (Janner et al., 2022) with two extra input for the STL embedding and the initial states. the flow matching, set the flow step N, 100. The learning pipeline is implemented in Pytorch Geometric (Fey & Lenssen, 2019; Paszke et al., 2019). The training is conducted for 1000 epochs with a batch size of 256. We use the commonly used ADAM (Kingma, 2014) optimizer with an initial learning rate 5 10-4 and a cosine annealing schedule that reduces the learning rate x 10 the 900-th epochs and then keep it constant for the rest 100 epochs. We use Nvidia L40S GPUs for the training, where each training job takes 6-24 hours
et al., 2023), which uses gradient guidance for the diffu- sion models, and LTLDoG: (Feng et al., 2024), which uses classifier guidance for the diffusion models (we change their LTT. classifier to STL classifier for tasks). We also consider varied forms of encoder architectures, such as GRU: (Chung et al., 2014), which uses gated recur- rent units to encode the sequence of STL formula, similar to Hashimoto et al. (2022), Transformer: (Vaswani, 2017), which uses attention-based auto-regressive models to en- code the sequence of STL formula similar GRU, and TreeLSTM: (Tai et al., 2015), which is similar to GNN but instead of synchronized message passing, TreeLSTM updates nodes features layer-by-layer via LSTM in a bottom- fashion on syntax trees. Our method consists three varia- tions, TeLoGraD (Diffusion): which uses GNN as encoder and learns trajectories via diffusion models, TeLoGraF: which uses GNN as encoder and learns the trajectories via flow models, and TeLoGraF (Fast): uses the pretrained TeLoGraF model with less ODE steps to generate samples.
single GPU. During evaluation, for each method, we sample 256 STL specifications for comparison (in Fig. 4 we sample on the validation set, whereas Fig. 5 we sample on both training and validation sets).
Metrics.. For each STL., we sample 1024 trajectories and pick the one with the highest STL score as the final trajec- tory. We compute the average STL satisfaction rate for the final trajectories (ratio of final trajectories that satisfy the STL) and the average computation runtime for the trajec- tory generation. Without special notice, we focused on the validation set STL satisfaction rate because the satisfaction rate in the training split is close to 1.
Baselines. We compare with both classical and learning- based methods for STL specification planning. For the clas- sical methods compare with Grad: gradient-basee based method in Dawson & Fan (2022), Grad-lite: using the gradient-based method but with fewer iterations, and CEM: a sampling-bart based method (Kapoor et al., 2020). For the learning-beot based baselines, we compare with CTG: (Zhong
5.1. Main results
We first compare method variations (TeLoGraD, TeroorraF, and TeLoGraF (Fast)) with classical and
Wee compare with classical methods only on selected differen- tiable environments.
6

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
GRU train
Transtoreer _ttain
TreeLSTM train
GNN (Ours) train
GRU val
Transtomer val
TreeLSTM val
GNN (Ours) val
STL satisfaction
1.00
1.00
1.00
1.00
0.75
0.75
0.75
0.75
0.75
0.50
0.50
0.50
0.50
0.50
0.25
0.25
2
0.25
0.25
0.25
Linear
Dubins
Pointmaze
Antmaze
Franka panda
Figure 5: Different encoder architecture comparisons. GNN and TreeLSTM works the best on the validation set.
learning-basee based STL planning baselines. As shown in Fig. 4, on most of the environments, our methods achieve a better trade-off between solution quality and runtime. ToroG achieves the highest performance regarding STL satisfac- tion, with the computation budget lower than almost all the baselines (except Grad-lite on Linear environment, but Grad- lite has low satisfaction rate), which first shows the efficacy of our designed pipeline. The advantage over classical meth- ods increases as we move from low-dimension environments to the high-dimension Franka Panda environment, as both gradient- and sampling-based methods struggles to provide high-quality solutions high-dimensien space. Compared to learning-basse LTLDoG, our methods do not compute the time-consuming guidance step in the inference stage, hence achieving better efficiency. Interestingly, the results under the maze envi- ronments (PointMaze and AntMaze) are very close among these learning-baas based methods, and the STL satisfaction rate the highest among all environments. This is probably because the data distribution limited to the maze layout, making learning easier. Among our methods, TeLoGraF and TeLoGraF(Fast) replace the diffusion models in TeLoGraD with flow- now-matching models, leading to performance drop in Dubins and Franka Panda environments, which might be owed to the nonlinear dynamics or cewward-kinemaltee under these environments. However, TeLoGraF (Fast) can achieve on par of TeLoGraF's satisfaction rate with only 1/10 of the runtime, making itself super-efficient algorithm. On Franka Panda environment, TeLoGraF (Fast) is 123,66 faster than Grad and 60.7X faster than CEM with a higher satisfaction rate than both methods. Overall, the results demonstrate that TeLoGral provides the best balance be- tween solution quality and computational efficiency, while TeLoGraF (Fast) emerges as a promising alternative for real-time applications for the temporal logic task planning.
Runtime (s) STL satisfaction
1.0
Train
Val
0.6
0.4
0.2
TeLoGraF (Fast)
TeLoGraF
20
40
60
100
methods such as CTG and
ODE Steps
Figure 6: Ablation studies on ODE steps in Dubins environ- ment. TeLooGrF((ass) achieves similar STL satisfaction compared to TeLoGraF with only 1/10 of its runtime.
for the sampling. The original TeLoGraF needs run 100 ODE steps for data generation. Here, we reduce the ODE steps by increasing the ODE time step size* in each flow step. We evaluate the solution quality by checking its STL satisfaction. As shown in Fig. 6, the algorithm runtime grows linearly with the number of ODE steps. The STL satisfaction rate for the original TeLoGraF 0.97 on the training split and 0.45 on the validation split. The scores do not drop until the number of ODE steps decreases to 10. Even with 2 ODE steps, the model can obtain STL satisfaction rate of 0.94 on the training split and 0.34 on the validation. These observations demonstrate the sampling efficiency of the flow models and we hence use 10 ODE steps for "TeLoGraF (fast)".
5.3. Ablation study on encoder designs for STL
We compare different architectures to encode STL syntax, including sequence models like GRU and Transformer, and
5.2. Ablation study on the flow steps
To understand how fast the flow model can be accelerated while maintaining the solution quality, design test the Dubins environment with varied number of flow steps
"This ODE time step size should be distinguished with the algorithm runtime. The ODE time interval is fixed from 0 to 1 in the flow model sampling process. Thus, the step size in each ODE step determines the number of ODE steps needed.

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
Linear
Dubins
Pointmaze
Antmaaee
Franka panda
0, Poblo
O.O.
O.E
II
IV
GRU
Transformer
TreeLSTM
GNN
Figure 7: STL satisfaction rate distribution for different categories (I. single-goal; II. multi-goal; III. sequential; IV. partial),
Original STL
DOD
GRU
Transformer
TreeLSTM
(Ours)
Linear
Dubins
Pointmaze
Antmaze
Fran panda
STL satifacttoonn
0.6
0.4
0.4
0.8
0.2
0.2
0.6
0.2
0.4
0.2
17/0 17/7
17/1817/3717886
17/0 17/7 17/1617/5717/86
8/0
8/2
8/6
8/10 8/17
8/0
8/2
8/6
8/10
8/18
16/0
16/5
16/1216/206/36
Average number nodes per STL (crigina//augmented))
Figure 8: Encoder robustness test under varied STL augmentation (shaded in red). Graph-based encoders (GNN, TreeLSTM) demonstrate greater resilience to synthetic modifications compared to sequence- baaeedd models (GRU, Transformer).
graph-encoding: GNN and TreeLSTM. We use the same pipeline TeLoGraF, and only change the encoder network. As shown in Fig. 5, all the encoders have close 100% satisfaction rate on the training splits, indicating they can distinguish different STL syntax. However, their abilities to generalize to unseen STL syntax are different: GRU and Transformer get lower STL scores than TreMLSTM and GNN; one reason could be that the graph-encoding models inherit sermutation-invarianne of the syntax tree ("AvB" is the same "BVA"), making the learning more efficient. The performance of TreeLSTM and GNN are similar, and we select GNN encoding owing to its brevity.
are necessary foster better temporal logic planning.
5.5. Robustness test for encoders on out-domain STLs
We alter the STLs in the validation splits and use the pre- trained models the original dataset produce trajectories. We deliberately keep the trajectories fixed and only change the STLs to ensure the backbone is not affected by out-of- distribution trajectories. For each A and V operator in the STL syntax tree, we randomly duplicate a number of their children nodes (c.g., "AΛB" - "A^BAB"). This augmen- tation will not affect the solutions. Ideally, if the model is robust, the output should have the same STL satisfaction rate, As shown in Fig. 8, all models result in degradation the number of nodes augmented increases, but the graph-based encoder (GNN, TreeLSTM) is resilient to the augmentation. In most out-domain cases, they can even outperform the sequence models with normal STL inputs. This implies graph-based encoders inherently capture the structural STL more effectively and generalize better under augmentations.
5.4. Encoder coverage analysis on varied STL types
We show the validation STL satisfaction over different STL categories in Fig. 7. As expected, most encoders can lead to high satisfaction rate on single-goal STLs. The improve- ments of the graph-encoding over sequence models are mainly from "Sequential" and "Partial" types, which implies graph-encoding meth-
that, beyond permutation-innariinn ods also excel propagating time constraints and temporal orderings than the sequence models. However, all mod- els' performance on II-IV STLs is relatively low on Linear, Dubins and Franka Panda, which implies it is challenging for current models to generalize to complex STLs such as multi-goal satisfaction, sequential, or partial constraints. This highlights the value of our dataset in examining the limitation of the current models in handling complex STLs. Future improvements in architectures or training strategies
Limitations. First, TeLoGraF is data-driven and does not offer soundness and completeness guarantees other clas- sical planning methods. Its performance degrades for tasks with complex STL syntax or STLs that are heavily out-of- distribution. This limitation is inherent to most learning- based methods, as they rely on the distribution of training data. Trajectory refinement with classical methods could enhance the model's generalization and robustness these temporal logic tasks. Besides, though TeLoGraF pre- dict "state-action" trajectories, in inference we only use
8

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
its predicted waypoints rather than rolling trajectories based on the predicted action sequence. Ensuring dynamic consistency can be achieved via tracking controllers (Sun et al., 2022) or inverse dynamics (Ajay et al., 2022), we leave these for future work.
International Conference on Intelligent Robots and Sys- tems (IROS), pp- 1916-1923, IEHE, 2023.
Chang. W.-D., Higuera, J. C. G., Fujimoto, S., Meger, D., and Dudek, G. II-flow: Imitation learning from observation using normalizing flows. arXiv preprint arXiv:2205.09251, 2022.
6. Conclusion
Chen, C., Deng, F., Kawaguchi, K., Gulcehre, C., and Ahn, S. Simple hierarchical planning with diffusion. arXiv preprint arXiv:2401 20002024404244, 2024.
We propose TeLoGraF, novel learning-based framework for solving general Signal Temporal Logic (STL) tasks via graph-encoding and flow-matching. Torao can handle flexible forms of specifications and outperforms existing classical and data-driven baselines while maintaining fast inference speed. Our analysis highlights the value of graph- based STL encoding. Aside from TeLoGraF, we introduce new dataset for temporal logic planning, addressing the lack of diverse and structured STL benchmarks. Future research directions include improving the model's generalization and robustness towards more complex temporal logic structure and out-of-distribution STL specifications.
Chen, Y., Li, H., and Zhao, D. Boosting continu- ous control with consistency policy. arXiv preprint arXiv:2310.06344 2023.
Chi, C., Xu, Z., Feng. S., Cousineau, E., Du Y., Burchfiel, B., Tedrake, R., and Song, S. Diffusion policy: Visuomo- tor policy learning via action diffusion. The International Journal of Robotics Research, pp. 02783649241273668 2023.
Chung. J., Gulcehre, C., Cho, K., and Bengio. Y. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv: 1412.3551 2014.
Acknowledgements
This work supported in part by the National Science Foundation (NSF) under Grant #CCF-2238030 and in part by ONR under Award N00014-22- 1-247 Any opinions, findings, conclusions, or recommendations expressed in this publication are those of the authors and don't 't reflect the views of the sponsors.
Clarke, E. M. and Emerson, E. A. Design and synthesis of synchronization skeletons using branching time temporal logic. In Workshop on logic of programs, pp. 52-71. Springer, 1981.
Coumans, E. and Bai, Y. Pybullet quickstart guide, 2021.
Impact Statement
Dawson, C. and Fan, C. Robust counterexample-guide optimization for planning from differentiable temporal logic. In 2022 JEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 7205-7212. IEEE, 2022.
This paper presents work whose goal is to advance the field of robotics and secision-making for long-horizon tasks. There are some potential societal consequences of our work, for example, a fully- autonomuss robot using our designed algorithm for decision-making could lead to potentially un- safe behavior. Thus, safety-filter or backup policy for the planned behavior is needed for deployment. No other aspects which we feel must be specifically highlighted here.
de Lazcano, R., Andreas, K., Tai, J. J., Lee, S. R., and Temry, J. Gymnasium robotics, 2024. URL http://githin cwm/Farama-aa-aaaaaaa aararmaaFFundtiooo Gymnas i um am-Roboticsss..oooooooooooocos-t
References
Donzé, A. and Maler, O. Robust satisfaction of temporal logic over real-valued signals. Formal Modeling and Analysis of Timed Systems, pp. 92, 2010.
Ajay, A., Du, Y.. Gupta, A., Tenenbaum, J., Jaakkola, T., and Agrawal, P. Is conditional generative model- ing all you need for decision-making? arXiv preprint arXiv:2211.15633 2022.
Donzé, A., Ferrere, T. and Maler, O. Efficient robust moni- toring for sti. In Computer Aided Verification: 25th Inter- national Conference, CAV 2013, pp. 264-277777 279. Springer, 2013.
Bacchus, F. and Kabanza, F. Using temporal logics to express search control knowledge for planning. Artificial intelligence, 116(1-2):123-10) 2000.
Eappen, J., Xiong, Z., Patel, D., Bera, A., and Jagannathan, S. Scaling safe multi-agent control for signal temporal logic specifications. arXiv preprint arXiv:2501 05639, 2025.
Carvalho, J., Le, A. T., Baierl, M., Koert, D., and Peters, Motion planning diffusion: Learning and planning of robot motions with diffusion models. In 2023 JEEE/RSJ

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
Fainekos, G. E., Girard, A., Kress-Gazit, H., and Pappas, J. Temporal logie motion planning for dynamic robots. Automatica, 45(2)3343-352, 2009.
Jackermeier, M. and Abate, A. Deepltl: Learning effi- ciently satisfy complex Itl specifications. arXiv preprint arXiv:2410.04633 2024.
Fang, X., Garrett, C. R., Eppner, C., Lozano-Pérez, Pérez, T., Kael- bling, L. P., and Fox, D. Dimsam: Diffusion models as samplers for task and motion planning under partial ob- servability. In 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 1412-1419. IEEE, 2024.
Janner, M., Du, Y. Tenenbaum, J. B., and Levine, S. Plan- ning with diffusion for flexible behavior synthesis. arXiv preprint arXiv:2205.099) 2022.
Kapoor, P., Balakrishnam, A., and Deshmukh, J. V. Model- based reinforcement learning from signal temporal logic specifications. arXiv preprini arXiv:2011.0499 1.04950, 2020.
Feng. Z., Luan, H., Goyal, P., and Soh, H. Lil- dog: Satisfying eemporally--eteended symbolic con- straints for safe diffusion- based planning. arXiv preprint arXiv:2405.04255, 2024.
Ke, T.-W., Gkanatsios, N., and Fragkiadaki, K. 3d diffuser actor: Policy diffusson with 3d scene representations. arXiv preprint arXiv:2402. 10885, 2024.
Fey, M. and Lenssen, J. E. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.
Kiefer, S. Power and limits of the Weisfeiler-Leman algo- rithm. PhD thesis, Dissertation, RWTH Aachen Univer- sity, 2020, 2020.
Finucane, C., Jing, G., and Kress-Gazit, H. Ltlmop: Experi- menting with language, temporal logic and robot control. In 2010 IEEE/RSJ International Conference on Intelli- gent Robots and Systems, pp. 1988-1993. IEEE, 2010.
Kingma, D. Adam: method for stochastic optimization. arXiv preprint arXiv:1412.00. 2014.
Kipf, T. N. and Welling, M. Semi-supervised classifica- tion with graph convolutional networks. arXiv preprint 2016.
Fu, J., Kumar, A., Nachum, O., Tucker, G., and Levine, S. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.072.11 2020.
Koymans, R. Specifying real-time properties with metric temporal logic. Real-time systems, 2(4):255-299 1990.
Gaz, C., Cognetti, M., Oliva, A., Giordano, P. R., and De Luca, A. Dynamic identification of the franka emika panda robot with retrieval of feasible parameters using penalty based optimization. IEFE Robotics and Automa- fion Letters, 4(4):4147
Kurtz, V. and Lin, H. Mixed-integer programming for signal temporal logic with fewer binary variables. IEEE Control Systems Letters, 6:2635-2640, 2022.
2019.
Leung, K. and Pavone, M. Semi-supervie trajectory- feedback controller synthesis for signal temporal logic specifications. In 2022 American Control Conference (ACC), pp. 178-185. IEEE, 2022.
Guo, Z., Zhou, W., and Li, W. Temporal logic specification- conditioned decision transformer for offline safe rein- forcement learning. In Forty-first International Confer- ence on Machine Learning, 2024.
Leung, K., Aréchiga, N., and Pavone, M. Backpropagation through signal temporal logic specifications: Infusing logical structure into gradient-based methods. The Inter- national Journal of Robotics Research, 42(6))356-370, 2023.
Hashimoto, W., Hashimoto, K., Kishida, M., and Takai, S. Neural controller synthesis for signal temporal logic specifications using decoder structured networks. arXiv preprint arw.vv2212..0533333222222222222 2022.
Hc, J., Bartocci, E., Ničković, D., Isakovic, H., and Grosu, R. Deepstl: from english requirements to signal temporal logic. In Proceedings of the 44th International Confer- ence on Software Engineering, pp. 610-622, 2022.
Li, W., Wang, X., Jin, B., and Zha, H. Hierarchical diffusion for offline decision making. In International Conference on Machine Learning, pp. 20035-20064 PMLR, 2023.
Li, X., Vasile, C.-L., and Belta, C. Reinforcement learning with temporal logic rewards. 2017 IEEE/RSJ Inter- national Conference on Intelligent Robots and Systems (IROS), pp. 3834 3839. IEFE, 2017.
Ho, J., Jain, A., and Abbeel, P. Denoising diffusion proba- bilistic models. Advances in neural information process- ing systems, 2020.
Huang, H., Sundaralingam, B., Mousavian, A., Murali, A., Goldberg, K., and Fox, D. Diffusionseeder: Seeding motion optimization with diffusion for rapid motion plan- ning. arXiv preprint arXiv:2410. 16727, 2024.
Liu, W., Mchdipour, N., and Belta, C. Recurrent neural network controllers for signal temporal logic specifica- tions subject to safety constraints. IEEE Control Systems Letters, 6:91-96, 2021.
10

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
Liu, X., Gong, C., and Liu, Q. Flow straight and fast: Learning to generate and transfer data with rectified flow. arXiv preprint 22t:::22000030003 2022.
Sun, D., Chen, J., Mitra, S., and Fan, C. Multi-agent motion planning from signal temporal logic specifications. IEEE Robotics and Automation Letters, 7(2):3451-3458, 2022.
Maierhofer, S., Moosbrugger, P., and Althoff, M. Formal- ization of intersection traffic rules in temporal logic. In 2022 IEEE Intelligent Vehicles Symposium (IV), pp. 1135- 1144. IEEE, 2022.
Tai, K. S., Socher, R., and Manning, C. D. Improved seman- tic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:/503.000 2015.
Maler, O. and Nickovic, D. Monitoring temporal properties of continuous signals. Formal Techniques, Modellingan- dAnalysis of Timed and Fault-Tolerant Systems, pp. 152, 2004.
Team, O. M., Ghosh, D., Walke, H.. Pertsch, K., Black, K., Mees, O., Dasari, S., Hejna, J., Kreiman, T., Xu, C., et al. Octo: An open-source generalist robot policy. arXiv preprint arXiv:2405. 122113 2024.
Meng. Y. and Fan, C. Signal temporal logic neural predictive control. IEEE Robotics and Automation Letters, 2023.
Todorov, E.,, Frez, T., and Tassa, Y. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ inter- national conference on intelligent robots and systems. pp. 5026-5033. IEEE, 2012.
Meng, Y. and Fan, C. Diverse controllable diffusion policy with signal temporal logic. IEEE Robotics and Automa- tion Letters, 2024.
Mishra, U. A., Xue, S., Chen, Y., and Xu, D. Generative skill chaining: Long-horizon skill planning with diffusion models. In Conference Robot Learning, pp. 2905- 2925. PMLR, 2023.
Urain, J., Mandlekar, A., Du, Y., Shafiullah, M., Xu, D., Fragkiadaki. K., Chalvatzaki, G., and Peters, J. Deep generative models in roboties: A survey on learn- ing from multimodal demonstrations. arXiv preprint arXiv:2408.043380 2024.
Nair, V. and Hinton, G. E. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10). pp. 807-814, 814, 2010.
Vaezipoor, P., Li, A. C., Icarte, R. A. T., and Mcilraith, S. A. Ltlactioo: Generalizing Itl instructions for multi-task rl. International Conference on Machine Learning, pp. 10497-10508. PMLR, 2021.
Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein, N., Antiga, L., et al. Pytorch: An imperative style, high-performance deep learning library. Advances in neural information processing systems, 32, 2019.
Vasile, C.-I., Raman, V., and Karaman, S. Sampling- controllers for tempo- ral logic specifications. 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). pp. 3840-3847. IEEE, 2017.
synthesis of
Pnueli, A. The temporal logic of programs. In 18th an- nual symposium on foundations of computer science (sfes 1977), pp. 46-57. ieee, 1977.
Vaswani, A. Attention all you need, Advances Neural Information Processing Systems, 2017.
Prasad, A., Lin, K., Wu, J., Zhou, L., and Bohg, Consis- tency policy: Accelerated visuomotor policies via con- sistency distillation. arXiv preprint 0755502405.07503, 2024.
Wongpiromsarn, T., Topcu, U., and Murray, R. M. Receding horizon temporal logie planning. IEEE Transactions on Automatic Control, 57(11): 11)71:2881722800 2012.
Puranic, A., Deshmukh, J., and Nikolaidis, S. Learning from demonstrations using signal temporal logic. In Con- ference on Robot Learning, pp. 2228-2242. PMLR, 2021. Raman, V., Donzé, A., Sadigh, D., Murray, R. M., and Se- shia, S. Reactive synthesis from signal temporal logic specifications. In Proceedings of the 18th international conference on hybrid systems: Computation and control, pp. 239-2488, 2015.
Xian, Z., Gkanatsios, N., Gervet, T., Ke, T.WW., and Fragki- adaki, K. Chaineddiffuser: Unifying trajectory diffusion and keypose prediction for robotic manipulation. In 7th Annual Conference on Robot Learning, 2023.
Xu, K., Hu, W., Leskovec, J., and Jegelka, S. How powerful are graph neural networks? arXiv preprint arXiv:1810.00 1810.0086, 2018.
Sadraddini, S. and Belta, C. Robust temporal logic model predictive control. In 2015 53rd Annual Allerton Confer- ence on Communication, Control, and Computing (Aller- ton), pp. 772-779. IEEE, 2015.
Yang, Z., Mao, J., Du, Y., Wu, J., Tenenbaum. J. B., Lozano- Pérez, T., and Kaelbling, L. P. Compositional diffusion- based continuous constraint solvers. arXiv preprint arXiv:2309 00966, 2023.

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
Ze, Y., Zhang, G., Zhang, K., Hu, C.,, Wang, M., and Xu, H. 3d diffusion policy. arXiv preprint arX1::2403.03954 2024.
Zhang, Q., Liu, Z., Fan, H., Liu, G., Zeng, B., and Liu, S. Flowpolicy: Enabling fast and robust 3d flow-based pol- iey via consistency flow matching for robot manipulation. arXiv preprint arXhv:2412.04987. 2024.
Zhong, S., Power, T., Gupta, A., and Mitrano, PyTTrrch Kinematics, February 2024.
Zhong. Z., Rempe, D., Xu, D., Chen, Y., Veer, S., Che, T., Ray, B., and Pavone, M. Guided conditional diffusion for controllable traffic simulation. In 2023 IEEE Interna- tional Conference on Robotics and Automation (ICRA), pp. 3560-3566. IEEE, 2023.
12

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
A. Experiment setups
A.1. Simulation Environments
A.1.1. LINEAR
We use a Linle-integrater dynamic model. The 2D state (I, represents the 2D coordinates on a zy-plane, and the 2D control input (u, v) reflects the velocities in these two directions. We set the time step duration At 0.5. The system dynamic described as:
T++1
2t + Ue ut
(6)
y++1
y/+ + U,
In this environment, randomly generate goal regions and obstacles in circle shape, and generate STL specifications using procedural methods. Finally, we use gradient-based trajectory optimization method implemented in PyTorch (Paszke et al., 2019) to compute the demonstration trajectories. The loss function is constructed as:
T
T 2 1=0
= m0. + G
Σ (min(u? - 1,00 + min(u? 1,0) + 22T
+ 0
(7)
The first loss term maximizes the truncated robustness score p for the trajectory (Io, Mg ...y -T-1, 1,))) ensure STL rule satisfaction for the STL 6. The second loss term regulates the magnitude of the control input to be within 1. The third loss term minimizes the control magnitude to make the trajectory smooth.
A.1.2. DUBINS
We use a car-like dynamic model. The 4D state yz, of the robot and the velocity of the robot, respectively. The 2D control input (w, a) represents the angular velocity and the acceleration. We set the time step duration At 0.5. The system dynamic described as:
y, 0, v) represents the 2D coordinates on the ry-plane, the heading angle
Ø++1
Ie + us cos (o,) At
V++1
Yt us sin At
(8)
be41
= -b At
U2+1 Ur At
In this environment, randomly generate goal regions and obstacles in circle shape, and generate STL specifications using procedural methods. Finally, we use gradient-based trajectory optimization method implemented in Py Torch (Paszke et al., 2019) to compute the demonstration trajectories. The loss similar to Eq. (7).
A.1.3. POINTMAZE
We adapt PointMaze and AntMaze from these two environments from (Fu et al., 2020). The original environments consist of 2D navigation tasks where agent must navigate maze reach goal while avoiding obstacles. The dynamic model is internally handled by MuJoCo (Todorov et al., 2012), and we use the Siiimaaium-Roobote package (de Lazcano et al., 2024) for simulation to collect data. We use the largest maze in both simulations with horizons set as 512 steps. In Pointmaze, the agent is modeled as a simple 2D point mass with position (x, y) and the control input is the linear force along xy directions. We collect the 4-dimension trajectory with 2d xy-coordinate and 2d control input. To collect trajectories, we first generate the skeleton of the STL syntax but leave the time intervals as placeholders; then, we use a planning algorithm to find waypoints and then use a geal-rea controller to collect trajectories. After the generation of the trajectories, we first ensure reaches the final destination, and then evaluate the robustness score the trajectory without considering the time intervals. If the robustness score is positive, we randomly infer the possible time intervals for the goal-reaching hub-formulas and run post-verification to ensure the trajectory satisfies this STL.
A.1.4. 1.4. ANTMAZE
In AntMaze, the agent is modeled as a more complex 8-DoF quadruped robot with 27-dimension observation (1-dimension for z-coordinate of the torso, 4-dimension for the torso orientation (in Quaternion representation). 3-dimension velocity and 3-dimension angular velocity for the torso, 8-dimension for each of the joints' angles and another 8-dimension for each of
13

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
the joints' angular velocities), 8-dimension control input serving as the torques applied to each of the 8 joint rotors, and an extra 2-dimension for the xy-coordinates of the torso. We collect the 10-dimension trajectory with 2d xy-coordinate and 8-dimension control input. We adopt similar data collection methods as in PointMaze, with the difference of switching from PD controller to RL goal-reaching policy.
A.1.5. FRANKA PANDA
We use a 7 DoF Franka Panda robot arm model and conduct the simulation via PyBullet Simulator (Coumans & Bai, 2021).
We use the standard URDF files to construct the scene: a table is generated via "table.urdf" at location [0.4, 0, 0] with Euler an- gle [0, O, np-pi/ p2/2]. A Franka Panda robot is generated via "franka/panda.urda urdf" at location [0, 0, 0.6] with Buler angle [0, 0, 0). The 7DoF joint angles for the robot are initialized at (in radian) [0.0000, 0.0000, 0.0000, -2.0000, 0.0000, 1.8675, 0.0000] 2.8972 11.7628, 2.8992, -3.0718, 22.9972, -0.0175, 2.8972]
and are clipped [2.8972, 1.7628, 2.8972, 00.0698, 2.8972, 35755, 2.8972] by following the guidelines. Random goal objects are generated on the table whereas the obstacles are generated both on the table and in the midair to increase the task difficulty. method to plan the trajectory to satisfy the STL conditions. We use pytorch-kinematee (Zhong et al., 2024) library to leverage Pytorch and GPU devices to compute the forward kinematic in a parallelized and efficient way. The time horizon is 64 with the time step duration At 0.05.
from
to
We use a gradient-basee
A.2. Procedural methods to generate STL formulas
We adopt procedural methods to generate the STL formulas. We first assign the type of STL we want to generate (Single- goal, multi-goal, sequential, partial-order). Then each formula is augmented with randomly chosen 0-6 obstacles and 0-4 goals while they are not colliding with each other. Next, we spawn the agent position in the free space and use either scarch-planning- weweiiinggthe-teeee then-tracking method or end-to-end tradient-based method to collect the trajectories. More details are in the code, and here in the following section we will show subset of demonstrations with the visualized STL syntax trees.
A.3. Baselines
A.3.1. GRAD/GRAD-LITE
We directly use the data collection method we have for the three benchmarks, Linear, Dubins, and Panda. We set different gradient-descent iterations for the different environments. For Linear and Dubins, we set niters=10 for "Grad-lite" and niters=50 for "Grad", and for Franka Panda environment, we set niters=50 for "Grad-lite" and niters=150 for "Grad",
A.3.2. CEM
We use the Cross Entropy Method with the elite size of 25, the population sample size of 64, and the number of iteration steps is set to 100.
A.3.3. CTG
We followed the guidance in Zhong et al. (2023) and implemented this baseline by ourselves, as the original baseline is conducted for the autonomous driving dataset. To ensure we don't have STL-condition-inpun encountered in training and to make fair comparison with TeLoGraF backbone, we train a goal-conditioned flow-matching policy where the goal condition is constructed as a set of subgoals and obstacles (we also mark whether they are goals or obstacles in this embedding). At the inference stage, we use the gradient-based method to construct the guidance for the flow-matching model.
A.3.4. LTLDoG
Similar to CTG, we first train goal-conditioned flow-matching policy. Further, we train STL classifier as suggested in Feng et al. (2024). At each iteration, in the minibatch data we add noise to the demonstration data and compute their robustness score (they are most likely to be negative scores) for the corresponding STL. We also save the STL score for the existing demonstration trajectories. We train our STL classifier to predict the scores for both the original trajectories and the perturbed trajectories using a simple L2 loss (suggested in Feng et al. (2024)). With 50 epochs of training, on most benchmarks the STL classifier can already achieve more than 90% accuracy classifying positive and negative sample trajectories regarding the STL specification (and since we need to evaluate the robustness score during training, the training
14

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
10-20X slower than the now-matching model training). We then this trained STL classifier in the flow-matching generation process guidance.
B. Additional visualizations from our flow-matching model
Here we show the TeLoGraF generated trajectories on the Dubins benchmark and show how the trajectory distribution and satisfaction results change as number ODE steps decrease from 100 (the original setup for TeLoGraF) to We plot the goals in blue color, obstacles in gray color, the initial state is plotted in marker shape. The green trajectories are the demonstration data, and the red ones are the flow-model generated trajectories (we only plot 4 of them each plot), where the dark red one is the generated trajectory with the highest robustness score for this STL. We ODE steps decreases, the trajectories set become more "concentratedd. The predicted trajectory can always satisfy the STI., until the last one (ODE steps=1) where the trajectory fails to reach goal-1, leading to a failure case.
that the number of
(a) ODE steps=100
(b) ODE steps=50
Figure 9: Varied ODE steps, Dubins environment, TeLoGraF
(a) ODE steps=25
(b) ODE steps=10
Figure 10: Varied ODE steps, Dubins environment, TeLoGraF
(a) ODE steps=5
(b) ODE steps=3
Figure 11: Varied ODE steps, Dubins environment, Tel.oGraF
C. Additional visualizations from demonstration dataset
The results shown here are the raw version (without data cleaning or improved visibility). Based on these data, we randomly select 2 demonstrations per STL listed in the dataset and collect 40K STLs for each of the benchmarks, gathering total 200K STLs with 400K trajectories.
15

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(a) ODE steps=2
ODE steps=1
Figure 12: Varied ODE steps, Dubins environment, Tel.oGraF
C.1. Linear environment
Here the Linear environment, for one given STL, we actually start from eight different initial locations and initialize with random control sequences for each initial location. The results satisfying the STL conditions (green) will be saved and the red ones are filtered out.
& (Jo145 611 1L (10M)) (R11)) 011001000000000031
Figure 13: Linear environment. Single-goal STL.
4191477631 COrA-71 [ROg.IGlO/05] (R13),
(820),/m66:85) i- (R30))
Figure 14: Linear environment. Single-goal STL
& (190699)00 (R0%) ope::aa
tlicaa (to.aili--taa
Figure 15: Linear environment. Multi-goal STL
16

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
2i0opan: ly (oni) 11o1se soj (at (SA0MME19 (NslliiTTioee (k30ii171 (8601))
Figure Linear environment. Multi-goal STI.
[1 & ( (480)) (CCEPS) (R2]) (1RE) [0(D622]
(M00). (R70))
Figure 17: Linear environment. Sequential STL
(17,591:92) & (GE3 60J (R1) & (-16.77) -ROII
Figure 18: Linear environment. Sequential STL
Ell- (RO)) U10:64: U10:641
(RDLLCT 65) (L (o0i 621 (Li0.81 (9210 on0 -01 (ui0.100 (R3))) (10:55] (IMb)..C (RS)) (166)))
Figure 19: Linear environment. Partial STL
17

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(li- (R09) U10:64] (RIILI (ROJ) (16:64] (RZIL])- ((0:64)
(R42))
Figure 20: Linear environment. Partial STL
C.2. Dubins environment
In Dubin's 's environment, the collected demonstration trajectories are more diverse and drastically change over time, owing to the large angular velocity and the acceleration rate.
& (I-F36 54) (80) [UTOVe5) I- (R:00)) (11211)/200005 (430)//18:88)) (RA1))
Figure 21: Dubins environment, Single-goal STL.
(10 (rEDuS) [nogurreess (RLLL ([266)))))))1--
(R20).)EE00633 (43N)_i010:65) i- (MA1)]:210055 (- IRS)I)
Figure 22: Dubins environment. Single-goal STL
20L2b-4/) (7E0-) (133))) 10-11465 146:5 IPTO-) (RUT))
(9136-911 (R3 (R1001/ (AG.)..L.1..0000 (C0005001 (871)))
Figure 23: Dubins environment. Multi-goal STL.
18

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(10138/49 11001111144 [RSSCI (R22)) CED ob)
Figure 24: Dubins environment. Multi-goal STL
(8202200)
Figure 25: Dubins environment. Sequential STL
(1912:84) HITOO (-11::311 (ICTOe)) (O1P (C0,064]
(KAI) to / (T0.)//000D (M4)), CLU:0111
Figure 26: Dubins environment. Sequential STL
(10g) U10:64: (- U10:44] (n3)
(R31)]-00.433 (L10.4 10.15 (0.00, (4.)1_.00.0311- ((S,0))
Figure 27: Dubins environment. Partial STL
19

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(800) u1o:64] (RLIUI- (823) U10:64) (RAI))I- (10654
Figure 28: Dubins environment. Partial STL
C.3. PointMaze
Here, the pink trajectories are the demonstration data collected.
c [401:425] (m[0: (RO))
start
goal
2-
-5
Figure 29; PointMaze environment. Single-goal STL
[453:4489 (R31) (0174:486) (CF0:11) (R4JII) 1195:
48.3] (0[0:15] (43::3044 (R2))) & (020:5113 (RO)
start
goal
0-
-2
-5
Figure 30: PointMaze environment. Multi-goal STL
C.4. AntMaze
Here, the pink trajectories are the demonstration data collected.
20

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
[c1203:496] [v'0i4] [0173:444] (R1))
start
goal
5 SF
-2
Figure 31: PointMaze environment. Multi-goal STL
[0:178) (([00111) (R1)) (0(3:665] (ROW)
start
goal
21
0-
-5
Figure 32: PointMaze environment. Sequential STL
00::195] (C[10:11 (R2)) (o10-87) ((R1) 10[0:407] (RO)))
goal
2
Figure 33: PointMaze environment. Sequential STL
21

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
[e:e13e ((R)) (010:370) (RD)))
start
goal
59
-2
Figure 34: PointMaze environment. Sequential STL
о [0:51] ((R3) & (0(0:167] (1R2) & [0)0:00] ((R3) & (c[0:320) (RO1111)
start
goal
-2
2-
0-
-5
Figure 35: PointMaze environment. Sequential STL
[K- (R4)) (RON (RI
R6) (1(0:513] (RZ))_[-- (87]) U1(0:513 (R3)).9
m[D:7] (A80)}
start
D2
K3
2-
TT
DIK2K1
-1
goal
DOKO
D3
Figure 36: PointMaze environment. Partial STL
22

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(82)) (ete:sitn [8 (R3)) U3jo:513] (81)))9124 6:375] (R41))
5H
start
DO
goar [KO
Figure 37: PointMaze environment. Partial STL
(403:422) (RO)
start
goal
10
Sife
0-
-3
-20
-10
20
Figure 38: AntMaze environment. Single-goal STL
[130:303 (RO))
15
start
goal
J
-5
-10
-11
Figure 39: AntMaze environment. Single-goal STL
23

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
<I [332:431] (8O)).19 (207:418] (122)))11499:333331111110010
(R2)11)
1
start
goal
10
-20
-10
20
Figure 40: AntMaze environment. Multi-goal STL
[0:05:113] (OI0:39) (R5)) & (c[0:513) (c[0:23) (R6)).
[334:364] (R41)) & (01 (99:133] (R2 & [0:5133) (R3
[10 [208:2424 (RO)) [9[141:178] (D]D:8] (R1))II))
start
goal
-5
-10
-3
Figure 41: AntMaze environment. Multi-goal STL
[00:117] (R1) & [010455] (L[D:216] (RO))))
12
goal
FiH
-10
-15
-20
-10
10
20
Figure 42: AntMaze environment. Sequential STL
24

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
(0:140) (R2) (ooo0:139] [9[0:348] (RDWN
1
start
goal
LiLL
10
-20
-10
20
Figure 43: AntMaze environment. Sequential STL
& (K( (R2)) U1(0:513] (RO)]((- (83)) (1:0:113) (81) 8:511) (010:2) (R4M))
start
0-
Prooggoai goalDo
-2
-10
-3
Figure 44: AntMaze environment, Partial STL
{ll- (R3)) 0110:5131 (RO) (R4) (110:513) (RI]
RSW 0110:513 (42)) (R01))
12
SP
start
T
D2
-10
goa
-15
-20
-10
10
20
Figure 45; AntMaze environment. Partial STL
25

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
C.5. Franka panda environment
Here, the blue trajectories in the last subfigure the demonstrations that were collected.
1.0
125
0.75
1.00
0.75
0.25
0.00
-0.5
0.0
0.5
-0.5
100
Figure 46: Franka Panda environment. Single-goal STL
125
0.75
1.00
0.75
0.50
0.25
0.5
0.0
-0.5
Figure 47: Franka Panda environment. Multi-goal STL.
26

---

Signal Temporal Logic Planning via Graph-encoded Flow Matching
1.0
0.50
0.50
0.00
-0.5
0.0% 0.0.2%..00 0.59.
8.7
-0.5
1.00
Figure 48: Franka Panda environment. Sequential STL
130
0.50
0.50
0.00
-0.5
-0.5
1000
Figure 49; Franka Panda environment. Partial STL
27


Reviews:
[{"review_id": "ZMLIWP9ysC", "reviewer": "Reviewer_8mCx", "summary": "This paper proposes to use learning-based methods to generate planning trajectories for STL specifications. The authors introduce some STL templates and then present a GNN to encode the STLs into feature representations. These features are then fed into flow matching as the conditioning factor for end-to-end learning of valid trajectories.", "questions": "", "limitations": "", "rating": 2, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for the thoughtful reviews. Below are our responses to the concerns.\n\n**Extend LTL work to STL**: We argue that it is non-trivial to extend the existing LTL2Action [1] to STL, particularly for the key technique “progression” [2] used to update task spec based on assignments. Consider an example (Sec 3.3 in LTL2Action) “First reach R, then reach G”. In LTL, this can be written as $F(R \\land F(G))$. Once it reaches R, following LTL2Action, the LTL is updated to $F(G)$, and the updated reward will encourage reaching G. \n\nSTL expresses this in $F_{[ta,tb]} (R \\land F_{[tc,td]} G)$ where [ta, tb] is the time range to reach R, and [tc, td] is the relative range that G should be reached after reaching R. Now, the progression is non-trivial - when reaching R, we need to: (1) ensure the event “reach R” happens in [ta, tb] (2) store this event time because the success of “reach G” will depend on the time R was reached. So we need to bookkeep all the “reach R” events as well as their times, and whenever we reach G, we need to iterate all the past “reach R” events to check if the “reach G” event happens after any of it within the [tc,td] range. The complexity is $O(T^2)$, where T is the trace length. The complexity is $O(T^L)$ for L nested temporal layers in STL. Thus, it is not trivial nor efficient to extend LTL2Action to STL.\n\nBecause STL doesn’t have automata-like forms as LTL does, it is hard to efficiently augment the state to be Markovian, as mentioned in our paper (page 2, lines 81-83, right column). Thus we use imitation learning to learn diverse STL, and we believe this distinction highlights the novelty and our contribution. That said, we value the reviewer’s observation, and we will cite LTL2Action [1] and the progression paper [2] with explanations in the final version.\n\n**Data collection labor in real-world**: We understand reviewer’s concern regarding paired expert data. However, we note that learning from demonstrations for robots is a widely adopted paradigm in both simulation and real-world settings. In cases where no efficient solver exists, it is common to collect demonstrations from scripted policies, human operators, or off-the-shelf planners. STL belongs to this category, as mentioned in our paper (page 1, L25-L36, right column). We view our work as a first step toward enabling STL-conditioned policy learning from demonstrations—an area that is currently underexplored and, to our knowledge, lacks dedicated prior work.\n\nAlthough we consider the paired data in our work, in the future, demonstrations do not need to be paired with STL. Recent works have shown STL can be inferred from offline demonstrations [3,4,5,6] or translated from natural language [7,8,9]. With these techniques and the increasing availability of open and modular data collection pipelines (e.g., UMI [10]), we argue that the reliance on demonstrations should not be viewed as a major limitation.\n\n**Contribution:** We respectfully disagree that our contribution is incremental. As acknowledged by the other reviewers, our work introduces a novel conditional flow model for general STL planning with solid experiments. Reviewer GKRz appreciated the diverse STL coverage and fast generation of satisfying plans, and Reviewer 8aYy highlighted that our model effectively captures STL semantics with efficient inference. During rebuttal, we also conduct extra experiments, including evaluations across varied random seeds and compare with an MILP baseline. These perspectives support the relevance of our contributions and their potential impact on the STL planning community.\n\nWe hope this addresses the concerns, and we welcome further discussions.\n\n**References:** \n1. Vaezipoor, Pashootan, et al. \"Ltl2action: Generalizing ltl instructions for multi-task rl.\" International Conference on Machine Learning. PMLR, 2021\n2. Bacchus, Fahiem, and Froduald Kabanza. \"Using temporal logics to express search control knowledge for planning.\" Artificial intelligence 116.1-2 (2000): 123-191\n3. Liu, Wenliang, et al. \"Interpretable generative adversarial imitation learning.\" arXiv 2024\n4. Leung, Karen, and Marco Pavone. \"Semi-supervised trajectory-feedback controller synthesis for signal temporal logic specifications.\" ACC 2022\n5. Meng, Yue, and Chuchu Fan. \"Diverse controllable diffusion policy with signal temporal logic.\" RA-L 2024\n6. Vazquez-Chanlatte, Marcell, et al. \"Learning task specifications from demonstrations.\" NeurIPS 2018\n7. Shah, Ankit, et al. \"Bayesian inference of temporal task specifications from demonstrations.\" NeurIPS 2018\n8. Cosler, Matthias, et al. \"nl2spec: Interactively translating unstructured natural language to temporal logics with large language models.\" CAV 2023\n9. He, Jie, et al. \"Deepstl: from english requirements to signal temporal logic.\" International Conference on Software Engineering. 2022\n10. Chi, Cheng, et al. \"Universal manipulation interface: In-the-wild robot teaching without in-the-wild robots.\" RSS 2024", "claims_and_evidence": "Partially. The authors claim that most previous work do not consider diverse STL or neural-network encoder, while there are existing work that can achieve this for a similar temporal logic -- linear temporal logic (LTL). Although their semantics are not entirely same, many template and encoder designs can be shared and re-utilized with minor modifications.\n\nVaezipoor P, Li AC, Icarte RA, Mcilraith SA. Ltl2action: Generalizing ltl instructions for multi-task rl. InInternational Conference on Machine Learning 2021 Jul 1 (pp. 10497-10508). PMLR.", "methods_and_evaluation_criteria": "The proposed methodology is reasonable. The proposed dataset can be used to test the proposed algorithm. However, it is unclear how difficult or laborious it is for a new environment in real applications.", "theoretical_claims": "No theoretical proofs.", "experimental_designs_or_analyses": "Experiments are reasonable.", "relation_to_broader_scientific_literature": "Will be interesting to the venue and researchers focusing on STL and neural-symbolic learning.", "essential_references_not_discussed": "Please see Claims And Evidence part for a previous work LTL2Action.", "other_strengths_and_weaknesses": "The contribution of STL templates and GNN encoder is incremental compared to LTL2Action as the extension of these for LTL to STL does not face significant challenges. Therefore, the technical contribution is limited.\n\nThe proposed method requires paired demonstrations for training the conditional generative model. If I am understanding correctly, this would require first collecting a set of demonstrations for a new environment in application before the method can be trained. In real physical world this might still be very laborious.", "other_comments_or_suggestions": "No.", "questions_for_authors": "No.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "YFYT9uKFHO", "reviewer": "Reviewer_GKRz", "summary": "This paper provides a flow-matching based approach to generate plans for a diverse range of Signal Temporal Logic (STL) specifications. Consequently, the proposed method can be optimized to be significantly faster than a diffusion-based approach as considered previously by skipping Ordinary Differential Equation (ODE) steps in the Euler sampling process. A Graphical Neural Network (GNN) encodes the STL specification which is then fed into a conditional flow model that predicts a satisfying trajectory given the current state. Experiments on simple differentiable environments as well as more complicated Maze-like non-differentiable environments show the merits of the approach in speed and trajectory performance.\n\n## update after rebuttal\n\nI appreciate the additional experiments (MILP planner) provided by the authors and the clarifications. It would be beneficial for the usability of the approach if the realizability of the trajectories generated was further discussed or evaluated. Regardless, the paper provides an interesting direction for STL-guided planning and I am still in favor of accepting the paper.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We appreciate Reviewer GKRz's thorough review and positive evaluations. We are glad to see that our contributions (first STL generative model; diverse setups; fast inference) have been recognized. We conducted new experiments as requested. Below are our responses to the concerns and questions.\n\n**(New experiment) MILP baseline**: We use the official codebase from [1] to run MILP baseline on Linear and PointMaze benchmarks. Dubins and AntMaze are omitted due to their nonlinear dynamics and similarity to Linear and PointMaze, respectively. We omit Franka Panda due to its nonlinear constraints from the configuration space. In Linear, we approximate the circular goal/obstacle regions using polygons. We run MILP under various timeouts (“second”):\n\n|Method | STL satisfaction | Runtime (s)|\n|-|-|-|\n|MILP (5) | 0.062 | 5.147|\n|MILP (10) | 0.203 | 18.682|\n|MILP (30) | 0.328 | 27.178|\n|MILP (45) | 0.375 | 37.131|\n|MILP (60) | 0.375 | 47.508|\n|MILP (90) | 0.383 | 68.913|\n|**TeLoGraF(Fast)** | **0.477** |**0.174**|\n\nThe result shows that TeLoGraF(Fast) outperforms MILP (90) in STL satisfaction, with 400X speed-up (MILP runtime is reasonable compared to TABLE I in paper [1]). MILP is slow as it generates thousands of binary variables in our long-horizon tasks (horizon T=64). We further ran MILP on “PointMaze” (horizon T=512) and it only achieves 0.02 STL satisfaction with average runtime 329.785 seconds, highlighting the efficiency and scalability of our method for long-horizon STL planning.\n\n**(New experiment) Evaluation with varied random seeds**: We redo the experiment in Figure 4 with three random seeds to generate error bars - for learning-based methods, we train and evaluate the NN from different seeds; for non-learning methods, we directly evaluate them with different seeds. Due to time constraints, current results are just for the first three benchmarks, and we will complete this figure by the end of the rebuttal phase. The updated Figure 4 is at https://postimg.cc/XX4LtW62 - the statistical trends remain consistent with those reported in our submission.\n\n**Q1: implementation details**: For each STL spec in the validation set, the robustness score is only used in evaluation to select the best quality trajectory (out of 1024 sampled trajectories). We have 256 STL specs in the validation set. For the gradient-based planner, we use “backprop-through-time” (BPTT) [2] to optimize trajectories thus, it differentiates through the dynamics. The timesteps are 64 for Linear, Dubins and Franka Panda, and 512 for PointMaze and AntMaze.\n\n**Q2: Grad outperforms TeLoGraD/F**: This is an interesting finding, and we agree with the reviewer’s insight. Another factor is that “Linear” has simple, fully actuated dynamics, making it well-suited for gradient-based optimization. In contrast, “Dubins” involves second-order dynamics (acceleration -> speed -> position) with limited control, making them more “dragged” and underactuated and hindering gradient-based planners from efficiently finding solutions.\n\n**Q3: Realistic trajectories**: We appreciate the reviewer’s question regarding dynamics consistency. In all cases, our method generates waypoint trajectories, regardless of whether actions are also predicted during training. These waypoints serve as high-level plans, which can directly get actions from inverse dynamics or be tracked by PD controllers. While we do not enforce dynamics during inference, our focus is on generating STL-compliant high-level paths. Ensuring executability can be done through future extensions such as trajectory refinement or policy warm-starting, as explored in prior works [3], and we will clarify this in the final version.\n\n**Q4: STL metrics**: The STL satisfaction rate is evaluated over 256 STL specs on the validation set (unless otherwise specified, like in Figure 5). For each STL spec, we use our method or other baselines to generate 1024 trajectories and pick the one with the highest STL score as the final trajectory. So these 256 trajectories (one for each STL spec) will be marked as 1 (satisfaction) or 0 (STL violation). And the STL satisfaction rate is computed across these binary outcomes.\n\n**Q5: MILP baseline**: Thanks for the suggestion; we have conducted the experiment showing “TeLoGraF (Fast)”’s advantage over MILP for long-horizon STL tasks.\n\n**Missing STL references**: Thanks. We will cite those accordingly.\n\n**Other suggestions**: Thanks for pointing out the potential improvement in P6, L310, and the typo in P12, L639. We will modify the paper in the final version.\n\n**References:**\n1. Kurtz, Vincent, and Hai Lin. \"Mixed-integer programming for signal temporal logic with fewer binary variables.\" IEEE Control Systems Letters 6 (2022): 2635-2640.\n2. Leung, Karen, and Marco Pavone. \"Semi-supervised trajectory-feedback controller synthesis for signal temporal logic specifications.\" ACC 2022.\n3. Ajay, Anurag, et al. \"Is conditional generative modeling all you need for decision-making?.\" ICLR 2023.", "claims_and_evidence": "The approach considered (to the best of my knowledge) is the first generative model for planning over STL specifications. The specifications considered are diverse and the experiments are shown on a variety of benchmarks ranging from simple linear dynamics to more complex non-differentiable settings like AntMaze.", "methods_and_evaluation_criteria": "I am mostly in agreement with the experiment setting and appreciate the thoroughness in finding a diverse range of STL specifications and goals to support the claims of generality.\n\nIt appears that the robustness score ($\\rho$) of the STL specification ($\\phi$) is not used during evaluation time and the GNN encoding of $\\phi$ alone is used in the conditional flow model.  Using the robustness score as part of the guidance (akin to LTLDoG) could in fact make TeLoGraD a stronger technique.\n\nFor the non-differentiable Maze environments, the time to satisfy the specification or length of the trajectories considered should be helpful to distinguish between the plan qualities of the various methods.", "theoretical_claims": "No novel theoretical advances were discussed.", "experimental_designs_or_analyses": "The STL satisfaction rate calculation is a little hard to understand. The highest STL score trajectory out of 1024 sampled outputs is denoted as the final trajectory. The satisfaction rate is quantified as the ratio of final trajectories that satisfy the STL specification out of 256 specs from the validation set. \n\nAdditionally, it is unclear how the trajectories are determined to be realistic without using the environment dynamics directly. For the differentiable environments (Linear, Dubins, Franka Panda), it would be helpful to clarify how the trajectories are deemed to achievable by a given controller. Unlike the proposed method (TeloGraD/F), the **Grad** baseline differentiates through the environment’s transition function and yields trajectories that respect the system dynamics.\n\nError bars representing standard deviation or spread are not present in any of the results considered.", "relation_to_broader_scientific_literature": "The study and modern dataset for diverse STL specifications along with a release for the GNN-based approach to encode the objectives is relevant and will be appreciated by the community. Diffusion based methods using STL as guidance have been considered previously but not in the general planning setting (except LTLDoG to the best of my knowledge).", "essential_references_not_discussed": "Mixed-integer linear programming (MILP)-based methods (Kurtz & Lin 2022) are mentioned but not evaluated even for the environments with simple dynamics like Linear and Dubins. To this reviewer, an additional baseline for the non-differentiable Maze environments can be assuming simple linear dynamics to generate waypoints using an MILP planner with the STL spec. objectives and obstacles as Avoid predicates. Since an A* planner is used between the proposed waypoints, the actual trajectories should similarly be realizable (if a path is found).\n\nSome relevant work on robotic control for Signal Temporal Logic is missing:\n\n[1] Co-learning Planning and Control Policies Constrained by Differentiable Logic Specifications, Xiong et al, ICRA 2024\n\n[2] Reinforcement Learning of Flexible Policies for Symbolic Instructions with Adjustable Mapping Specifications, Hatanaka et al, RA-L\n\n[3] Synthesis of Temporally-Robust Policies for Signal Temporal Logic Tasks using Reinforcement Learning, Wang et al, ICRA 2024", "other_strengths_and_weaknesses": "The ability to generate satisfying plans quickly is especially interesting and begs the question whether slower inference diffusion models, that could be more powerful and diverse, are necessary for most environments.", "other_comments_or_suggestions": "- p6L310 : referencing the graphs mentioned (Fig. 5) would help clarify if they are different from Fig. 4.\n- p12L639 : The equation referenced is wrong (should be Eq. 7)", "questions_for_authors": "1. Is the robustness score used at all during evaluation (and not only during generating the demonstration data)? On a related note , how is this gradient based planner used for demonstration data implemented (for the differentiable environments)? Does it differentiate through the dynamics? How many time steps are the given trajectories for Linear and Dubins?\n2. It appears that the **Grad** baseline significantly outperforms **TeloGraD/F** in Linear environment. Is this because, unlike **Grad,** the proposed method does not use environment dynamics which can help significantly when the environment is simple (like in Linear)?\n3. How are the generated trajectories verified to be consistent with environment dynamics?\n4. Is the same methodology to calculate satisfaction rates carried out for all baselines? (the same 256 specs from the validation set followed by sampling 1024 trajectories to pick 256 final trajectories). If this understanding is incorrect, an explanation would be appreciated.\n5. Can there be comparisons provided with MILP based methods for the differentiable environments?  If this is not an appropriate baseline, why?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "OcTQfw5vN2", "reviewer": "Reviewer_8aYy", "summary": "The paper studies the problem of training an RL/planning agent that takes as input (i) a Signal Temporal Logic (STL) specification and (ii) a start state and then generates a plan/trajectory in the environment that starts at the given start state and satisfies the given STL specification. The proposed learning algorithm involves (i) sampling STL specifications from four main categories that appear commonly in practice, (ii) sampling expert trajectories that satisfy each specification (computed using well-known but slow optimization procedures), and (iii) using the sampled dataset of specification-trajectory pairs to fit a generative model that generates trajectories given a specification and a start state. The generative model architecture involves two main components: (i) a graph neural network architecture to encode the given STL specification and (ii) a temporal U-Net flow model that can be used to generate a trajectory given the encoding of the specification. Experiments in complex environments indicate that the proposed approach can outperform baselines w.r.t. satisfaction rate under compute constraints.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank Reviewer 8aYy for the thoughtful feedback and appreciation of our ablation studies and graph-based encoding, which aim to enhance symbolic understanding in decision-making. Below, we address the comments on novelty and trajectory realizability.\n\n**Significance of STL planning**: (same to Reviewer 8mCx) We argue that it is non-trivial to extend the existing LTL2Action [1] to STL, particularly for the key technique “progression” [2] used to update task spec based on assignments. Consider an example (Sec 3.3 in LTL2Action) “First reach R, then reach G”. In LTL, this can be written as $F(R \\land F(G))$. Once reach R, following LTL2Action, the LTL is updated to $F(G)$, and the updated reward will encourage reaching G. \n\nSTL expresses this in $F_{[ta,tb]} (R \\land F_{[tc,td]} G)$ where [ta, tb] is the time range to reach R, and [tc, td] is the relative range that G should be reached after reaching R. Now, the progression is non-trivial - when reaching R, we need to: (1) ensure the event “reach R” happens in [ta, tb] (2) store this event time because the success of “reach G” will depend on the time R was reached. So we need to bookkeep all the “reach R” events as well as their times, and whenever we reach G, we need to iterate all the past “reach R” events to check if the “reach G” event happens after any of it within the [tc,td] range. The complexity is $O(T^2)$, where T is the trace length. The complexity is $O(T^L)$ for L nested temporal layers in STL. Thus, it is not trivial nor efficient to extend LTL2Action to STL.\n\nBecause STL doesn’t have automata-like forms as LTL does, it is hard to efficiently augment the state to be Markovian, as mentioned in our paper (page 2, lines 81-83, right column). Thus we use imitation learning to learn diverse STL, and we believe this distinction highlights the novelty and our contribution. That said, we value the reviewer’s observation, and we will cite LTL2Action [1] and the progression paper [2] with explanations in the final version.\n\n**Realizability**: (same to Reviewer GKRz) We appreciate the reviewer’s question regarding dynamics consistency. In all cases, our method generates waypoint trajectories, regardless of whether actions are also predicted during training. These waypoints serve as high-level plans, which can directly get actions from inverse dynamics or be tracked by PD controllers. While we do not enforce dynamics during inference, our focus is on generating STL-compliant high-level paths. Ensuring executability can be done through future extensions such as trajectory refinement or policy warm-starting, as explored in prior works [3], and we will clarify this in the final version.\n\n**Q1: $\\phi_{and}$ and $\\phi_{or}$**: This is a good observation, and the distinction was intentionally designed: $\\phi_{and}$ and $\\phi_{or}$ are used to enforce “structured”, canonical forms: $\\phi_{and}$ requires all its children nodes to be “disjunctions” (OR-type) while $\\phi_{or}$ requires its children to be conjunctions (AND-type). The reviewer's proposed formula will allow both cases. For instance, we allow STL formulas like $A \\lor (B \\land C)$ but do not allow redundant nesting such as $A \\land (B \\land C)$, which can be flattened into $A \\land B \\land C$. This structural design eases the NN training by reducing the variability of data in syntactic forms.\n\n**Q2: $\\phi_{partial}$**: Sorry for the confusion. In fact, in our implementation, we additionally add “Eventually Reach $O_p$” to ensure the agent will first reach $O_q$ and then move to $O_p$ (as shown in our appendix, Figures 19, 20). In some other cases (Figure 37 in our appendix for the PointMaze env), we don’t explicitly specify to reach K0 and K1, but from the layout the agent has to reach the keys first. We will make these clear in our final paper. \n\n**Q3: measure in executable policy**: It is possible to define the executable policy for simple cases like Linear and Dubins from the predicted waypoint trajectories, but hard for PointMaze (higher-order ODE for dynamics), AntMaze (higher-order ODE, contact force) or Franka Panda (inverse kinematics to convert workspace trajectories to the configuration space to derive the policy). We can measure satisfaction by executing this calculated policy in some cases, but as mentioned in the **Realizability** section, we focus on planning STL-compliant high-level paths. Ensuring executability can be done through future extensions as explored in [3], and we will clarify it in the final version.\n\n**References:**\n1. Vaezipoor, Pashootan, et al. \"Ltl2action: Generalizing ltl instructions for multi-task rl.\" ICML 2021.\n2. Bacchus, Fahiem, and Froduald Kabanza. \"Using temporal logics to express search control knowledge for planning.\" Artificial intelligence 116.1-2 (2000): 123-191.\n3. Ajay, Anurag, et al. \"Is conditional generative modeling all you need for decision-making?.\" ICLR 2023", "claims_and_evidence": "The high-level claims are supported by decent evidence in the paper. For instance, the authors show that the chosen encoder architecture outperforms alternatives via a sufficiently thorough ablation study. The only claim that seems slightly problematic is that authors are the first to train a generative model for planning conditioned on STL specifications. Although it appears that this claim is true, I am not sure if this is a significant claim given there is already work on training RL agents that output actions conditioned on LTL specifications (see below).", "methods_and_evaluation_criteria": "The benchmark environments seem appropriate and the authors present experiments on a wide range of environments (including standard MuJoCo environments). The evaluation criterion also makes sense. One thing that is not very clear is how the satisfaction of an output trajectory is calculated. For the evaluation to make sense, the generated trajectories do not only need to satisfy the given specification but also need to be realizable (follow the dynamics in the environment). It is not apparent from reading the paper that the authors are considering realizability in the evaluations.", "theoretical_claims": "There are no new theoretical claims in the paper.", "experimental_designs_or_analyses": "Apart from the minor question I posed earlier, the experimental design appears sound and valid.", "relation_to_broader_scientific_literature": "- The presented approach can be considered as a meta reinforcement learning algorithm. STL offers a natural syntax to encode specifications in the context of meta RL.\n- Although there has been a lot of recent work on reinforcement learning from temporal logic specifications, there is relatively less research on zero shot execution given a new specification. This paper attempts to tackle this important problem.\n- Obtaining good embeddings of code (in this case, STL specifications) is a relevant problem. For instance, it is known that LLMs do not understand the semantics of code very well (even though they can generate good code). It appears that the approach in the paper enables the agent to understand the semantics of STL specifications.", "essential_references_not_discussed": "I think the below reference [1] is very similar to this paper. The approach presented in [1] also involves using a GNN to encode the temporal specification (LTL). Although this paper differs slightly since the focus is on using a generative model for planning, it is still very similar to [1] which trains an actor network instead of generative model. The main differences seem to be (i) using STL instead of LTL and (ii) using a generative model for planning instead of training an actor network. These differences are fairly minor and [1] is tackling the same high-level problem. Hence, I think this paper should be discussed and the authors should clarify how their contributions add value beyond existing findings in [1].\n\n[1] Vaezipoor, Pashootan, et al. \"Ltl2action: Generalizing ltl instructions for multi-task rl.\" International Conference on Machine Learning. PMLR, 2021.", "other_strengths_and_weaknesses": "- In spite of the similarity with prior work, the idea of using a flow model in this context appears novel and natural. The results look encouraging since the required number of flow steps for a decent performance is small (in the study in the paper), which improves the time taken for planning.\n- Clarity can be improved slightly and some things can be made more precise (see questions below).", "other_comments_or_suggestions": "N/A", "questions_for_authors": "- Why is there a distinction between $\\phi_{and}$ and $\\phi_{or}$ in page 4? From the definition, it looks like a $\\phi_{or}$ formula is also a $\\phi_{and}$ formula and vice-versa. Aren't they just equivalent to $\\phi_{bool} := \\phi_{reach}\\ |\\ \\phi_{bool,1}\\lor\\phi_{bool,2}\\ |\\ \\phi_{bool,1}\\land\\phi_{bool,2}$? Then $\\phi_{multi}$ can also be written as just $\\phi_{bool}\\land\\phi_{avoid}$.\n- In page 4, the description of $\\phi_{partial}$ is confusing. It is mentioned that $O_p$ has to be reached after $O_q$ is reached. But $(\\lnot O_p)\\ \\mathcal{U}\\ O_q$ is satisfied even if $O_p$ is never reached.\n- Is it possible to define an executable policy from the trajectory generated by the model? If so, why not measure the satisfaction of the specification based the trajectory resulting from executing this policy (instead of directly analyzing the generated trajectory which may not exactly follow system dynamics)?", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: The reviewers acknowledged that the paper presents a novel approach, TeLoGraF, which combines graph neural networks and flow-matching to solve general signal temporal logic (STL) planning tasks. The authors successfully demonstrated the method's effectiveness across a diverse set of simulation environments, significantly improving STL satisfaction rates and offering substantial runtime efficiency compared to classical algorithms. Although concerns were raised regarding incremental contributions relative to similar LTL-based methods, the authors' rebuttal convincingly addressed these points, clarifying the complexity and uniqueness of extending their approach from LTL to STL. The reviewers also highlighted the paper's limitations, such as reliance on pre-collected demonstrations and lack of executable policies, but recognized the practical pathways proposed for future work. Overall, given the robustness of the method, convincing experimental validation, and effective author responses, this submission represents a solid contribution and warrants acceptance.
Decision: Accept (poster)