🤖 machine learning

Stability and Discretization Error of State Space Model Neural Operators

This paper establishes theoretical guarantees for the discretization error and stability of State Space Model-based and Fourier Neural Operators by deriving analytical bounds that link solution regularity to input discretization and validating these findings through empirical experiments on 1D and 2D benchmarks.

Original authors: Abderrahim Bendahi, Adrien Fradin, Johan Peralez, Julie Digne, Madiha Nadri

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Abderrahim Bendahi, Adrien Fradin, Johan Peralez, Julie Digne, Madiha Nadri

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 teach a computer to predict how water flows through a pipe, or how heat spreads through a metal rod. In the real world, these things happen continuously—smoothly and without breaks. But computers are digital; they only understand grids, like a chessboard made of tiny squares. To make a computer solve these problems, we have to chop the smooth world into these little squares. This process is called discretization.

For a long time, scientists have built "Neural Operators"—special AI models designed to learn these continuous flows. They work amazingly well, but there's been a missing piece of the puzzle: We didn't have a strict mathematical rulebook explaining exactly how much error is introduced when we chop that smooth world into digital squares, or how stable the model stays when we do.

This paper, by Bendahi and colleagues, fills that gap. They focus on a specific type of AI called State Space Model Neural Operators (SS-NOs). Here is what they found, explained simply:

1. The "Smooth vs. Pixelated" Problem

Think of a continuous function (like a smooth river) as a high-resolution photograph. A computer sees this as a grid of pixels.

The Old Way: We knew the AI could learn the picture, but we weren't sure how blurry the picture would get if we lowered the resolution (made the pixels bigger).
The New Discovery: The authors proved a mathematical "rule of thumb." They showed that the error (the blurriness) depends on two things:
1. How smooth the original river is (is it calm water or choppy waves?).
2. How fine your grid is.
  They proved that if your input is smooth enough, the error shrinks predictably as you make the grid finer. It's like saying, "If you double the number of pixels, the picture gets twice as clear," but with a specific mathematical formula for how clear it gets.

2. The "Domino Effect" of Errors

Neural networks are like a stack of layers. The output of the first layer becomes the input for the second, and so on.

The Fear: If a tiny error happens in the first layer, does it get magnified into a huge disaster by the last layer?
The Guarantee: The authors proved that for SS-NOs, the system is stable. They showed that even if you have a stack of many layers, the errors don't explode out of control. They provided a formula that acts like a "safety cap," ensuring that the total error stays within a predictable limit, no matter how deep the network is.

3. The "Rough vs. Smooth" Activations

AI models use "activation functions" (mathematical switches that decide what information gets passed along).

The Smooth Switch: Some switches are perfectly smooth curves (like a gentle ramp).
The Rough Switch: Others are jagged, like a step function (think of a light switch that is either ON or OFF, with no in-between).
The Finding: Previous theories mostly worked for the smooth switches. This paper proved that even with the "rough" switches (like the popular ReLU function used in many AIs), the math still holds up. The model remains stable and the error bounds still apply, even if the math gets a bit "jagged" inside the network.

4. The "Noise" Test

In the real world, your data might be a little noisy (like a photo taken in the dark).

The authors tested what happens if you feed the model a slightly "noisy" or imperfect input.
They proved that the model is Input-to-State Stable (ISS). In plain English: If you wiggle the input a little bit, the output will only wiggle a little bit. It won't go crazy. This is crucial for real-world applications where data is never perfect.

5. The Experiments (The "Proof in the Pudding")

They didn't just write equations; they tested it.

They ran simulations in 1D (like a line) and 2D (like a flat surface).
They used different types of "inputs" (some very smooth, some a bit rough).
The Result: The actual errors they saw in the computer matched their mathematical predictions perfectly. When they made the grid finer, the error dropped exactly as their formulas said it would. Even when they made the network very deep (many layers), it stayed stable.

Summary Analogy

Imagine you are trying to copy a smooth, flowing river onto a grid of graph paper.

The Paper's Contribution: They wrote a manual that tells you exactly how much the river's shape will distort based on the size of your graph paper squares. They also proved that if you have a chain of people passing the drawing down the line (the layers of the AI), the drawing won't get ruined, even if the paper is a bit rough or the people are a bit shaky.
The Takeaway: We now have a solid theoretical foundation that says, "Yes, these AI models are reliable, and here is exactly how to calculate their accuracy and stability when we turn them into digital code."

This work is purely about the mathematics of reliability for these specific AI models. It ensures that when we use them to solve complex physics problems, we know exactly how much trust we can put in the numbers they give us.

Title: Stability and Discretization Error of State Space Model Neural Operators

Problem Statement
Neural operators (NOs) have emerged as a powerful framework for solving partial differential equations (PDEs) by learning mappings between infinite-dimensional function spaces. While architectures like DeepONet and Fourier Neural Operators (FNOs) have demonstrated universal approximation capabilities and algebraic convergence rates, a precise theoretical connection between their continuous formulations and discrete numerical implementations remains under-explored. Specifically, the relationship between continuous theory and discrete numerical stability, particularly for State Space Model-based Neural Operators (SS-NOs), lacks rigorous quantification. Existing analyses often focus on the continuous setting or provide discretization error bounds only for FNOs, leaving a gap in understanding how discretization affects the accuracy and stability of SS-NOs, which utilize different kernel parameterizations (damped oscillatory components vs. hard frequency truncation).

Methodology
The authors establish a rigorous continuous-to-discrete theory for convolution-based neural operators, with a specific focus on SS-NOs. The methodology involves three primary theoretical pillars:

Continuous Stability Analysis: The authors prove Lipschitz stability for deep SS-NO architectures in infinite-dimensional Hilbert spaces ( $L^2(\mathbb{T}^d)$ ). They derive explicit Lipschitz constants dependent on model parameters (weights, biases, and kernel norms) by analyzing the integrability of SS-NO kernels. This analysis confirms that continuous SS-NO layers define stable nonlinear operators.
Discretization Error Derivation: The paper derives explicit error bounds linking the continuous operator to its discrete numerical implementation (using grid quadrature).
- Kernel Analysis: The authors characterize the Fourier transforms of FNO and SS-NO kernels. They highlight that FNO kernels have compact spectral support due to hard truncation, whereas SS-NO kernels exhibit algebraic decay ( $O(\|\xi\|^{-1})$ ) and lack smoothness across boundaries.
- Error Bounds: Using Input-to-State Stability (ISS) analysis and Sobolev regularity assumptions, the authors derive bounds for the discretization error. These bounds account for the regularity of the input function ( $s$ ), the decay of kernel Fourier coefficients, and the regularity of the activation function. Crucially, the analysis extends to non-smooth activations (e.g., ReLU, LeakyReLU) by leveraging composition results in fractional Sobolev spaces, showing that the error bound holds under weaker assumptions than previous works.
Global Discrete Stability (ISS): The authors perform an Input-to-State Stability analysis on the discretized model. They prove a global stability bound that quantifies how input perturbations and numerical discretization errors propagate through the layers of the discretized SS-NO. This establishes that the discrete model remains a stable Lipschitz map provided the discrete operator norm of the kernel is bounded.

Key Contributions

Continuous Stability: Proof of Lipschitz stability for deep SS-NO architectures in infinite-dimensional Hilbert spaces, with explicit constants derived from model parameters.
Discretization Error Theorem: Derivation of explicit continuous-to-discrete error bounds for SS-NOs. Unlike prior FNO results, this analysis covers fractional Sobolev regularity, general convolution kernels, and non-smooth activations (ReLU). The bounds demonstrate algebraic convergence rates dependent on input smoothness and kernel spectral decay.
Discrete Stability: Proof of a global stability bound for the discretized model that incorporates both discretization error and input perturbations, formally assessing the impact of discretization on the stability of results obtained in the continuous domain.
Theoretical Extension: The work extends the theoretical framework established for FNOs (e.g., Lanthaler et al., 2025) to the SS-NO architecture, addressing the missing rigorous quantification of discretization error and numerical stability for this class of models.

Results
The theoretical findings are validated through empirical experiments on 1D and 2D benchmarks:

Discretization Error: Experiments using Gaussian Random Fields (GRFs) with varying smoothness ( $s$ ) confirm the theoretical prediction that relative $\ell^2$ error decays algebraically with increasing spatial resolution ( $N$ ). The observed convergence rates align with the theoretical exponent $\beta = d/2 - s$ (or limited by activation regularity for non-smooth functions like ReLU).
Stability: Perturbation experiments on fixed discretized SS-NO layers show that output error grows linearly with input perturbation magnitude, consistent with the derived Lipschitz stability bounds.
Depth and Training: Additional experiments on trained SS-NOs solving the 1D Burgers equation demonstrate that the discretization-scaling behavior persists after training and that increasing network depth does not induce pathological amplification of discretization errors.
Stress Testing: Experiments with under-resolved oscillatory inputs confirm that discretization error plateaus when the grid resolution is insufficient to resolve input frequencies, validating the theory's prediction of failure modes in under-resolved regimes.

Significance
The paper claims to provide a rigorous pathway for reasoning about resolution generalization and stability in neural operators. By establishing explicit error bounds and stability guarantees, the work offers a formal quantification of neural operator accuracy under real-world numerical constraints. The authors suggest these results provide principled guidelines for selecting kernels, activation functions, and network depth to control discretization effects in operator learning. The findings bridge the gap between continuous theoretical guarantees and discrete numerical implementation, ensuring that the robustness of SS-NOs is not merely empirical but theoretically grounded.