STL-Constrained DMP Optimization

• The paper shows that re-optimizing the DMP forcing term preserves natural motion while satisfying spatiotemporal constraints such as obstacle avoidance and velocity limits.
• The methodology leverages quantitative STL robustness to enforce specific temporal and spatial requirements, ensuring safe and goal-directed motion.
• Various optimization formulations, from perturbing DMP basis weights to employing barrier certificates, demonstrate a balance between preserving learned dynamics and meeting formal task constraints.

STL-constrained DMP optimization is the problem of modifying a Dynamic Movement Primitive (DMP) so that the generated motion satisfies Signal Temporal Logic (STL) requirements while remaining close to the dynamics learned from demonstration. In the explicit low-level formulation of "BT-TL-DMPs: A Novel Robot TAMP Framework Combining Behavior Tree, Temporal Logic and Dynamical Movement Primitives" (Liu et al., 19 Jul 2025), the optimization acts on the DMP forcing term so that the rollout satisfies spatiotemporal constraints such as obstacle avoidance, via-point passage, workspace bounds, and velocity limits, while preserving demonstrated motion characteristics. A closely related precursor is "Constrained Dynamic Movement Primitives for Safe Learning of Motor Skills" (Shaw et al., 2022), which is not an STL method but already formulates safety-constrained trajectory deformation by perturbing DMP forcing weights and certifying forward invariance through a Zeroing Barrier Function (ZBF). Taken together, these works define a spectrum: from safety-only constraint enforcement on DMPs to explicit optimization against richer temporal logic specifications.

1. Conceptual scope and problem definition

At its narrowest, STL-constrained DMP optimization refers to the low-level motion-planning subproblem in which a learned primitive is adapted to satisfy continuous-time or sampled-time logical requirements without discarding the primitive’s attractor structure. In (Liu et al., 19 Jul 2025), this is the motion-level half of a hierarchical framework: high-level task structure is handled by Behavior Trees (BTs) derived from temporal logic, while the active subtask’s DMP is re-optimized under the associated STL motion constraints. The paper’s stated motivation is that long-horizon manipulation requires more than reaching a goal: the motion may need to pass through a via-point, avoid obstacles throughout an interval, remain inside a workspace region during a time window, or obey translational and angular velocity limits.

The central design choice is to optimize the DMP forcing term rather than an arbitrary trajectory. In the formulation of (Liu et al., 19 Jul 2025), this is intended to preserve the “natural force features” and convergence behavior of DMPs better than a direct trajectory-distance objective. In (Shaw et al., 2022), the same preservation principle appears in a different form: the learned forcing weights are treated as nominal and only perturbed by optimization variables, so the method deforms the demonstrated primitive in parameter space rather than synthesizing a motion from scratch.

This suggests two closely related meanings of the topic. The first is explicit STL-constrained forcing-term optimization, exemplified by (Liu et al., 19 Jul 2025). The second is logic-constrained deformation of DMP dynamics, in which STL may be replaced by a more specific certificate such as a barrier condition, as in (Shaw et al., 2022). The second is not yet full STL, but it provides the architectural template of “learn a primitive, then optimize a compact deformation subject to formal constraints.”

2. DMP parameterizations used as optimization substrates

The DMP substrate in (Liu et al., 19 Jul 2025) comprises standard second-order position DMPs and quaternion DMPs for orientation. The position DMP uses end-effector position $\mathbf y \in \mathbb R^3$, goal $\mathbf y_g$, velocity state $\mathbf v$, and a forcing term $\mathbf F(\phi)$ driven by a phase variable. The forcing term is learned from demonstration, and multiple demonstrations are summarized with GMM-GMR into a mean trajectory and time-varying covariance. The mean trajectory is then used for DMP fitting, while the variance is used to weight the subsequent optimization so that low-variance segments are preserved more strongly.

The paper’s low-level decision variable is not the trajectory itself and not the basis weights explicitly. Instead, for each subtask $\epsilon$, the optimized object is the forcing term signal over a finite horizon, written as $\mathbf F^\epsilon \in \mathbb R^{T\times 3}$ for position or $\mathbb R^{T\times 7}$ for pose. The nominal learned forcing term is $\mathbf F_{\text{lrn}}^\epsilon$, and the optimized one is $\mathbf F_{\text{opt}}^\epsilon$. The preservation objective is first introduced as

$$J_{\text{DMP}}^{0}(\mathbf F^\epsilon)=\|\mathbf F^\epsilon-\mathbf F_{\text{lrn}}^\epsilon\|_2,$$

and then weighted by a matrix $\mathbf y_g$0 derived from GMM-GMR variance:

$\mathbf y_g$1

This weighting is designed so that low-variance portions of the demonstrations are penalized more strongly (Liu et al., 19 Jul 2025).

By contrast, (Shaw et al., 2022) stays within the standard point-to-point DMP parameterization and modifies the forcing weights directly. If the learned forcing term is

$\mathbf y_g$2

the constrained DMP uses

$\mathbf y_g$3

where the perturbations $\mathbf y_g$4 are optimization variables (Shaw et al., 2022). The representation is explicitly in workspace or end-effector trajectory space, not joint space. This is significant because the logical predicates and safety constraints are imposed directly in the robot workspace.

The distinction between these two parameterizations is substantive. One optimizes sampled forcing signals; the other optimizes perturbations of basis weights. Both are compact motion-deformation spaces relative to direct trajectory optimization. A plausible implication is that the choice between them determines which solver families are practical: sampled forcing terms align naturally with black-box rollout optimization, whereas basis-weight perturbations align naturally with smooth nonlinear programming.

3. STL semantics, safety fragments, and temporal expressivity

The STL layer in (Liu et al., 19 Jul 2025) is built on quantitative robustness. The syntax includes atomic predicates, negation, conjunction, disjunction, eventually, always, and implication, with robustness semantics such as

$\mathbf y_g$5

$\mathbf y_g$6

The motion-level STL predicates used in the paper include examples such as $\mathbf y_g$7, $\mathbf y_g$8, $\mathbf y_g$9, and $\mathbf v$0 (Liu et al., 19 Jul 2025).

The barrier-based precursor (Shaw et al., 2022) covers a narrower fragment. Its ZBF condition

$\mathbf v$1

is a forward-invariance certificate, so it naturally expresses “always remain in a safe set.” The paper itself notes that this aligns with STL formulas of the form $\mathbf v$2, but not with eventuality, sequencing, or until formulas. The same source is explicit that ZBFs can prevent bad events while never reaching a goal set, so a formula such as $\mathbf v$3 is not equivalent to any pure barrier condition (Shaw et al., 2022).

This division between invariance and richer temporal structure is one of the main organizing principles of the area. Safety-dominated tasks map well to barrier methods. Richer STL tasks require direct temporal-logic reasoning. The 2021 paper on time robustness makes a further distinction: time robustness is not ordinary quantitative or spatial robustness, but a measure of how much timing uncertainty can be tolerated while preserving truth of the formula (Rodionova et al., 2021). That distinction is particularly relevant for DMPs because temporal scaling and phase variation are intrinsic to primitive execution.

A separate but related issue is continuous-time satisfaction between sample points. (Yang et al., 2020) addresses continuous-time STL for linear systems with ZOH controls by deriving interval-valid lower bounds for predicates and Control Barrier Functions over nonuniform control segments, instead of checking formulas only at uniform samples. This suggests a remedy for one of the recurrent caveats in DMP-based STL optimization: sampled satisfaction alone does not preclude inter-sample violation.

For smooth optimization, (Uzun et al., 2024) introduces the discrete-time generalized mean-based smooth robustness measure (D-GMSR), denoted $\mathbf v$4, with the exact sign property

$\mathbf v$5

The paper proves that D-GMSR is $\mathbf v$6-smooth, sound, and complete. This is not a DMP paper, but it provides a robustness layer that can, in principle, be composed with any differentiable rollout map, including a DMP rollout.

4. Optimization formulations and algorithmic backends

The explicit low-level formulation in (Liu et al., 19 Jul 2025) defines

$\mathbf v$7

and combines it with the forcing-term preservation term:

$\mathbf v$8

The paper is explicit that there is a sign ambiguity here: since $\mathbf v$9, minimizing the objective as written would minimize robustness, whereas the intended behavior is to favor STL satisfaction. The surrounding text and experiments indicate that the practical interpretation is to seek high STL robustness while penalizing departure from the learned forcing term. The paper states that the STL term is computed using PyTeLo, but it does not specify a concrete numerical optimizer, pseudocode, convergence criterion, or complexity bound (Liu et al., 19 Jul 2025).

The CDMP formulation in (Shaw et al., 2022) is more explicit at the nonlinear-program level. It optimizes jointly over the trajectory and the perturbation parameters, with DMP dynamics, a ZBF inequality, the initial condition, and optionally a trajectory-deviation trust region

$\mathbf F(\phi)$0

The paper says that “the simplest cost function can penalize the $\mathbf F(\phi)$1-norm of the decision variables $\mathbf F(\phi)$2,” so the intended objective is to minimize deviation from the original forcing weights rather than to track the demonstration directly. The problem is transcribed with PyRoboCOP and solved offline with IPOPT. A practical limitation is stated unambiguously: constraints are enforced only at collocation points, so coarse discretization may miss violations between points (Shaw et al., 2022).

Several other papers provide solver backends that are not DMP-specific but are repeatedly analyzed as transferable to parameterized trajectory generators. One line treats STL robustness as a black-box objective and uses Bayesian optimization; the adaptation note for (Kurtz et al., 2019) states explicitly that the paper’s control sequence can be replaced by a DMP parameter vector $\mathbf F(\phi)$3, yielding

$\mathbf F(\phi)$4

The same note emphasizes that this is especially attractive when DMPs compress the search from a full control tape to a lower-dimensional parameter space.

A second line uses direct trajectory optimization with smooth or underapproximated robustness. (Kurtz et al., 2020) reformulates a restricted STL fragment into stage costs for Differential Dynamic Programming, while (Takayama et al., 2023) decomposes reversed STL robustness into convex max-derived and concave min-derived constraints and solves the resulting difference-of-convex program by an STL-aware convex-concave procedure with mellowmin smoothing. A third line uses sampling-based control updates: (Halder et al., 3 Mar 2025) optimizes exact, nonsmooth STL costs by deterministic path integral control without smoothing or mixed-integer reformulation. A fourth line uses smooth robustness directly: (Uzun et al., 2024) combines D-GMSR with sequential convex programming and a prox-linear method.

These methods are not themselves STL-constrained DMP algorithms. The data repeatedly frame them as adaptation templates. This suggests that the field is less a single method family than a design space: choose a DMP parameterization, choose an STL semantics, and then choose an optimization backend compatible with the resulting rollout map.

5. Hierarchical, uncertainty-aware, and multi-agent extensions

The most explicit hierarchical architecture is (Liu et al., 19 Jul 2025). A long-horizon task is first represented in STL and partially abstracted into LTL to build a reactive Behavior Tree. The task-level logic handles sequencing, preconditions, and postconditions; the residual motion-level constraint set $\mathbf F(\phi)$5 is attached to the active action node and passed to the DMP optimizer. This is how the framework “bridges the symbolic-motion gap”: BT provides reactivity and modularity, STL provides a formal interface, and the DMP optimizer turns motion-level logic into executable trajectories.

A different hierarchical decomposition appears in (Liu et al., 20 Apr 2026). DAG-STL does not use DMPs, but it decomposes STL formulas into reachability and invariance progress conditions linked by shared timing constraints, allocates timed waypoints, and only then synthesizes motion segments. The paper explicitly presents this as an alternative to direct robustness-guided trajectory optimization for complex long-horizon STL tasks. It also notes that the low-level generator is modular. This suggests a natural DMP interpretation: DMP segments can be treated as local motion realizers between allocated waypoints, while the higher-level logic and timing allocation remain unchanged.

Under uncertainty, (Bouzid et al., 18 Jun 2026) introduces lexicographic ordering over STL specifications together with risk-aware robustness aggregation. For each rule, robustness under multimodal uncertainty is aggregated with a risk metric, mainly CVaR, and the resulting vector is mapped to a rank-preserving reward. The paper is about autonomous driving and MPPI, not DMPs, but it gives a concrete template for prioritizing conflicting STL requirements under uncertainty. A plausible implication is that the same lexicographic, risk-aware robustness machinery can be attached to DMP-generated trajectories when obstacle motion, object motion, or contact outcomes are uncertain.

For multi-robot settings, (Raxit et al., 6 Mar 2026) combines a constrained Bayesian Optimization-based Tree search at the single-robot level with STL-enhanced Kinodynamic Conflict-Based Search at the multi-robot level. The low-level acquisition uses

$\mathbf F(\phi)$6

with feasibility probability built from GP surrogates over constraints. The high-level layer monitors pairwise safety conflicts via STL. The paper is framed as an architectural template rather than a DMP method, but the transfer is straightforward: replace the local control vector by a DMP parameter vector and keep the same surrogate-based low-level search plus STL-based conflict resolution.

6. Empirical behavior, limitations, and open directions

The empirical evidence in the dedicated DMP papers is mostly qualitative but targeted. In (Liu et al., 19 Jul 2025), simulation includes via-point, obstacle-avoidance, space-limit, and velocity-limit constraints, and the main ablation compares a trajectory-space objective against the proposed forcing-term objective. The trajectory-based objective yields what the paper describes as “unnatural generalization,” whereas the forcing-term objective produces more natural obstacle-avoiding trajectories that remain dynamically similar to the demonstrations. Real-robot tasks include breakfast preparation and afternoon-tea preparation, with successful completion under via-point, workspace-limit, obstacle-avoidance, and translational or angular velocity constraints. The paper reports successful adaptation and preservation of learned movement characteristics, but not detailed quantitative metrics such as success rate or solve time distributions (Liu et al., 19 Jul 2025).

The CDMP experiments in (Shaw et al., 2022) include a cone-shaped allowable set, comparison with dynamic artificial potential fields in an adversarial obstacle configuration, and physical demonstrations on a Kinova Gen3 and a Mitsubishi Electric Assista in wall-hopping, chess-piece moving, and whiteboard-drawing tasks. The method is qualitatively successful and explicitly shows that the barrier-certified optimization is not merely a reactive repulsion heuristic. At the same time, the paper emphasizes the discretization caveat: the continuous-time forward-invariance theorem is weakened numerically because the optimization enforces constraints only at collocation points.

Several limitations are recurrent across the literature. In (Liu et al., 19 Jul 2025), the numerical formulation is underspecified: the solver, discretization scheme, gradient computation, and robustness smoothing are not stated; the sign in the STL term is inconsistent with standard robustness maximization; and strict satisfaction depends on the weighting of STL and DMP terms, optimizer quality, and discretization resolution. In (Shaw et al., 2022), the barrier-function machinery covers only the safety fragment of STL and does not directly encode eventually, until, ordered sequencing, or richer temporal composition.

Two broader directions emerge from the surrounding literature. First, infeasibility under conflicting STL requirements can be handled by minimal relaxation followed by Pareto refinement. (Wu et al., 6 Mar 2026) formalizes this for STL-constrained MPC with negotiable robustness slacks and an $\mathbf F(\phi)$7-constraint approximation of the Pareto front. The paper is not about DMPs, but it explicitly motivates a two-stage logic-aware compromise mechanism. This suggests a natural extension for DMP optimization: first restore feasibility with the smallest possible STL relaxation, then choose among Pareto-optimal DMP rollouts trading off task error, smoothness, energy, and logical satisfaction.

Second, the continuous-time issue remains unresolved in most sampled-trajectory DMP formulations. (Liu et al., 19 Jul 2025) and (Shaw et al., 2022) are explicit about discretization caveats, while (Yang et al., 2020) shows that interval-valid bounds can be used to enforce continuous-time STL without dense uniform sampling, at least for continuous-time linear systems with ZOH controls. A plausible implication is that a full continuous-time STL-constrained DMP optimizer would need additional machinery beyond sampled robustness, such as interval bounding, barrier certificates, or conservative segmentwise verification.

In that sense, STL-constrained DMP optimization is best understood not as a single settled method but as a layered synthesis problem. The core low-level idea—optimize a compact deformation of a demonstrated primitive under temporal-logic constraints—has been made explicit (Liu et al., 19 Jul 2025). Its safety-only precursor is already formalized with barrier certificates (Shaw et al., 2022). Around that core, the literature supplies alternative robustness semantics, optimization backends, hierarchical decompositions, uncertainty treatments, and conflict-resolution mechanisms. The remaining gaps are equally clear: precise continuous-time guarantees, better-specified numerical solvers for forcing-term optimization, principled handling of conflicting formulas, and scalable integration of rich STL semantics with the attractor structure that makes DMPs useful in the first place.