⚡ electrical engineering

Distributionally Robust Safety Under Arbitrary Uncertainties: A Safety Filtering Approach

This paper proposes a distributionally robust safety filtering framework that ensures probabilistic safety for nonlinear systems under arbitrary distributional uncertainties by reducing safety certification to a one-dimensional switching-time search and employing a sampling-based procedure with finite-sample guarantees.

Original authors: Daniel M. Cherenson, Haejoon Lee, Taekyung Kim, Dimitra Panagou

Published 2026-05-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Daniel M. Cherenson, Haejoon Lee, Taekyung Kim, Dimitra Panagou

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are driving a very fast, high-performance race car. You have a "Nominal Driver" who is incredibly talented at driving fast and taking the perfect racing line. However, this driver doesn't know about the potholes, the sudden gusts of wind, or the fact that the road might be slippery in ways they haven't seen before. If they drive too fast, they might crash.

To keep you safe, you have a "Backup Driver" in the passenger seat. This driver is a bit slower and more cautious, but they are a master of survival. They know exactly how to steer the car into a safe, slow orbit if things go wrong.

The problem is: When should you switch from the Fast Driver to the Safe Driver?

If you switch too early, you drive too slowly and miss the race. If you switch too late, you crash.

This paper introduces a new "Safety Filter" called DRS-gatekeeper. It acts like a super-smart co-pilot that decides the exact moment to hand over the controls. Here is how it works, using simple analogies:

1. The Problem: "We Don't Know the Weather"

Most safety systems assume they know the "weather" (the uncertainties). They might say, "We know the wind is always between 5 and 10 mph." But in the real world, the wind might be 2 mph one minute and 50 mph the next, or it might follow a weird pattern we've never seen.

If your safety system assumes the wind is gentle, but it's actually a hurricane, your car crashes. The authors call this Distributional Ambiguity—we don't know the true rules of the game, only a guess based on past data.

2. The Solution: The "Wasserstein Umbrella"

To handle this unknown weather, the authors use a mathematical tool called a Wasserstein Ambiguity Set.

The Analogy: Imagine you have a map of where the wind usually blows (your "Nominal Distribution"). But you know your map might be slightly wrong. So, you draw a giant, invisible "umbrella" around that map. This umbrella represents all the possible ways the wind could actually behave, including the weird, unexpected patterns.
The Goal: The system doesn't just check if the car is safe under the "usual" wind. It checks if the car is safe under every possible wind pattern inside that umbrella.

3. The Trick: The "One-Dimensional Search"

Checking every possible wind pattern inside that umbrella is usually a nightmare for computers. It would take too long to calculate, and the car would crash while the computer is still thinking.

The authors found a clever shortcut. Because they have the "Backup Driver" ready to take over, they don't need to calculate the whole future. They only need to find one number: The exact second to switch drivers.

The Analogy: Instead of simulating every possible future storm, the system asks: "If I switch to the Safe Driver at 1 second, am I safe? What about 2 seconds? 3 seconds?"
They turn a massive, complex math problem into a simple search for the latest possible moment to switch safely.

4. The "Sampling" Safety Net

Since they can't check every possible wind scenario (there are infinite of them), they use a sampling trick.

The Analogy: Imagine you want to know if a bridge can hold a heavy truck. You don't need to test it with every truck in the world. You test it with 1,000 random trucks.
The system simulates the car's path 1,000 times using random "wind" samples.
The Safety Boost: To account for the fact that the real wind might be worse than their samples, they add a "safety buffer" (inflating the failure threshold). If the car survives 99% of the simulated winds plus this extra buffer, they are confident it will survive the real world, even if the weather is weird.

5. Real-World Tests

The authors tested this "Safety Filter" on three very different machines to prove it works:

A Dubins Vehicle (A simple robot car): It had to navigate around obstacles. The new filter kept it safer than older methods, even when the robot's sensors were confused.
A Formula 1 Race Car: This car was driving on a real race track with complex physics. The filter allowed the car to drive fast (using the Nominal Driver) but switched to the backup just in time when the track conditions got tricky. It was much safer than the standard racing AI.
An F-16 Fighter Jet: This was the hardest test. The jet was flying low and fast through a narrow canyon. The wind and the plane's own aerodynamics were unpredictable. The standard method (which didn't use this filter) crashed or got too close to the walls. The new filter kept the jet safe, flying low and fast, only switching to the backup when absolutely necessary.

The Bottom Line

This paper presents a "Safety Gatekeeper" that lets high-performance robots and vehicles do their jobs fast and efficiently. It doesn't guess the future; instead, it prepares for the worst-case scenario within a reasonable range of possibilities.

It's like having a co-pilot who says, "I trust you to drive fast, but I'm watching the weather. If the wind gets even a little bit stranger than we expected, I'll take the wheel immediately so we don't crash." This allows for high performance without sacrificing safety, even when the rules of the world are unclear.

Technical Summary: Distributionally Robust Safety Under Arbitrary Uncertainties

Problem Statement

Ensuring safety for autonomous robotic systems is complicated by nonlinear dynamics, actuation limits, and uncertainties arising from model mismatch, perception errors, and exogenous disturbances. While safety filters (or "gatekeepers") offer a modular solution by switching from a high-performance nominal policy to a certified backup policy when safety is at risk, existing approaches face significant limitations under distributional ambiguity.

Current methods typically rely on either:

Robust Safety Filters: Assuming worst-case deterministic bounds, which can be overly conservative.
Stochastic Safety Filters: Assuming known, specific disturbance distributions (e.g., Gaussian), which fail when the true distribution is unknown, partially observed, or shifted (distributional shift).
Distributionally Robust (DR) Planning: While promising, directly integrating DR constraints into safety filters for general nonlinear systems is computationally prohibitive. It often requires solving high-dimensional optimization problems over worst-case distributions within ambiguity sets, rendering real-time implementation infeasible.

The core challenge addressed in this work is how to provide probabilistic safety guarantees for general nonlinear systems under arbitrary uncertainty structures (non-additive, non-affine) where the true noise distribution is unknown, without incurring the computational cost of online DR trajectory optimization.

Methodology: DRS-gatekeeper

The authors propose Distributionally Robust Stochastic gatekeeper (DRS-gatekeeper), a real-time safety filter that extends the backup-based safety filtering framework. The method combines a Wasserstein ambiguity set with finite-sample statistical analysis to certify safety.

Core Architecture

The system operates by switching between a high-performance nominal policy ( $\pi_N$ ) and a pre-verified backup policy ( $\pi_B$ ). The backup policy is designed to render a specific safe set $\mathcal{C}$ forward-invariant with high probability (an $\alpha$ -probabilistic controlled invariant set). The goal is to remain on the nominal policy as long as possible while ensuring that a switch to the backup policy occurs before safety is compromised.

Key Technical Components

Distributionally Robust Chance Constraint (DRCC):
Instead of optimizing against a single nominal distribution $\hat{P}_t$ , the method ensures safety against an ambiguity set $\mathcal{B}_\beta(\hat{P}_t)$ defined by the $\infty$ -Wasserstein distance with radius $\beta$ . This set contains all distributions consistent with available data. The objective is to satisfy:
$\inf_{Q \in \mathcal{B}_\beta(\hat{P}_t)} \Pr_{w \sim Q} [\text{Safety}] \geq 1 - \varepsilon$
Dimensionality Reduction via Switching Time Search:
Rather than solving a high-dimensional DR optimization problem online, the authors exploit the structure of backup-based filtering. The safety certification problem is reduced to a one-dimensional search over the switching time $s_t$ between the nominal and backup policies.
Sampling-Based Certification with Finite-Sample Guarantees:
The method uses a Monte Carlo-inspired approach:
- Parallel Rollouts: For each candidate switching time $m$ , the algorithm generates $N$ independent noise trajectory samples from the nominal distribution $\hat{P}_t$ .
- Wasserstein-Inflated Threshold: To account for the ambiguity set without sampling from it directly, the algorithm computes a safety margin $H$ for each rollout. It then counts "failures" not just when $H < 0$ , but when $H < L_H \beta$ , where $L_H$ is the Lipschitz constant of the safety function and $\beta$ is the ambiguity radius. This effectively inflates the failure set to cover the worst-case distribution within the ambiguity set (Lemma 1).
- Statistical Bounds: The observed failure count is used to compute an upper bound on the true failure probability using the binomial distribution and a user-specified confidence level $1-\delta$ .
- Selection: The algorithm selects the latest switching time $s_t$ such that the statistical upper bound on the failure probability remains below the threshold $(\varepsilon - \alpha)/(1 - \alpha)$ .

Theoretical Guarantees

The paper provides a formal proof (Theorem 1) that if the assumptions regarding the Lipschitz continuity of the safety function and the existence of a valid backup policy hold, the DRS-gatekeeper satisfies the DRCC with probability at least $1-\delta$ . This guarantee is independent of the trajectory dimension or the number of samples $N$ , though $N$ affects the conservativeness of the filter.

Key Contributions

DRS-gatekeeper Algorithm: Introduction of a real-time safety filter for nonlinear systems with arbitrary disturbance structures and distributional ambiguity.
Finite-Sample Certificate: Derivation of a probabilistic safety certificate under a Wasserstein ambiguity set by computing an upper bound on the worst-case failure probability with a specified confidence level.
Computational Efficiency: Reformulation of the infinite-dimensional DR safety problem into a one-dimensional search, enabling real-time implementation via parallel sampling.
Empirical Validation: Demonstration of the method across three distinct domains of increasing complexity: a Dubins vehicle, a Formula 1 racing car, and an F-16 fighter jet.

Experimental Results

The authors validated DRS-gatekeeper through simulations comparing it against baseline methods (including Distributionally Robust Control Barrier Functions, DR-CBF, and Model Predictive Path Integral control, MPPI).

Dubins Vehicle: Compared to DR-CBF, DRS-gatekeeper achieved significantly higher safety rates (up to 100% vs. 15-75% depending on parameters) across varying failure probabilities ( $\varepsilon$ ) and ambiguity radii ( $\beta$ ). While goal-reaching times were slightly higher in some cases, the method offered a more reliable safety-performance trade-off.
Formula 1 Racing Car: In a high-dimensional (7-state) scenario with complex, non-Gaussian empirical uncertainty:
- Under Gaussian noise, DRS-gatekeeper maintained 96% safety compared to MPPI's 92%.
- Under empirical noise (simulating distributional shift), MPPI's safety dropped to 76%, while DRS-gatekeeper maintained 94% safety.
- The method achieved these results with minimal backup intervention (<1.5%) and computation times (~21 ms) suitable for real-time control.
F-16 Fighter Jet: In a 12-state, 4-input scenario flying through a narrow canyon with turbulence and model residuals:
- A baseline optimal trajectory tracking method achieved only 40% safety (88% when considering the full horizon, still below the 95% target).
- DRS-gatekeeper improved the safety rate to 88% (with a target of 95% per iteration, the cumulative effect is noted) with low backup usage (13.9%) and minimal computational overhead (12.2 ms).
- The method successfully handled the high relative degree and input constraints that rendered DR-CBF inapplicable for this system.

Significance and Claims

The paper claims that DRS-gatekeeper addresses a critical gap in autonomous safety: the ability to handle arbitrary uncertainty structures and distributional shifts without the computational burden of online DR optimization. By leveraging the backup-based architecture and Wasserstein-based robustness, the method provides rigorous probabilistic safety guarantees for complex, high-dimensional nonlinear systems where traditional robust or stochastic filters fail or are too conservative. The authors emphasize that their approach is particularly significant for systems where the true noise distribution is unknown or non-stationary, such as in high-speed racing or aerial maneuvers under turbulence.