🔢 mathematics

Interpretable and flexible non-intrusive reduced-order models using reproducing kernel Hilbert spaces

This paper introduces an interpretable and flexible non-intrusive reduced-order modeling technique based on regularized kernel interpolation in reproducing kernel Hilbert spaces, which combines user-defined feature maps with nonlinear closure terms to mirror full-order model structures while providing computable a posteriori error bounds.

Original authors: Alejandro N Diaz, Shane A McQuarrie, John T Tencer, Patrick J Blonigan

Published 2026-01-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alejandro N Diaz, Shane A McQuarrie, John T Tencer, Patrick J Blonigan

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 predict the weather. The "Full-Order Model" (FOM) is like a supercomputer running a massive, incredibly detailed simulation of every single air molecule, cloud, and wind current. It's accurate, but it takes so much computing power that you can't run it a thousand times to test different scenarios (like "what if the temperature rises by 2 degrees?").

To solve this, scientists build a "Reduced-Order Model" (ROM). Think of a ROM as a simplified map. Instead of showing every tree and house, it just shows the main roads and landmarks. It's much faster to use, but it still needs to tell you how to get from point A to point B.

The problem with many existing "maps" is that they are either:

Too rigid: They assume the world is a straight line (linear), but reality is often curved and twisty.
Black boxes: They use complex neural networks that work well but are impossible to understand (you don't know why they made a prediction).
Intrusive: To build them, you need to peek inside the supercomputer's code, which is often impossible if the code is old or proprietary.

The New Solution: "Kernel ROMs"

This paper introduces a new way to build these maps called Kernel ROMs. Here is how it works, using simple analogies:

1. The "Magic Trampoline" (Reproducing Kernel Hilbert Space)

Imagine you have a trampoline (the mathematical space called an RKHS). You want to stretch a sheet over it to match a specific shape (the physics of your problem).

Old methods tried to force the sheet to look like a straight line or a simple curve by solving a puzzle with a fixed set of rules.
This new method lets you choose the texture of the trampoline itself. If you know the physics involves curves, you choose a "curvy" trampoline. If you don't know the shape, you choose a flexible, stretchy one.

2. The "Feature Map" (The Blueprint)

The authors say you can design the trampoline to match the physics you already know.

Analogy: Imagine you know a car's speed depends on the engine (linear) and the wind resistance (quadratic). You can build a "Feature Map" that tells the trampoline: "Hey, make sure the sheet has a straight part for the engine and a curved part for the wind."
The Result: The resulting model is interpretable. You can look at the final equation and say, "Ah, this part is the engine, and this part is the wind." It's not a black box; it's a transparent blueprint.

3. The "Hybrid" Approach (The Safety Net)

Sometimes, you know the main rules (like the engine and wind), but you suspect there are tiny, weird forces you don't fully understand (like a sudden gust or a pothole).

The Solution: The authors suggest a Hybrid Kernel. You build the main part of the trampoline with your known rules (the Feature Map), but you add a "safety net" of flexible, stretchy material (an RBF kernel) to catch the weird, unknown stuff.
Why it helps: This acts as a "closure term." It fills in the gaps where your simplified physics might be missing something, without needing to know exactly what that missing piece is.

4. The "Error Ruler" (A Posteriori Bounds)

One of the biggest worries with simplified models is: "How wrong could this be?"

Most non-intrusive methods (those that don't peek inside the supercomputer code) can't easily tell you this.
This paper provides a mathematical ruler. Because they built the model using this specific "trampoline" math, they can calculate a guaranteed upper limit on the error. It's like having a ruler that says, "This map is accurate to within 2%," giving you confidence in the results.

What They Tested

The authors tested this "Kernel ROM" on three different physical problems:

Heat moving through a pipe (Advection-Diffusion): A linear problem where the new method worked just as well as the old "best" methods but with the added benefit of being interpretable.
Shockwaves in air (Burgers' Equation): A nonlinear problem with sharp gradients. The new method handled the sharp turns better than simple linear maps and matched the performance of complex neural networks while remaining understandable.
Explosions and gas flow (Euler Equations): A very difficult 2D problem with shockwaves. The new method produced results very close to the most accurate (but slow) simulations, proving it can handle chaotic, high-speed physics.

The Bottom Line

This paper presents a tool that builds fast, simplified models of complex physics. Unlike other tools that are either too rigid or too mysterious, this tool:

Listens to what you know: It lets you bake known physics (like linear or quadratic rules) directly into the model.
Handles the unknown: It uses a flexible "safety net" to catch things you don't know.
Explains itself: The final model looks like a standard physics equation, so you can understand why it predicts what it does.
Measures its own mistakes: It comes with a built-in ruler to tell you how accurate it is.

It's a way to get the speed of a sketch, the accuracy of a photograph, and the clarity of a textbook explanation, all without needing to see the original, complex "supercomputer" code.

Technical Summary: Interpretable and Flexible Non-Intrusive Reduced-Order Models Using Reproducing Kernel Hilbert Spaces

Problem Statement

Large-scale numerical simulations, often referred to as Full-Order Models (FOMs), are essential for engineering design but are frequently computationally prohibitive for many-query tasks such as uncertainty quantification and design optimization. Model reduction techniques aim to construct low-dimensional Reduced-Order Models (ROMs) that approximate FOM dynamics efficiently.

While classical projection-based ROMs (e.g., Proper Orthogonal Decomposition, POD) are rigorous and often come with error bounds, they require "intrusive" access to the FOM code to project governing equations, which is often impossible with legacy or commercial software. Non-intrusive alternatives, such as Operator Inference (OpInf) and neural network-based approaches, learn dynamics from snapshot data without accessing the FOM code. However, these methods face trade-offs:

OpInf produces interpretable, structured ROMs (e.g., polynomial) but relies on least-squares regression for specific function spaces and lacks rigorous, computable a posteriori error bounds.
Neural Network (NN) approaches offer flexibility but often result in "black-box" models that lack interpretability and physical structure.
Latent Space Dynamics Identification (LaSDI) attempts a hybrid but struggles to preserve the intrinsic structure of the FOM when using autoencoders.

There is a need for a non-intrusive framework that is interpretable (mirroring FOM structure), flexible (handling unknown or partial structures), and capable of providing computable error bounds.

Methodology

The authors propose "Kernel ROMs," a non-intrusive framework that utilizes regularized kernel interpolation within a Reproducing Kernel Hilbert Space (RKHS) to learn reduced-order dynamics.

1. Dimension Reduction and Data Preparation

The method begins by projecting FOM snapshot data onto a low-dimensional latent space using either:

Linear Subspaces: Via Proper Orthogonal Decomposition (POD).
Quadratic Manifolds (QM): Using a greedy-optimal approach to capture curvature in the data, defined by a decompression map $g(\tilde{q}) = \bar{q} + V\tilde{q} + W[\tilde{q} \otimes \tilde{q}]$ .

The reduced state $\hat{q}(t)$ and its time derivative $\dot{\hat{q}}(t)$ (approximated via finite differences or projected FOM derivatives) serve as the training data pairs $(\hat{q}, \dot{\hat{q}})$ .

2. Kernel Interpolation for Dynamics Learning

Instead of solving a least-squares regression for polynomial coefficients (as in OpInf), the method seeks a function $\hat{f}$ in a user-defined RKHS $\mathcal{H}_K$ that minimizes the residual between the predicted and observed time derivatives, regularized by the RKHS norm:
$\hat{f} = \arg \min_{s \in \mathcal{H}_K} \sum \|\dot{\hat{q}} - s(\hat{q})\|_2^2 + \gamma \|s\|_{\mathcal{H}_K}^2$
By the Representer Theorem, the solution takes the form $\hat{f}(\hat{q}) = \Omega^T K(\hat{Q}, \hat{q})$ , where $\Omega$ is a coefficient matrix derived from the training data and the kernel matrix.

3. Kernel Design for Structure and Flexibility

The core innovation lies in the selection of the kernel $K$ to control the ROM's structure:

Feature Map Kernels (Interpretable): If the FOM structure is known (e.g., linear-quadratic), a feature map $\phi$ is chosen to induce a kernel $K(x, x') = \phi(x)^T G \phi(x')$ . This forces the learned ROM to share the exact algebraic structure of the intrusive projection-based ROM (e.g., preserving polynomial terms), ensuring interpretability without needing FOM operators.
Radial Basis Function (RBF) Kernels (Flexible): If the structure is unknown, general-purpose RBF kernels are used to model arbitrary nonlinearities.
Hybrid Approach: A sum of a feature map kernel and an RBF kernel allows the model to capture dominant known structures while using the RBF term as a "closure" for unknown or complex nonlinearities. This balances computational efficiency (feature maps are independent of training set size) with flexibility.

4. Error Analysis

The paper derives a computable a posteriori error bound (Theorem 5.1) that combines standard intrusive ROM error estimates with kernel interpolation error bounds (specifically the power function bound). This bound relates the FOM solution, the intrusive ROM solution, and the Kernel ROM solution, providing a theoretical guarantee on the approximation quality.

Key Contributions

Non-Intrusive, Interpretable ROMs: The framework constructs ROMs that explicitly mirror the structure of intrusive projection-based models (e.g., linear, quadratic, quartic) using feature map kernels, overcoming the "black-box" nature of neural networks and the structural limitations of standard OpInf.
Flexibility via Hybrid Kernels: The method introduces a hybrid kernel strategy that combines structural priors (feature maps) with generic nonlinear approximators (RBFs), effectively incorporating closure terms for unknown dynamics.
Computable Error Bounds: The authors derive a rigorous a posteriori error bound for non-intrusive Kernel ROMs, a feature largely absent in existing non-intrusive literature. This bound also yields a new error estimate for intrusive Quadratic Manifold ROMs.
Unified Framework: The approach unifies linear (POD) and nonlinear (QM) dimension reduction under a single kernel interpolation paradigm.

Numerical Results

The method was validated on three numerical experiments:

1D Advection-Diffusion Equation (Linear):
- Kernel ROMs (both Feature Map and Hybrid) matched the performance of intrusive projection-based ROMs and OpInf.
- The computed error bounds successfully bounded the true error without significant overestimation.
- The analysis showed that the "closure" term (RBF) in hybrid models could be negligible when the feature map was optimal, but significant when the model form was mismatched.
1D Viscous Burgers' Equation (Nonlinear):
- For advection-dominated problems with sharp gradients, Kernel ROMs performed comparably to OpInf and projection errors.
- Quadratic Manifold (QM) ROMs showed diminishing returns over POD in this specific non-intrusive setting, likely due to the difficulty of stabilizing QM ROMs without intrusive access.
- Error bounds again held, with the analysis suggesting that large error contributions from the kernel term ( $\alpha_K$ ) could indicate a suboptimal choice of feature map.
2D Euler–Riemann Problem (Hyperbolic Conservation Laws):
- This challenging problem involved discontinuities and slow singular value decay.
- Kernel ROMs (Feature Map, RBF, and Hybrid) achieved errors within a few percent of the projection error.
- QM ROMs required very large regularization parameters to remain stable, and their performance did not significantly exceed POD, highlighting the challenges of applying QM to highly discontinuous flows in a non-intrusive setting.

Significance and Claims

The paper claims that Kernel ROMs offer a novel, entirely data-driven framework that successfully bridges the gap between the interpretability of projection-based methods and the flexibility of data-driven learning. By leveraging the mathematical properties of RKHS, the approach:

Preserves Physics: It allows users to inject known physical structures (e.g., conservation laws, polynomial forms) directly into the ROM via feature maps.
Quantifies Uncertainty: It provides a theoretical mechanism for error estimation, which is critical for certification in engineering applications.
Adapts to Complexity: The hybrid approach offers a practical solution for problems where the governing dynamics are only partially understood, using the RBF component to model unresolved physics.

The authors conclude that while the current implementation requires tuning of hyperparameters (like the shape parameter $\epsilon$ and regularization $\gamma$ ), the framework provides a robust foundation for future developments, including parameterized FOMs and greedy sampling strategies to reduce training costs.