⚡ electrical engineering

Adaptive and Neural Operator Control of Nonlinear Volterra Hyperbolic PDEs

This paper presents a hybrid control framework for nonlinear Volterra hyperbolic PDEs that combines online adaptive identification of unknown plant dynamics with offline neural operator approximation of complex backstepping gain synthesis, thereby achieving closed-loop stability and asymptotic regulation despite truncation, identification, and approximation errors.

Original authors: Miroslav Krstic

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Miroslav Krstic

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 steer a very complex, unpredictable ship through a storm. The ship's engine and rudder are controlled by a computer, but the ship itself has a "memory" of its past movements that affects how it reacts right now. In the world of physics and engineering, this ship is described by a Partial Differential Equation (PDE), and its "memory" is a Volterra series (a fancy way of saying the ship's behavior depends on a long chain of past interactions).

The problem is twofold:

We don't know the ship's exact rules: The computer doesn't know the specific "memory" settings (the kernels) of the ship.
The rules are too hard to calculate in real-time: Even if we did know the rules, figuring out the perfect steering adjustment takes so much computing power that it would take hours to solve a problem that needs an answer in milliseconds.

This paper, by Miroslav Krstic, proposes a clever solution that combines Adaptive Control (learning on the fly) with Neural Operators (learning the math beforehand).

Here is the breakdown using simple analogies:

1. The Two Main Problems

The "Unknown Map" Problem: To steer the ship perfectly, you need a map of how the ship reacts. But the map is hidden. You have to guess it while you are sailing.
The "Too Slow Calculator" Problem: Every time you update your guess of the map, you have to solve a massive, multi-dimensional math puzzle to figure out the new steering angle. Doing this puzzle every second is impossible for a real-time computer. It's like trying to solve a Sudoku puzzle the size of a city every time you turn the steering wheel.

2. The Solution: A Two-Part Team

The author creates a system with two distinct "learners" working together:

Part A: The "Passive Observer" (The Online Learner)

Think of this as a co-pilot sitting next to the captain.

What it does: It watches the real ship and a "virtual" model of the ship. It constantly compares the two.
How it learns: If the real ship drifts away from the virtual one, the co-pilot updates its guess of the ship's "memory rules" (the kernels).
Key feature: It learns online (while the ship is moving) without needing to be forced to move in specific ways (no "persistence of excitation" needed). It just passively absorbs the error.

Part B: The "Neural Operator" (The Offline Learner)

Think of this as a super-smart apprentice who has spent years studying the math before the ship ever left the dock.

What it does: It learns the relationship between "Guessing the Map" and "Calculating the Steering Angle."
How it learns: Before the ship starts, researchers feed the apprentice thousands of examples of different ship maps and their corresponding perfect steering angles. The apprentice uses a Neural Operator (a type of AI designed for continuous math) to learn the pattern.
The Magic: Once trained, the apprentice doesn't need to solve the massive math puzzle. When the co-pilot says, "I think the ship's memory is this," the apprentice instantly says, "Okay, based on my training, the steering angle should be that." It replaces the hours-long calculation with a split-second lookup.

3. How They Work Together

The system runs in a loop:

The Co-pilot (Observer) watches the ship and updates its guess of the ship's hidden rules.
The Apprentice (Neural Operator) takes that guess and instantly spits out the correct steering command.
The ship steers, the co-pilot sees the result, updates the guess, and the cycle repeats.

4. The "Self-Coupled" Twist

Usually, if you know the rules, you can calculate the steering angle with a simple formula. But here, the most basic part of the ship's rules (the linear part) is also unknown. This makes the math puzzle "self-coupled"—it's like trying to solve a riddle where the answer is part of the question.

The Paper's Claim: The author proves that even with this tricky, self-referential math, the system is still solvable and stable, provided the ship's non-linear behavior isn't infinitely wild.

5. The Result: Stability and Regulation

The paper proves mathematically that:

Stability: The ship won't crash or spin out of control, even while the co-pilot is still guessing the rules.
Regulation: Eventually, the ship will settle down and stop moving (reach zero state), and the steering will stop.
The "Basin of Attraction": The system works as long as the ship starts within a certain "safe zone." As the apprentice (Neural Operator) gets better at its job (more accurate), this safe zone gets bigger, eventually matching the size of the safe zone you would have if you knew the perfect rules from the start.

6. What the Simulation Shows

The paper includes a computer simulation of a ship with a "quadratic memory" (a specific type of non-linearity).

Without control: The ship explodes (diverges) quickly.
With the new system: The ship stabilizes.
The Catch: The co-pilot's guess of the ship's rules does not become perfectly accurate. It stops changing once the ship stops moving because there is no more "error" to learn from. However, this doesn't matter! The steering command generated by the apprentice is "good enough" to keep the ship safe and steady. The system doesn't need to know the exact truth; it just needs a good enough guess to generate a good enough steering command.

Summary

This paper solves a "chicken and egg" problem in controlling complex physical systems. You can't steer without knowing the rules, but you can't learn the rules without steering. By using an online observer to guess the rules and an offline-trained AI to instantly convert those guesses into steering commands, the author creates a controller that is both adaptive and fast enough for real-time use. It turns a mathematically impossible real-time calculation into a simple, fast lookup.

Problem Statement
This paper addresses the adaptive control of a class of nonlinear hyperbolic partial differential equations (PDEs) where the in-domain nonlinearity is governed by an unknown Volterra series of arbitrarily many kernels. The specific plant is a first-order hyperbolic PDE with a boundary control input. The control objective is to stabilize the plant state to the origin.

Two primary obstacles prevent the deployment of standard PDE backstepping control on such imperfectly known plants:

Model Dependency: The feedback gains (kernels) required for backstepping are functionals of the plant coefficients. Without a known model, these gains cannot be computed.
Computational Prohibitions: Even if the model were known, the backstepping gains for this class of nonlinear Volterra PDEs are the solution to a cascade of kernel PDEs defined on simplex domains of increasing dimension ( $n$ -dimensional simplices for the $n$ -th order kernel). In an adaptive setting, where plant estimates change continuously, solving this cascade online is computationally prohibitive.

Methodology
The authors propose a unified architecture that combines adaptive control with neural operator learning to overcome both obstacles simultaneously. The system operates through two learning processes in series:

Online Adaptive Identifier: An observer-based passive identifier is designed to estimate the unknown Volterra kernels ( $f_1, \dots, f_N$ ) online. This identifier uses a truncated $N$ -order Volterra series and a projection-based parameter update law. Crucially, the design ensures stability without requiring a persistence-of-excitation assumption, as the estimation error appears as a dissipative term in the Lyapunov derivative.
Offline Neural Operator Solver: The mapping from the estimated plant parameters to the required backstepping control gains is a complex, infinite-dimensional operator involving a cascade of linear Volterra integral equations. This mapping, denoted as $Q_N$ $Q_{N}$ , is approximated offline by a neural operator ( $\hat{Q}_N$ $\hat{Q}_{N}$ ).
- Unlike previous works where the neural operator learns the controller for a known plant, this paper learns the kernel-generation map. The neural operator takes the running parameter estimates $\hat{f}(t)$ as input and outputs the control kernels $\hat{k}(t)$ in real-time.
- The implemented controller uses these learned kernels in a certainty-equivalence framework, acting on the observer state.

Key Contributions

Adaptive Design for Unknown Linear Kernels: The paper extends adaptive control to the fully nonlinear Volterra class where even the linear kernel ( $f_1$ ) is unknown. This transforms the gain cascade from a sequence of closed-form quadratures (as in known-model designs) into a sequence of self-coupled linear Volterra integral equations. The authors prove the invertibility of these equations for any admissible nonlinearity size, without smallness conditions.
Stability with Truncation and Approximation: The authors establish a priori $L^2$ $L^{2}$ stability and asymptotic regulation for the closed-loop system. They utilize a single Lyapunov function to simultaneously absorb perturbations arising from:
- Truncating the infinite Volterra series.
- Online parameter estimation errors.
- The approximation error of the neural operator.
Neural Operator Implementation (Theorem 2): The paper proves that replacing the online PDE cascade solve with an offline-trained neural operator surrogate preserves closed-loop stability. The basin of attraction for the neural-operator-based controller expands to match the exact-kernel basin as the approximation error vanishes.
Lipschitz Continuity of the Kernel Map: A rigorous proof is provided showing that the kernel-generation operator $Q_N$ is Lipschitz continuous on the space of parameter estimates, which is a prerequisite for the universal approximation capabilities of the neural operator.

Results

Theoretical Guarantees: Theorem 1 establishes Lyapunov stability and asymptotic regulation of the plant state, observer state, and input for the exact-kernel case. Theorem 2 extends these guarantees to the neural-operator implementation, showing that the system remains stable and regulates to zero, provided the initial conditions lie within a specific basin and the neural operator accuracy is sufficient.
Numerical Illustration: A simulation with a quadratic Volterra PDE ( $N=2$ $N = 2$ ) demonstrates the design. The results show:
- The open-loop system blows up in finite time.
- The adaptive closed-loop system successfully regulates the state to zero.
- The parameter estimates and the neural operator's output kernels converge and stabilize early, while the plant states decay more slowly on the transport time scale.
- The estimates do not necessarily converge to the true plant parameters (due to lack of persistent excitation once the state vanishes), but they are sufficient to generate kernels that stabilize the system.
- The neural operator reduces the online computational cost significantly (0.17 ms per step vs. 0.64 ms for the numerical cascade solve) while maintaining a low approximation error (~ $2 \times 10^{-2}$ ).

Significance
The paper claims to solve a fundamental bottleneck in infinite-dimensional adaptive control: the inability to recomputed complex, high-dimensional feedback gains in real-time as plant estimates evolve. By decoupling the heavy computational load of solving the kernel PDE cascade (handled offline via neural operators) from the online adaptation loop, the authors enable the practical deployment of adaptive backstepping for nonlinear hyperbolic PDEs with unknown Volterra nonlinearities. The work bridges the gap between theoretical adaptive control for PDEs and real-time implementation, specifically addressing the unique difficulty of unknown linear kernels in nonlinear cascades.