betaFeedback

WorksComputer Science

HyCOP: Hybrid Composition Operators for Interpretable Learning of PDEs

Abstract

We introduce HyCOP, a modular framework that learns parametric PDE solution operators by composing simple modules (advection, diffusion, learned closures, boundary handling) in a query-conditioned way. Rather than learning a monolithic map, HyCOP learns a policy over short programs - which module to apply and for how long - conditioned on regime features and state statistics. Modules may be numerical sub-solvers or learned components, enabling hybrid surrogates evaluated at arbitrary query times without autoregressive rollout. Across diverse PDE benchmarks, HyCOP produces interpretable programs, delivers order-of-magnitude OOD improvements over monolithic neural operators, and supports modular transfer through dictionary updates (e.g., boundary swaps, residual enrichment). Our theory characterizes expressivity and gives an error decomposition that separates composition error from module error and doubles as a process-level diagnostic.

Introduction

Scientific machine learning (SciML) is moving beyond monolithic replacement of numerical solvers. Across fluid dynamics, climate modeling, and multi-physics simulation, practitioners increasingly build hybrid pipelines that embed pretrained neural surrogates alongside classical numerical modules within larger workflows [15, 36]. Verification and validation frameworks now treat such hybrid models as a first-class category [15], recognizing that trustworthy SciML requires not only accurate components but principled ways to combine them. A central question therefore remains: given a heterogeneous collection of numerical and learned

Preprint. components, how should a scientist compose them into a surrogate that is robust, interpretable, and modular?

This paper provides one answer for a broad and practically important class of problems: spatiotemporal PDEs that admit a meaningful decomposition into constituent physical mechanisms, for example, advection–diffusion–reaction equation, shallow-water equation, Navier–Stokes equation, and many multi-physics systems with advective, viscous, and forcing splits. Traditionally, such systems have been modeled incrementally: a modeler starts with known or postulated physical mechanisms to compose processes that explains data; when the composition fails to explain the data, modelers use the pattern of failure to identify, hypothesize, or discover the missing mechanism. Monolithic neural operators discard this workflow: they learn a single black-box map from paired data, and when they fail under distribution shift, they provide little guidance on why or what to fix.

The myth of expensive numerical solvers. A common motivation for monolithic surrogates is that numerical PDE solvers are slow. But this conflates the cost of the full coupled solver with the cost of its constituent processes. The full solver is expensive because it resolves the non-commutative interaction of multiple mechanisms at fine scales. By contrast, individual process solvers—a spectral diffusion step, an upwind advection scheme, an explicit reaction update—benefit from decades of algorithmic and hardware optimization, and often run faster than a neural operator forward pass at comparable resolution. The bottleneck is not the primitives; it is knowing how to compose them.

Scientific Machine Learning Regimes

These observations motivate the central thesis: encoding a PDE’s process decomposition as a structural prior—and learning only the composition policy—yields surrogates that are more robust under shift, more interpretable, and more modular for transfer than monolithic alternatives. HyCOP is designed to address two distinct SciML needs.

Regime A: surrogate fitting (physics is known). When the governing equations are fully specified, the scientist wants a fast surrogate for downstream tasks that remains accurate as initial conditions, boundary conditions, parameters, or resolution shift at test time. HyCOP encodes each known process as a dictionary primitive and learns only the composition policy (∼\sim50–100 parameters), yielding short programs adapted to each query’s physical regime. Because each primitive generalizes independently, the composition degrades gracefully under shift. For example, a HyCOP policy trained on smooth shallow-water equations with periodic boundaries transfers zero-shot to dam-break shocks, wall boundaries, discontinuities, and parameter ranges never seen in training, outperforming monolithic baselines by 10×. Swapping the boundary primitive for a wall-boundary module, without retraining, yields a further 4× improvement (§ 6).

Compose–diagnose–enrich workflow

Figure 1. Compose–diagnose–enrich. HyCOP’s workflow for incomplete or hybrid physics (§ 6.2).

Regime B: adaptation and discovery (physics is incomplete or heterogeneous). When the process decomposition is only partially known, or when components come from different sources, HyCOP supports a compose–diagnose–enrich loop (Figure 1). We demonstrate two complementary use cases on the same AD→\toADR benchmark:

(a) Unknown missing physics. A scientist models advection–diffusion (AD) but encounters ADR data. Composing the AD dictionary produces structured failure: errors concentrate where reaction dominates. A residual closure (UNO) trained on the discrepancy is added to the dictionary, and relearning only the policy recovers accuracy while revealing where the closure activates.

(b) Known missing physics, heterogeneous primitives. A lab already has a pretrained AD surrogate, and new data reveals missing reaction that is well characterized. HyCOP composes the pretrained AD surrogate (learned primitive) with a textbook reaction solver (numerical primitive), learning a policy over this hybrid dictionary without retraining either component.

Both paths arrive at a hybrid dictionary—numerical and learned components orchestrated by a small policy—but from different scientific starting points. This is why “Hybrid” appears in the title.

Monolithic neural operators are therefore not replaced by this framework, but absorbed into it: as expensive constituent processes in Regime A, or as learned primitives modeling missing physics in Regime B. HyCOP orchestrates heterogeneous building blocks rather than competing with them.

Our contributions (overview in Figure 2).

HyCOP at a glance

Figure 2. HyCOP at a glance. (a) A small learned policy πθ\pi_\theta (∼50\sim50–100100 parameters) maps a query x=(u0,μ,T)x=(u_0,\mu,T) to a program of (primitive, duration) pairs from dictionary D\mathcal{D}, composed over [0,T][0,T] to produce u^(T)\hat{u}(T); programs adapt to the regime (walkthrough in § 3.1). (b) Each primitive can be numerical, learned, or both, enabling hybrid dictionaries (§ 6.2.1). (c) πθ\pi_\theta smoothly reallocates time with regime numbers, consistent with dominant-process physics. (d) The framework applies across PDE systems (coverage: Table 6; results: § 5, Appendix § 11).

SystemNonlinearMultiphysicsMultiscaleChaoticLong-time
(Benchmarked)
1D Advection–Diffusion (AD)–✓✓–✓
1D Viscous Burgers✓–✓–✓
1D Shallow Water (smooth ICs)✓✓✓–✓
2D ADR (Fisher–KPP)✓✓✓–✓
2D SWE (smooth / vortices)✓✓✓–✓
2D Compressible Navier–Stokes✓✓✓–✓
Dam-break SWE (transfer)✓✓✓–✓
(Validated)
1D Kuramoto–Sivashinsky (KS)✓–✓✓✓

Table 6. Benchmark coverage and validation tests.

  1. Framework. We introduce HyCOP, a modular framework that learns PDE solution operators as query-conditioned compositions of reusable primitives—numerical, neural, or learned closures—supporting hybrid dictionaries and multi-time prediction without autoregressive rollout (§ 3).

  1. Theory. We introduce compositional operator flows as a new hypothesis class and provide the first learning-theoretic analysis of learned query-conditioned compositions, including an error decomposition that separates splitting error from primitive error and doubles as a diagnostic (§ 4).

  1. Experiments. Across five benchmarks including 2D Navier–Stokes, HyCOP delivers order-of-magnitude OOD improvements over state-of-the-art monolithic baselines, with more than 25×25\times fewer training forward passes and over 10×10\times shorter wall-clock training time (§ 5).

  1. Modularity. HyCOP supports zero-shot adaptation through dictionary updates: on the dam-break experiment, the learned policy alone handles OOD shock initial conditions and a 100×100\times larger grid, while swapping the boundary primitive resolves the remaining boundary mismatch. For missing physics (AD→\toADR), learned residuals and hybrid numerical–neural dictionaries capture the absent reaction mechanism without retraining existing primitives (§ 5, § 7).

Background and Positioning

Operator splitting. When a PDE generator decomposes as F=∑i=1nFi\mathcal{F}=\sum_{i=1}^{n}\mathcal{F}_i, operator splitting approximates the coupled flow etFe^{t\mathcal{F}} by composing simpler sub-flows. Lie–Trotter [42] gives first-order accuracy; Strang [37] second-order; higher-order schemes also exist [38, 11]. The error is governed by commutators [Fi,Fj][\mathcal{F}_i,\mathcal{F}_j], but the schedule is fixed a priori and cannot adapt to each query. Neural operators. Neural operators learn monolithic maps between function spaces, including FNO [20], DeepONet [Lu et al., 2021], Loc. Int. Diff. FNO [24], CNO [32], PINO [21], PDE-Refiner [23], and Poseidon [12]. These methods are powerful in distribution, but under shift the learned map degrades globally and the architecture does not localize failure to a specific process. Related approaches such as operator inference [19], PINNs [31], GP/kernel surrogates [7, 3], and Koopman methods [5] address adjacent goals, but none learns an explicit, query-conditioned composition over reusable process primitives. The gap. Classical splitting encodes process structure but does not learn from data; neural operators learn from data but discard process structure. HyCOP bridges this gap by learning a query-conditioned sequential composition—which process to apply and for how long—preserving the physics of each sub-flow rather than using fixed schedules or weighted blends. Concurrent work. Recent papers validate compositional structure but keep the schedule fixed: Serrano et al. [35] compose DISCO [28] operators via fixed Strang splitting; LegONet [45] composes spectral blocks with fixed Strang and a related error decomposition; Gopakumar et al. [10] learn physical operators under a fixed schedule; and Koch et al. [17] apply splitting to neural DAEs with structurally fixed decompositions. HyCOP differs in that the learned object is the composition itself: it learns what to compose, for how long, and conditioned on the regime.2 Positioning. Table 4 contrasts the three paradigms; the capability unique to HyCOP among learned surrogates is process-level failure diagnosis.

HyCOP: Hybrid Composition Operators

We introduce HyCOP through a worked example (§ 3.1), then present the general framework (§ 3.2).

A Worked Example: Advection–Diffusion–Reaction

Figure 2a illustrates HyCOP on the 2D advection–diffusion–reaction equation ∂tu+c⋅∇u=DΔu+ru(1−u)\partial_t u+\mathbf{c}\cdot\nabla u=D\Delta u+r u(1-u) with advection velocity c\mathbf{c}, diffusivity DD, and reaction rate rr. The dictionary contains three primitives—Oadv\mathcal{O}_{\mathrm{adv}}, Odiff\mathcal{O}_{\mathrm{diff}}, Oreact\mathcal{O}_{\mathrm{react}}—each implemented numerically, by a learned surrogate, or a mix of both (Figure 2b). Each can be evaluated for any duration τ>0\tau>0; none solves the coupled problem alone. Given u0u_0, ∣c∣=2.0\lvert\mathbf{c}\rvert=2.0, D=0.1D=0.1, r=1.0r=1.0, and query time t=0.5t=0.5, the policy πθ\pi_\theta maps dimensionless features (Péclet number, Damköhler number, variance, gradient variance) to

[Oadv, τ=0.20] → [Odiff, τ=0.06] → [Oadv, τ=0.16] → [Oreact, τ=0.08].[\mathcal{O}_{\mathrm{adv}},\ \tau=0.20]\ \rightarrow\ [\mathcal{O}_{\mathrm{diff}},\ \tau=0.06]\ \rightarrow\ [\mathcal{O}_{\mathrm{adv}},\ \tau=0.16]\ \rightarrow\ [\mathcal{O}_{\mathrm{react}},\ \tau=0.08].

The durations sum to t=0.5t=0.5, so the program allocates prediction time across processes rather than advancing with a fixed step. Execution composes the four sub-flows to produce u(0.5)u(0.5). When Pe increases at test time, the policy reallocates time toward advection; each primitive remains valid, so the composition adapts where a monolithic network cannot. If the dictionary is incomplete—e.g., the true system includes a process absent from the dictionary—HyCOP’s errors localize where the missing process dominates, enabling the compose–diagnose–enrich loop described in § 1 and demonstrated in § 6.2.1.

General Framework: Training and Inference

Setup and query-conditioned programs. We consider ∂tu=F(u,μ)\partial_t u=\mathcal{F}(u,\mu), u(0)=u0u(0)=u_0, on Ω\Omega with boundary condition bb. For a query x=(μ,u0,b,Ω)x=(\mu,u_0,b,\Omega) and time tt, the solution operator is S(t;x)=ΦtF(u0)S(t;x)=\Phi_t^{\mathcal{F}}(u_0). When F≈∑j=1nFj\mathcal{F}\approx\sum_{j=1}^{n}\mathcal{F}_j, HyCOP collects implemented sub-flows into a dictionary D={O^1,…,O^n}\mathbb{D}=\{\widehat{\mathcal{O}}_1,\ldots,\widehat{\mathcal{O}}_n\}, where each primitive may be a numerical sub-solver, a neural operator, or a learned closure. The policy πθ\pi_\theta predicts a program (j1,τ1),…,(jk,τk)(j_1,\tau_1),\ldots,(j_k,\tau_k) and evaluates

S^(t;x)=Ψ^θ(x,t):=Φ^τk(jk)∘⋯∘Φ^τ1(j1)(u0).(1)\widehat{S}(t;x)=\widehat{\Psi}_\theta(x,t):=\widehat{\Phi}_{\tau_k}^{(j_k)}\circ\cdots\circ\widehat{\Phi}_{\tau_1}^{(j_1)}(u_0). \tag*{(1)}

HyCOP is therefore a learned integrator family: a policy-selected composition of flows, not a weighted blend. Multi-time queries are answered without autoregressive rollout. Dictionary specifications and policy sizes appear in Table 7 (Appendix C).

BenchmarkDictionary D\mathbb{D}nnPolicy params
1D Advection–Diffusion{Adv., Diff.}2∼\sim50
1D Viscous Burgers{Nonlin. adv., Visc. diff.}2∼\sim50
1D Shallow Water{Wave/adv., Gravity}2∼\sim50
1D Kuramoto–Sivashinsky{Linear, Nonlinear}2∼\sim50
2D ADR (Fisher–KPP){Adv., Diff., Reaction}3∼\sim73
2D Shallow Water{Wave/adv., Gravity}2∼\sim50
2D Compressible Navier–Stokes{Euler adv., Viscous diff.}2∼\sim50
AD→\toADR transfer, Path (a){Adv., Diff., Learned resid.}3∼\sim73
AD→\toADR transfer, Path (b){Learned AD, Reaction}2∼\sim50
Ablation: fully learned ADR{Learned Adv, Learned Diff, Learned Reaction}3∼\sim73

Table 7. Dictionary and policy size. Primitives are single-process routines; For AD→\toADR transfer, we report two complementary adaptation tracks (Path (a): numerical AD primitives + learned residual; Path (b): pretrained AD + numerical reaction), and a fully-learned ablation where every primitive is a per-process learned surrogate.

Training objective. We minimize the expected prediction error

J(θ):=E(x,t)∼ρ[L(x,t;θ)],L(x,t;θ)=∥u(t;x)−Ψ^θ(x,t)∥L2,(2)J(\theta):=\mathbb{E}_{(x,t)\sim\rho}\left[\mathcal{L}(x,t;\theta)\right],\qquad\mathcal{L}(x,t;\theta)=\lVert u(t;x)-\widehat{\Psi}_\theta(x,t)\rVert_{L_2}, \tag*{(2)}

where reference targets u(t;x)u(t;x) come from a trusted solver. The policy conditions on (x,t)(x,t) and scale-free features f(x)f(x)—dimensionless regime numbers (Péclet, Damköhler, Froude) and coarse state statistics—rather than raw grid values, promoting resolution-invariant scheduling (§ 7).

Algorithm 1 Training HyCOP with Evolution Strategies (ES)

Inputs: dictionary D={O1,…,On}\mathbb{D}=\{\mathcal{O}_1,\ldots,\mathcal{O}_n\}; query distribution ρ\rho over (x,t)(x,t); policy πθ\pi_\theta; ES settings (M,σ,η,λ)(M,\sigma,\eta,\lambda).

Outputs: trained parameters θ⋆\theta^\star; at inference, πθ⋆(x,t)\pi_{\theta^\star}(x,t) emits per-step primitive logits zrz_r, durations τr=softplus⁡(ar)\tau_r=\operatorname{softplus}(a_r), and program length kk — together prescribing which Oj∈D\mathcal{O}_j\in\mathbb{D} to apply, for how long, and in what order.

  1. for generation =1,2,…=1,2,\ldots do

  2. Sample minibatch {(xb,tb)}b=1B∼ρ\{(x_b,t_b)\}_{b=1}^{B}\sim\rho; sample ϵi∼N(0,I)\epsilon_i\sim\mathcal{N}(0,I) for i=1,…,Mi=1,\ldots,M

  3. Li±←1B∑b=1BL(xb,tb;θ±σϵi)L_i^{\pm}\leftarrow\frac{1}{B}\sum_{b=1}^{B}\mathcal{L}(x_b,t_b;\theta\pm\sigma\epsilon_i) // L\mathcal{L} runs Ψ^θ\widehat{\Psi}_\theta from Eq. (1)

  4. {wi+,wi−}i=1M←rank-shape⁡({Li+,Li−})\{w_i^+,w_i^-\}_{i=1}^{M}\leftarrow\operatorname{rank\text{-}shape}(\{L_i^+,L_i^-\}); g←12Mσ∑i=1M(wi+−wi−)ϵig\leftarrow\frac{1}{2M\sigma}\sum_{i=1}^{M}(w_i^+-w_i^-)\epsilon_i

  5. θ←(1−λ)(θ−ηg)\theta\leftarrow(1-\lambda)(\theta-\eta g) // ES step with weight decay

  6. end for

  7. return θ⋆←θ\theta^\star\leftarrow\theta

Policy and optimization. At each program position r∈{1,…,Kmax⁡}r\in\{1,\ldots,K_{\max}\}, the policy outputs (i) logits zr∈Rnz_r\in\mathbb{R}^n selecting a primitive via σr=softmax⁡(zr)\sigma_r=\operatorname{softmax}(z_r), (ii) a positive duration τr=softplus⁡(ar)\tau_r=\operatorname{softplus}(a_r), and (iii) an effective program length k∈[2,Kmax⁡]k\in[2,K_{\max}]. We train with Evolution Strategies (ES) [34] because θ↦L(x,t;θ)\theta\mapsto\mathcal{L}(x,t;\theta) is generally non-differentiable when primitives are legacy solvers or other black-box modules. ES is practical here because the policy is low-dimensional (∼\sim50–100 parameters) and population rollouts parallelize trivially. The same hyperparameters (M=500M=500, σ=0.02\sigma=0.02, 200 generations) are used across all benchmarks without per-problem tuning. Algorithm 1 and further details are in Appendix B; Figure 5 illustrates the pipeline.

HyCOP training with Evolution Strategies

Figure 5. HyCOP training with Evolution Strategies (ES). HyCOP conditions the policy on low-dimensional physics-based features f(x)f(x) (e.g., Péclet/Damköhler/Froude numbers and state statistics) to predict a split program (primitive choices and durations). We optimize policy parameters via ES using black-box evaluations of the composed operator loss.

References

  1. [1]Adams, R. A., & Fournier, J. J. F. (2003). Sobolev Spaces. In Academic Press (Number 2nd edition).
  2. [2]Igor A. Baratta, Joseph P. Dean, Jørgen S. Dokken, Michal Habera, Jack S. Hale, Chris N. Richardson, Marie E. Rognes, Matthew W. Scroggs, Nathan Sime, and Garth N. Wells. DOLFINx: The next generation FEniCS problem solving environment, 2023.DOI
  3. [3]Battle, P., Darcy, M., Hosseini, B., & Owhadi, H. (2024). Kernel methods are competitive for operator learning. Journal of Computational Physics, 496, 112549. https://doi.org/10.1016/j.jcp.2023.112549
  4. [4]Berge, C. (1963). Topological Spaces. In Oliver and Boyd.
  5. [5]Petar Bevanda, Stefan Sosnowski, and Sandra Hirche. Koopman operator dynamical models: Learning, analysis and control. Annual Reviews in Control, 52:197–212, 2021. doi: 10.1016/j.arcontrol.2021.09.002.DOI
  6. [6]Blanes, S., Casas, F., & Murua, A. (2024). Splitting methods for differential equations. Acta Numerica, 33, 1–161.
  7. [7]Yifan Chen, Bamdad Hosseini, Houman Owhadi, and Andrew M. Stuart. Solving and learning nonlinear PDEs with Gaussian processes. Journal of Computational Physics, 447:110668, 2021. doi: 10.1016/j.jcp.2021.110668.DOI
  8. [8]Cybenko, G. (1989). Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems, 2(4), 303–314.
  9. [9]Clint Dawson, Mark Loveland, Benjamin Pachev, Jennifer Proft, and Eirik Valseth. SWEMniCS: a software toolbox for modeling coastal ocean circulation, storm surges, inland, and compound flooding. npj Natural Hazards, 1(1):44, 2024.DOI
  10. [10]Gopakumar, V., Gray, A., Giles, D., Zanisi, L., Kusner, M. J., Betcke, T., Pamela, S., & Deisenroth, M. P. (2026). Learning physical operators using neural operators. In arXiv preprint. https://arxiv.org/abs/2602.23113
  11. [11]Hairer, E., Lubich, C., & Wanner, G. (2006). Geometric Numerical Integration. In Springer (Number 2nd edition).
  12. [12]Maximilian Herde, Bogdan Raonic, Tobias Rohner, Roger Käppeli, Roberto Molinaro, Emmanuel de Bézenac, and Siddhartha Mishra. Poseidon: Efficient foundation models for PDEs. In Advances in Neural Information Processing Systems (NeurIPS), 2024. URL https://arxiv.org/abs/2405.19101.
  13. [13]Hornik, K., Stinchcombe, M., & White, H. (1989). Multilayer feedforward networks are universal approximators. Neural Networks, 2(5), 359–366.
  14. [14]Jahnke, T., & Lubich, C. (2000). Error bounds for exponential operator splittings. BIT Numerical Mathematics, 40(4), 735–744.
  15. [15]John D. Jakeman, Lorena A. Barba, Joaquim R. R. A. Martins, and Thomas O’Leary-Roseberry. Verification and validation for trustworthy scientific machine learning. Machine Learning: Science and Technology, 7(2):025055, 2026. doi: 10.1088/2632-2153/ae59ec.DOI
  16. [16]Armand Kassaï Koupaï, Jorge Mifsut Benet, Yuan Yin, Jean-Noël Vittaut, and Patrick Gallinari. GEPS: Boosting generalization in parametric PDE neural solvers through adaptive conditioning. arXiv preprint arXiv:2410.23889, 2024.arxiv.org/abs/2410.23889
  17. [17]James Koch, Madelyn Shapiro, Himanshu Sharma, Draguna Vrabie, and Ján Drgona. Learning neural differential algebraic equations via operator splitting. arXiv preprint arXiv:2403.12938, 2024.arxiv.org/abs/2403.12938
  18. [18]Kovachki, N., Li, Z., Liu, B., Azizzadenesheli, K., Bhattacharya, K., Stuart, A., & Anandkumar, A. (2023). Neural operator: Learning maps between function spaces with applications to PDEs. Journal of Machine Learning Research, 24(89), 1–97. https://www.jmlr.org/papers/v24/21-1524.htmljmlr.org/papers/v24/21-1524.html
  19. [19]Boris Kramer, Benjamin Peherstorfer, and Karen E. Willcox. Learning nonlinear reduced models from data with operator inference. Annual Review of Fluid Mechanics, 56:521–548, 2024. doi: 10.1146/annurev-fluid-121021-025220.DOI
  20. [20]Zongyi Li, Nikola Kovachki, Kamyar Azizzadenesheli, Burigede Liu, Kaushik Bhattacharya, Andrew Stuart, and Anima Anandkumar. Fourier neural operator for parametric partial differential equations. In International Conference on Learning Representations (ICLR), 2021. URL https://arxiv.org/abs/2010.08895.
  21. [21]Zongyi Li, Hongkai Zheng, Nikola Kovachki, David Jin, Haoxuan Chen, Burigede Liu, Kamyar Azizzadenesheli, and Anima Anandkumar. Physics-informed neural operator for learning partial differential equations. ACM/JMMS Journal of Data Science, 1(3):9:1–9:27, 2024. doi: 10.1145/3648506. Earlier version available as arXiv:2111.03794.DOI
  22. [22]Zongyi Li, Samuel Lanthaler, Catherine Deng, Michael Chen, Yixuan Wang, Kamyar Azizzadenesheli, and Anima Anandkumar. Scale-consistent learning for partial differential equations, 2025. URL https://arxiv.org/abs/2507.18813.
  23. [23]Phillip Lippe, Bastiaan S. Veeling, Paris Perdikaris, Richard E. Turner, and Johannes Brandstetter. PDE-Refiner: Achieving accurate long rollouts with neural PDE solvers. In Advances in Neural Information Processing Systems (NeurIPS), 2023.arxiv.org/abs/2308.05732
  24. [24]Miguel Liu-Schiaffini, Julius Berner, Boris Bonev, Thorsten Kurth, Kamyar Azizzadenesheli, and Anima Anandkumar. Neural operators with localized integral and differential kernels. In Proceedings of the 41st International Conference on Machine Learning (ICML), volume 235 of Proceedings of Machine Learning Research, pages 32576–32594. PMLR, 2024. URL https://proceedings.mlr.press/v235/liu-schiaffini24a.html.proceedings.mlr.press/v235/liu-schiaffini24a.html
  25. [26]McLachlan, R. I., & Quispel, G. R. W. (2002). Splitting methods. Acta Numerica, 11, 341–434.
  26. [27]Michael, E. (1956). Continuous selections. I. Annals of Mathematics, 63(2), 361–382.
  27. [28]Rudy Morel, Jiequn Han, and Edouard Oyallon. DISCO: Learning to discover an evolution operator for multi-physics-agnostic prediction. In Proceedings of the 42nd International Conference on Machine Learning (ICML), 2025.arxiv.org/abs/2504.19496
  28. [29]Perez, E., Strub, F., de Vries, H., Dumoulin, V., & Courville, A. (2018). FiLM: Visual reasoning with a general conditioning layer. Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence and Thirtieth Innovative Applications of Artificial Intelligence Conference and Eighth AAAI Symposium on Educational Advances in Artificial Intelligence, AAAI’18/IAAI’18/EAAI’18.
  29. [30]Rahman, M. A., Ross, Z. E., & Azizzadenesheli, K. (2023). U-NO: U-shaped neural operators. Transactions on Machine Learning Research. https://openreview.net/forum?id=j3oQF9coJdopenreview.net/forum?id=j3oQF9coJd
  30. [31]Maziar Raissi, Paris Perdikaris, and George E. Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686–707, 2019. doi: 10.1016/j.jcp.2018.10.045.DOI
  31. [32]Bogdan Raonić, Roberto Molinaro, Tim De Ryck, Tobias Rohner, Francesca Bartolucci, Rima Alaifari, Siddhartha Mishra, and Emmanuel de Bézenac. Convolutional neural operators for robust and accurate learning of PDEs. In Advances in Neural Information Processing Systems (NeurIPS), 2023. URL https://arxiv.org/abs/2302.01178.
  32. [33]Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-Net: Convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer-Assisted Intervention – MICCAI 2015, volume 9351 of Lecture Notes in Computer Science, pages 234–241. Springer, 2015. doi: 10.1007/978-3-319-24574-4_28.DOI
  33. [34]Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and Ilya Sutskever. Evolution strategies as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03864, 2017.arxiv.org/abs/1703.03864
  34. [35]Louis Serrano, Jiequn Han, Edouard Oyallon, Shirley Ho, and Rudy Morel. Test-time generalization for physics through neural operator splitting. arXiv preprint arXiv:2602.00884, 2026.arxiv.org/abs/2602.00884
  35. [36]Anand Pratap Singh, Karthikeyan Duraisamy, and Ze Jia Zhang. Augmentation of turbulence models using field inversion and machine learning. In 55th AIAA Aerospace Sciences Meeting, 2017. doi: 10.2514/6.2017-0993.DOI
  36. [37]Strang, G. (1968). On the construction and comparison of difference schemes. SIAM Journal on Numerical Analysis, 5(3), 506–517.
  37. [38]Masuo Suzuki. Fractal decomposition of exponential operators with applications to many-body theories and Monte Carlo simulations. Physics Letters A, 146(6):319–323, 1990. doi: 10.1016/0375-9601(90)90962-N.DOI
  38. [39]Takamoto, M., Praditia, T., Leiteritz, R., MacKinlay, D., Alesiani, F., Pflüger, D., & Niepert, M. (2022). PDEBENCH: An extensive benchmark for scientific machine learning. Advances in Neural Information Processing Systems (NeurIPS) Track on Datasets and Benchmarks. https://arxiv.org/abs/2210.07182
  39. [40]Thalhammer, M. (2008). High-order exponential operator splitting methods for time-dependent Schrödinger equations. SIAM Journal on Numerical Analysis, 46(4), 2022–2038.
  40. [41]Tran, A., Mathews, A., Xie, L., & Ong, C. S. (2023). Factorized Fourier neural operators. International Conference on Learning Representations (ICLR). https://openreview.net/forum?id=tmIiMPl4IPaopenreview.net/forum?id=tmIiMPl4IPa
  41. [42]Trotter, H. F. (1959). On the product of semi-groups of operators. Proceedings of the American Mathematical Society, 10(4), 545–551.
  42. [43]Maite J. C. Wilhelm and Simon Portegies Zwart. VENICE: A multi-scale operator-splitting algorithm for multi-physics simulations. Astronomy & Astrophysics, 691:A71, 2024. doi: 10.1051/0004-6361/202348614.DOI
  43. [44]Enrui Zhang, Adar Kahana, Alena Kopanicáková, Eli Turkel, Rishikesh Ranade, Jay Pathak, and George Em Karniadakis. Blending neural operators and relaxation methods in PDE numerical solvers. Nature Machine Intelligence, 6(11):1303–1313, 2024. doi: 10.1038/s42256-024-00910-x.DOI
  44. [45]Jiahao Zhang, Yueqi Wang, and Guang Lin. LegONet: Plug-and-play structure-preserving neural operator blocks for compositional PDE learning. arXiv preprint arXiv:2603.07882, 2026.arxiv.org/abs/2603.07882

Paper details

vlnc:W_yrbnbuxm
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 7

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents