Neural Operators for Scientific Simulation: FNO and DeepONet in 2026

A finite-element solver simulating airflow over a turbine blade can take hours per design. Change one boundary condition and you pay the full cost again, because the solver knows nothing about the run you did yesterday. Neural operators attack this waste at the root: instead of solving one partial differential equation (PDE) instance, they learn the solution map itself – the operator that takes any input field and returns the corresponding solution field – so a new instance becomes a single forward pass measured in milliseconds.

That is a genuinely different object from a normal neural network. A standard network maps a fixed-length vector to a fixed-length vector. A neural operator maps a function to a function, and because of how it is built, it keeps working when you change the grid resolution. This post explains the two architectures that defined the field – the Fourier Neural Operator and DeepONet – down to the mechanism, then shows how to wire one into a real surrogate-modeling pipeline and where the whole approach quietly breaks.

What this covers: what an operator is versus a function approximator, the FNO spectral-convolution mechanism, the DeepONet branch-trunk design, an honest FNO-versus-DeepONet trade-off matrix, training and data generation, physics-informed operators, a reference SciML surrogate pipeline, applications, and the failure modes that matter for high-stakes engineering.

Context and Background

Classical numerical solvers – finite element method (FEM), finite difference (FDM), and spectral methods – remain the gold standard for scientific simulation because they discretize the governing equations and converge to the true solution as the mesh refines. Their weakness is economic, not mathematical: each new input requires a fresh, expensive solve, and many engineering and science workflows are fundamentally many-query problems. Design optimization, uncertainty quantification (UQ), inverse problems, and real-time control all call the solver thousands of times over slightly different inputs.

Machine-learning surrogates promise to amortize that cost. Early attempts used ordinary convolutional networks trained on solver snapshots, but they inherited a crippling limitation: a CNN trained on a 64×64 grid produces garbage on a 128×128 grid, because it learned a mapping between fixed-size arrays, not between functions. The conceptual fix – operator learning – was formalized by Kovachki, Li, and collaborators in their Neural Operator framework (JMLR 2023), which unified the architectures under one theory of learning maps between function spaces. The two flagship instances arrived earlier: DeepONet from Lu et al. (2019; Nature Machine Intelligence 2021), grounded in a 1995 universal approximation theorem for operators by Chen and Chen, and the Fourier Neural Operator from Li et al. (arXiv:2010.08895, ICLR 2021). Neural operators now underpin fast weather models like FourCastNet and are an active, fast-moving corner of scientific machine learning, as recent arXiv surveys and reporting in outlets like MIT Technology Review have noted. For a data-driven weather angle, see our companion piece on AI weather forecasting models, and the broader arc in the Neural Operator survey by Kovachki et al.

What a Neural Operator Actually Is

A neural operator is a model that learns a mapping between infinite-dimensional function spaces – it takes an entire input function and returns an entire output function – and it does so in a way that is largely independent of the grid used to represent those functions. That last property, called discretization invariance or resolution independence, is the single feature that separates operator learning from an ordinary surrogate.

To make this concrete, consider Darcy flow through a porous medium. The input is a permeability field a(x) defined over a spatial domain; the output is the pressure field u(x) that solves the governing elliptic PDE. A neural operator learns the map G: a -> u for the whole family of permeability fields at once. Feed it a permeability field it has never seen and it returns the pressure field directly, no iterative solve required.

An operator maps functions, not vectors

The distinction matters more than it first appears. A plain network f: R^n -> R^m is tied to the dimensions n and m. Sample your input function at more points and n changes, so the trained network no longer applies. An operator G is defined on functions, and its discretized implementation is designed so the same learned parameters act correctly whether you sample the function at 1,000 points or 100,000. You train the map once, at whatever resolution your data came in, and query it at another.

Discretization invariance and zero-shot super-resolution

Because the operator approximates the underlying continuous map, a well-built neural operator can be trained on coarse data and evaluated on a finer grid, producing a plausible higher-resolution solution it never saw during training. This zero-shot super-resolution is not magic – it works because the model learned the operator’s structure rather than memorizing pixel arrays – and it fails gracefully rather than catastrophically when the target resolution introduces frequencies the training data could not contain. This is the practical litmus test that tells a true neural operator apart from a CNN surrogate wearing operator clothing.

Why this beats a plain CNN surrogate

A CNN’s convolution kernel has a fixed physical footprint tied to the training grid spacing. Refine the grid and each kernel now covers a smaller physical region, so the receptive field shrinks and long-range physical dependencies are lost. Neural operators are built from kernel integral operators whose action is defined continuously, sidestepping this coupling. The Fourier Neural Operator takes the most elegant route to a global kernel, which is where we turn next.

The Fourier Neural Operator Mechanism

The Fourier Neural Operator (FNO) replaces the expensive global convolution of an operator layer with an element-wise multiplication in the Fourier domain, giving every layer a global receptive field at a fraction of the parameter cost. In one sentence: lift the input to many channels, transform to frequency space with an FFT, keep only the lowest few modes, multiply them by learnable complex weights, transform back, add a pointwise linear residual, and apply a nonlinearity.

Figure 1: One Fourier layer of a neural operators FNO block. The upper path performs a global spectral convolution by truncating to the lowest k Fourier modes and multiplying by learnable complex weights; the lower path is a local pointwise linear term; the two are summed and passed through a nonlinearity.

Figure 1 traces a single Fourier layer. The input feature function is first lifted by a pointwise linear map into a higher channel dimension – this gives the layer room to represent richer features. The lifted field goes down two parallel paths. The upper path applies a fast Fourier transform, truncates the spectrum to the lowest k modes, multiplies those retained modes by a learned complex weight tensor, and applies an inverse FFT to return to physical space. The lower path applies a simple pointwise linear transform (a residual or skip term that preserves local, high-frequency information the truncation discards). The two paths are summed and passed through a nonlinear activation. Stacking several such layers between a lifting layer and a projection layer gives the full FNO.

Global convolution as spectral multiplication

The mathematical backbone is the convolution theorem: convolution in physical space equals multiplication in Fourier space. A global convolution kernel spanning the whole domain would be enormous to store and slow to apply directly. By moving to the frequency domain, the FNO turns that global convolution into a cheap element-wise product. Each retained Fourier mode gets its own learnable complex weight, and because every mode is a global basis function, a single multiplication couples information across the entire domain at once. This is the source of the FNO’s long-range modeling power.

Mode truncation is the whole trick

Keeping only the lowest k modes is not a compromise forced by compute – it is a deliberate design choice with two payoffs. First, parameter efficiency: the number of learnable spectral weights scales with k, not with grid size, which is why the same FNO weights transfer across resolutions. Second, it acts as a smoothness prior, filtering out high-frequency noise that would otherwise be fitted spuriously. The cost is a built-in spectral bias (also called frequency bias): the model preferentially learns smooth, low-frequency structure and struggles to reproduce sharp gradients, shocks, and fine turbulent detail. Recent work on spectral boosting and residual high-frequency branches exists precisely to claw that detail back.

Grids, geometry, and the FNO variant zoo

Vanilla FNO assumes data on a regular, ideally periodic grid, because the FFT it relies on does. That assumption is fine for many climate and homogeneous-media problems and awkward for complex engineering geometries. A family of variants relaxes it: Geo-FNO deforms irregular domains into a uniform latent grid; factorized or F-FNO reduces cost in higher dimensions; adaptive and tensorized FNOs target 3D problems; and the Spherical FNO (SFNO) respects the geometry of the globe for weather and climate, where a flat-grid FFT would distort the poles. Choosing the right variant for your geometry matters as much as tuning the mode count.

The DeepONet Mechanism

DeepONet takes a completely different route to operator learning: it splits the job between two networks – a branch net that encodes the input function and a trunk net that encodes the coordinate where you want the output – and combines them with a dot product. This design is not a heuristic; it is a direct realization of the universal approximation theorem for operators proved by Chen and Chen in 1995, which guarantees that a sufficiently large branch-trunk network can approximate any continuous operator.

Figure 2: The DeepONet branch-trunk design used in neural operators. The branch net ingests the input function sampled at fixed sensor locations; the trunk net ingests a single query coordinate; the two feature vectors are combined by a dot product plus a bias to predict the output at that coordinate.

Figure 2 shows the split. The branch network reads the input function u, sampled at a fixed set of sensor points, and produces a feature vector [b1 ... bp]. The trunk network reads a single query coordinate y – the location where you want to know the output – and produces its own feature vector [t1 ... tp]. The predicted output value at y is the dot product of the two vectors plus a bias. To evaluate the solution at many coordinates you reuse the branch output and only re-run the trunk, which makes DeepONet naturally suited to querying scattered, arbitrary points.

Branch, trunk, and the dot product

The elegance is in the factorization. The trunk net effectively learns a set of p global basis functions of the coordinate y, and the branch net learns the coefficients of those basis functions as a function of the input u. Reconstructing the output is then just a linear combination – a learned, nonlinear analog of a spectral expansion. This is why DeepONet is often described as learning a data-driven basis: the trunk supplies the basis, the branch supplies the coordinates in that basis for each input function.

Sensors, meshes, and flexible output

DeepONet’s practical signature is decoupling. The input is fixed to sensor locations, but the output can be queried anywhere in the domain, at any resolution, on any point cloud – the trunk simply takes whatever coordinate you hand it. That makes DeepONet a strong fit for problems on irregular geometries, for outputs on meshes that differ from the input discretization, and for cases where you only need the solution at a handful of points. The flip side is sensor dependence: the branch expects the input function at the same sensor points it trained on, so changing the input sampling means retraining or interpolating.

POD-DeepONet and physics-informed variants

Several refinements improve the base model. POD-DeepONet replaces the learned trunk basis with a proper orthogonal decomposition (POD) basis computed from the training data, which often improves accuracy and interpretability by giving the trunk a physically meaningful set of modes. Physics-informed DeepONet adds a PDE-residual term to the loss so the operator respects the governing equations even where labeled data is thin – the same idea that motivates the physics-informed neural operator discussed below.

FNO vs DeepONet vs Classical Solver vs PINN

There is no universally best method; the right tool depends on grid regularity, output flexibility, data availability, and how much you need guaranteed accuracy. The matrix below summarizes the trade-offs that actually drive the decision in practice. Treat the accuracy and speed entries as qualitative – real numbers depend heavily on the specific PDE and data budget.

Dimension	Fourier Neural Operator	DeepONet	Classical solver (FEM/FDM)	PINN
What it learns	Operator, whole solution field	Operator, value at query points	Single PDE instance	Single PDE instance (or small family)
Input geometry	Regular/periodic grid best; variants for irregular	Fixed sensor points, flexible output mesh	Any mesh	Any, mesh-free
Output flexibility	Grid-tied per forward pass	Arbitrary query coordinates	Mesh nodes	Any coordinate
Discretization invariance	Yes (mode-based)	Partial (output flexible, input fixed)	N/A (re-mesh, re-solve)	N/A
Inference speed	Milliseconds	Milliseconds	Minutes to hours	Fast at inference, slow to train per instance
Training data	Solver-generated pairs, data-hungry	Solver-generated pairs, data-hungry	None (it is the ground truth)	Little/no data; uses PDE residual
Accuracy guarantees	None; surrogate	None; surrogate	Convergent, verifiable	Soft (residual), no hard guarantee
Spectral/frequency bias	Strong (mode truncation)	Milder, basis-dependent	None	Present (smoothness bias)
Best fit	Many-query, homogeneous, periodic problems	Scattered outputs, irregular geometry	Single high-stakes verified solve	One-off inverse/forward with known physics, sparse data

Read the matrix as a routing table, not a leaderboard. A PINN solves one instance by minimizing the PDE residual and needs little or no data, but it must be retrained for each new input, so it is not a fast many-query surrogate – it is closer to a mesh-free solver. FNO and DeepONet are the many-query specialists: pay a large upfront training cost, then amortize it over thousands of cheap inferences. The classical solver remains the arbiter of truth that generates their training data and validates their outputs.

Figure 3: A reference scientific machine learning pipeline built on neural operators. A classical solver generates paired data, the operator is trained with optional PDE-residual loss and validated against held-out solver runs, then deployed as a fast surrogate inside design-optimization and uncertainty-quantification loops with periodic solver spot-checks.

Training a Neural Operator End to End

Training a neural operator is a supervised regression problem over function pairs, and most of the engineering effort goes into data generation, normalization, and choosing a loss that respects the physics. Figure 3 shows the full loop; this section walks its stages.

Generating data from solvers

The training set is pairs of input functions and their solver-computed solutions. You choose a distribution over inputs – random permeability fields drawn from a Gaussian random field, random initial conditions, or a sweep over boundary conditions and material parameters – and run a trusted FEM, FDM, or spectral solver on each sample to produce the target. Two decisions dominate quality. First, the input distribution must cover the region of function space you intend to query later, because neural operators extrapolate poorly beyond their training distribution. Second, the solver resolution sets an accuracy ceiling: the operator can be no more accurate than the data it learned from, and any solver discretization error is baked in as label noise.

Losses, normalization, and metrics

The standard objective is a relative L2 loss over the whole output field rather than a mean squared error, because relative error is scale-invariant and comparable across problems with different magnitudes. Normalizing inputs and outputs to zero mean and unit variance (Gaussian normalization) per channel is close to mandatory for stable training, and the statistics must be computed on the training set only. Because operators output whole fields, report field-level metrics – relative L2, maximum pointwise error, and spectral error broken down by frequency band – not a single scalar, since a low average error can hide a badly wrong shock front. When the model will run autoregressively in time, evaluate rollout error over many steps, because single-step accuracy badly overstates long-horizon reliability.

The discretization-invariance test

Before trusting a neural operator, verify the property that justifies using one: train at one resolution, evaluate at a higher resolution the model never saw, and confirm the error stays bounded. A true operator degrades gracefully; a disguised CNN surrogate diverges. This zero-shot super-resolution check is cheap and is the most informative single diagnostic you can run. It also reveals spectral bias directly – the error will concentrate in exactly the high-frequency bands the mode truncation discarded.

Physics-Informed Neural Operators

Physics-informed training embeds the governing PDE directly into the loss, so the operator is penalized for violating the equation – not just for disagreeing with data – which sharply reduces how much labeled data it needs and improves generalization. The Physics-Informed Neural Operator (PINO) of Li et al. (2021) is the canonical example, marrying the operator-learning backbone of FNO with the PDE-residual philosophy of PINNs.

The mechanics are straightforward in principle. Alongside the usual data-fitting term, you add a residual term that plugs the operator’s predicted field back into the PDE and measures how badly the equation is violated at collocation points. Computing that residual requires spatial derivatives of the output; on the regular grids FNO uses, these can be evaluated efficiently in the Fourier domain via spectral differentiation, which is both accurate and cheap. The combined loss lets PINO learn from a mix of abundant physics and scarce data – useful when high-fidelity solver runs are expensive to generate.

The payoff is better extrapolation and data efficiency; the caveat is that a residual penalty is a soft constraint, not a hard guarantee. The trained operator will approximately satisfy the PDE where you placed collocation points, and can still violate conservation laws or drift outside that region. Physics-informed training narrows the trust gap; it does not close it. This is a recurring theme in scientific machine learning, and it echoes the accuracy-versus-guarantee tension we cover in machine learning interatomic potentials, where learned surrogates likewise trade rigor for speed.

Deploying Operators as Surrogates: A Reference Pipeline

The point of a neural operator is rarely a single prediction; it is to serve as a fast inner loop inside an outer workflow – design optimization, uncertainty quantification, or inverse problems – that would be infeasible with a classical solver in the loop. Figure 3 lays out the reference pipeline that most production SciML surrogates follow.

The flow has four stages. First, a classical solver generates a curated dataset of input-output pairs across the design or parameter space you care about. Second, the operator is trained and validated against held-out solver runs, with the discretization-invariance and rollout checks above acting as gates – if validation error exceeds tolerance, you return to training, often with more or better-distributed data. Third, the validated operator is deployed as a surrogate and called thousands of times inside the outer loop: a gradient-based shape optimizer that needs the flow field for each candidate design, or a Monte Carlo UQ sweep that propagates input uncertainty through the operator to get an output distribution. Fourth – and this is the stage teams skip at their peril – you periodically spot-check surrogate predictions against the real solver, especially near the optimum the outer loop is driving toward, because that is exactly where the search pushes into thin, under-sampled regions of training space.

Where the speedup comes from and where it does not

The headline is real: once trained, a neural operator returns a full solution field in milliseconds where the solver took minutes to hours – orders-of-magnitude speedups that turn overnight design sweeps into interactive ones. But the speedup is only free after you have paid two costs the headline omits: the one-time data-generation cost (thousands of solver runs) and the training cost. Neural operators pay off precisely when the number of downstream queries is large enough to amortize that upfront investment. For a one-off simulation, the classical solver is still both faster overall and correct by construction.

Uncertainty quantification for trust

Because a surrogate has no built-in error bars, high-stakes deployments increasingly wrap the operator in an uncertainty-quantification layer. Recent 2025-2026 work applies conformal prediction to neural operators to produce distribution-free, statistically valid prediction sets around each output, giving downstream users a calibrated sense of when to trust the surrogate and when to fall back to the solver. Ensembles of operators and Bayesian last-layer approaches serve a similar role. UQ does not fix a wrong model, but it flags the inputs where the model is least sure – typically the out-of-distribution cases where surrogates fail silently.

Applications Across Science and Engineering

Neural operators have moved from PDE benchmarks to production-adjacent use across weather, fluids, subsurface, and design, wherever a solver is accurate but too slow for the query volume. The clearest win is weather and climate: FourCastNet, built on the FNO/AFNO family, and the later Spherical FNO produce global forecasts in a fraction of the time a numerical weather prediction model needs, which is why data-driven forecasting has become a serious field – a topic we cover in depth in AI weather forecasting models.

Beyond weather, neural operators are used as turbulence and computational-fluid-dynamics surrogates for rapid aerodynamic evaluation, as fast seismic-wavefield models for imaging and earthquake studies, and in subsurface applications such as carbon-storage and reservoir simulation where each classical solve is punishingly expensive. In materials and engineering design, operators act as the fast physics evaluator inside optimization loops, and they increasingly connect to the broader trend of large pretrained models for the sciences – see our overview of scientific foundation models. The common thread is the many-query regime: the operator earns its keep only when the same expensive physics must be evaluated over and over.

The 2025-2026 research frontier is active on several fronts, which recent arXiv surveys frame as one of the fastest-moving areas of SciML. Decomposed and tensorized FNOs push operator learning into full 3D problems that were previously memory-prohibitive. Spectral-boosting methods target the frequency bias head-on to recover fine detail. Temporal neural operators specialize in time-dependent PDEs with more stable rollouts, and transformer-based operators bring attention mechanisms to operator learning for irregular data and long-range coupling. None of these are settled; the field is still converging on what works.

Trade-offs, Gotchas, and What Goes Wrong

Neural operators are surrogates, and every failure mode traces back to that fact: they approximate a solver from data and offer no correctness guarantees, so they break in the ways learned models always break. The most dangerous failure is out-of-distribution extrapolation. Push an operator to inputs unlike its training set – a permeability contrast beyond what it saw, an off-design flow regime – and it returns a confident, plausible-looking, and wrong answer. There is no internal signal that says “I have not seen this”; that is what the UQ wrapper and solver spot-checks are for.

Autoregressive error accumulation is the second trap. Time-dependent problems are often solved by feeding the operator’s output back as its next input. Small per-step errors compound, and a rollout that looks excellent for ten steps can diverge into physically absurd states by a hundred. Single-step metrics hide this completely, so long-horizon rollout evaluation is non-negotiable for temporal models.

Third, spectral bias means FNOs systematically under-resolve sharp features – shocks, boundary layers, fine turbulence – because mode truncation discards exactly those frequencies. If your physics lives in the high-frequency tail, a vanilla FNO will smooth it away, and you need spectral-boosting variants or a hybrid scheme that hands fine scales to a solver. Fourth, conservation laws (mass, energy, momentum) are not respected unless explicitly constrained; a physics-informed loss makes violations smaller but not zero, which matters when downstream analysis assumes exact conservation.

Finally, the practical gotchas: neural operators are data-hungry, and generating the solver data can cost more than it saves for small query budgets; irregular geometries and complex boundary conditions remain hard and often need specialized variants or careful domain mappings; and for regulated, high-consequence engineering – aircraft certification, nuclear safety – the absence of verifiable error bounds means a learned operator can accelerate exploration but cannot yet replace a verified solver in the sign-off loop. Treat the operator as a fast scout, not the final authority.

Figure 4: A selection decision flow for neural operators. Regular-grid and periodic problems favor FNO and its geometry variants; needs for output at arbitrary scattered points favor DeepONet; very-high-frequency detail argues for spectral boosting or a hybrid solver, and scarce data argues for adding a physics-residual loss either way.

Practical Recommendations

Choose a neural operator only when you face a genuine many-query problem, then match the architecture to your data geometry and validate ruthlessly against the solver you are trying to replace. Figure 4 encodes the routing: regular or periodic grids point to FNO and its variants; arbitrary output locations or mismatched input/output meshes point to DeepONet; sharp high-frequency physics argues for spectral-boosting variants or a solver hybrid; and scarce data argues for adding a physics-residual loss regardless of backbone.

Before committing engineering time, work through this checklist:

Confirm the many-query economics. Estimate downstream query count and compare against the combined data-generation plus training cost. If you will query a few dozen times, use the solver.
Cover the input distribution. Sample training inputs across the full region you will later query; operators fail on out-of-distribution inputs.
Run the discretization-invariance test. Train coarse, evaluate fine, and confirm bounded error before trusting the model as an operator.
Evaluate rollouts, not single steps, for any time-dependent deployment, and watch for divergence over long horizons.
Report field-level and spectral metrics, not just mean error, so you catch missed shocks and high-frequency structure.
Wrap deployment in UQ and solver spot-checks, especially near the optima that outer optimization loops drive toward.
Add a physics-residual loss (PINO-style) when data is scarce, and remember it is a soft constraint, not a guarantee.

Start with a published benchmark problem (Darcy flow, Burgers, Navier-Stokes at modest Reynolds number) to build intuition before applying an operator to your own PDE, and keep the classical solver in the loop as the source of truth throughout.

Frequently Asked Questions

What is the difference between a neural operator and a normal neural network?

A normal neural network maps a fixed-length input vector to a fixed-length output vector, so it is tied to the exact dimensions it trained on. A neural operator maps a function to a function – an entire input field to an entire solution field – and is built to be discretization-invariant, meaning you can train it on one grid resolution and evaluate it on another. That resolution independence, enabling zero-shot super-resolution, is the defining property. It is why an operator can learn a PDE solution map that generalizes across grids, while a plain CNN surrogate breaks when the grid changes.

How does a Fourier Neural Operator work?

An FNO stacks Fourier layers between a lifting layer and a projection layer. Each Fourier layer transforms its input to the frequency domain with an FFT, truncates to the lowest few Fourier modes, multiplies those modes by learnable complex weights, and applies an inverse FFT – performing a global convolution as a cheap element-wise multiplication. A parallel pointwise linear term is added back to preserve local detail, and a nonlinearity follows. Truncating to low modes gives parameter efficiency and resolution transfer but introduces a spectral bias against high-frequency features.

When should I use DeepONet instead of FNO?

Prefer DeepONet when you need the solution at arbitrary, scattered query points rather than on a regular grid, when your input and output live on different meshes, or when the geometry is irregular. DeepONet’s trunk network takes any coordinate, so evaluating at new points is trivial. Prefer FNO when your data sits on a regular, ideally periodic grid and you want the full field fast, since its FFT-based spectral convolution is highly efficient there. In practice, grid regularity and output-location flexibility are the two questions that decide it.

Are neural operators accurate enough to replace physics solvers?

Not as a general replacement. Neural operators are learned surrogates with no built-in correctness guarantees, and they fail on out-of-distribution inputs, accumulate error in long time-rollouts, and can violate conservation laws unless explicitly constrained. They excel as fast inner loops in many-query workflows – design optimization, uncertainty quantification, real-time estimation – where you accept approximate answers and validate against a classical solver. For high-stakes engineering sign-off that needs verifiable error bounds, the classical solver remains the authority; the operator accelerates exploration around it.

What is a physics-informed neural operator?

A physics-informed neural operator (PINO) adds the governing PDE’s residual to the training loss, so the model is penalized for violating the equation in addition to disagreeing with data. This reduces the amount of labeled solver data needed and improves generalization, since the physics constrains regions where data is sparse. On the regular grids FNO uses, the required derivatives can be computed efficiently by spectral differentiation. The residual is a soft constraint, however – the trained operator only approximately satisfies the PDE and can still drift, so it narrows but does not eliminate the trust gap.

Why do FNOs struggle with sharp or high-frequency features?

Because an FNO keeps only the lowest few Fourier modes and discards the rest, it inherently band-limits its output. Sharp gradients, shock fronts, and fine turbulent structure live in the high-frequency modes that truncation removes, so the model smooths them away – a phenomenon called spectral or frequency bias. The pointwise linear residual term recovers some local detail, but not all. When high-frequency physics is essential, practitioners use spectral-boosting variants, add high-frequency branches, or hand the fine scales to a classical solver in a hybrid scheme.

Neural Operators for Scientific Simulation: FNO & DeepONet (2026)