Neural Koopman Operator Model

• Neural Koopman operator models are frameworks that learn a nonlinear lifting of state data into a latent space where linear dynamics prevail, enabling efficient prediction and control.
• They employ various architectures—such as deep-DMD, autoencoder variants, and physics-informed networks—to transform traditional observability into data-driven representations.
• Empirical results highlight significant improvements in prediction accuracy and control efficiency compared to fixed dictionary methods, validated on both synthetic and real-world systems.

Searching arXiv for the core and related papers to ground the article. A neural Koopman operator model is a representation of a nonlinear dynamical system in which a neural network learns a nonlinear lifting of the state, or of the available measurements, into a latent observable space where the evolution is modeled by a finite-dimensional linear operator. In its most common form, the model seeks coordinates $z=\phi(x)$ such that $z_{k+1}\approx K z_k$, or in controlled settings $z_{k+1}\approx K z_k + B u_k$, while a decoder or direct output map recovers physically meaningful variables from the lifted state (Yeung et al., 2017, Shi et al., 2022, Liang et al., 2021). Across the literature, the term denotes not one architecture but a family of constructions that combine Koopman operator theory with neural representation learning, ranging from deep dictionary learning and autoencoder-based latent linear models to continuous-time generators, bilinear control formulations, physics-informed constraints, and noise-robust variants (Frion et al., 2023, Liu et al., 2022, Singh et al., 5 Jan 2026).

1. Mathematical formulation

The classical starting point is a nonlinear discrete-time dynamical system

$x_{n+1}=f(x_n), \qquad y_n=h(x_n),$

with Koopman operator $\mathcal{K}$ acting on observables $g$ by composition,

$(\mathcal{K}g)(x)=g(f(x)).$

If a vector of observables $\psi(x)$ spans, or approximately spans, a Koopman-invariant subspace, then the dynamics in that observable space are linear: $\psi(x_{n+1}) \approx K\,\psi(x_n).$ The physical output is then a linear functional of the observables, $y_n = H(\psi(x_n))$, after finite-dimensional truncation (Yeung et al., 2017).

A neural Koopman operator model replaces the hand-crafted dictionary $z_{k+1}\approx K z_k$0 used in EDMD by a learned map. In the simplest deep dictionary formulation, a neural network $z_{k+1}\approx K z_k$1 defines the lifting

$z_{k+1}\approx K z_k$2

and the model enforces

$z_{k+1}\approx K z_k$3

This shifts the modeling problem from selecting polynomial, trigonometric, or radial basis dictionaries to learning an observable space jointly with the Koopman matrix itself (Yeung et al., 2017).

The same idea extends naturally to controlled systems. One standard latent model is

$z_{k+1}\approx K z_k$4

estimated either directly or through an autoencoder latent space (Liang et al., 2021). For nonlinear control-affine systems, the lifted dynamics may instead be bilinear,

$z_{k+1}\approx K z_k$5

which is the Koopman bilinear form used when control enters multiplicatively after lifting (Zinage et al., 2022). Another controlled formulation preserves linearity by introducing a learned transformed control $z_{k+1}\approx K z_k$6, so that

$z_{k+1}\approx K z_k$7

while the nonlinearity of the original control channel is absorbed by an auxiliary control network (Shi et al., 2022).

Continuous-time variants replace the discrete propagator by an infinitesimal generator. In that case the latent dynamics satisfy

$z_{k+1}\approx K z_k$8

with $z_{k+1}\approx K z_k$9 obtained from a learned discrete operator $z_{k+1}\approx K z_k + B u_k$0 through a matrix logarithm, or learned directly as a stable generator (Frion et al., 2023, Pan et al., 2019). This suggests that neural Koopman models are best understood as learned finite-dimensional realizations of either a Koopman operator or its generator, depending on whether the target problem is discrete- or continuous-time.

2. Architectural families

The earliest deep formulation in this corpus is deep dynamic mode decomposition, or deep-DMD, which uses a feedforward network as a learned observable dictionary and directly learns the Koopman matrix $z_{k+1}\approx K z_k + B u_k$1. It does not explicitly introduce a separate decoder, and prediction is organized around the encoder and linear latent propagation rather than full latent-state reconstruction (Yeung et al., 2017).

A second major family is the autoencoder-based Koopman model. Here an encoder $z_{k+1}\approx K z_k + B u_k$2 maps observations into a latent space, a linear operator advances the latent state, and a decoder $z_{k+1}\approx K z_k + B u_k$3 reconstructs the physical variables. In the epilepsy framework, the encoder is a 3-layer fully connected network, the decoder is symmetric, and $z_{k+1}\approx K z_k + B u_k$4 and $z_{k+1}\approx K z_k + B u_k$5 are computed in closed form by least squares within each batch rather than represented as neural layers. The same work also generalizes the latent dynamics to autoregressive order $z_{k+1}\approx K z_k + B u_k$6, yielding

$z_{k+1}\approx K z_k + B u_k$7

for richer temporal structure (Liang et al., 2021).

A third family is explicitly control-oriented. In the deep Koopman operator with control framework, the lifting is state-preserving,

$z_{k+1}\approx K z_k + B u_k$8

so the original state can be recovered by a fixed linear map $z_{k+1}\approx K z_k + B u_k$9. This design keeps quadratic costs in state space compatible with LQR in the lifted space. The same framework adds an auxiliary control network $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$0 that encodes state-dependent or fully nonlinear control terms while keeping the lifted dynamics linear in a transformed control variable (Shi et al., 2022).

Physics-informed architectures inject the governing equations directly into the learning problem. The Physics-Informed Koopman Network uses an encoder $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$1, a linear latent generator $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$2, and either a linear or nonlinear decoder, but it augments reconstruction with the Lie-derivative constraint

$x_{n+1}=f(x_n), \qquad y_n=h(x_n),$3

implemented by automatic differentiation. In this design, the latent coordinates are trained to approximate Koopman eigenfunctions not only from trajectories but also from collocation points in state space or function space (Liu et al., 2022).

Continuous-time probabilistic models further refine this picture. The physics-informed probabilistic framework of 2019 embeds an SVD–DMD baseline into the encoder and decoder so that the network learns only the nonlinear residual beyond a linear modal approximation. Its Koopman generator is structurally parameterized as a negative semi-definite tridiagonal matrix, which enforces non-positive real parts of eigenvalues and thus provable stability of the learned latent dynamics (Pan et al., 2019).

For PDE families, the Koopman neural operator extends the paradigm from state prediction to operator learning between Banach spaces. KNO uses an encoder, a Fourier-domain Koopman layer acting on low-frequency modes, a convolutional high-frequency complement, and a decoder, thereby combining FNO-like spectral representations with linear latent evolution (Xiong et al., 2023). In a different direction, diffusion maps can supply the observable space while neural networks model the dynamics on that space; the fMRI framework with parsimonious diffusion-map coordinates and either FNN or Koopman reduced-order models is an example of this hybrid neural–spectral design (Gallos et al., 2023).

3. Training objectives and identification strategies

The simplest deep objective enforces one-step linearity in latent space with regularization: $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$4 This directly targets Koopman consistency and was trained with AdaGrad and ADAM, with dropout, $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$5 regularization on network parameters, and $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$6 regularization on $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$7 (Yeung et al., 2017).

Autoencoder-based models typically add reconstruction and multi-step rollout losses. In the epilepsy model, the total loss is

$x_{n+1}=f(x_n), \qquad y_n=h(x_n),$8

where $x_{n+1}=f(x_n), \qquad y_n=h(x_n),$9 penalizes autoencoder reconstruction and $\mathcal{K}$0 penalizes decoded rollout predictions from the latent linear model. A noteworthy identification choice is that $\mathcal{K}$1 and $\mathcal{K}$2 are not backpropagated as generic neural parameters; they are recomputed by least squares from the current latent states, making the Koopman operator explicit and amenable to online updates (Liang et al., 2021).

Control-oriented variants replace one-step losses by multi-step rollout objectives. The deep Koopman with control framework uses a $\mathcal{K}$3-step loss

$\mathcal{K}$4

where the rollout occurs in the lifted space under the learned linear controlled dynamics. This directly penalizes long-horizon mismatch and empirically improves both prediction and control quality over one-step regression (Shi et al., 2022).

Continuous-time models for scarce or irregular data retain a discrete training phase but regularize the learned discrete operator geometrically. In the intrinsically continuous model, the training uses prediction losses

$\mathcal{K}$5

and linearity losses

$\mathcal{K}$6

together with the orthogonality penalty

$\mathcal{K}$7

Training is staged: a short-term objective first stabilizes reconstruction and moderate-horizon prediction, then a long-term objective enforces trajectory consistency over larger time spans (Frion et al., 2023).

Physics-informed models replace, or supplement, rollout losses by residuals derived from the governing equations. For ODEs, the core term is

$\mathcal{K}$8

combined with either linear or nonlinear reconstruction. When trajectories are available, an additional data term penalizes

$\mathcal{K}$9

and decoder mismatch at those times. This makes the training objective a hybrid of collocation-based operator identification and data-driven autoencoding (Liu et al., 2022).

Noise-robust identification introduces another layer of structure. The Deep Robust Koopman Network learns a shared encoder, forward and backward latent linear models, and a forward–backward consistency penalty

$g$0

along with forward and backward prediction losses in both state space and lifted space. After training, it synthesizes a reduced-bias Koopman operator by

$g$1

and the paper derives a first-order bias reduction result under explicit small-noise and invertibility assumptions (Singh et al., 5 Jan 2026).

4. Structural properties, guarantees, and control synthesis

A recurring point in the literature is that most neural Koopman models are approximate rather than exact. The 2017 deep-DMD paper is explicit that there is no guarantee that the learned dictionary spans a Koopman-invariant subspace; model quality is evaluated empirically through prediction accuracy, especially long-horizon behavior (Yeung et al., 2017). This directly addresses a common misconception: latent linearity in a learned coordinate system is usually approximate, data-dependent, and local to the regions explored during training.

Several later works add formal structure. The continuous-time probabilistic framework parameterizes the Koopman generator as a negative semi-definite tridiagonal matrix, guaranteeing non-positive real parts of eigenvalues and hence stable latent dynamics. It then places hierarchical Bayesian priors on network and Koopman parameters and uses mean-field variational inference to quantify uncertainty in Koopman spectra, eigenfunctions, and predictions (Pan et al., 2019).

Control-oriented guarantees appear in two main forms. First, the deep Koopman operator with control preserves linearity in the transformed control variable so that LQR can be solved directly in the lifted space. In the DKAC variant, the transformed control satisfies $g$2, giving

$g$3

and allowing optimal control design on the latent linear system while mapping the result back to the original control through the learned control network (Shi et al., 2022).

Second, Neural Koopman Lyapunov Control learns a bilinear Koopman embedding, a neural control Lyapunov function, and a stabilizing feedback law under a learner–falsifier loop. The lifted model has the form

$g$4

and the CLF is verified with an SMT-based falsifier. The resulting feedback is synthesized through Sontag’s formula, providing asymptotic stability guarantees for the learned bilinear Koopman representation of an unknown control-affine nonlinear system (Zinage et al., 2022).

Real-time MPC is another domain where linear latent dynamics become operationally decisive. In the epilepsy framework, online least-squares updates of $g$5 and $g$6 yield a time-varying but horizon-wise fixed latent linear model, and the MPC objective is quadratic with linear dynamics and linear constraints. This makes the controller a convex quadratic program, which explains the reported computational advantage over GRU-MPC and LSTM-MPC (Liang et al., 2021). The shipboard carbon capture framework pushes the same idea further by learning time-varying latent matrices and quadratic stage-cost surrogates from partial measurements while preserving convexity of the economic MPC problem at each time step (Han et al., 9 Apr 2025).

Recent work extends guarantees beyond stability. A 2025 framework learns an unconstrained neural Koopman model and then minimally perturbs its parameters to enforce strict dissipativity, with theoretical bounds that transfer dissipativity properties from the learned model back to the original nonlinear system through explicit treatment of noisy data, truncation, and generalization errors (Xu et al., 8 Sep 2025). This suggests that neural Koopman identification is increasingly being coupled to system-theoretic certificates rather than evaluated only by rollout accuracy.

5. Empirical behavior and application domains

The original deep-DMD study established a characteristic empirical pattern that reappears throughout the literature: neural dictionaries can outperform fixed EDMD dictionaries, especially under partial observability. On partially observed random linear systems with network sizes from 4 to 128 nodes, EDMD showed approximately 11–16% one-step error, whereas deep-DMD obtained less than 1% one-step training and test error after 10,000 iterations and about 0.1% with more training. On the glycolytic oscillator, deep-DMD reduced one-step errors from approximately $g$7 for EDMD to approximately $g$8 across 7-, 5-, and 3-species observation cases, and it could predict quantitatively for about 100 time steps from a single time point and qualitatively for about 400 steps (Yeung et al., 2017).

In closed-loop neurostimulation, the deep Koopman autoencoder model was benchmarked against VAR, VARMA, SINDy, RNN, GRU, and LSTM on synthetic Jansen–Rit, synthetic Epileptor, and real multi-channel iEEG data. On Jansen–Rit, the Koopman model achieved MSE approximately $g$9 and $(\mathcal{K}g)(x)=g(f(x)).$0 approximately $(\mathcal{K}g)(x)=g(f(x)).$1, whereas the best GRU baseline had MSE approximately $(\mathcal{K}g)(x)=g(f(x)).$2 and $(\mathcal{K}g)(x)=g(f(x)).$3 approximately $(\mathcal{K}g)(x)=g(f(x)).$4. In real iEEG, the Koopman model generalized better than RNN-type models, and in closed-loop control the resulting Koopman-MPC was roughly $(\mathcal{K}g)(x)=g(f(x)).$5 faster per control update than GRU-MPC or LSTM-MPC because it reduced control to a convex QP (Liang et al., 2021).

For sparse or low-frequency observations, the intrinsically continuous formulation changes the comparison. On the pendulum with low-frequency training data, the continuous-time model achieved $(\mathcal{K}g)(x)=g(f(x)).$6 MSE, outperforming DeepKoopman’s $(\mathcal{K}g)(x)=g(f(x)).$7, whereas in high-frequency settings DeepKoopman could be more accurate. On the fluid-flow benchmark, the continuous model retained strong low-frequency performance while supporting latent propagation at arbitrary times through $(\mathcal{K}g)(x)=g(f(x)).$8 (Frion et al., 2023). This indicates that continuous-time latent semigroups are especially useful when the sampling grid is sparse or irregular.

Physics-informed training alters the data-efficiency frontier. For the simple nonlinear ODE $(\mathcal{K}g)(x)=g(f(x)).$9, a purely physics-informed Koopman network trained on collocation points, without trajectory data, recovered eigenvalues very close to $\psi(x)$0, $\psi(x)$1, and $\psi(x)$2, and produced accurate long-term predictions. For the heat equation, the physics-informed model captured high-frequency modes well, the data-driven model captured low-frequency modes well, and the hybrid model recovered essentially the full spectrum with the best predictions. For Burgers’ equation, adding harmonic collocations to Gaussian-trajectory training reduced test MSE on unseen harmonic initial conditions by about one order of magnitude relative to the purely data-driven model (Liu et al., 2022).

Neural Koopman models also now span large-scale operator-learning and industrial control settings. The Koopman neural operator was evaluated on five representative PDEs and three real dynamic systems, including Navier–Stokes, Rayleigh–Bénard convection, global water vapor patterns, and western boundary currents, with reported advantages in mesh-independent, long-term, and zero-shot prediction (Xiong et al., 2023). The shipboard carbon capture model learned from partial state measurements and four operating conditions, then drove a convex economic MPC that improved both economic performance and carbon capture rate while maintaining hard output constraints in a high-fidelity simulation environment (Han et al., 9 Apr 2025).

Robotics provides the current benchmark for noise robustness. The Deep Robust Koopman Network was tested on the Van der Pol oscillator, a 4R manipulator, and the Franka FR3. On Van der Pol at 20 dB noise, its mean prediction error was 0.097 versus 0.476 for DKND. On the 4R manipulator at 25 dB, it achieved prediction error 0.114 and tracking error 0.245 rad, outperforming DKND, a recurrent roll-out method, and a nominal Koopman learner, while keeping MPC solve times around $\psi(x)$3 s. On Franka FR3, the same framework maintained end-effector tracking under both low and high feedback noise, and real hardware experiments showed smoother torques and fewer safety-triggering transients than competing Koopman models (Singh et al., 5 Jan 2026).

6. Scope, misconceptions, and adjacent uses

The term “neural Koopman operator model” is sometimes used narrowly for encoder–linear-operator–decoder systems, but the literature is materially broader. Some works use a neural network to learn the observable map; others use a non-neural spectral geometry such as diffusion maps and then either a Koopman operator or a neural network for reduced dynamics. In the fMRI study, a five-dimensional parsimonious diffusion-map basis served as the observable space, and a Koopman reduced-order model achieved results that were, for practical purposes, equivalent to an FNN-plus-Geometric-Harmonics pipeline while bypassing both a nonlinear dynamics map and a nonlinear pre-image model (Gallos et al., 2023). This suggests that the essential feature is not necessarily a neural encoder, but rather the coupling of learned or data-driven observables with linear latent evolution.

A second misconception is that the phrase always refers to modeling physical systems. Several papers apply Koopman ideas to neural networks themselves. One treats training as a dynamical system on weight space and builds local linear Koopman surrogates of optimizer-induced weight evolution, reporting speedups greater than $\psi(x)$4 over gradient-based optimizers during the predicted window (Dogra et al., 2020). Another uses Koopman spectra and modes of the training dynamics to identify convergence, bad initialization, and pruning opportunities (Manojlović et al., 2020). More recently, Koopman/DMD constructions have been used to replace nonlinear layers in pretrained MLPs: on Yin–Yang, DMD-based substitution achieved accuracy up to $\psi(x)$5 against the original $\psi(x)$6, and on MNIST up to $\psi(x)$7 against $\psi(x)$8; a related study showed that replacing nonlinear middle layers with Koopman matrices and pruning the Koopman matrix can preserve sufficient classification accuracy even at high compression ratios (Aswani et al., 2024, Sugishita et al., 2024). These are adjacent uses rather than canonical system-identification models, but they demonstrate how widely the Koopman perspective has spread across neural computation.

The principal limitations remain consistent across subfields. Learned finite-dimensional invariant subspaces are generally approximate; interpretability of neural dictionaries is weaker than that of explicit polynomial or trigonometric bases; and reliability is local to the state-space regions visited in the data (Yeung et al., 2017). Additional limitations arise from variant-specific assumptions: continuous-time logarithms of $\psi(x)$9 require spectral conditions that make a real generator well defined (Frion et al., 2023); physics-informed losses require access to the governing equations or their residuals (Liu et al., 2022); robustness guarantees in noisy settings rely on small-noise and invertibility assumptions (Singh et al., 5 Jan 2026); and control-oriented guarantees such as CLFs, stability, or dissipativity require extra structural constraints beyond ordinary prediction training (Zinage et al., 2022, Pan et al., 2019, Xu et al., 8 Sep 2025).

A plausible implication is that the field is moving from “learn a latent linear model that predicts well” toward “learn a latent linear or bilinear model that also satisfies control, robustness, and systems-theoretic constraints.” The open directions stated across these works include stochastic extensions, online adaptation, uncertainty quantification, input- and state-constrained control, more expressive but certifiable encoders, and richer operator-learning architectures for high-dimensional PDEs and multi-subject or multi-regime data (Yeung et al., 2017, Pan et al., 2019, Han et al., 9 Apr 2025, Singh et al., 5 Jan 2026). In that broader sense, the neural Koopman operator model has become a unifying template for combining representation learning with linear systems structure, rather than a single fixed model class.