Hand a controller a deadline — and it delivers, even under attack

A control system that must act at the edge of its physical limits — a robot arm that draws, a drone that lands, a power grid that balances — faces a brutal triple threat. Its dynamics are never perfectly known, its actuators can only push so hard before they burn out, and an adversary may be quietly corrupting the very sensor readings it trusts. Most controller designs handle one of these problems at a time, and usually only promise that the system will settle down eventually, whenever that may be. A new framework from researchers at Ho Chi Minh City University of Technology (Vu & Doan, 2026) does something stranger and far more useful: it lets the designer choose the exact moment of convergence in advance, while guaranteeing the controller never exceeds its physical limits and remains resilient against false-data-injection attacks — all without ever asking for a mathematical model of the system it controls.

The team calls it predefined-time resilient integral reinforcement learning, and the key promise is audacious. Instead of guaranteeing that your robot arm will reach its target "in finite time" (which could be a millisecond or a century depending on how unlucky the initial conditions are), the convergence deadline is baked into the design from the start. The learning gain — the knob that controls how fast the controller learns — is not tuned by trial and error but computed directly from the deadline you specify. Set the deadline, and the math hands you a controller that hits it.

This matters well beyond robotics. It is a concrete step toward cyber–physical systems — power grids, autonomous vehicles, medical devices, industrial plants — that can be told "you have this much time to stabilize" and then actually deliver on that promise, even while under attack and even though no exact model of the plant exists.

The Science

Control theory has a long-standing obsession with the Hamilton–Jacobi–Isaacs (HJI) equation, the governing equation of optimal control. Solving it gives you the ideal feedback policy: the rule that tells the actuator exactly how hard to push in every state to drive the system to equilibrium while minimizing cost. But the HJI equation is brutally hard. It requires exact knowledge of the system's drift dynamics — the function $\mathbf{f}(\mathbf{x})$ in the equation $\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})+\mathbf{g}(\mathbf{x})(\mathbf{u}+\mathbf{a})+\mathbf{k}(\mathbf{x})\mathbf{d}$ — and in most real systems that function is unknown. Nobody has written down the complete dynamics of a fluid pipeline, a chemical reactor, or even a well-characterized robot arm in a way that remains accurate as parts wear and operating conditions drift.

The standard escape hatch has been reinforcement learning: instead of solving the equation, learn its solution from data. Integral reinforcement learning (IRL), the variant the authors build on, uses a clever trick. By integrating the cost over a moving time window $[t-T,t]$, the unknown drift term drops out of the learning equation entirely — what matters is only the measured state transition $\mathbf{x}(t-T)\mapsto \mathbf{x}(t)$, not the underlying dynamics. It is model-free by construction (Vrabie & Lewis, 2009).

But earlier IRL methods had two wounds. First, they promised only asymptotic convergence: the state and the learned critic weights drift toward their targets forever, approaching but never actually arriving in finite time. Second, they typically required persistent excitation — the system had to be continuously probed with exploratory signals forever, even after good regulation was achieved. Continuous probing is not just wasteful; it is actively dangerous in a setting where an adversary can read those probing signals.

The HCMC group's contribution is to close both wounds at once. The convergence is predefined-time: a settling-time bound $T_s$ is assigned a priori, and the system is guaranteed to reach its target within that window regardless of initial condition. The persistent-excitation requirement is replaced by a finite stack of recorded "replay" data — a handful of stored Bellman–Isaacs windows that keep the learning well-posed after active probing stops.

The architecture is elegant. A constrained minimax cost is constructed whose state penalty generates exactly the right low- and high-order dissipation to produce predefined-time behavior, and whose nonquadratic input term — a barrier function $U(\mathbf{u})=2{\sum }_{\ell }{\bar{u}}_{\ell }{r}_{\ell }{\int }_0^{u_{\ell }}\mathrm{atanh}(\sigma /{\bar{u}}_{\ell })d\sigma$ — embeds the actuator limits directly into the cost. The penalty's gradient blows up at the constraint boundary $|u_{\ell }|={\bar{u}}_{\ell }$, which means the optimal policy is pushed away from saturation by construction, not clamped after the fact with a clipping step that would wreck the optimality guarantees.

The adversarial dimension comes through a zero-sum game formulation. The secure controller $\mathbf{u}$ minimizes a worst-case cost; the FDI attack $\mathbf{a}$ and external disturbance $\mathbf{d}$ are treated as players trying to maximize it. The value function $V^{\ast }({\mathbf{x}}_0)={\min }_{\mathbf{u}\in \mathcal{U}}{\max }_{\mathbf{a},\mathbf{d}}J({\mathbf{x}}_0,\mathbf{u},\mathbf{a},\mathbf{d})$ is the saddle value of this game. This is the standard framework for robustness, but its fusion with predefined-time convergence — letting the designer write the deadline directly into the learning gain via the gamma-function expression in Theorem 1 — appears to be new.

The critic — the learned approximation of the value function — is trained by a normalized two-power law that combines current integral data with the recorded replay stack. The normalization $\mathbf{\omega }(t)=\Delta \mathbf{\varphi }(t)/(1+\Vert \Delta \mathbf{\varphi }(t){\Vert }^2)$ caps every regressor at $\Vert \mathbf{\omega }\Vert \le 1/2$, preventing any single large state transition from drowning out the others.

What They Found

The paper's analytical core is a chain of guarantees that connect learning to stabilization. The most important is a coupled predefined-time bound: the state and the critic weights are not analyzed separately but together, in one deadline. This matters because of a subtle timing hazard the authors identify explicitly. After the critic converges at time $t_c$, the integral residual in the Bellman–Isaacs window still contains pre-convergence data until one full reinforcement window of length $T$ has elapsed. The recorded data must flush out, the critic must finish learning, and the state must converge — all inside the same assigned deadline. A controller that converges but whose learning is still catching up, or vice versa, is not actually useful in practice.

The results are stated as "practical" predefined-time convergence: in the presence of bounded attacks $\Vert \mathbf{a}(t)\Vert \le \bar{a}$ and disturbances $\Vert \mathbf{d}(t)\Vert \le \bar{d}$, the coupled state–critic system converges to a small neighborhood of the origin (and of the ideal weights), with the size of that neighborhood shrinking as the bounds $\bar{a},\bar{d}$ shrink. This is the honest version of a strong claim — world-class robustness is achievable, but adversarial energy above zero leaves a footprint in the terminal set.

Three computational findings stand out. The finite-replay condition replaces persistent excitation with something far more practical: once a finite stack of informative windows is recorded, active probing can stop. This is a genuine operational improvement — in a CPS under attack, the ability to stop emitting exploratory signals is itself a security feature, because those signals are observable to the attacker. The learning gain is also computed explicitly from the deadline rather than tuned: the predefined-time comparison theorem (Theorem 1) gives a closed-form gamma-function expression for the gain that makes the deadline $T_s$ hold for every initial condition.

The validation is a two-link robot manipulator — the standard testbed for nonlinear control — under actuator constraints, external disturbances, and an FDI attack injected into the same channel as the control input. The experiments show the state converging within the prescribed window while the control input remains strictly inside the actuator bounds throughout, a combination previous methods could not deliver simultaneously.

The four timing components fused into one predefined-time deadline

Label	Value
Data informativity	1
Critic learning	1
Window flushing	1
State convergence	1

Schematic of the four timing elements the coupled state–critic Lyapunov analysis must reconcile within one deadline.

The chart above sketches how the pieces interact conceptually: the assigned deadline $T_s$ sets the learning gain through the gamma-function expression; the learning gain drives critic convergence; the finite replay stack keeps learning well-posed without persistent excitation; and all four timing elements — data informativity, critic learning, window flushing, and state convergence — are fused into a single deadline by the coupled Lyapunov analysis.

How predefined-time tightens the convergence guarantee

Label	Value
Asymptotic (traditional IRL)	100
Fixed-time (prior work)	60
Predefined-time (this paper)	30

Illustrative comparison of settling-guarantee strength; asymptotic methods never promise a finite settling time, while predefined-time stability assigns Ts in advance.

Why This Changes Things

For decades, the standard answer to "when will my controller converge?" has been "eventually." Asymptotic stability is a beautiful mathematical property but a weak engineering guarantee. A system that is asymptotically stable could, in principle, take an arbitrarily long time to settle depending on where it starts. Fixed-time stability improved on this by making the bound independent of the initial condition, but the bound itself was a byproduct of the gains — you discovered it after the fact. Predefined-time stability inverts the logic: the designer states the deadline first, and the math hands back a controller that meets it.

This matters most for cyber–physical systems, where the authors' motivation is explicit. A power grid node recovering from a fault, an autonomous vehicle receding from an obstacle, a robotic surgeon's arm correcting a trajectory — in all of these, "eventually" is not a specification. The operator wants to know: will this system recover in 0.5 seconds? The framework turns that question from a hope into a design constraint.

The resilience dimension is equally consequential. False-data-injection attacks — attacks that corrupt sensor measurements or trusted signals so that the system acts on lies — are one of the canonical threats to modern infrastructure, and they are specifically dangerous because they are hard to detect. Many defensive schemes add an anomaly-detection layer on top of a nominally designed controller. The HCMC approach instead bakes the adversary into the control objective itself: the controller is designed from the outset as the minimizing player in a zero-sum game against the attack. There is no separate detection stage; the robustness is structural.

The hard actuator constraint deserves special emphasis because it is the kind of detail that separates theory from practice. Real actuators saturate. Most of the control literature handles this by designing an unconstrained controller and then clipping its output — a pragmatic hack that silently destroys the optimality and stability guarantees the mathematics promised. Here, the constraint is embedded in the cost through a barrier function whose gradient becomes infinite at the saturation boundary. The optimal policy can never cross the limit because doing so is infinitely expensive. It is a guarantee by construction rather than by afterthought.

Six challenges addressed in a single framework

Label	Value
Unknown drift	1
Actuator saturation	1
FDI attacks	1
Disturbances	1
Persistent excitation removed	1
Assigned deadline	1

1 Unknown drift

The paper asserts all six properties are addressed jointly — a combination its authors note prior methods could not deliver simultaneously.

The combination of all three properties — predefined-time convergence, model-free learning, and hard constraint satisfaction under adversarial disturbance — in a single framework is, to the authors' knowledge and mine, unprecedented. Each property has a literature, but the intersections have been largely empty.

What's Next

The honest caveats matter as much as the promises. The convergence is practical rather than exact: with nonzero bounded attacks and disturbances, the state converges to a neighborhood of the origin, not the origin itself. The size of that neighborhood scales with the attack and disturbance bounds. For missions that demand precision down to the millimeter, the residual footprint of adversarial energy is a real design consideration, not a theoretical footnote.

The assumptions are also noteworthy for being both standard and demanding. The attack and disturbance are required to be bounded and ${\mathcal{L}}_2\cap {\mathcal{L}}_{\infty }$ — reasonable but real restrictions. The input maps $\mathbf{g}(\mathbf{x})$ and $\mathbf{k}(\mathbf{x})$ are assumed known, even as the drift $\mathbf{f}(\mathbf{x})$ remains unknown. This is a standard split in the IRL literature — the actuation geometry is often better characterized than the dynamics — but it means the framework does not yet handle the fully black-box regime where even the input channels are unknown.

The validation is a simulation on a two-link robot arm, not hardware. The gap between simulated and physical systems is precisely where control theory often goes to die, and the authors do not claim otherwise. Hardware demonstration — with a real arm, real motor saturation, real noise, and a real injected attack — is the natural and necessary next step.

The most exciting open direction is what the framework might unlock beyond stabilization. The paper focuses on regulation — drive the state to the origin — but the machinery generalizes in principle to trajectory tracking and to multi-agent coordination, where the authors' own prior work on fixed-time IRL has already begun to move. If the predefined-time, finite-replay, constraint-respecting formulation can be extended to teams of agents, it would point toward cooperative systems — formations of robots, fleets of vehicles, microgrids — that can promise, in advance, when they will reach formation, even under attack, even without knowing their own dynamics precisely.

That is the quiet radicalism of this work. It is not proposing a faster controller or a cleverer cost function. It is proposing a new kind of specification: a controller that can be given a deadline, told its physical limits, handed a data stream instead of a model — and then trusted to deliver, constrained, on time, and under fire.