Structured Koopman Lifted Finite Memory Identification via Truncated Grunwald Letnikov Kernels

arXiv:2603.16851 · eess.SY, cs.SY, math.OC · Submitted 2026-03-17 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "Structured Koopman Lifted Finite Memory Identification via Truncated Grunwald Letnikov Kernels".

Dev: We propose a data-driven linear modeling framework for controlled nonlinear hereditary systems that combines Koopman lifting with a truncated Grunwald–Letnikov memory term,

Rosa: First, who's behind it and why it matters.

Paper summary: Rosa: So we’re looking at this paper, "Structured Koopman Lifted Finite Memory Identification via Truncated Grunwald Letnikov Kernels," and it seems they've developed a way to handle those complex nonlinear systems that depend on their past states without losing the linear modeling advantage of the Koopman approach.

Dev: Yeah, I’m interested in how they manage to keep things linear in the lifted coordinates even when you introduce that history dependence directly through fractional-difference weights, Rosa. It sounds like a tricky balancing act for loop rates and latency control.

Taro: From an autonomy standpoint, if this framework can accurately model the system's hereditary nature using only finite memory terms, it could mean we can design controllers for systems where the immediate state isn't enough to predict future behavior when things get messy in the environment.

Rosa: Exactly, Taro, and what they claim is that by using a truncated Grunwald–Letnikov memory term instead of ignoring history dependence under a standard Markovian lifted predictor, they get this memory-compensated regression that lets you identify the lifted model using standard least squares on input–state data.

Dev: That identification part sounds promising for control engineers because it means we can actually learn the system matrices, A and B, from real experimental data without having to guess the underlying dynamics beforehand. But I wonder how robust this identification is when the actual memory structure deviates significantly from what the truncated kernel captures.

Taro: The paper suggests that this structure allows them to view a non-Markovian recursion as a "structured hereditary correction of the Markovian lifted predictor," which is an interesting conceptual framing for how autonomy algorithms might need to adapt in dynamic situations.

Rosa: And they go further by deriving an exact augmented Markovian realization, stacking the history into `zaug k:=

zk, zk−one <ref:2603.16851#pg0>..., zk−N+one: `, which turns the non-Markovian recursion into a standard one-step state-space model <ref:2603.16851#pg0>.

Dev: That's a big deal for computational efficiency; if we can convert it to that augmented Markovian form, we might be able to run the prediction loop much faster because it’s just a standard state transition equation rather than dealing with complex convolution terms every time.

Taro: If you can get an exact realization like that, it gives us a solid foundation for planning around the system's memory constraints, especially when the world presents unexpected disturbances or changing conditions.

Rosa: The paper also provides error analysis, showing how the approximation error from using a truncated kernel is bounded by terms related to kernel mismatch and neglected memory tails. Specifically, Lemma one establishes that the coefficients decay according to w j(alpha) C alpha j-(one plus alpha), which leads to a tail mass delta N(alpha) decaying as delta N(alpha) C alpha N-alpha <ref:2603.16851#pg0>.

Dev: That bound on the tail mass is quite concrete, Rosa; knowing that the error doesn't just grow indefinitely as you increase the memory length N helps us understand exactly how much information we are losing by truncating it.

Taro: That decay rate tells us that if we choose a sufficiently large memory length N, we can control the approximation error with respect to alpha, which is tied to the fractional order of the memory kernel itself.

Rosa: And they validated this entire framework on a nonlinear hereditary benchmark using a non-Grunwald–Letnikov Prony-series ground-truth kernel, showing improved multi-step openloop prediction accuracy compared to other methods.

Dev: Improved accuracy in prediction is what matters for control latency, Rosa; if the model predicts the trajectory better over several steps, it gives us more time to react before a failure mode occurs.

Taro: The implication here is that this method moves beyond just modeling a single step and allows for better anticipation of dynamic behavior where history plays a role in the system's current state evolution.

Rosa: So, we’ve covered how they combine Koopman lifting with the truncated Grunwald–Letnikov term to model nonlinear hereditary systems, how they use this to derive a memory-compensated regression for identification, and how they achieve an exact augmented Markovian realization.

Dev: That means we can potentially build a more accurate, computationally feasible model for these complex systems by treating history dependence explicitly within the lifted coordinates rather than ignoring it under simpler assumptions.

Taro: I think the impact could be significant in areas where system behavior is inherently dependent on long-term past interactions, like complex robotic navigation or certain types of industrial process control where delayed effects matter a lot.

Rosa: In conclusion, this paper presents a data-driven linear modeling framework for controlled nonlinear hereditary systems by combining Koopman lifting with a truncated Grunwald–Letnikov memory term to identify finite-memory lifted models and provide an exact augmented Markovian realization.

Dev: It gives us a concrete method for identifying the lifted state-transition and input matrices via least squares, which is powerful because it grounds the identification process in observable data.

Taro: The real impact seems to be extending standard Koopman-based identification beyond simple Markovian settings, allowing us to capture structured hereditary effects with quantifiable error bounds.

Rosa: This research suggests that we can build more sophisticated, yet manageable, models for systems where history dependence is present and important for accurate prediction and control.

Conclusion: Rosa: So, we've been talking about how this paper tackles modeling complex, history-dependent systems using Koopman lifting and a specific type of memory term.

Dev: Yeah, I'm really focused on the practical side here; it seems to offer a way to keep the model structure manageable while still capturing that necessary system inertia.

Taro: From my research angle, I'm curious about how this finite-memory approach handles situations where the environment suddenly changes its dynamics mid-operation.

Rosa: Exactly, and I want to know what this means for real-world applications; can we deploy these models in a field roboticist setting without constant recalibration?

Dev: The paper suggests that by using a truncated Grunwald–Letnikov kernel, you get an exact augmented Markovian realization, which implies we can convert the complex history dependence into a standard state-space form for faster loop rates.

Taro: That conversion is key; if we can treat it like a standard Markovian system with augmented states, that opens up possibilities for robust autonomy when things misbehave.

Rosa: It sounds like they've managed to find a way to quantify the error of truncating that memory, which is crucial because real-world systems have infinite history, and I want to know how large that error term actually gets.

Dev: The authors provide explicit bounds on the approximation error, showing it depends on the kernel mismatch and neglected tail terms, giving us a clear limit on how much we can trust the model for a given memory length.

Taro: That quantifiable error bound is what researchers need; knowing exactly where the model starts failing under extreme conditions tells us precisely where we need to improve the identification process.

Rosa: So, in simple terms, this paper offers a data-driven method to build linear models for systems that remember their past, and it gives us a mathematical way to measure how accurate those models are.

Dev: It really boils down to taking a highly non-Markovian system and extracting a structured low-parameter model that is identifiable from just input–state data, which simplifies the control loop immensely.

Taro: If this works reliably outside of controlled lab settings, it could significantly impact how we design adaptive control systems for robots navigating unpredictable environments where past interactions matter.

University of California, Davis

eess.SY, cs.SY, math.OC

Submitted: 2026-03-17

Updated: 2026-10-05

Comments: 8 pages, 4 figures; submitted to the 2027 American Control Conference (ACC)

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 79/100

The gist: We propose a data-driven linear modeling framework for controlled nonlinear hereditary systems that combines Koopman lifting with a truncated Grunwald–Letnikov memory term, which enables

Key concepts

Koopman Lifting: This technique transforms a nonlinear system's dynamics into a linear one in a higher-dimensional space called the lifted coordinates. By choosing an appropriate observable map, the original nonlinear state evolution becomes a simple linear equation in these new coordinates.
Grunwald–Letnikov Kernels: These are fractional-difference operators used to model history dependence or memory effects in discrete systems. They allow the model to account for past states not just through immediate neighbors but through a weighted sum of all previous states, controlled by a fractional order $\alpha$.
Augmented Markovian Realization: This is the key output where the complex, finite-memory system is shown to be exactly equivalent to a standard, one-step Markovian system. This means the memory effects are absorbed into an expanded state vector, simplifying analysis and identification.

Terminology

alpha — 8× in this paper · explained in 1 episode
Accuracy — 7× in this paper · explained in 1 episode
Benchmark — 6× in this paper · explained in 2 episodes
Dynamic Modeling — 1× in this paper · explained in 3 episodes
Hysteresis — 1× in this paper · explained in 3 episodes
Latent Space — 1× in this paper · explained in 7 episodes
Regularization — 1× in this paper · explained in 3 episodes
Robustness — 1× in this paper · explained in 5 episodes
Temporal Correlations — 1× in this paper · explained in 2 episodes

Summary

We propose a data-driven linear modeling framework for controlled nonlinear hereditary systems that combines Koopman lifting with a truncated Grunwald–Letnikov memory term, which enables identification of finite-memory lifted models from input–state data and provides an exact augmented Markovian realization.

The gist

The proposed framework combines Koopman lifting with a truncated Grunwald–Letnikov memory term to model nonlinear state dependence through lifted observables while imposing history dependence directly in the lifted coordinates through fixed fractional-difference weights, yielding a memory-compensated regression that can be identified from input–state data by least squares and extending standard Koopman-based identification beyond the Markovian setting.

System Modeling and Lifting

The paper considers a discrete-time nonlinear hereditary system defined by the state evolution equation:

xk+1 = f(xk, uk) + XJrefj=1hj g(xk+1−j) + ηk, k ∈ N. Unlike Markovian systems, this evolution depends on the history of past states through a convolution term involving a memory kernel. To obtain a linear predictor in lifted coordinates, the authors adopt a finite-dimensional Koopman lifting where the lifted state is defined as zk:= ψ(xk) ∈ R p, with the observable map chosen as ψ(x) = [1, x, ϕ(x)] (3). This construction ensures that the original state remains an exact linear readout of the lifted coordinates: xk = Czk.

Finite-Memory Correction via Truncated Grunwald–Letnikov Kernels

To address the limitation where standard Koopman identification assumes Markovian dynamics, a finite-memory Grunwald–Letnikov (GL) correction term is introduced in the lifted coordinates. For a fractional order α ∈ (0, 1), the discrete-time GL fractional difference of a lifted sequence is defined as [6]. A finite-memory lifted model is then proposed:

zk+1 = Az¯k + Bu¯k − XN j=1 wj (α) zk+1−j + dk, k ≥ N − 1, where dk ∈ R p collects the residual effects not captured by the imposed finite-memory GL structure. This structure allows the non-Markovian recursion to be viewed as a structured hereditary correction of the Markovian lifted predictor, where (A, ¯ B¯) capture instantaneous dynamics and the GL convolution term accounts for memory effects.

Memory-Compensated Regression and Identification

The key innovation lies in rewriting the finite-memory recursion into a linear regression form. By defining a memory-compensated target yk = zk+1 + XN j=1 wj (α) zk+1−j, the dynamics reduce to:

yk = Az¯k + Bu¯k + dk. This allows for identification of the lifted state-transition and input matrices by stacking data into Y, Z, U, and D vectors. The identification problem is then reduced to a least-squares problem: Θˆ ∈ arg min Θ∥Y − Θomega∥2 F. Under standard excitation conditions (full row rank of omega), the unique minimizer is found via the closed-form expression: Θ =ˆ Yomega† = Yomega⊤(omegaomega⊤)−1.

Exact Augmented Markovian Realization

The paper derives an exact augmented Markovian realization by stacking a finite window of lifted states, which constitutes the second main contribution. The augmented lifted state is defined as zaug k:= [zk, zk−1,..., zk−N+1] ∈ R pN. This N-step recursion (9) is shown to be exactly equivalent to a one-step Markovian system: zaug k+1 = Aaug zaug k + Baug uk + daug k. The augmented matrices Aaug and Baug are derived in block companion form, where the GL structure enters only through the scalar coefficients wj (α) in the first block row of Aaug, preserving a structured low-parameter form.

Finite-Memory Approximation Error Analysis

The framework explicitly quantifies the approximation error induced by replacing an infinite-memory kernel with a truncated GL kernel. The error dk is decomposed into three contributions: (i) a retained-lag kernel-mismatch term over the retained lags j = 1,..., N, (ii) a tail term due to neglecting lags beyond N, and (iii) the residual term ξk. Theorem 2 provides an explicit bound on this disturbance: dk squared ≤ Mz εN (α; c⋆) + ξk squared. Furthermore, Lemma 1 establishes the decay of GL coefficients: wj (α) ≤ Cα j−(1+α), leading to a tail mass δN (α) that decays as δN (α) ≤ Cα α N−α.

Improvements for AI systems

Here are the specific improvements to an AI system based on this research, along with what those improved systems can achieve:

The proposed framework, Koopman-GL Finite-Memory Identification, allows for the development of a class of data-driven models capable of accurately simulating and predicting the behavior of complex, nonlinear systems that exhibit hereditary (memory) effects.

Here are the specific improvements and capabilities:

The AI system can be fundamentally upgraded from a standard Markovian predictor to a model that explicitly accounts for long-term temporal dependencies in its dynamics.
The system can perform Memory-Compensated Regression, meaning it learns the underlying nonlinear state transition and input matrices while simultaneously using a truncated, structured memory term (via Grunwald–Letnikov kernels) to compensate for the inherent history dependence of the physical process.

This leads to several specific capabilities:

The system can identify and accurately model systems where past states significantly influence current evolution, such as viscoelastic materials, compliant robotic systems with friction/hysteresis, or dielectric phenomena—areas where memoryless models fail.
It enables robust long-horizon prediction (open-loop control) that maintains accuracy over extended time horizons, a critical capability for applications like autonomous vehicle control or process optimization where small errors accumulate rapidly.
The system can be trained directly from input–state data using standard least-squares regression, providing a straightforward and scalable data-driven identification pipeline that goes beyond local linearization methods (like Taylor series).
The framework allows for the derivation of an Exact Augmented Markovian Realization. This means the complex, non-Markovian finite-memory recursion can be mathematically transformed into a standard, solvable one-step state-space model by augmenting the state vector with a history stack. This makes the resulting model amenable to standard linear control design techniques (e.g., LQR, MPC).
The system provides explicit error quantification: it allows researchers to decompose the total prediction error into three components: (i) retained-lag kernel mismatch, (ii) neglected memory tail error, and (iii) residual model mismatch. This diagnostic capability is crucial for understanding the limitations of the finite-memory approximation and for guiding future model refinement.
The system can be used to generate highly accurate surrogate models for complex physical phenomena even when the true underlying kernel is non-standard (e.g., a Prony series instead of a simple GL kernel), provided the memory length and order are appropriately tuned, as demonstrated by the numerical experiments with a non-GL ground truth.

Sources

Mori-Zwanzig latent space Koopman closure for nonlinear autoencoder