Safety Without the Model: How Data Alone Can Now Certify a Control System

Ships, drones, chemical reactors, and autonomous vehicles all share a quiet, unglamorous problem: nobody knows exactly how they behave. Their physics is approximated by engineers, baked into models that drift from reality, and corrected with margins so fat they waste fuel, battery, and time. But a new approach, outlined by Zhijie Ning of Harbin Institute of Technology in a paper posted to arXiv in 2026, shows how a control system can be built — and, crucially, guaranteed safe — using nothing but a pile of noisy measurements. No model identification. No hand-derived equations of motion. Just data, and a set of convex optimization problems that a laptop can solve.

The tool that makes this possible is called a robust positively invariant set — RPI for short. It is, in plain terms, a bounded region of state space with a promise attached: if the system starts inside it, it stays inside it, forever, no matter what disturbances push against it. Invariant sets are the reason a tube-based controller can promise a robot arm won't crash into a wall even when wind, friction, and measurement error are all working against it. Historically, computing one required knowing the system's equations. Ning's contribution is to sidestep that requirement entirely — deriving the invariant set directly from raw offline data, through semidefinite programs (SDPs), which are essentially optimization problems over matrices that have efficient, polynomial-time solvers. The result is a framework that works in both the idealized case where the full state is measurable and the far more practical case where only noisy, partial outputs are available. It is a step toward control design that treats a system not as an equation to be identified, but as a behavior to be learned from.

The Science

To appreciate what Ning has done, it helps to understand the old way of doing things. Classically, you begin with the state-space model

$$x_{k+1}=A{x}_k+B{u}_k+w_k,y_k=C{x}_k+v_k,$$

where $x_k$ is the state at step $k$, $u_k$ the control input, $y_k$ the measured output, $w_k$ the process noise, and $v_k$ the measurement noise. The matrices $A$, $B$, and $C$ encode the system's true dynamics. In traditional robust control, you identify these matrices first — a process riddled with estimation bias — and then compute your invariant set on top of the identified model. The problem, as Ning and others have pointed out, is that errors in the identified model can silently shift the invariant set, and a guarantee computed against the wrong model is no guarantee at all.

The modern alternative, which Ning builds on, rests on a remarkably elegant result called Willems' fundamental lemma. It states that under a condition called persistency of excitation — roughly, that your input must have been rich enough to probe all directions of the system — every possible trajectory of the system can be expressed as a linear combination of the offline data you already collected. You don't need to identify $A$ and $B$; you can parameterize the closed-loop behavior directly through the data matrices $X_0,X_1,U_0,Y_0$. Persistent excitation is guaranteed by a persistently exciting input of order $n+1$ under a controllability assumption — a technical phrase meaning: keep wiggling the input in enough distinct ways, and the data will encode everything you need.

Ning's framework assumes the noise is bounded in ellipsoidal sets $\mathcal{W}$ and $\mathcal{V}$, defined by shape matrices $Q_w$ and $Q_v$. He imposes signal-to-noise ratio (SNR) conditions — known scalars ${\gamma }_w$ and ${\gamma }_v$ bounding the noise relative to the collected data. These are reasonable, verifiable assumptions for real systems: you don't need to know the exact noise statistics, only a bound on how loud they are relative to the signal. Three assumptions carry the whole framework: the pairs $(A,B)$ and $(A,C)$ are controllable and observable; the SNR bounds hold; and the data matrix $[X_0;U_0]$ has full row rank. With these in place, the feedback gain, the observer gain, and the invariant sets can all be computed by solving SDPs — optimization problems over positive-semidefinite matrices that enjoy polynomial-time algorithms.

The synthesis proceeds in a deliberately decoupled, sequential fashion. First, an LQ-type (linear-quadratic) feedback gain $K$ is computed by solving a discrete-time algebraic Riccati inequality, which guarantees a performance bound on the infinite-horizon cost. Then, with $K$ fixed, the RPI set is optimized directly. This decoupling is a deliberate trade: jointly optimizing gain and invariant set introduces non-convex coupling that is hard to solve, whereas the decoupled version is convex and tractable. Ning accepts a possible loss of optimality in exchange for a guarantee that the optimization can actually be solved. As he puts it, this "retains the LQ-type gain and avoids the non-convex coupling between gain synthesis and invariant-set computation."

In the output-feedback case, things get harder because the true state $x_k$ is unavailable online. Ning introduces a Luenberger observer with gain $L$, reconstructing a state estimate ${\hat{x}}_k$, with the control law $u_k=K{\hat{x}}_k$. The estimation error $e_k=x_k-{\hat{x}}_k$ obeys its own dynamics, and to handle the coupling between the error and the true state, he adopts the robust output-feedback paradigm: first compute an invariant set ${\mathcal{S}}_e$ for the error dynamics, then treat $e_k\in {\mathcal{S}}_e$ as a bounded internal disturbance when computing the true-state RPI set ${\tilde{\mathcal{S}}}_x$. The observer gain $L$ is synthesized through a covariance-type condition dual to the state-feedback Lyapunov condition — a structure familiar from robust Kalman filtering.

Two mathematical tools underpin the proofs. Young's inequality bounds cross terms in the noise matrices, and the S-procedure converts the subtle "for all disturbances in the ellipsoid" implications into tractable matrix inequalities. Together they let Ning turn hard, worst-case invariance conditions into convex SDPs with provable guarantees.

What They Found

The paper's central contribution is a set of three theorems — one for state-feedback RPI synthesis, one for the observer gain, and one for the true-state RPI set in the output-feedback case — each reducing a previously intractable or non-convex problem to a semidefinite program. The results show that invariant sets can be synthesized directly from data without ever constructing an intermediate model-uncertainty set, which is the key source of conservatism in prior approaches like zonotope-based reachability [2, 8] and set-membership methods [5, 12, 19].

The first major finding concerns the state-feedback gain. Ning shows that the feedback gain $K$ satisfying the discrete-time algebraic Riccati inequality can be recovered from data by minimizing the trace of the Lyapunov matrix $P$, which serves as an aggregate surrogate for the infinite-horizon cost bound. The SDP in Proposition 1 yields $P={\bar{P}}^{-1}$ and $K=U_0{F}_1{\bar{H}}^{-1}$, all expressed purely in terms of the data matrices and the SNR bound ${\gamma }_w$. The minimization of $\mathrm{trace}(Z_P)$ over the feasible controller designs provably achieves the minimum of $\mathrm{trace}(P)$ — a tightness result that matters, because larger invariant sets in general mean more conservative control.

The second finding concerns the RPI set itself. Parameterized as an ellipsoid ${\mathcal{S}}_x=\{x\mid x^T{Q}_S^{-1}x\le 1\}$, its shape matrix $Q_S$ is optimized by minimizing the trace, and Theorem 1 shows the resulting set is invariant in the formal sense: if the state starts in ${\mathcal{S}}_x$, it stays in ${\mathcal{S}}_x$ for all admissible disturbances. Because the shape matrix is free rather than tied to a fixed polyhedral template, the scheme can adapt the invariant set's geometry to the actual data. This matters in practice: a poorly shaped invariant set — one that's large in directions the system never actually ventures — forces needless conservatism onto the controller.

The third finding extends all of this to output feedback Satisfying the problem formulation, where the true state is unavailable onlineathe conditioned on the estimation error $e_k$. Ning derives the joint noise characterization in Lemma 3, which bounds the coupled noise matrix using the scalar $ϵ$, and shows the optimal choice

$${ϵ}^{\star }=\sqrt{\frac{{\gamma }_v\mathrm{tr}(Y_0{Y}_0^T)}{{\gamma }_w\mathrm{tr}(X_1{X}_1^T)}}$$

balances the process and measurement noise contributions and minimizes the trace of the $ϵ$-dependent upper bound. This gives a principled, automatic way to tune the noise-handling trade-off rather than relying on manual tuning. The final output-feedback theorem shows that the observer gain $L$ and the error covariance matrix $P_e$ satisfying the dual Lyapunov condition can be recovered from the data-driven parameterization $(A-LC)=(X_1-L{Y}_0){\Phi }_1^{†}+(L{V}_0-W_0){\Phi }_1^{†}$, with the SDP in Theorem 2 minimizing the trace of $Z_e$ to reduce the guaranteed estimation-error bound across all state components.

Together these results establish a coherent, unified framework for both state- and output-feedback invariant-set synthesis, with guarantees that hold in the worst case over all noise realizations consistent with the SNR assumptions.

Why This Changes Things

The significance of this work lies less in any single theorem and more in what it removes. Prior data-driven RPI synthesis approaches suffered from a common bottleneck: to get a worst-case guarantee, they had to first characterize — or over-approximate — a family of models consistent with the noisy data, and then compute invariant sets that remain valid over that whole family. The conservatism of these model-set-based methods depended critically on how tight that model family wascars. Ning's direct approach writes the synthesis conditions straight from the measured data matrices, never constructing an intermediate model-uncertainty set. As he points out, this "avoids the potential conservatism associated with model-uncertainty descriptions."

The output-feedback extension is arguably the more consequential of the two contributions. Extending data-driven RPI synthesis to output feedback "remains challenging and comparatively less explored," Nanjing acknowledges, precisely because the coupling of process noise, measurement noise, and estimation error introduces extra uncertainty channels into the invariant-set construction. His solution — bounding the estimation error with its own invariant set and then treating it as a bounded internal disturbance — mirrors the architecture used in much real-world observer-based control, making the approach usable in deployed systems.

This matters for applied domains where systems are hard to model from first principles. Consider an autonomous vehicle operating on GPS and noisy onboard sensors. In the lab, high-precision motion capture can record the full state; in operation, the vehicle sees only partial, noisy measurements. That is precisely the setting Ning formalizes in Problem 2, where the full state is available offline (for data collection) but not online. Or consider a chemical reactor whose kinetics are poorly understood, or a drone whose aerodynamics shift with wind. In each case, the promise is the same: safety guarantees without the intellectual labor of deriving accurate models. You collect a sufficiently exciting dataset, solve a few SDPs, and receive both a controller and a certificate of safety.

The decoupled, hierarchical design also matters from an engineering standpoint. Joint synthesis of gains and invariant sets is non-convex and notoriously hard; Ning's sequential approach keeps the synthesis convex, retains the well-understood LQ-type performance objective, and accepts the inevitable trade-off between convex tractability and global optimality. This is the kind of pragmatic compromise that survives contact with real engineering.

What's Next

The paper leaves important ground open. The decoupled design, while tractable, is acknowledged to be suboptimal compared to joint synthesis: the separate designs of $K$ and $L$ are "generally suboptimal for minimizing the resulting invariant bounds." Future work might seek ways to close part of that optimality gap without reintroducing non-convexity — perhaps through iterative refinement or through richer parameterizations of the coupled problem.

The framework also assumes bounded noise with known ellipsoidal bounds ($Q_w$ and $Q_v$) and known SNR ratios (${\gamma }_w$ and ${\gamma }_v$). In practice, these are estimated quantities, and misspecifying them would degrade the guarantees. A natural next step is to make the framework robust to uncertainty in the noise model itself, or to adaptively update the noise bounds online as more data arrives.

Finally, the paper's numerical examples illustrate effectiveness, but the details are concise; seeing the method applied to real physical systems — a quadrotor, a vehicle, a chemical process — would be the natural validation. The mathematical foundation is laid, the SDPs are solved, the invariant sets are drawn. The promising next chapter is where those sets meet actual hardware, and where data-driven certificates of safety become something you can hold in your hand.

For now, the contribution is clear. Ning has shown that the ancient promise of control theory — guarantee the system stays where it should — no longer requires the fiction that you know the system's equations. Wrung from data alone, the invariant set stands as a certificate that safety, in the worst case, can be bought with measurements and convex optimization. That is a quiet but real shift in what it means to design a system you cannot fully model.