⚡ electrical engineering

Controller Design for Structured State-space Models via Contraction Theory

This paper introduces an indirect data-driven output feedback controller synthesis framework for nonlinear systems using Structured State-space Models (SSMs), establishing their controllability, observability, and a separation principle to enable scalable, exponentially stable control design via contraction theory and Linear Matrix Inequalities.

Original authors: Muhammad Zakwan, Vaibhav Gupta, Alireza Karimi, Efe C. Balta, Giancarlo Ferrari-Trecate

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Muhammad Zakwan, Vaibhav Gupta, Alireza Karimi, Efe C. Balta, Giancarlo Ferrari-Trecate

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 teach a robot to drive a car, but the car is very strange. It has a sticky steering wheel, a brake pedal that doesn't work until you push it hard enough (a "dead zone"), and the engine behaves differently when it's cold versus hot. This is a nonlinear system—it's messy, unpredictable, and hard to control with standard math.

This paper presents a new, clever way to build a "brain" for that robot. Instead of guessing how the car works, the authors teach the robot to learn from data, and then they use a special mathematical safety net to make sure the robot never crashes.

Here is the breakdown of their approach using simple analogies:

1. The Problem: The "Black Box" vs. The "Glass Box"

Traditionally, when engineers try to control complex machines, they either:

Simplify too much: They pretend the car is a simple, linear toy car. This works okay on a smooth track, but fails miserably when the road gets bumpy or the brakes stick.
Use "Black Box" AI: They use powerful neural networks (like deep learning) that are great at guessing the future but are impossible to understand. It's like having a driver who knows how to drive but you can't ask them why they turned left. You can't trust them with safety guarantees.

2. The Solution: The "Structured" Model (SSM)

The authors use a new type of AI called a Structured State-Space Model (SSM). Think of this as a "Glass Box" driver.

The Core (The Engine): At the heart of the model is a simple, predictable linear engine (like a standard car engine).
The Scaffolding (The Tuning): Surrounding this engine are special "scaffolding" layers (neural networks) that stretch and twist the data.
The Magic: These scaffolds are designed with strict rules (called bi-Lipschitz). Imagine these rules are like a rubber band: no matter how much you stretch the input, the output can't stretch infinitely. It guarantees that if you nudge the car slightly, the result won't be a catastrophic explosion. This makes the model predictable enough to be safe.

3. The Safety Net: Contraction Theory

How do we know this "Glass Box" driver will stay safe? The authors use Contraction Theory.

The Analogy: Imagine two cars driving side-by-side on a highway. In a normal chaotic system, a tiny difference in their starting position might cause them to drift apart wildly over time (like two leaves in a storm).
Contraction: In this system, the math guarantees that no matter where the two cars start, the "distance" between them will shrink over time. It's like a rubber band pulling them back together. If the robot makes a mistake, the system naturally corrects itself and pulls the car back to the right path.

4. The Two-Part Team: The Driver and The Navigator

To control the car, you need two things:

The Driver (State-Feedback Controller): This part decides how to turn the wheel and press the gas based on where the car is.
The Navigator (Observer): Since we can't see inside the engine perfectly, the Navigator estimates the car's hidden state (like internal temperature or friction) based on what we can see (speed, voltage).

The Big Breakthrough (The Separation Principle):
In most complex systems, you can't design the Driver and the Navigator separately; they mess each other up. You have to design them as one giant, complicated puzzle.

This Paper's Trick: The authors proved that for their specific "Glass Box" model, you can design the Driver and the Navigator separately.
Why it matters: It's like hiring a driver and a navigator independently. As long as both are good at their jobs, the team will work perfectly together. This makes the math much simpler and the system much faster to build.

5. The Real-World Test: The Sticky Motor

The authors tested this on a DC Motor (like the one in a toy car or a drone) that had:

Dead zones: The motor wouldn't move until the voltage was high enough.
Friction: The gears were sticky.
Noise: The sensors were a bit fuzzy.

They fed data into their SSM, trained it, and then used their new math to design the controller. The result? The controller successfully stabilized the motor, even with the sticky friction and dead zones, and it worked perfectly from many different starting positions.

Summary

In short, this paper is about building a safe, learnable, and controllable AI for complex machines.

They created a model that is smart enough to learn from data but structured enough to be understood.
They proved that this model naturally pulls itself back to safety (Contraction).
They showed that you can build the controller and the sensor-estimator separately, making the whole process much easier and more reliable.

It's a bridge between the "magic" of modern AI and the "rigor" of classical engineering safety.

1. Problem Statement

The paper addresses the challenge of nonlinear System Identification (SysId) and subsequent controller synthesis. While linear SysId is mature, nonlinear SysId remains difficult due to the trade-off between model expressivity, interpretability, and the ability to design stable controllers.

Limitations of existing methods: Classical nonlinear models (e.g., NARX, RKHS) often lack interpretability and scalable controller design methods. Deep learning models (e.g., RNNs, Transformers) are expressive but suffer from "black-box" nature, high computational complexity (quadratic in sequence length for Transformers), and difficulties in guaranteeing stability during controller synthesis.
The Gap: There is a need for a data-driven framework that uses expressive models for nonlinear systems but retains the structural properties necessary for rigorous control design (stability, observability, and separation principles).

2. Methodology

The authors propose an indirect data-driven output feedback control synthesis framework using Structured State-space Models (SSMs) as surrogate models.

A. Model Architecture: Structured State-space Models (SSMs)

The paper utilizes a specific SSM architecture (similar to Mamba) composed of three parts:

Input Lifting ( $S_u$ ): A nonlinear neural network map.
Recurrent Unit (RU): A discrete-time Linear Recurrent Unit (LRU), which is a linear time-invariant (LTI) system.
Output Projection ( $S_y$ ): A nonlinear neural network map.

The system dynamics are defined as:
$x_{k+1} = A x_k + B S_u(u_k)$
$y_k = S_y(C x_k + D S_u(u_k))$

Key Assumption: The nonlinear mappings $S_u$ and $S_y$ are assumed to be bi-Lipschitz. This property is crucial for ensuring the model's structural properties and is enforced or verified via the spectral norms of the neural network weights.
Advantage: Unlike Transformers, SSMs offer linear computational complexity with respect to sequence length and allow for parallel training (via parallel scan), making them efficient for long-term dependencies.

B. Theoretical Framework: Contraction Theory

The core theoretical tool is Contraction Theory, specifically Discrete-time Control Contraction Metrics (DCCMs).

Instead of analyzing global stability directly, the method analyzes the differential dynamics (the evolution of infinitesimal displacements between trajectories).
If the differential dynamics contract (distance between trajectories shrinks exponentially), the system is globally exponentially stable.
This approach allows the derivation of Linear Matrix Inequalities (LMIs) for controller and observer design, which are convex and computationally tractable.

C. Control Synthesis Steps

System Identification: Train the SSM on input-output data of the nonlinear plant.
Structural Analysis: Verify that the recurrent unit is controllable/observable and the nonlinearities are bi-Lipschitz.
State-Feedback Design: Solve an LMI to find a gain $K$ such that the closed-loop system is contracting.
Observer Design: Solve a dual LMI to find an observer gain $L$ (Luenberger-like) ensuring the estimation error converges exponentially.
Output Feedback: Combine the controller and observer.

3. Key Contributions

The paper makes three primary theoretical and practical contributions:

Controllability and Observability Analysis of SSMs:
- The authors provide the first formal analysis of these properties for SSMs.
- Result: They prove that if the internal linear recurrent unit is controllable (observable) and the input/output nonlinearities are bi-Lipschitz, the entire SSM is locally controllable and observable. This bridges the gap between neural network structures and classical control theory.
LMI-Based Controller and Observer Synthesis:
- State-Feedback: Derived sufficient conditions (LMIs) to synthesize a state-feedback controller that guarantees global exponential stability for any admissible bi-Lipschitz nonlinearity.
- Observer: Derived a novel Luenberger-like observer design using DCCMs, guaranteeing exponential convergence of the state estimation error.
- Unlike previous works that rely on infinite-dimensional conditions or specific structural constraints, these conditions are convex (semidefinite programs) and efficiently solvable.
Separation Principle for Nonlinear SSMs:
- In general nonlinear systems, the separation principle (designing controller and observer independently) does not hold.
- The paper establishes a separation principle for this specific class of SSMs. It proves that if the controller and observer are designed independently using the derived LMIs, the combined closed-loop system (using estimated states) remains globally exponentially stable. This relies on the input-to-state stability (ISS) properties derived from contraction theory.

4. Results

The framework was validated through a numerical example involving a nonlinear DC motor subject to:

Coulomb friction.
Input dead-zone nonlinearity.
Load disturbances.

Experimental Findings:

Identification: The SSM successfully identified the nonlinear dynamics of the DC motor, capturing long-term dependencies with high accuracy.
Control Performance: The synthesized output feedback controller (using the SSM model) successfully stabilized the system for 10 different initial conditions (randomly sampled from $[-4, 4]$ rad/s).
Robustness: The controller demonstrated robustness against the nonlinearities and disturbances, with the load velocity converging to the desired trajectory exponentially.
Efficiency: The use of SSMs allowed for efficient training compared to RNNs, and the LMI-based design provided a systematic way to ensure stability without trial-and-error tuning.

5. Significance and Impact

Bridging ML and Control: This work effectively integrates modern deep learning architectures (SSMs) with rigorous control theory (Contraction Theory). It moves beyond "black-box" control by providing mathematical guarantees on stability and convergence.
Scalability: By leveraging the linear complexity of SSMs and convex LMI solvers, the approach is scalable to longer sequences and more complex systems than Transformer-based or standard RNN-based control methods.
Practical Applicability: The establishment of a separation principle is a major breakthrough, as it allows engineers to design observers and controllers independently for complex nonlinear systems, a task that is typically intractable for general nonlinear models.
Future Directions: The authors suggest integrating the Internal Model Principle to further enhance robustness against persistent disturbances, paving the way for industrial applications in robotics and automation.

In summary, this paper presents a rigorous, data-driven framework that uses Structured State-space Models to identify nonlinear systems and synthesize stable output feedback controllers, overcoming the interpretability and stability limitations of current deep learning control methods.