⚡ electrical engineering

Data-Driven Reachability of Nonlinear Lipschitz Systems via Koopman Operator Embeddings

This paper proposes a data-driven reachability framework that leverages Koopman operator embeddings and zonotopic set representations to lift nonlinear Lipschitz systems into a linear state-input-dependent model, thereby generating significantly tighter and less conservative over-approximations of reachable sets while maintaining formal safety guarantees for robotic systems.

Original authors: Alireza Naderi Akhormeh, Ahmad Hafez, Abdulla Fawzy, Amr Alanwar

Published 2026-04-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Alireza Naderi Akhormeh, Ahmad Hafez, Abdulla Fawzy, Amr Alanwar

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 brand-new, self-driving car through a foggy, winding mountain road. You need to know: "If I steer this way, will I stay on the road, or will I crash?"

To answer this, engineers use something called Reachability Analysis. Think of it as drawing a "safety bubble" around the car. This bubble represents every single spot the car could possibly end up in over the next few seconds, accounting for wind, slippery roads, and tiny steering errors.

The Problem: The "Too-Safe" Bubble

Traditionally, there are two ways to draw this bubble:

The Model-Based Way: You try to write a perfect math equation for how the car moves. But real cars are messy. The equation is never perfect, so to be safe, engineers make the bubble huge. It's like drawing a safety zone that covers the entire mountain just to be sure you don't hit a tree. It's safe, but it's too conservative (it says "crash!" when you're actually fine).
The Data-Driven Way: Instead of writing equations, you just look at videos of the car driving before. You say, "Okay, based on these past drives, here is where it might go." This is better, but for complex, twisting roads (nonlinear systems), the bubble still tends to get too big, too fast, especially if the data is a bit noisy (blurry).

The Solution: The "Magic Translator" (Koopman Operator)

This paper introduces a clever new trick using something called the Koopman Operator.

Here is the analogy:
Imagine the car's movement is a chaotic dance. It's hard to predict the next step because the dancer is twisting and turning in complex ways.

Old Method: You try to predict the dance by watching the dancer's feet directly. It's messy and hard to guess the next move.
The Koopman Trick: You put on a pair of special glasses (the "lifting" function). Through these glasses, the chaotic dance doesn't look like a twisty mess anymore; it looks like a simple, straight line walking across a stage.

The Koopman Operator is that pair of glasses. It takes the messy, non-linear reality of the car and "lifts" it into a higher-dimensional world where the rules are simple and linear (like a straight line).

How the New Method Works (Step-by-Step)

The Translation: The system takes real-world data (noisy videos of the car driving) and uses math to find the "special glasses" that turn the messy car movements into a simple, straight-line pattern.
The Prediction: In this "straight-line world," it's very easy to draw a tight, accurate safety bubble. Because the rules are simple here, the bubble doesn't need to be huge to be safe.
The Translation Back: The system then takes that tight bubble and translates it back into the real world.
The Safety Net: Since the "glasses" aren't perfect (there's a little bit of translation error), the authors add a small "error cushion" (a residual set) to the bubble. This ensures that even if the translation isn't 100% perfect, the safety bubble still covers everything the car could possibly do.

Why This is a Big Deal

The authors tested this on a real autonomous racing car (a JetRacer).

The Result: Their new "Koopman Bubble" was much tighter than the old methods.
The Metaphor: Imagine the old methods drew a safety bubble the size of a football field around the car. The new method draws a bubble the size of a small tent. Both keep the car safe, but the new one lets the car drive much closer to the edge of the road without crashing, allowing for faster and more efficient driving.

Summary

This paper teaches us how to use data to build a translator that turns complex, messy real-world physics into simple, predictable math. By doing this, we can predict where robots and self-driving cars will go with much higher precision, keeping them safe without being overly cautious. It's the difference between guessing a path through a jungle by looking at a blurry map versus using a high-tech GPS that sees the path clearly.

1. Problem Statement

The paper addresses the challenge of safety verification for robotic systems operating in dynamic, uncertain environments. Specifically, it targets the computation of reachable sets (the set of all possible future states) for nonlinear, non-affine systems with unknown dynamics and bounded process noise.

The Gap: Traditional model-based verification requires accurate system dynamics, which are often unavailable for complex robots. Data-driven approaches exist but often rely on Linear Time-Invariant (LTI) assumptions or simple linear regression, leading to overly conservative reachable sets (over-approximations that are too large to be useful), especially over long prediction horizons.
The Goal: Develop a data-driven framework that provides formal safety guarantees (deterministic over-approximations) while significantly reducing conservatism compared to existing linear data-driven methods.

2. Methodology

The proposed framework combines Koopman operator theory with zonotopic set representations to lift nonlinear dynamics into a linear, state-input-dependent space.

A. Koopman Operator Embedding

Instead of modeling the nonlinear system $x_{k+1} = f(x_k, u_k) + w_k$ directly, the method lifts the state and input into a higher-dimensional space of observables using a lifting function $\psi(x_k, u_k)$ .

State-Input Dependent Lifting: Unlike standard Koopman methods that often assume autonomous (unforced) systems or simple affine structures, this paper employs lifting functions that explicitly depend on both the state $x$ and the input $u$ . This allows for a more accurate linear representation of non-affine nonlinear dynamics.
Linear Dynamics in Lifted Space: In the lifted space, the dynamics are approximated as linear:
$z_{k+1} = A z_k + B \nu(x_k, u_k) + \text{residuals}$
where $z$ represents the lifted coordinates.

B. Data-Driven Identification

The Koopman operator matrices ( $A$ and $B$ ) are identified directly from noisy input-state trajectory data using Least Squares (LS) regression.

The method utilizes Extended Dynamic Mode Decomposition (EDMD) principles to solve for the operator without requiring an explicit analytical model of $f$ .

C. Handling Uncertainty and Errors

To ensure formal guarantees (that the true reachable set is contained within the computed set), the framework rigorously bounds four sources of error:

Process Noise ( $w_k$ ): Bounded by a known noise zonotope. The noise is lifted into the observable space using the Lipschitz constant of the lifting function.
Linearization Error ( $\bar{L}_k$ ): Since the lifted dynamics are approximated via Taylor expansion around a linearization point, a remainder term is bounded using the Hessian of the nonlinear dynamics.
Koopman Modeling Residual ( $L_k$ ): The error between the learned linear model and the true lifted dynamics is computed by aggregating multi-step prediction errors across all available training trajectories.
Covering Radius Error ( $Z_\epsilon$ ): To generalize from the finite dataset to the entire reachable domain, the method uses a covering radius argument. It assumes the dataset is dense enough such that any state in the reachable set has a nearby data point within distance $\delta$ , bounded by the system's Lipschitz constant.

D. Reachability Computation

The algorithm proceeds as follows:

Lift: Transform the initial state set (zonotope) into the lifted space.
Propagate: Evolve the lifted zonotopes through the identified linear dynamics, adding the bounded error sets (noise, linearization, modeling residual) at each step using Minkowski sums.
Project: Map the resulting lifted reachable sets back to the original state space.
Combine: Add the covering radius error set to the projected set to guarantee that the final result is a valid over-approximation of the true nonlinear system.

3. Key Contributions

Novel Framework: Introduction of a data-driven reachability analysis framework for non-affine, Lipschitz nonlinear systems using state-input-dependent Koopman embeddings.
Improved Accuracy: Development of a lifting strategy that outperforms standard LTI Koopman models and linear regression methods by capturing nonlinear interactions between states and inputs more effectively.
Formal Guarantees: A rigorous proof that the computed reachable sets are guaranteed over-approximations of the true system behavior, accounting for process noise, learning errors, and data sparsity.
Scalability: Utilization of zonotopes allows for computationally efficient propagation of sets, making the method scalable for higher-dimensional systems and longer time horizons.

4. Results and Evaluation

The authors validated the method through three distinct scenarios:

Example 1: Continuous Stirred Tank Reactor (CSTR): A discrete-time affine system. The proposed method produced significantly tighter reachable sets than CORA (a model-based tool) and standard Least Squares (LS) data-driven methods, particularly over long horizons.
Example 2: Non-Affine Nonlinear System: A system with complex non-affine dynamics (exponential terms and input-state coupling). The proposed method maintained tight bounds where the LS method became excessively conservative.
Example 3: Real-World Autonomous Vehicle: Experiments were conducted on a JetRacer (autonomous racing robot).
- Setup: The vehicle's position and heading were tracked with noisy sensors.
- Outcome: The Koopman-based approach yielded substantially tighter reachable set over-approximations compared to the LS baseline. This demonstrates the method's ability to handle real-world noise and complex dynamics without an explicit physics model.

Visual Evidence: Figures in the paper (Fig. 2, 3, and 5) visually confirm that the "Koopman-based" reachable sets (often depicted as tighter polygons) enclose the "Exact Reachable Sets" (from random simulations) much more tightly than the "LS" or "Model-based" sets, which tend to explode in size over time.

5. Significance

This work bridges the gap between data-driven system identification and formal safety verification.

Safety Critical Applications: It enables the deployment of autonomous systems in uncertain environments where precise models are unavailable, providing mathematically proven safety guarantees.
Reduced Conservatism: By reducing the "conservatism" (the gap between the predicted safe set and the actual reachable set), the method allows for more aggressive and efficient control strategies without compromising safety.
Generalizability: The approach is applicable to a wide class of nonlinear systems (Lipschitz continuous) and does not require the system to be control-affine, making it highly relevant for modern robotics and autonomous vehicles.

In summary, the paper presents a robust, scalable, and theoretically sound method for predicting the future behavior of complex nonlinear robots using only measured data, ensuring safety through rigorous mathematical bounds.