⚡ electrical engineering

Data-driven invariant set for nonlinear systems with application to command governors

This paper proposes a novel data-driven framework that synthesizes positive invariant sets for unmodeled nonlinear systems using sum-of-squares Lyapunov-like functions and linear programming, enabling the design of robust command governors that enforce constraints despite plant uncertainty.

Original authors: Ali Kashani, Claus Danielson

Published 2026-06-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ali Kashani, Claus Danielson

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 car that has a very skilled, but slightly "blind" autopilot. This autopilot knows how to keep the car stable and follow a general path, but it doesn't know the specific rules of the road (like staying within the lane lines) or the exact physics of how the car reacts to every possible turn. You want to add a "safety guardian" that watches the autopilot and gently nudges its commands to ensure the car never crashes or leaves the road, without firing the autopilot and starting over.

This paper presents a new way to build that safety guardian for complex, unpredictable systems (like robots or self-driving cars) using data instead of complex math models.

Here is the breakdown of their approach using everyday analogies:

1. The Problem: The "Black Box" and the "Safety Net"

In many real-world machines, we don't have a perfect mathematical formula describing exactly how they move. We might have a controller that works well, but we don't know why it works or if it will break the rules in a new situation.

The Goal: Create a "Command Governor" (CG). Think of this as a co-pilot sitting next to the main driver. The main driver tries to go where they want, but the co-pilot checks: "If you go there, will we hit a wall?" If yes, the co-pilot slightly adjusts the steering wheel to keep us safe, then lets the main driver take over again.
The Challenge: Usually, to build this co-pilot, you need a perfect map of the terrain (a mathematical model). If you don't have the map, or if the map is wrong, the co-pilot might make bad guesses.

2. The Solution: Learning from "Safe Drives"

Instead of trying to write a perfect map, the authors say: "Let's just watch what happens when we drive the car with different, constant steering angles."

The Data: They drive the system with a fixed command (e.g., "turn left slightly") and record the path. They do this for many different commands.
The "Safe Zone" (Invariant Set): For every specific command, they look at the data to find a "Safe Bubble." If the car is inside this bubble and you use that specific command, the car will stay inside the bubble forever. It's like a force field that keeps the car safe.
The Magic Trick: They combine all these individual "Safe Bubbles" (one for each command) into one giant, flexible "Admissible Set." This set tells the co-pilot: "As long as the car is in this big shape, and you pick a command from this list, we are safe."

3. The Math: Turning a Puzzle into a Simple Checklist

Usually, figuring out these "Safe Bubbles" for complex, non-linear systems is like trying to solve a 1,000-piece puzzle where the pieces keep changing shape. It requires heavy, slow computer calculations (called Semi-Definite Programming).

The Innovation: The authors found a way to simplify this. They used a technique called "lifting" (imagine taking a 2D shadow and stretching it into 3D to see the shape better) and then turned the hard puzzle into a simple checklist (Linear Programming).
Why it matters: This makes the calculation fast enough to be done offline (before the car even starts), so the safety system is ready to go instantly.

4. Handling Uncertainty: The "Fuzzy" Safety Margin

Since they are learning from data, there might be gaps. Maybe they drove the car 100 times, but there's a spot in the road they never drove. What if the car behaves strangely there?

The Fix: They use a "Lipschitz" property (a fancy way of saying "the car can't teleport or change speed instantly"). They calculate a safety margin based on how close their data points are to each other. If the data is dense (lots of points), the safety margin is small. If the data is sparse, they shrink the "Safe Bubble" to be extra cautious. This ensures that even if the math isn't perfect, the system is robust and won't accidentally break the rules.

5. Real-World Tests

They tested this idea in two ways:

A Simple Spring: They used a standard physics system where they knew the answer. They compared their data-driven "Safe Bubble" to the perfect mathematical answer. It was almost identical, proving their method works.
A Self-Driving Car: They simulated a car trying to stay in its lane. The car had an inner controller (the driver) that was good but not perfect.
- Without the Guardian: The car swerved out of the lane.
- With their Data-Driven Guardian: The car stayed perfectly in the lane, even when the speed changed or the road got tricky. It performed just as well as if they had used the perfect mathematical model, but without needing the model at all.

Summary

The paper says: "Don't try to write a perfect textbook description of how a robot moves. Instead, watch it move, find the 'Safe Zones' for different commands using data, and build a safety guard that keeps the robot inside those zones. We found a fast, reliable way to do this even if the robot is unpredictable."

This allows engineers to add safety features to existing, complex systems without having to rebuild the whole system from scratch or understand every tiny detail of its physics.

Technical Summary: Data-Driven Invariant Set for Nonlinear Systems with Application to Command Governors

Problem Statement
Safety-critical cyber-physical systems, such as autonomous vehicles and industrial robots, must operate within strict state constraints. While existing controllers (e.g., PID or LQR) often handle stability and reference tracking, they may not guarantee constraint satisfaction, particularly when the system dynamics are unmodeled, complex, or uncertain. Replacing these controllers with Model Predictive Control (MPC) is often undesirable due to the loss of tuned legacy controllers and the requirement for an accurate system model. Command Governors (CGs) offer an alternative as an outer-loop controller that adjusts the reference command to ensure constraints are met without redesigning the inner controller. However, synthesizing a CG for unmodeled nonlinear systems is challenging. Traditional methods rely on computing Controlled Invariant (CI) sets, which often require solving intractable non-convex optimization problems or depend on a known system model. Furthermore, purely data-driven approaches that attempt to learn invariant sets directly often struggle with the "curse of dimensionality" and lack formal guarantees of invariance due to finite data and plant uncertainty.

Methodology
The paper proposes a direct data-driven approach to synthesize Positive Invariant (PI) sets for unmodeled nonlinear systems, which are then aggregated to form a CI set for use in a Command Governor. The methodology proceeds as follows:

Problem Reformulation via PI Sets: Instead of directly computing a complex CI set for the controlled system, the authors decompose the problem. They assume a set of constant commands $\bar{r}$ . For each constant command, the system becomes an autonomous system. The authors compute a PI set $O(\bar{r})$ for each autonomous dynamics. The union of these PI sets forms a CI set for the original controlled system. This reduces the CG synthesis to an integer program that selects the nearest constant command $\bar{r}$ such that the current state lies within the corresponding PI set.
Functional Synthesis with Basis Functions: To compute the PI sets $O(\bar{r})$ , the authors represent them as sub-level sets of a Lyapunov-like function $V(x; \bar{r}) \leq 1$ . They parameterize this function using a combination of pre-selected basis functions $\phi(x)$ (e.g., thin-plate splines or neural network features) and a positive definite matrix $P$ . The function is constructed to satisfy conditions ensuring the set is contained within the constraint set and that the function decreases (or remains bounded) along system trajectories.
Data-Driven Semidefinite Programming (SDP):
- Equilibrium Approximation: Since the true equilibrium $x_\infty(\bar{r})$ is unknown, it is approximated using the ensemble average of the final states of trajectories generated by constant commands.
- Robustness via Lipschitz Properties: To handle the uncertainty arising from finite data and the lack of a model, the authors leverage the Lipschitz continuity of the system dynamics ( $L_f$ ) and the basis functions ( $L_\phi$ ). They derive a "tightening" term $\epsilon_k$ based on the data density (Hausdorff distance between the constraint set and the data) and the Lipschitz constants.
- Optimization: The synthesis problem is formulated as a Semidefinite Program (SDP) that minimizes the volume of the invariant set (by minimizing an integral of the Lyapunov function) subject to constraints that ensure invariance on the sampled data points, adjusted by the robustness term $\epsilon_k$ .
Computational Tractability: Recognizing that SDPs are computationally expensive for high-dimensional systems, the authors propose a relaxation technique. They approximate the solution matrix $P$ as a linear combination of fixed positive definite matrices. This transforms the SDP into a Linear Program (LP), significantly reducing computational complexity while maintaining provable invariance guarantees.

Key Results
The paper validates the approach through two examples:

Illustrative Linear Example: A linear time-invariant (LTI) system with under-damped dynamics and polytopic constraints was used. The data-driven CG was compared against a CG synthesized using the true maximal admissible set (computed via standard model-based methods). The results demonstrated that the data-driven CG successfully enforced constraints and achieved performance close to the optimal model-based CG, despite not having access to the system model.
Autonomous Lane-Keeping: A nonlinear kinematic bicycle model was used to simulate an autonomous vehicle. The inner controller was a Linear Quadratic Regulator (LQR) designed for a nominal speed. The data-driven CG was tested during overtaking maneuvers where the vehicle speed increased from 20 m/s to 27 m/s. The results showed that the data-driven CG prevented the vehicle from leaving the road (violating constraints) in scenarios where the system without a CG, or a CG using a sample-based approach, failed.

Significance and Claims
The paper claims to present a novel direct data-driven technique for synthesizing invariant sets for unmodeled nonlinear systems without requiring an intermediate system identification step. Key contributions include:

Direct Learning: The invariant sets are learned directly from data trajectories, bypassing the need for a parametric model.
Robustness Guarantees: By utilizing Lipschitz properties and data density metrics, the method provides formal guarantees that the learned sets are robust to the inherent uncertainty of the data-driven framework.
Scalability: The relaxation of the SDP to an LP addresses the curse of dimensionality, making the approach computationally feasible for higher-dimensional systems.
Practical Utility: The method is demonstrated to be effective in both linear and nonlinear scenarios, specifically showing utility in safety-critical applications like autonomous driving where model uncertainty and constraint satisfaction are paramount.

The authors maintain a modest tone, acknowledging that the approach yields a "sub-maximal" invariant set rather than the exact maximal set, but emphasize that the guarantee of invariance and constraint admissibility is the primary objective. They note that measurement noise and external disturbances are not currently considered but are subjects for future work.