The Math Trick That Teaches Robots to Learn From Noisy Data
When Your Robot Learns on the Job
Imagine a robot arm in a factory, adjusting its movements in real-time based on what it observes. Traditional controllers need a perfect mathematical model of that arm—its mass, its friction, how it responds to forces. Building those models is expensive and time-consuming. So engineers have been building controllers that learn directly from data: watching how the robot moves, then predicting what it will do next.
The problem is that real factories are noisy places. Motors vibrate. Sensors hiccup. Air currents push on the arm. And when these controllers learn from data corrupted by that noise, they make bad predictions, leading to jerky movements, missed targets, and systems that teeter on the edge of instability.
A paper from the University of Southern Denmark, published in July 2026, offers a solution. Mahmood Mazare and Hossein Ramezani have developed a control method they call Projection-Regularized Predictive Control—PRPC—that learns from noisy data without losing stability. Their key insight is elegant: by adding a small mathematical nudge called regularization, they can separate the true physics of the system from the noise contaminating it. The result is a controller that works in real-time, handles limited data gracefully, and comes with ironclad proofs that it won't misbehave.
The implications stretch far beyond factory robots. This same challenge—learning to predict and control a system from imperfect, limited data—appears everywhere from power grids to autonomous vehicles. Mazare and Ramezani's work addresses one of the core unsolved problems in modern control theory: how do you guarantee safety when your controller is continuously learning from its own experience?
The Data-Driven Control Problem
To understand why this matters, you need to understand what control engineers are trying to do. At its heart, control is about making systems behave the way you want. A thermostat keeps your house at 68 degrees. An autopilot keeps an airplane level. A factory robot precisely positions a welding torch.
The classic approach is Model Predictive Control, or MPC. Before the controller runs, engineers build a mathematical model of the system—equations describing how inputs (like motor torques) translate into outputs (like arm positions). Then, at every moment, the controller solves an optimization problem: "Given where I am now and where I want to be, what's the best sequence of inputs for the next few seconds?" MPC is powerful, but that upfront modeling step is expensive. For a complex system, it can take months.
Data-driven control aims to skip that step. Instead of building a model from first principles, the controller watches the system run. It collects trajectories—sequences of inputs and resulting outputs—and learns the system's behavior directly from the data. This approach has exploded in popularity over the past decade, fueled by advances in machine learning and a theoretical foundation called the Fundamental Lemma.
Published by Jan Willems in 2005, the Fundamental Lemma states something remarkable: for a certain class of systems (linear, time-invariant, discrete-time), every possible input-output trajectory can be expressed as a combination of columns in something called a Hankel matrix—a structured array built from historical data. In other words, the data itself encodes the system's dynamics. You don't need to estimate parameters like "mass" or "damping coefficient." You just need enough data.
This insight birthed methods like DeePC—Data-Enabled Predictive Control—which embeds raw data matrices directly into the online optimization. DeePC is theoretically elegant and has been deployed in buildings, power grids, drones, and autonomous vehicles. But it has a dirty secret: it hates noise.
When sensors are imperfect, the data matrices become corrupted. The controller overfits to that corrupted data, making predictions that reflect the noise rather than the physics. The result is a predictor that's biased and brittle. Moreover, DeePC's computational cost scales poorly—it grows roughly with the cube of the dataset size, which means bigger datasets (the usual prescription for noise problems) make it slower, not faster.
A lighter-weight alternative is Subspace Predictive Control, or SPC. Rather than working with the full raw data matrices, SPC does an offline preprocessing step: it uses least-squares regression to extract fixed "prediction matrices" that map from past data to future outputs. Once these matrices are computed, the online controller just multiplies them—no need to solve large optimization problems at every timestep. SPC matches the computational efficiency of traditional model-based MPC.
But SPC has its own Achilles heel. Its unregularized least-squares pseudo-inverse is notoriously sensitive to process noise—the kind of disturbance that affects the system itself, not just the measurements. When process noise contaminates the historical data, SPC's predictions become systematically wrong. It's statistically inconsistent: more data doesn't fix the bias, it just confirms the error.
Mazare and Ramezani identified this as the central problem: how do you get SPC's computational efficiency without its noise sensitivity? Their answer is PRPC.
The PRPC Method: A Gentle Correction
The core innovation in PRPC is deceptively simple. Where SPC uses an unregularized pseudo-inverse to extract prediction matrices, PRPC adds a regularization term. Think of it as a gentle penalty on the complexity of the learned model—a mathematical nudge that says "don't overfit to this particular dataset."
Mathematically, the PRPC predictor is defined by a constrained optimization problem. You start with raw data matrices from historical trajectories. You want to find a weight vector that, when multiplied through those matrices, reproduces the observed system behavior. SPC does this by solving a least-squares problem: minimize the squared error between the predicted and actual outputs.
PRPC adds one more term to that objective: a penalty on the squared norm of the weight vector, multiplied by a regularization parameter lambda. This term doesn't care about prediction accuracy—it cares about keeping the model "simple" in a specific mathematical sense. When lambda is zero, you recover the standard SPC problem. When lambda is positive, you get a slightly smoothed version.
The key question is: why would this help?
In classical statistics, regularization is a standard tool for handling ill-conditioned problems—situations where the data doesn't support precise estimation. A regularized estimator trades a small increase in bias for a large decrease in variance, often achieving lower overall mean-squared error. In machine learning, this shows up as "ridge regression" or "Tikhonov regularization."
But Mazare and Ramezani discovered something deeper. Under process noise, regularization isn't just about handling ill-conditioned data. It's about correcting a fundamental bias. The unregularized SPC predictor assumes that the regressor—the matrix containing historical data—is measured without error. Process noise violates that assumption, creating an errors-in-variables problem. The estimator becomes inconsistent: even with infinite data, it converges to the wrong answer.
Regularization fixes this. By adding the lambda penalty, you inject a small amount of bias into the estimator—but that bias pushes it in the right direction, toward the true system dynamics. The variance also drops. The net effect is a strictly lower mean-squared error.
The paper proves this rigorously. In Proposition 4, the authors show that under process noise, there always exists a strictly positive optimal regularization parameter lambda* that makes PRPC outperform SPC. The optimal lambda is monotonically non-decreasing with the ratio of process noise to measurement noise: the worse the process noise, the more regularization you need.
Conversely, when process noise is absent and only measurement noise remains, the optimal lambda converges to zero. SPC is asymptotically optimal in this regime—the regularization benefit disappears. This matches intuition: if only your sensors are noisy but the system itself behaves cleanly, unregularized SPC isn't biased; it just has variance that regularization can't fix.
The distinction matters. Regularization isn't a one-size-fits-all fix for all noise problems. It's specifically targeted at process noise contamination—the scenario where the system itself is disturbed, not just observed imperfectly.
Computing at the Speed of Thought
One of the paper's most elegant contributions is computational. The naive way to solve the PRPC optimization problem would be to invert a large matrix—specifically, the matrix H = Z_p^T Z_p + lambda I, where Z_p contains the past input-output data. For a dataset with M columns, this inversion costs O(M^3) operations—cubic in the dataset size. For modern applications where datasets contain thousands of samples, this is prohibitive.
Mazare and Ramezani show that you can analytically collapse the problem onto fixed-dimension covariance matrices. Instead of inverting an M-by-M matrix, you invert matrices whose dimension depends only on the prediction horizon and the number of inputs and outputs—not on the dataset length.
The prediction matrices P1 and P2—responsible for mapping past data and future inputs to future outputs—can be written entirely in terms of cross-covariance matrices: Sigma_pp (past-past), Sigma_up (past-future inputs), Sigma_yp (past-future outputs), and so on. Each of these is a fixed-dimension matrix computed once offline. The online controller just multiplies these matrices. The computational complexity of the offline step is O(T_z^3 + T_z^2 M), where T_z depends on the horizon and number of signals but not on M. The online step is a standard quadratic program of fixed, low dimension.
The authors state this clearly: "the dominant offline computational complexity...rendering the cubic inversions completely independent of the dataset length M." Your dataset could be 1,000 samples or 1,000,000—the online computation is the same.
This analytical collapse is a genuine contribution. It means PRPC doesn't just theoretically outperform SPC—it matches SPC's computational profile exactly. The regularization happens offline. The online controller is a lean, efficient quadratic program. You get the noise robustness without paying the computational price.
When Data Is Scarce
Modern adaptive control systems face another challenge: they often operate with limited data. A traditional SPC controller needs the regressor matrix to have full row rank—a condition that requires roughly M >= T_h data samples, where T_h depends on the system order and prediction horizon. In adaptive settings, where the controller updates its model in real-time using a sliding window of recent data, this condition fails regularly.
Consider an autonomous vehicle navigating a new environment. The controller uses the last T timesteps of data to predict the next few timesteps. But T might be small—perhaps because the system has been operating near equilibrium, or because the environment changed and old data is no longer relevant. When M < T_h, the regressor matrix loses rank, and standard SPC collapses. The pseudo-inverse is undefined. The controller breaks.
PRPC doesn't break. Because the design matrix H = Z_p^T Z_p + lambda I is strictly positive definite for any lambda > 0, the PRPC predictor remains well-posed even when the raw data matrix is rank-deficient. The only requirement is that the future input matrix U_f has full row rank—a much weaker condition, requiring M >= n_u N (where n_u is the number of inputs and N is the prediction horizon) rather than M >= T_h.
This structural robustness matters for adaptive systems. As the system operates, the controller can recursively update its covariance estimates without worrying about rank collapse. The authors introduce a convex blending strategy: at each timestep, the new empirical covariance is mixed with the previous estimate. This guarantees the predictor stays well-posed even when the system is regulated to equilibrium and loses "persistent excitation"—the condition that the historical data spans the relevant dynamics.
In simulation, the authors test this on a linear time-varying system with randomly switching dynamics—simulating a scenario where the system's parameters drift over time. Even when the system loses excitation and the rank condition fails, PRPC continues to produce well-defined predictions. The predictor "remains analytically well-posed," the paper notes, enabling stable closed-loop regulation despite the statistical challenges.
Proving Safety in the Loop
Here is where the paper makes its most sophisticated contribution: rigorous stability guarantees for an adaptive controller operating under noise.
Classical control theory offers tools for proving stability—showing that a system won't diverge, oscillate wildly, or violate constraints. Model-based MPC comes with such proofs: if the model is accurate and the constraints are satisfied, the closed-loop system maintains some formal property like recursive feasibility (you can always find a feasible control action) or Input-to-State practical Stability (ISpS, meaning the tracking error stays bounded and shrinks when disturbances vanish).
Data-driven control lacks these guarantees. The problem is subtle but crucial: when the controller updates its predictor using closed-loop data, the prediction regressor becomes correlated with past noise. This correlation violates the independence assumptions that underpin classical robust control and concentration inequalities—the mathematical tools used to bound prediction error with high probability.
Existing adaptive algorithms have to choose: either abandon rigorous stability guarantees and accept that the system might misbehave, or impose overly conservative deterministic assumptions that cripple performance.
Mazare and Ramezani refuse to choose. Using self-normalized martingale (SNM) concentration inequalities—a powerful tool from probability theory—they derive uniform-in-time, finite-sample confidence bounds on the prediction error. These bounds hold even when the regressor is correlated with noise, because martingales are specifically designed to handle sequential dependencies.
The key result is a confidence radius delta that bounds the prediction error with user-specified probability. For example, you might want "99% confidence that the true error is less than delta." The bound is uniform in time: it holds for all timesteps, not just in expectation or asymptotically. And it's finite-sample: it doesn't assume infinite data or asymptotic regimes.
This bound feeds into the controller design. Rather than enforcing constraints on nominal predictions only, PRPC enforces constraints on a dynamically tightened set: the nominal feasible region shrunk by the uncertainty radius. If the nominal prediction says "this input is safe," the controller checks whether it's safe even if the true error is as large as delta. This robust constraint tightening guarantees that constraints are satisfied with high probability, regardless of prediction errors.
The authors prove that this robust design achieves recursive feasibility and ISpS with high probability. In plain terms: the system never dead-ends (you can always find a feasible control action), and the tracking error stays bounded. These are not asymptotic or expected-value guarantees—they hold in finite time, with explicit probability levels.
This is a genuine theoretical advance. The paper explicitly identifies the void it fills: "classical concentration inequalities and traditional robust tube formulations" assume statistical independence that breaks down in online learning. By leveraging recent breakthroughs in self-normalized martingale theory, PRPC bridges this gap.
The Bias-Variance Tradeoff, Quantified
To understand the practical performance of regularization, the authors conduct extensive numerical experiments across different noise regimes and dataset sizes. The metric is the mean-squared error (MSE) of the predictor, normalized by SPC's error. A ratio below 1 means PRPC beats SPC; above 1 means SPC wins.
The results confirm the theory. Under pure measurement noise, the optimal regularization parameter converges to zero—SPC wins. Under process noise, the ratio dips below 1, with the benefit strongest when data is scarce.
Best-case predictor MSE ratio vs noise regime (M/T_h ≈ 20)
| Label | Value |
|---|---|
| Measurement noise only (σw=0) | 1 MSE ratio |
| Process noise (σw/σv=1) | 0.97 MSE ratio |
| Process noise (σw/σv=5) | 0.9 MSE ratio |
| Process noise (σw/σv=10) | 0.82 MSE ratio |
Figure 1 illustrates this: at moderate data length (M/T_h ≈ 20), the regularization benefit is modest under measurement noise alone, but process noise creates a clear valley where PRPC outperforms SPC. As lambda increases beyond the optimum, the ratio climbs back above 1—the predictor "over-regularizes" and becomes too biased.
Best-case predictor MSE ratio vs data length (process noise)
| Label | Value |
|---|---|
| M/T_h → 1 (scarce) | 0.55 MSE ratio |
| M/T_h = 2 | 0.72 MSE ratio |
| M/T_h = 5 | 0.85 MSE ratio |
| M/T_h = 10 | 0.92 MSE ratio |
| M/T_h = 20 | 0.9 MSE ratio |
Figure 2 shows the data-scarcity regime more starkly. When the dataset shrinks toward the minimum viable size (M/T_h → 1), the regularization benefit explodes. For a system operating with just barely enough data, PRPC's robustness to rank deficiency translates into a dramatic prediction improvement. This is the regime where real adaptive systems spend most of their time: updating on-the-fly with limited recent data.
The process-to-measurement noise ratio controls the magnitude of the benefit. Higher sigma_w/sigma_v (more process noise) increases both the optimal lambda and the improvement over SPC. The authors report that at sigma_w/sigma_v = 10, the best-case MSE ratio drops to its lowest value—the regularization correction is most valuable when process noise dominates.
Closed-Loop Control: Smooth Tracking Under Noise
Theory is valuable, but the ultimate test is closed-loop performance. The authors simulate a tracking problem: the controller must drive a system to follow a reference trajectory while satisfying constraints, under high measurement noise (variance 0.25). They run 10 Monte Carlo trials—different random noise realizations—and report the mean plus/minus one standard deviation.
The results show tight tracking despite the noise. The shaded regions representing one standard deviation are small, indicating consistent performance across noise realizations. The controller doesn't panic or jitter; it smooths through the noise using its regularized predictor.
Tracking trajectory (k)
| Label | Value |
|---|---|
| 0 | 0 σ²=0.25) |
| 20 | 20 σ²=0.25) |
| 40 | 40 σ²=0.25) |
| 60 | 60 σ²=0.25) |
| 80 | 80 σ²=0.25) |
| 100 | 100 σ²=0.25) |
Figure 5 (top) shows the closed-loop trajectories. The system tracks the reference closely, with variations attributable to noise rather than controller instability. Crucially, the controller satisfies input and output constraints throughout—no constraint violations, even though the predictor is learning from noisy data.
The authors also compare the input energy (a measure of control effort) and total weighted cost across different data-driven controllers. PRPC achieves competitive or superior cost values while maintaining strict constraint satisfaction. The regularization doesn't just improve prediction accuracy—it translates into better practical control performance.
Adapting to Change: Time-Varying Systems
Static systems are rare in the real world. Factory robots wear down. Aircraft burn fuel and become lighter. Power grids shift load as demand fluctuates. A truly useful data-driven controller must adapt to such changes.
The authors test PRPC on linear time-varying systems with two scenarios: i.i.d. polytopic switching (where the system dynamics jump randomly between a finite set of possible configurations) and slow sinusoidal drift (where the dynamics oscillate smoothly over time).
In the switching scenario, the controller's predictor must track discrete jumps in the system matrix. In the drift scenario, it must track continuous variation. Both are challenging for adaptive control—the predictor risks lagging behind true dynamics, or becoming unstable as it tries to update in real-time.
PRPC handles both. The convex covariance blending strategy ensures the predictor remains well-posed as data windows shift. When the system is near equilibrium and loses persistent excitation, the blending prevents rank collapse. When dynamics shift, the updated covariance reflects the new information.
Figure 7 shows the switching scenario: despite 50 random runs, the mean trajectory stays close to the reference, with small variance. The predictor "remains analytically well-posed," the paper notes, enabling stable closed-loop regulation despite the statistical challenges.
Figure 8 shows the drift scenario: tracking performance degrades slightly as dynamics move away from the initial model, but the controller adapts and recovers. The 40-run mean shows smooth tracking without divergence.
These simulations demonstrate that PRPC is not just a theoretical exercise. It's a practical controller for real systems with time-varying dynamics—the kind you'd find in robotics, aerospace, or industrial automation.
What PRPC Means for the Field
The contributions of this paper are layered. At the surface, PRPC is a new control algorithm. Dig a level deeper, and it's a rigorous analysis of the bias-variance trade-off in data-driven prediction. Look deeper still, and it's a bridge between two usually separate literatures: subspace identification (the indirect methods) and behavioral systems theory (the direct methods).
The authors show that PRPC reduces to SPC as lambda → 0+, establishing that regularization is a strict generalization—no conservatism introduced. But lambda provides a degree of freedom absent from SPC: the ability to tune the predictor for noise robustness. This connects the indirect tradition (efficient but brittle) with the direct tradition (robust but expensive).
More importantly, the paper addresses a gap that has held back practical deployment of adaptive data-driven control: the lack of finite-sample stability guarantees. Previous work on adaptive DPC either sacrificed rigorous guarantees for performance, or imposed such conservative assumptions that performance suffered. PRPC threads the needle by leveraging modern martingale concentration theory to derive bounds that are uniform in time, finite in sample, and high in probability.
The practical implications are significant. Factories could deploy adaptive controllers that learn on the job without risking constraint violations. Autonomous vehicles could adapt to terrain or payload changes without requiring extensive retuning. Power grids could handle shifting load patterns without conservative safety margins.
Caveats and Open Questions
No paper is complete, and this one is honest about its limitations.
First, the analysis assumes conditionally subgaussian noise—a broad but not universal noise model. Heavier-tailed distributions or non-independent noise sequences might violate the martingale assumptions underpinning the confidence bounds. Extending the results to these regimes is an open problem.
Second, the optimal regularization parameter lambda* depends on the true noise statistics, which are unknown in practice. The paper provides theoretical guidance (it increases with process noise), but doesn't offer a complete adaptive tuning rule. Heuristic approaches like cross-validation or Bayesian optimization might work, but rigorous adaptive tuning remains for future work.
Third, the focus is on linear systems. Nonlinear systems exhibit richer dynamics that may not be captured by the linear predictor, even with time-varying adaptation. Extending PRPC's framework to nonlinear settings is a natural next step, though it poses significant theoretical challenges.
Fourth, while the simulations demonstrate real-time tractability, they are limited to low-dimensional benchmark problems. High-dimensional industrial systems—large power grids, complex robotic manipulators—may exhibit numerical challenges not captured in the current experiments. Practical deployment will require further validation on real hardware.
Finally, the stability guarantees are probabilistic. A 99% confidence bound means there's still a 1% chance that the prediction error exceeds the bound, potentially causing constraint violations. For safety-critical applications, this residual risk may be unacceptable. Deterministic robustness margins—guaranteed even in worst-case scenarios—would strengthen the safety case, though likely at the cost of conservativeness.
These are not fatal flaws. They are the natural frontiers of any research: each answer opens new questions. The authors have established a solid theoretical foundation; the community will build on it.
What Comes Next
The paper opens several promising directions. The most immediate is adaptive lambda tuning: algorithms that estimate the optimal regularization parameter online, without requiring prior knowledge of the noise statistics. This would make PRPC truly plug-and-play.
A second direction is nonlinear extensions. The behavioral systems theory underpinning the Fundamental Lemma extends to certain nonlinear classes. If the PRPC framework can be adapted to these settings, it could enable noise-robust learning for broader classes of systems.
A third direction is experimental validation. The simulations demonstrate feasibility, but real hardware introduces sensor biases, latency, communication delays, and modeling errors not captured in the numerical studies. Testing PRPC on physical systems—robot manipulators, quadrotors, power electronics—would establish its practical viability.
A fourth direction is integration with learning. Reinforcement learning controllers often suffer from the same bias-variance problems addressed in this paper. PRPC's regularization framework might inform more stable RL algorithms, particularly in settings where process noise is significant.
Finally, the theoretical tools developed here—self-normalized martingale bounds for adaptive prediction—have applications beyond control. Any system that learns sequentially from correlated data could benefit from the same approach: finance, neuroscience, climate modeling, epidemiology.
The Broader Picture
Data-driven control is at an inflection point. The theoretical foundations are maturing. The algorithms are scaling to real systems. But a gap remains between theory and practice: rigorous guarantees often assume conditions that don't hold in the real world, while practical implementations often abandon those guarantees for performance.
Mazare and Ramezani's work narrows that gap. PRPC offers a principled middle ground: a controller that's computationally efficient, noise-robust, adaptive, and provably stable with high probability. The regularization isn't a hack or a heuristic—it's a theoretically justified correction for a specific bias. The stability guarantees aren't asymptotic or probabilistic in the weak sense—they're finite-sample, uniform-in-time, and user-specified in their confidence level.
The path from theory to practice is long. But papers like this one lay the stepping stones.
As data-driven control methods mature, they'll reshape how we build and operate engineered systems. Factories will learn to optimize themselves. Vehicles will adapt to their drivers, their cargo, their terrain. Power grids will absorb renewable fluctuations without operator intervention. These applications demand controllers that learn from data without sacrificing the guarantees that make automation safe.
PRPC is a step toward that future. It's a reminder that sometimes the old ideas—regularization, bias-variance trade-offs, statistical learning theory—still have fresh applications. And it's an invitation: the theoretical void that this paper begins to fill has more to explore.
The controller that learns on the job without losing stability is closer than ever. What it will enable, we can only imagine.