Learn-To-Propagate: Distributionally Robust Motion Planning for Nonlinear Uncertain Systems
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.
Rosa: I'm Rosa.
Dev: And I'm Dev, here with Taro.
Rosa: We're looking at the paper: "Learn-To-Propagate: Distributionally Robust Motion Planning for Nonlinear Uncertain Systems".
Title and authors: Rosa: So we're looking at this paper called Learn-To-Propagate: Distributionally Robust Motion Planning for Nonlinear Uncertain Systems. It looks like they're tackling the problem of finding a path for a robot where the environment and how it moves are not perfectly known, and they want to find a sequence of controls that gets it to its goal without hitting any dangerous spots, even when things are noisy.
Dev: Right, so the core idea is moving beyond those old methods that only work if you know exactly what kind of noise you have or if your system dynamics are perfectly linear. They’re proposing this algorithm called Learn-To-Propagate Distributionally Robust Forest, or L2P-DR-Forest, which handles systems with unknown initial states and process noise distributions.
Taro: That sounds intense because when the underlying distributions are unknown, you can't just assume a nice Gaussian noise model for things like a robot's movement or the road surface. How does this approach actually deal with that uncertainty without needing to know everything upfront?
Rosa: Well, they use something called Distributionally Robust Optimization, or DRO. Think of it like this: instead of planning for one specific noise scenario, you plan for the worst-case scenario within a certain range of possibilities defined by a distribution set. They then use recent advances in optimal transport to learn these "ambiguity sets," which are basically regions where the true noise distribution is guaranteed to live with high probability.
Dev: And this is where it gets clever because they learn these sets from data and then propagate them through the system dynamics, which they keep efficient by not having to relearn everything every single time you take a step. They construct a compact ambiguity set centered around a discrete distribution that they claim contains the true underlying system distributions with high probability, which lets them propagate these sets through the system dynamics and verify safety.
Taro: So instead of checking every possible path against every possible noise model, they are focusing their uncertainty there using this learned set? What's the practical mechanism for learning these sets from data?
Rosa: They partition a bounding box of pre-training samples into hyperrectangles and then use a mixed integer linear problem, or MILP, to find the radius epsilon. This tells them how big their ambiguity set needs to be to cover the samples they've seen so far with high probability. Then, they use Lipschitz continuous dynamics where one ambiguity set is contained within the transformed version of the other one by a factor related to epsilon.
Title and authors: Dev: That propagation step is key because it keeps things manageable, and they use a multi-tree strategy to stop that uncertainty from just piling up over very long planning horizons while still keeping their safety guarantees sound. The structure of the algorithm itself involves growing a forest where each new tree is rooted at a node of an earlier tree, and the ambiguity set at that root is re-learned only from samples rolled out through the controller leading to that node.
Taro: That sounds like it’s trying to manage complexity by only refreshing the uncertainty when things get really interesting or when you need to commit to a new direction. What about when you're actually selecting which tree or node to root the new tree at? That seems like a critical decision point for the whole process.
Rosa: They have a mechanism called SelectRoot that tries to pick a promising node from an existing tree, but it also has an option to draw one uniformly if it can't find anything better. This restart mechanism is really important because it prevents the planner from getting stuck committing to just one sequence of decisions and allows them to prove probabilistic completeness under certain conditions.
Dev: Probabilistic completeness means that if there is even a tiny chance that a control sequence is robustly feasible with some margin, and the noise stays sub-Gaussian, then running the algorithm for an unbounded number of stages will eventually give you a controller with probability one. That’s a strong guarantee for real-time systems.
Taro: So if we take that completeness guarantee seriously, what does this mean for us when we're trying to run this on something like a complex system, maybe the 4D Tractor Trailer benchmark? Can it handle those highly nonlinear dynamics where things get really messy?
Rosa: They’ve shown empirical validation on several robotic benchmarks where this algorithm significantly outperforms existing methods while providing these formal guarantees with high confidence. They reported a one hundred percent success rate on all five benchmarks, including the most demanding one, Tractor Trailer. It also showed that you absolutely need this re-learning step because when they turn off the no-relearning mechanism, their success rate drops to zero on all five benchmarks.
Dev: That’s interesting regarding the re-learning necessity; it suggests that just relying on a single fixed distribution estimate isn't enough for robust control in these nonlinear settings. I wonder how much more computationally expensive this is compared to simpler methods when the state space gets bigger?
Taro: The paper does mention scalability as a limitation, saying that its scalability to high-dimensional systems can be affected by the curse of dimensionality because of those Wasserstein ambiguity sets. They also flagged that it depends on having reasonably tight Lipschitz bounds and access to a preferably large dataset of noise samples. That’s a real practical constraint for deployment.
Title and authors: Rosa: Exactly, so it's not a magic solution that works everywhere right out of the box; you need good data and reasonable assumptions about the system's smoothness, like those Lipschitz constants they mentioned being over one in some cases for the Tractor Trailer benchmark. The paper suggests looking into alternative metrics, like sliced Wasserstein distance, to see if that helps with that high-dimensional issue.
Dev: It seems they are connecting this distribution learning idea—the Wasserstein-based uncertainty propagation—directly to motion planning in a way we haven't seen before, providing a formal framework for safety in stochastic systems. The result is that the proposed Learn-To-Propagate Distributionally Robust Forest gives superior performance compared to comparable methods on benchmarks like the Double Integrator, especially when using their informed search heuristic to guide tree expansion.
Taro: So, what's the big picture here? If this works robustly for nonlinear systems where you don't know the noise distribution, it means we can move towards deploying AI-driven control in environments that are much more unpredictable than just linear or Gaussian ones.
Rosa: It opens up a path for motion planning in situations where uncertainty is high and non-Gaussian, moving us closer to real-world applications where safety is paramount despite the unknown nature of the system noise. We'll see how this translates into faster planning times as they mentioned, especially when they use their informed search to guide the tree expansion.
Dev: It’s a solid piece of work because it doesn't just give you a plan; it gives you a formal guarantee that the plan will respect safety specifications under those distributional uncertainties. It’s about building confidence in complex autonomous systems.
Taro: I think focusing on how they handle the failure modes—how gracefully it recovers when the world misbehaves—is what really shows the value here, not just finding *a* path.
Rosa: Yeah, and that’s what we saw with the Tractor Trailer results; it didn't just find a path; it found a safe one consistently. It’s about making AI systems reliable outside of perfect laboratory conditions.
Dev: So, to wrap up, this paper, Learn-To-Propagate: Distributionally Robust Motion Planning for Nonlinear Uncertain Systems, shows how learning distributionally robust ambiguity sets and propagating them through Lipschitz dynamics can yield a formally correct and probabilistically complete sampling-based planner for nonlinear stochastic systems.
Taro: And it shows that the need to re-learn is essential across different benchmarks, which tells us we can't just rely on one fixed estimate of the uncertainty for long planning horizons.
Rosa: It’s a major step in tying distribution learning directly into robust motion planning, giving us tools to handle real-world nonlinearity and noise better than before.
Dev: We'll keep an eye on how they tackle those high-dimensional scaling issues and whether alternative metrics like sliced Wasserstein distance can help make this approach more practical for massive systems.
The paper's summary: Rosa: So, to recap, this paper is about building a motion planner called Learn-To-Propagate that can handle systems where you don't know exactly what kind of noise or starting position the system has.
Dev: Right, it uses distributionally robust optimization and learns these uncertainty regions from data to make sure the robot gets to its goal safely without hitting anything dangerous.
Rosa: What’s really interesting is how they handle those unknown distributions—they use a method involving optimal transport to figure out where the true noise is likely hidden, creating an ambiguity set around that estimate.
Dev: And they propagate those sets through the system dynamics, which is usually hard because the uncertainty keeps growing, but this method manages it by only re-learning at specific points in their planning tree.
Rosa: It sounds like they’re trying to find a way to keep the planning process fast while still being formally safe against all those unknown noise scenarios.
Dev: That’s the core challenge, isn't it? Finding that balance between speed and guaranteeing safety when you don't have perfect information about the system's noise characteristics.
Rosa: And they prove that this entire process is probabilistically complete under some assumptions, meaning if a solution is even slightly possible within a certain noise margin, this algorithm will eventually find it with high probability.
Dev: That completeness proof is important because it tells us that the planner won't just fail silently if there’s a path available within the uncertainty bounds.
Rosa: They showed some strong empirical results on real robots, like a one hundred percent success rate on even tough benchmarks such as Tractor Trailer, which really shows how this translates to practical systems.
Dev: But they also laid out some limitations, and the main one is that it can get computationally expensive when the state space is very high-dimensional because of those Wasserstein ambiguity sets.
Rosa: Yeah, they mention that you need pretty tight bounds on things like Lipschitz constants, and if your noise samples aren't good enough, the accuracy suffers.
Dev: So what this means for us in real-time control is that we can build these complex safety guarantees for nonlinear systems where the noise isn't Gaussian or linear anymore.
Rosa: It points toward a new way of thinking about motion planning where you don't just plan for one scenario, but you plan robustly against a whole family of possibilities defined by data uncertainty.
Dev: And that robustness, coupled with the efficient propagation through those learned ambiguity sets, is what gives this approach its edge over older methods that rely on assuming everything is perfectly known.
The paper's improvements: Rosa: So, to wrap up on the improvements, these authors suggest two main things for making this work even better for real life.
Dev: First, they point out that the way they handle uncertainty propagation can be made much faster by only re-learning at selected restart nodes instead of having to do it constantly.
Rosa: That makes sense because we know exhaustive sampling is too slow when you’re dealing with complex, nonlinear dynamics and high noise.
Dev: Exactly, and that reduction in the need for constant re-learning leads to faster planning times overall, which is crucial for real-time applications where latency matters.
Rosa: They also suggest using an informed search heuristic to guide the tree expansion toward the target set instead of just growing trees randomly from every node.
Dev: That’s a smart way to balance exploration and guidance; you don't just wander everywhere, you use some reference trajectory to help the planner focus on where it needs to go.
Rosa: It sounds like this combination of smarter uncertainty propagation and guided search is what really pushes the empirical performance up on those challenging tests.
Dev: And they also flag that for very high-dimensional systems, like a 4D environment, these Wasserstein ambiguity sets can still cause scaling problems because of the curse of dimensionality.
Rosa: That’s the caveat they mention; it’s not a perfect solution for every massive system without some tweaks to how we measure uncertainty.
Dev: So, while they show this works really well for many benchmarks, we still have to worry about making it practical when you move from simple 2D tasks to those truly high-dimensional robotic systems <ref:2611.13863#pg1>.
Rosa: The next step in their research is looking at alternative ways to measure probability that might not suffer as much from that curse of dimensionality issue.
Dev: They specifically mention looking into things like the sliced Wasserstein distance, which they think could help alleviate the scaling problems we see with these distribution sets.
Conclusion: Rosa: So we’re wrapping up this look at Learn-To-Propagate: Distributionally Robust Motion Planning for Nonlinear Uncertain Systems by Rosa and Dev.
Dev: To sum it up, this paper shows how to build a motion planner that can handle nonlinear systems where you don't know the noise or initial state distribution by learning and propagating uncertainty sets from data.
Rosa: It’s about moving beyond those old methods that assume linear dynamics or perfect Gaussian noise to find safe paths even when the world is unpredictable.
Dev: And they prove that this entire process is probabilistically complete, which means if a solution exists within certain noise bounds, the planner will eventually find it with high probability.
Taro: I just want to say that seeing one hundred percent success on benchmarks like Tractor Trailer shows how reliably this method handles real-world failure modes when the dynamics are really messy.
Rosa: And that necessity of re-learning is what really proves the concept, because if you don't re-learn, the success rate drops to zero on all those tests.
Dev: It changes things for someone in real-time loops because it gives us a formal safety case even when we can’t perfectly model the noise distribution upfront.
Taro: It means autonomous systems can be deployed in environments that are much more unpredictable than just simple laboratory settings, provided you have enough data to build those robust ambiguity sets.
Rosa: Right, so this paper connects distribution learning directly into motion planning for complex systems with formal guarantees on safety under uncertainty.
Dev: And while they flag the scalability issues for high-dimensional systems and the need for tight Lipschitz bounds, the core idea of using learned ambiguity sets to guide propagation is pretty compelling.
Rosa: It’s a solid piece of work that shows how we can build confidence in complex AI control systems by incorporating uncertainty awareness directly into the planning framework.
Dev: We'll see if they can address those high-dimensional scaling concerns with things like sliced Wasserstein distance in future work, which is where the next challenge for this approach lies.
Eduardo Figueiredo, Adrien Banse, Qi Heng Ho, Raphaèl Jungers, Morteza Lahijanian, Luca Laurenti
Delft University of Technology · ETH Zurich · Virginia Tech · UCLouvain · University of Colorado Boulder
cs.RO, cs.SY, eess.SY
Submitted: 2026-11-10
Updated: 2026-11-10
Code: https://github.com/StanfordASL/randUP_RRT
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 96/100
The gist: Motion planning for stochastic systems aims to find a sequence of control inputs that drives a system to a goal set while avoiding unsafe states with high probability Learn-To-Propagate…
Key concepts
- Distributionally Robust Optimization (DRO)
- DRO is a method used to handle uncertainty when the exact probability distributions of noise or initial states are unknown. Instead of assuming a single distribution, DRO optimizes for the worst-case scenario within an 'ambiguity set' that is guaranteed to contain the true distribution with high confidence.
- Wasserstein Ambiguity Set
- This is a mathematical set that captures all possible probability distributions consistent with the observed data. The algorithm learns this set from samples and uses it to bound the uncertainty of the system's state, ensuring that any plan generated remains safe under the worst-case distribution within that learned set.
- Forest Structure
- The planning process grows a 'forest' of trees, where each new tree is rooted at a node from an earlier one. This multi-tree strategy helps manage uncertainty accumulation over long planning horizons by selectively re-learning ambiguity sets only at key nodes, improving efficiency and soundness.
- Probabilistic Completeness
- This guarantee ensures that if a solution exists under certain conditions (like the noise being sub-Gaussian), the algorithm is guaranteed to find it eventually. This is achieved through a restart mechanism that prevents getting stuck in local optima by periodically re-evaluating promising parts of the search space.
Terminology
Summary
Motion planning for stochastic systems aims to find a sequence of control inputs that drives a system to a goal set while avoiding unsafe states with high probability Learn-To-Propagate Distributionally-Robust Forest (L2P-DR-Forest), a distributionally robust sampling-based planning algorithm for nonlinear stochastic systems with unknown initial state and process noise distributions. p. 0 nl
Abstract
Motion planning for stochastic systems aims to find a sequence
of control inputs that drives a system to a goal set while avoiding
unsafe states with high probability. Existing approaches, however,
are either restricted to linear dynamics with perfect knowledge
of the underlying distributions or lack formal correctness guarantees.Where the paper says it
Core Methodology
The proposed approach, L2P-DR-Forest, combines Distributionally Robust Optimization (DRO), sampling-based planning, and nonlinear uncertainty propagation to handle stochastic systems with unknown initial state and disturbance distributions. The algorithm leverages recent advances in optimal transport to learn ambiguity sets that contain the true system distributions with high confidence. p. 0 To address these limitations, we propose Learn-To-Propagate
Distributionally-Robust Forest (L2P-DR-Forest), a distributionallyrobust sampling-based planning algorithm for nonlinear stochastic
systems with unknown initial state and process noise distributions. Our approach leverages recent advances in optimal transport to
learn ambiguity sets that contain the true system distributions with
high confidence. In this paper, we propose Learn-To-Propagate DistributionallyRobust Forest (L2P-DR-Forest), a novel and computationally efficient
motion-planning algorithm that combines DRO, sampling-based
planning, and nonlinear uncertainty propagation to handle stochastic systems with unknown initial state and disturbance distributions. Leveraging recent results in optimal transport, our approach
estimates a compact ambiguity set centered around a discrete distribution that is guaranteed, with high probability, to contain the true
underlying system distributions. 1 Learning Wasserstein Ambiguity Sets
Our approach is based on learning Wasserstein ambiguity sets centered at discrete distributions. As shown below, this representation
allows us to leverage existing frameworks for learning Wasserstein
ambiguity sets while also enabling particularly efficient propagation
through the system dynamics.Where the paper says it
Where the paper says it
Where the paper says it
Learning and Propagation Mechanisms
The core building blocks involve learning Wasserstein ambiguity sets from data and propagating them through the system dynamics. The learning process involves constructing a discrete distribution bP, together with a radius epsilon >= 0, such that P in Bepsilon (bP) contains PXc with high probability. p. 2 Given a set of 𝑁 +𝑁pre i. samples D𝑁 +𝑁pre from P, our goal is
to construct a discrete distribution bP, together with a radius 𝜀 ≥ 0,
such that, with high probability, P ∈ B𝜀 (bP). As the
sample sizes increase through successive learning and re-learning
stages, the learned radii and escaped masses converge to zero. The
sub-Gaussian assumption on P𝜔 ensures that the bounding box of
the pre-training samples, which scales the learned radius, grows
at most logarithmically with the sample size, so that the radius
can vanish. Our full planning
algorithm is then presented in Section 4. 3, where we also propose a
multi-tree strategy that mitigates the accumulation of uncertainty
over long horizons while maintaining soundness guarantees.Where the paper says it
Where the paper says it
Where the paper says it
Algorithm Structure
The L2P-DR-Forest algorithm operates in stages, growing a forest where each new tree is rooted at a node of an earlier tree and re-learned from new data. The stage involves four steps: (i) selecting a tree and node, (ii) learning the ambiguity set of the state distribution induced by the controller leading to that node, (iii) growing a new tree rooted at the newly learned node, and (iv) adding the tree to the forest. p. 4 Instead, we root each
new tree at a node of an earlier tree and re-learn its ambiguity set
from new data. The trees are stored in a forest F, initially empty, and each stage
has four steps: (i) it selects a tree in F and a node 𝜈 from it (Line 3); (ii)
it learns, from fresh data, the ambiguity set of the state distribution
induced by the controller leading to 𝜈 (Lines 5–7); (iii) it grows
a new tree rooted at the newly learned node (Lines 8–16); and
(iv) it adds the tree to the forest (Line 17). 2, and a node drawn
uniformly from tree′ otherwise. Such exploration (by setting both
𝜆1, 𝜆2 > 0) prevents the algorithm from committing irreversibly to
a single refined prefix and will prove to be fundamental to show
the probabilistic completeness of our algorithm in Theorem 4.Where the paper says it
Where the paper says it
Formal Guarantees and Completeness
The paper proves that the algorithm is correct, i.e., any returned plan satisfies the specifications with the prescribed confidence, and probabilistically complete under some feasibility and distributional assumptions. p. 0 We prove that the algorithm is correct, i. ,
every returned plan satisfies the specifications with the prescribed
confidence, and, under some feasibility and distributional assumptions, is probabilistically complete. , RRT, for 𝑁iter iterations, after which
it is added to the forest F (Line 17). In Lines 10–12, SelectNode()
selects a node6
, and Propagate() propagates the ambiguity set and
escaped-mass bound of the selected node using (7) and Proposition 5, respectively, under a chosen control input 𝑢
★ ∈ U. In our stochastic
setting, we state it directly on the propagated distributions P
𝒖𝑘−1
𝑥𝑘
induced by a control sequence. Assumption 2 below requires the
existence of a nominal controller 𝒖˜ such that the induced state distributions stay strictly safe under any perturbation of Wasserstein
size Δ, thus allowing for a margin in probability space.Where the paper says it
Where the paper says it
Where the paper says it
Empirical Validation
Empirical evaluations on several robotic benchmarks demonstrate that our algorithm significantly outperforms existing methods while providing formal guarantees with high confidence. The results show high task-success rates while enforcing safe controllers, achieving a 100% success rate on all five benchmarks including the most demanding one, Tractor Trailer. p. 6 Our key takeaways are:
Strong performance on nonlinear systems. Our approach
successfully synthesizes formally safe controllers across challenging
environments, achieving a 100% success rate on all five benchmarks,
including the most demanding one, Tractor Trailer, whose dynamics
are given by a learned neural network with a (LipSDP-certified, see
Appendix D. The uncertainty re-learning mechanism proves essential. The no-relearning ablation reaches 0% success on all five benchmarks, despite being granted the same total
iteration budget. HSCC+ICCPS ’27, May 17–20, 2027, Boulder, CO, USA Eduardo Figueiredo, Adrien Banse, Qi Heng Ho, Raphaël Jungers, Morteza Lahijanian, and Luca Laurenti
that the proposed approach achieves superior performance compared to comparable methods. More broadly, the theoretical framework developed in this work establishes a new connection between
Wasserstein-based distribution learning and uncertainty-aware motion planning, opening new directions for scalable and provably
safe planning.Where the paper says it
Where the paper says it
Where the paper says it
Limitations and Future Work
A limitation of the approach is its scalability to high-dimensional systems due to the curse of dimensionality affecting Wasserstein ambiguity sets. The algorithm also depends on reasonably tight Lipschitz bounds and access to a preferably large dataset of noise samples. p. 8 This limitation stems from the well-known curse of dimensionality affecting Wasserstein ambiguity sets, where the sample
complexity required to attain a given approximation accuracy increases rapidly with the dimension of the uncertainty space [14]. We should also stress its dependence on reasonably tight Lipschitz
bounds and access to a preferably large dataset of noise samples (or,
equivalently, the ability to easily query them). We should also stress its dependence on reasonably tight Lipschitz
bounds and access to a preferably large dataset of noise samples (or,
equivalently, the ability to easily query them). An important future
work direction is to investigate alternative probability metrics that
alleviate this dependence, such as the sliced Wasserstein distance
[4, 23]. Closely related work [18] learns
Wasserstein ambiguity tubes from trajectory data under unknown
disturbance distributions and incorporates them into a probabilistically complete sampling-based planner. Its construction exploits
linear or feedback-linearizable dynamics to decouple uncertainty
propagation from nominal planning, allowing the ambiguity tube to
be learned offline and reused during search. The uncertainty re-learning mechanism proves essential. The no-relearning ablation reaches 0% success on all five benchmarks, despite being granted the same total
iteration budget. Our approach
successfully synthesizes formally safe controllers across challenging
environments, achieving a 100% success rate on all five benchmarks,
including the most demanding one, Tractor Trailer, whose dynamics
are given by a learned neural network with a (LipSDP-certified, see
Appendix D. 5) Lipschitz constant exceeding one (1. HSCC+ICCPS ’27, May 17–20, 2027, Boulder, CO, USA Eduardo Figueiredo, Adrien Banse, Qi Heng Ho, Raphaël Jungers, Morteza Lahijanian, and Luca Laurenti
that the proposed approach achieves superior performance compared to comparable methods. More broadly, the theoretical framework developed in this work establishes a new connection between
Wasserstein-based distribution learning and uncertainty-aware motion planning, opening new directions for scalable and provably
safe planning. HSCC+ICCPS ’27, May 17–20, 2027, Boulder, CO, USA Eduardo Figueiredo, Adrien Banse, Qi Heng Ho, Raphaël Jungers, Morteza Lahijanian, and Luca Laurenti
that the proposed approach achieves superior performance compared to comparable methods. More broadly, the theoretical framework developed in this work establishes a new connection between
Wasserstein-based distribution learning and uncertainty-aware motion planning, opening new directions for scalable and provably
safe planning.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Learn-To-Propagate Distributionally-Robust Forest (L2P-DR-Forest) can synthesize formally safe controllers for nonlinear stochastic systems with unknown initial state and process noise distributions. This allows the AI system to provide safety guarantees even when underlying uncertainty is not linear or Gaussian, a significant improvement over existing methods restricted to linear dynamics or Gaussian assumptions.
-
The algorithm learns Wasserstein ambiguity sets from data and propagates them through Lipschitz continuous dynamics efficiently, mitigating the growth of ambiguity-set radii by re-learning only at selected restart nodes. This capability enables rapid exploration of the planning tree and substantially reduces the computational burden associated with exhaustive sampling, leading to faster planning times compared to methods that require relearning at every propagation step.
-
The system can achieve probabilistic completeness under mild distributional assumptions by utilizing a restart mechanism in the forest, which ensures that
if a control sequence is robustly feasible with some margin and the noise is sub-Gaussian, then, run for an unbounded number of stages with growing sample sizes, it returns a controller with probability one.
This guarantees that the planner will eventually find a solution if one exists under specified conditions. -
The system can handle complex environments like the 4D Tractor Trailer benchmark where dynamics are modeled by residual neural networks, achieving a success rate of 100% and producing safe controllers despite Lipschitz constants exceeding one in some cases, by utilizing LipSDP semidefinite relaxation for uncertainty bounding.
-
The algorithm incorporates an informed search heuristic that generates reference trajectories prior to planning to guide the tree expansion towards the target set. This guidance balances exploration (nodes far from the root) and guidance (progress along the reference), leading to stronger empirical performance on cluttered mazes like the Double Integrator benchmark compared to uniform sampling baselines.
Abstract
Motion planning for stochastic systems aims to find a sequence of control inputs that drives a system to a goal set while avoiding unsafe states with high probability. Existing approaches, however, are either restricted to linear dynamics with perfect knowledge of the underlying distributions or lack formal correctness guarantees. To address these limitations, we propose Learn-To-Propagate Distributionally-Robust Forest (L2P-DR-Forest), a distributionally-robust sampling-based planning algorithm for nonlinear stochastic systems with unknown initial state and process noise distributions. Our approach leverages recent advances in optimal transport to learn ambiguity sets that contain the true system distributions with high confidence. We develop an efficient method for propagating these sets through the system dynamics and for verifying their safety. We then integrate these techniques into a novel sampling-based planning algorithm to grow a forest of search trees in the system's state space while accounting for and mitigating the growth of ambiguity-sets radii. We prove that the algorithm is correct, i.e., every returned plan satisfies the specifications with the prescribed confidence, and, under some feasibility and distributional assumptions, is probabilistically complete. Evaluations on several robotic benchmarks demonstrate that our algorithm significantly outperforms existing methods while providing formal guarantees with high confidence.
Sources
- Efficient Uncertainty Propagation with Guarantees in Wasserstein Distance
- Efficient Distribution Learning with Error Bounds in Wasserstein Distance
- Provably Safe Motion Planning Under Unknown Disturbances
Related papers
- Rethinking Actions: Continuity-Aware Priors for World-Model Planning
- MOSAIC: Modular Obstacle and Spatial-Aware Framework for Manipulation In Cluttered Scenes
- SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning
- DexSeed: Expanding Human Hand-Object Interactions into Robot Demonstrations for Dexterous Policy Learning
- LaST0.5: A Generalist World Action Model with Interaction-Centric Latent Reasoning
- CIALLO: Learning Shared Intent Representations for Cross-Embodiment Manipulation