⚡ electrical engineering

GPU-Parallel Linearization Error Bounds for Real-Time Robust Optimal Control of Nonlinear and Neural Network Dynamics

This paper presents GPUSLS-LEO, a GPU-parallel framework that computes tight, differentiable linearization error bounds for both analytic and neural network dynamics to enable real-time, formally verified robust optimal control for high-dimensional uncertain nonlinear systems.

Original authors: Jeffrey Fang, Keyi Shen, Anutam Srinivasan, Glen Chou

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jeffrey Fang, Keyi Shen, Anutam Srinivasan, Glen Chou

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 trying to drive a very fast, high-tech car (a robot or drone) through a crowded, unpredictable city. You want to get to your destination as quickly as possible, but you must never hit a wall or a pedestrian. The problem is that the car's physics are complicated (nonlinear), and the road might have sudden bumps or gusts of wind (disturbances).

To drive safely, your computer needs to predict exactly where the car will be in the next few seconds. However, predicting the exact path of a complex car is like trying to calculate the path of a leaf blowing in a hurricane—it's too hard to do perfectly in real-time.

The Old Way: The "Worst-Case" Bubble
Most current methods solve this by drawing a giant, fuzzy safety bubble around the car. They assume the car could go anywhere within that bubble, just in case.

The Problem: To be safe, these bubbles are often huge and sloppy. They assume the worst possible error at every single step. This makes the car drive very cautiously, taking slow, roundabout paths to stay inside the giant bubble. It's like driving a car with your eyes closed, assuming you might be anywhere in the entire lane, so you hug the center line and go 5 mph.

The New Method: The "Smart, Tight Bubble"
This paper introduces a new system called GPUSLS-LEO. Think of it as a super-smart navigator that draws a safety bubble that is tight, accurate, and constantly updating.

Here is how it works, using simple analogies:

1. The "Path-Based" Map (Tighter Bounds)

When the computer tries to guess where the car will go, it usually draws a straight line (a linear approximation) and then adds a "safety margin" for how much the car might drift off that line.

Old Method: It measures the drift by looking at the entire city at once. It asks, "What is the maximum possible drift anywhere in the world?" This results in a huge safety margin.
New Method (Path-Based Hessian): Instead of looking at the whole city, this method looks at the specific path the car is taking right now. It calculates the drift step-by-step, coordinate by coordinate, like walking up a staircase and measuring the exact height of each step rather than guessing the height of the whole building. This creates a much tighter, more accurate safety bubble.

2. The "Neural Network" Translator

Sometimes, the car's physics are so complex that no human can write a simple formula for them. Instead, engineers use a "Neural Network" (a type of AI) to learn how the car moves.

The Challenge: AI models are like black boxes; it's hard to know exactly how much they might be wrong.
The Solution: The paper uses a special "AI verifier" tool. Imagine this as a rigorous inspector that checks the AI's work and says, "Okay, based on what you just did, you can't be off by more than this specific amount." This allows the system to safely use AI predictions without the safety bubble becoming too huge.

3. The "GPU" Super-Brain

Calculating these tight, step-by-step safety bubbles for a complex car is mathematically heavy. Doing it one step at a time would be too slow for a real-time controller.

The Solution: The authors built this system to run on GPUs (the powerful chips used in video games). Imagine having a thousand tiny calculators working in parallel instead of one. This allows the system to recalculate the safety bubble dozens of times per second (up to 67 times a second!), keeping the car moving fast and safely.

4. The "Non-Zero" Disturbance

Real-world wind or bumps don't always push equally in all directions; sometimes they push harder to the left than the right.

The Innovation: Old safety bubbles were often centered perfectly in the middle, assuming equal push in all directions. This new method allows the bubble to be off-center, shifting exactly where the wind is blowing. This prevents the car from wasting space on the "safe" side and allows it to hug the edge of the danger zone more efficiently.

The Results: Faster, Safer, and Smarter

The paper tested this on everything from simple satellites to a swarm of 14 flying drones (168 dimensions of complexity) and a robot arm pushing a T-shaped object.

Tighter Tubes: The safety bubbles were significantly smaller (less conservative) than previous methods, allowing the robots to take more direct, efficient paths.
Real-Time: It runs fast enough to control these robots in real-time, even with hundreds of variables.
Safety Guaranteed: Despite being tighter, the system mathematically guarantees that the robot will never leave the safety bubble, even if the wind blows or the AI makes a small mistake.

In Summary:
This paper gives robots a new way to "see" their future. Instead of driving with a giant, fuzzy safety net that forces them to move slowly, they now use a tight, custom-fitted safety suit that moves with them. This allows them to drive faster and smarter while still being mathematically guaranteed to stay safe.

Technical Summary: GPU-Parallel Linearization Error Bounds for Real-Time Robust Optimal Control

Problem Statement
Safe real-time control of uncertain nonlinear systems (including those with neural network dynamics) requires solving the Robust Nonlinear Optimal Control Problem (RNOCP). This involves finding a control policy that guarantees constraint satisfaction under worst-case disturbances. While System-Level Synthesis (SLS) offers a tractable framework for high-dimensional systems by approximating nonlinear dynamics with Linear Time-Varying (LTV) models, this approximation introduces linearization error. Existing methods often ignore this error to maintain performance or use global bounds that result in overly conservative (loose) reachable tubes, rendering the controller ineffective. The core challenge is to develop Linearization Error Bounds (LEBs) that are simultaneously tight, computable in real-time, and differentiable, allowing an optimizer to reshape trajectories to minimize error while preserving formal safety guarantees.

Methodology
The paper proposes GPUSLS-LEO, a GPU-parallel framework that integrates tight, differentiable LEBs into an SLS-based robust controller. The methodology consists of three main components:

Tight, Differentiable LEBs:
- For Analytic Dynamics: The authors introduce Path-Based Hessian (PBH) bounds. Unlike standard interval arithmetic methods that evaluate Hessians over the entire state space (leading to wrapping effects and conservatism), PBH utilizes a coordinate-wise path from a nominal point to the current state. This allows for tighter interval enclosures of the Taylor remainder by evaluating Hessian entries over smaller, prefix subsets of the domain.
- For Neural Network (NN) Dynamics: The method leverages CROWN (a neural network verification tool) to generate affine bounds on the NN output. These bounds are then adjusted using the local Jacobian at the nominal point to derive certified, sound interval bounds for the linearization error.
- Implementation: Both methods are implemented in JAX, enabling automatic differentiation and GPU parallelization. This allows for gradient-based refinement of nominal trajectories to minimize error bounds online.
Robust SLS Formulation with Zonotopic Propagation:
- The framework extends existing SLS solvers to handle non-zero-centered disturbance sets and right-invertible disturbance matrices. This is crucial because the derived LEBs produce zonotopic uncertainty sets that are not necessarily centered at zero.
- The authors prove that if the disturbance scaling matrix is right-invertible, the optimization problem for the robust controller (originally formulated with weighted costs) is equivalent to a standard LQR-like problem solvable via efficient Riccati-based methods.
- The reachable tubes are propagated using zonotopes, which allow for exact Minkowski sums of exogenous disturbances and linearization errors, avoiding the conservatism of ellipsoidal approximations.
Iterative Optimization Loop:
- The solver operates via an iterative process (Sequential Quadratic Programming). In each iteration, it computes a nominal trajectory and a robust feedback controller.
- Crucially, the differentiable nature of the LEBs allows the solver to penalize error accumulation directly in the cost function, biasing the nominal trajectory toward regions where linearization error is minimal.

Key Contributions

Novel Bounding Methods: A set of provably sound LEBs, including path-based interval bounds for analytic systems and NN verifier-based bounds for neural dynamics, which are tighter than standard global or interval methods.
Enhanced SLS Formulation: A new nonlinear SLS formulation that incorporates linearization error via tight zonotopic propagation, specifically handling right-invertible disturbance matrices and non-zero-centered sets to guarantee robust constraint satisfaction.
GPU-Accelerated Solver (GPUSLS-LEO): A differentiable, GPU-parallel implementation in JAX that enables real-time, gradient-based robust nonlinear optimal control.
Scalability and Performance: Empirical validation on systems up to 168 state dimensions (14 coupled 3D quadrotors) and problems with approximately $2 \times 10^5$ decision variables.

Results

Tightness: On satellite and quadrotor systems, the Path-Based Hessian method produced the tightest over-approximations compared to global sampling, standard interval Hessian, and random sampling baselines.
Conservativeness Reduction: In a 7D satellite attitude control task, GPUSLS-LEO achieved tubes 20% smaller than NL-SLS (which uses global bounds) and 45% smaller than GPUSLS-E (ellipsoidal propagation). For a planar quadrotor, the method reduced tube area by 91% compared to Control Contraction Metrics (CCM).
Safety Guarantees: In all tested scenarios, including a Neural T-pusher system and high-dimensional coupled quadrotors, the method achieved 100% containment of simulated rollouts within the computed robust tubes. Baselines that omitted linearization error (e.g., standard GPUSLS) failed to contain all trajectories.
Real-Time Performance: The method achieved control rates up to 67 Hz on an NVIDIA RTX 4090. Solve times were as low as 15 ms for smaller systems and remained below the discretization time step even for complex, high-dimensional problems. The PBH method ran in under 1 ms for analytic systems, significantly faster than dense random sampling.

Significance
The paper claims to close the gap between theoretical robustness and practical performance in nonlinear control. By providing tight, differentiable, and real-time computable error bounds, the method enables RNOCP solvers to formally account for linearization error without sacrificing computational efficiency or introducing excessive conservatism. This allows for the deployment of formally verified, robust controllers on complex, high-dimensional systems (including those with learned dynamics) in real-time, a capability previously limited by the intractability of exact reachability or the looseness of existing bounds.

1. The "Path-Based" Map (Tighter Bounds)

2. The "Neural Network" Translator

3. The "GPU" Super-Brain

4. The "Non-Zero" Disturbance

The Results: Faster, Safer, and Smarter

More like this