acceptodds
Under review as a conference paper at ICLR 2027

APIC: Routing Corrections for Neural PDE Rollouts

Abstract

Inference-time correction is part of a neural PDE simulator's evolution rule, and its numerical structure determines which prediction errors it can address. A shared correction template can therefore impose a restriction even when its residual is equation-dependent. We study equation class as a prior for selecting correction operators. We introduce Analytical Predictor–Inference Correction (APIC), which selects an analytical update according to the equation's numerical structure and combines it with optional bounded learned refinement. This separates the choice of update family from the surrogate architecture while retaining a frozen pretrained predictor; the Navier–Stokes branch requires no predictor evaluation. Across three PDEs and three architectures, fixed class-level routing reduces rollout relative-L2 error by a mean of 83.48% over PhysicsCorrect, within 0.25 percentage points of selecting the best evaluated variant separately for each PDE–architecture pair. An analytical-only policy achieves 81.68%, and the Navier–Stokes branch reduces error by 93.4% without a network forward pass. These results support a coarse structural prior for correction selection on the evaluated benchmark and establish an analytical reference for assessing the contribution of learned refinement.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
Neural PDE Surrogates, Equation-Class Routing, Inference-Time Correction

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_FG4AOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies how to fix a neural PDE rollout at test time, without training the main network again. The baseline is PhysicsCorrect (Huang and Perdikaris, 2026). That method uses one shared linear correction on every equation. APIC instead picks a classical update from the equation class. Wave uses a Numerov step plus a small learned fix. Navier–Stokes uses Strang splitting and does not call the network. Kuramoto–Sivashinsky uses many small Crank–Nicolson steps, or a frequency mask, plus an optional learned fix.

The test is the nine-cell setup from PhysicsCorrect: three equations times three frozen networks (FNO, U-Net, ViT). A fixed class rule cuts the rollout error by 83.48% relative to PhysicsCorrect. Picking the best variant for each cell reaches 83.73%. A classical-only rule reaches 81.68%.

Critical strengths

The paper asks a clear question. Should the correction family change with the equation, or should one template serve every equation? Table 1 and Algorithm 1 show which pieces turn on for each class.

The authors are open about several limits. They say S1, S2, S3, and S4 are full policies, not a clean factorial test (Table 3 and the discussion). They say the Navier–Stokes branch never calls the network, and that the three architecture cells match for that reason (Table 6 and Table 9). They show that on Kuramoto–Sivashinsky the gain falls from about 66% at 50 steps to about 2% at 600 steps (Figure 10a). They also show that a smaller CD2 residual need not mean a smaller error against the reference (Table 10).

The classical pieces are named and cited: Numerov (Noumerov, 1924), Strang splitting (Strang, 1968), Crank–Nicolson (Crank and Nicolson, 1947), and ETDRK4 (Kassam and Trefethen, 2005). Appendix E puts ETDRK4 on the same Navier–Stokes data. The Wave ablation separates the stencil change from the small learned term: Verlet at 2.82×10⁻³, Numerov at 5.07×10⁻⁴, and the learned term adds about 5%.

Three seeds are reported, and the PhysicsCorrect numbers are rerun from the authors’ code on the same checkpoints.

Critical weaknesses

1. On Navier–Stokes, APIC does not correct the neural rollout. It replaces it.

Algorithm 1, for the semi-implicit class, sets the next state with Strang splitting and never calls fθ. The abstract reports a 93.4% error cut with no network pass. Table 2 shows the same error, 2.66×10⁻⁵, for FNO, U-Net, and ViT. Table 9 lists the seed spread as 0.00. Those three cells are one solver written three times.

The data generator is already “a pseudo-spectral solver with 2/3-rule dealiasing” (Appendix B). APIC’s Navier–Stokes step is a dealiased spectral advection step plus an exact Fourier diffusion step (Equation 3). A match to that reference is what a reader should expect if the correction uses the same family as the generator. ETDRK4, a standard stiff spectral scheme (Kassam and Trefethen, 2005), has error 1.28×10⁻⁴, about 3.8 times the Strang error (Appendix E). Higher formal order loses. That pattern fits “closer to the generator,” not “a better correction of the network.”

This is the opposite of the usual hybrid. Solver-in-the-loop keeps a cheap solver and learns a fix around it (Um et al., 2020; Kochkov et al., 2021). INC learns an indirect corrector for a hybrid solver (Wei et al., 2026). ANCHOR calls a solver when an error check fires (Roy et al., 2025). In the authors’ own ANCHOR-style sweep, error keeps falling until the analytical step is on at 100% (Figure 14). Full replacement wins. That result does not show that a neural state was corrected. It shows that the spectral step should run every time.

The 83.48% mean gives these three identical Navier–Stokes cells one third of the average. The headline is pulled up by a solver swap.

2. On Wave, the network is also a small add-on, and the horizon is short.

The Wave update is a Numerov field plus a tanh term scaled by ϵ = 0.05 (Algorithm 1). The ablation says the learned part adds about 5%. PhysicsCorrect’s Wave error is 2.82×10⁻³ on all three networks, the same number as the Verlet line in the ablation. So both methods already sit on a classical stencil. The three architectures do not change the story.

The saved Wave test has only 15–20 steps (Section 5 and Appendix B). A fourth-order stencil on a short window does not show a long rollout. The order plots also disagree. Figure 6c says Verlet has slope 1.98 and Numerov has slope 3.96. Figure 10b says Verlet goes as dt^3.9 and Numerov as dt^4.5. A reader cannot tell which fit is the result.

3. The class “router” is a hand lookup, and the 0.25 point gap is weak evidence.

The router is a fixed table from the known class (Section 3). It is not trained, and it is not tried on a new equation. S1 is the best variant after looking at the test cells. The authors call it an upper bound, which is fair. The gap from 83.73% to 83.48% is then “our hand choice is close to the best hand choice in this small set.” Navier–Stokes has only one analytical option, so S1 and S2 match there by construction. S4 uses different Kuramoto–Sivashinsky step counts, so the 1.80 point gap from S2 to S4 is not a clean test of learning (Table 3).

Frequency-mask constants are fit on one held-out trajectory, and the corrector constants are fixed on the seed-0 validation rollout (Section 3 and Table 5). If that rollout is part of the reported test pool, the mask sees evaluation data.

4. The Kuramoto–Sivashinsky gain is expensive and fades.

The selected inner step counts are M = 100 and M = 400. Those cost 56 ms and 224 ms per step (main text). The plain KS-FNO step is 0.37 ms (Table 8). Figure 6a shows Navier–Stokes latency, where APIC is faster because it skips the network. It does not show this much larger KS cost. At 600 steps the error cut versus PhysicsCorrect is about 2% (Figure 10a). Both methods then sit near the same plateau (Figure 9). Past the Lyapunov time, a finer classical step does not keep the chaotic path.

5. The setup numbers in the main text and in Table 5 do not match.

The experiment section says KS uses 512 grid points and ∆t = 0.05, and Wave uses a 128×128 grid and ∆t = 10⁻⁴. Table 5 says KS uses 128 points and ∆t = 0.25, and Wave uses 64×64, with integration at ∆t = 10⁻³ and storage every 10 steps. Those are different problems. A rerun cannot know which one produced Table 2.

6. Close methods are cited, but the missing ones are the hybrids that still use the network.

PhysicsCorrect is the right shared-template baseline, and it is rerun. PDE-Refiner changes training, not the test-time step (Lippe et al., 2023). The paper’s own Table 4 does not put INC, ANCHOR, or PDE-Refiner on this nine-cell set, and it warns that the headlines are not comparable. That warning is good. The gap that remains is a hybrid that keeps fθ in the loop: Strang or Numerov as the base step, and the frozen network as a bounded defect, as in Um et al. (2020) and Kochkov et al. (2021). Those two papers are not in the reference list. Test-time operator splitting is cited (Serrano et al., 2026) but not run on these nine cells.

The introduction also points to weather models (Pathak et al., 2022; Bi et al., 2022; Lam et al., 2023). No weather task is run. The claim should stay on KS, Navier–Stokes, and Wave.

Equation (5) is the standard Lipschitz step en+1 ≤ Ln en + δn. The experiments do not estimate Ln. It does not explain the tables.

Questions for authors
  1. Please state the exact Navier–Stokes generator: grid, time scheme, dealiasing, and Poisson solve. Is Equation 3 the same scheme as that generator, or a different one? If you change only the generator’s time scheme and keep the network fixed, does the 93.4% cut remain?

  2. Please add one Navier–Stokes row that still calls the frozen network: un+1 = Strang(un) + ϵ tanh(fθ(·)). Report error and time next to full replacement. The current branch cannot support the phrase “correction for neural PDE rollouts” on that equation.

  3. Why do Figure 6c and Figure 10b give different slopes for the same Verlet and Numerov sweeps? Which fit matches the saved logs?

  4. Which grid and time step produced Table 2? The experiment section says KS is 512 points at ∆t = 0.05 and Wave is 128×128 at ∆t = 10⁻⁴. Table 5 says KS is 128 points at ∆t = 0.25 and Wave is 64×64. Please make one table and recompute if the runs used the other setting.

  5. Can you report the mean error reduction with the three Navier–Stokes cells counted once? They are the same solver. Also please give the mean of the raw errors, not only the mean of the nine percentages.

  6. For Kuramoto–Sivashinsky, please plot error against inner-step count and against milliseconds per step, for M from 1 to 400, with and without the learned term. The 2% gain at 600 steps (Figure 10a) needs that cost beside it. Table 8 currently omits the 56 ms and 224 ms steps.

  7. Were the FAPC numbers (1.0, 0.6, 0.12, 0.01) fit on a trajectory that is also inside the reported test mean? Please refit on a split that is never scored, and give the test error again.

  8. Please run the same nine cells for a true hybrid from Um et al. (2020) or Kochkov et al. (2021): a classical step every time, and the frozen network only as a correction. Please also run INC’s corrector (Wei et al., 2026) if the code allows one shared checkpoint. ANCHOR at 100% activation is the same analytical step (Appendix E), so it is not a separate method there.

  9. The Wave test stops at 15–20 steps. Can you roll the same Numerov rule to the horizon you use for Navier–Stokes, on a newly generated Wave set? The current window cannot show whether the fourth-order gain lasts.

  10. S2 never sees a fourth equation. If the class label is wrong, or the PDE is mixed, what does the lookup do? Please try one held-out equation, such as Burgers or Allen–Cahn from the ANCHOR suite (Roy et al., 2025), with the router frozen before that run.

References

  • Bi et al. (2022). Pangu-Weather. arXiv:2211.02556.
  • Crank and Nicolson (1947). A practical method for numerical evaluation of solutions of partial differential equations of the heat-conduction type. Proc. Cambridge Philos. Soc.
  • Hairer, Lubich, and Wanner (2006). Geometric Numerical Integration. Springer.
  • Huang and Perdikaris (2026). PhysicsCorrect. AAAI.
  • Kassam and Trefethen (2005). Fourth-order time-stepping for stiff PDEs. SIAM J. Sci. Comput.
  • Kochkov et al. (2021). Machine learning–accelerated computational fluid dynamics. PNAS.
  • Lam et al. (2023). GraphCast. Science.
  • Lippe et al. (2023). PDE-Refiner. NeurIPS.
  • Noumerov (1924). A method of extrapolation of perturbations. Monthly Notices of the Royal Astronomical Society.
  • Pathak et al. (2022). FourCastNet. arXiv:2202.11214.
  • Roy, Nayak, and Goswami (2025). ANCHOR. arXiv:2512.
  • Serrano et al. (2026). Test-time generalization through neural operator splitting. arXiv:2602.00884.
  • Strang (1968). On the construction and comparison of difference schemes. SIAM J. Numer. Anal.
  • Um et al. (2020). Solver-in-the-loop. NeurIPS.
  • Wei et al. (2026). INC: An indirect neural corrector. NeurIPS.
7 comments

We thank the reviewer for a careful, constructive review. Answering it required new experiments and a full re-audit of our pipeline. Several findings change our claims, so we list them first. Unless noted, every number comes from new runs: new trajectories, selection on validation or a never-scored calibration file, and a single scoring of test.

Findings from the re-audit

  1. NS is solver replacement (W1, Q1, Q2). The branch never calls the network, and its step is in the generator's family. Against an independent reference the gain over PhysicsCorrect drops from 93% to ≈68%.
  2. Selection used the scored test file (W3, Q7, Q8).
    • The Wave and KS refinement heads were trained on ¾ of the test trajectories, and the reported iterate was the test-best one.
    • The FAPC constants and reference count were chosen on test. They also differ per seed, so "fit on one held-out trajectory" and the Table 5 caption ("fixed once on the seed-0 validation rollout") are both wrong. To answer W3 directly: yes, the selection data were in the reported test pool.
  3. Denominator mismatch. The KS-FNO cells of S1 and S4 run on a different FNO checkpoint from the one whose PhysicsCorrect error is their denominator. With matched denominators:
    • S1 = 83.43%, not 83.73%. It is below S2 (83.48%), so the 0.25-point gap in W3 carries no information.
    • S4 = 81.27%, not 81.68%.
  4. Wave Numerov is unstable at the stored step (W2, Q9). 165 of 4096 modes have a = c²Δt²|k|²/12 > 1/2, with growth up to 2.42 per step.
  5. The §5 setup sentence was wrong (W5, Q4). Table 2 is unaffected.

Q1 (NS generator; change the time scheme)

Generator. It is the PhysicsCorrect NS script:

  • vorticity form on [0,1]², periodic, 64²;
  • ψ̂ = ŵ/(4π²|k|²) by spectral Poisson solve, with the k = 0 mode pinned;
  • spectral derivatives, with the advection product formed in physical space under the 2/3 rule;
  • forcing 0.1(sin 2π(x+y) + cos 2π(x+y)), ν = 10⁻³;
  • Δt = 0.01, one step per stored frame, with explicit-Euler advection and forcing and Crank–Nicolson diffusion;
  • Gaussian-random-field initial vorticity (α = 4, τ = 8).

Comparison with Eq. 3. Eq. 3 shares the grid, Poisson solve, dealiasing, forcing and advection. It differs only in using exact diffusion half-steps. Our replica of the generator reproduces the shipped data to 1.0·10⁻⁵.

Changing only the reference time scheme. We kept the network, test ICs and grid fixed and replaced the reference with near-exact ETDRK4 at Δt/20 in fp64. Mean relative L2 over 200 steps:

Methodvs shipped datavs near-exact
PhysicsCorrect4.0·10⁻⁴4.36·10⁻⁴
Strang (submitted)2.89·10⁻⁵1.40·10⁻⁴
Generator scheme1.0·10⁻⁵1.28·10⁻⁴
ETDRK4 at Δt1.28·10⁻⁴1.22·10⁻⁵
IMEX Heun–CN at Δt1.28·10⁻⁴1.26·10⁻⁵

The 93.4% cut does not survive: it becomes ≈68%, and ETDRK4 at the same Δt is then 11× more accurate than Strang. The gain mostly reflects closeness to the generator.

Q2 (an NS row that still calls the network)

We added a solver-in-the-loop hybrid (Um et al. 2020; Kochkov et al. 2021):

u ← Strang(u) + ε·tanh(g_φ(f_θ(u) − Strang(u), …))

  • The head is trained on newly generated trajectories and selected on validation.
  • Rows: 3 architectures × 3 seeds.
  • Latency: batch 1 (Table 8 protocol).
MethodError vs generator datams/step
Network alone—2.3 / 7.0 / 2.5
Strang, full replacement (submitted)2.89·10⁻⁵1.2
Strang + bounded head on f_θ − Strang1.19–1.25·10⁻⁵4.1 / 7.6 / 3.5
Same head, network input zeroed1.17–1.29·10⁻⁵1.8
Strang + α(f_θ − Strang), α chosen on valα = 01.2

Against the near-exact reference (ETDRK4 at Δt/20, fp64; head retrained and selected on that target, same 3 × 3 grid): Strang 1.40·10⁻⁴, hybrid 1.01–1.52·10⁻⁵, no-network control 0.86–1.16·10⁻⁵. The blend picks α ≤ 0.003 and changes the error by < 0.4%. The conclusion is the same: the head helps, the network does not.

Reading the table:

  • The head helps.
  • The network contributes nothing: the control without the network is just as good, and the zero-training blend picks α = 0.
  • So on NS the phrase "correction for neural rollouts" is not supported, and we remove it for NS.
  • The hybrid and the control are added to Related Work and to the NS table.

Q3 (Fig. 6c vs Fig. 10b)

The two figures measure different quantities.

Fig. 6c is the order study, and it matches the saved logs:

  • global error at T = 0.08 against the exact spectral solution;
  • spectral Verlet vs Numerov, in fp64, with an exact first step;
  • recomputed slopes are 1.98 and 3.96.

Fig. 10b measures something else:

  • It is a one-step error from stored pairs (u⁰, u^{s−1}) → u^{2s−1}, for strides s = 1, 2, 4, 8.
  • It compares FD4-Verlet against spectral Numerov, scored against generator data that carries FD4 spatial error.
  • The slope comes from a four-point polyfit.
  • Its two coarsest strides lie in the unstable range a > 1/2.
  • "dt^3.9" and "dt^4.5" are therefore neither global orders nor reliable local orders. The pairwise slopes of the Numerov curve are 2.96, 4.24 and 6.53.

We remove the slope labels from Fig. 10b and describe it as a local-defect comparison.

Q4 / W5 (which setup produced Table 2)

Table 2 was produced with the Table 5 setup:

  • KS: N = 128, L = 64, Δt = 0.25, ETDRK4 generator, 400 spin-up steps.
  • Wave: 64², FD4 + RK4 at Δt = 10⁻³, stored every 10 steps (Δt_eff = 0.01).
  • NS: 64², Δt = 0.01, ν = 10⁻³.

The §5 sentence (512 / 0.05 and 128² / 10⁻⁴) was wrong. Re-running from the stored data and checkpoints reproduces Table 2:

  • Wave Numerov 4.85·10⁻⁴ (A800) and 5.07·10⁻⁴ (4090).
  • KS FAPC seed 0: 1.527·10⁻².
  • NS Strang 2.89·10⁻⁵ (A800) and 2.66·10⁻⁵ (4090). The difference is fp32 hardware rounding.

We merge the two descriptions into one table.

Q5 (NS counted once; raw-error means)

PolicyNine-cellNS counted onceWithout NS
S1 submitted / denominator matched83.73 / 83.4380.97 / 80.6078.91 / 78.47
S283.4880.6678.54
S372.5673.9474.97
S4 submitted / denominator matched81.68 / 81.2778.34 / 77.8275.84 / 75.23
S2 families, no learned heads (leakage-free)81.1877.8675.38
Same + KS heads retrained on clean splits83.4880.8278.82

Raw-error means for S2 vs PhysicsCorrect:

S2PhysicsCorrectReduction
KS1.68·10⁻²6.44·10⁻²−74%
NS2.66·10⁻⁵4.00·10⁻⁴−93%
Wave4.78·10⁻⁴2.82·10⁻³−83%

The geometric mean of the error ratios is 0.143.

Q6 / W4 (KS: error vs M and vs ms, with and without the learned term)

All nine KS cells, M = 1–400.

  • The learned term is retrained for each M on new trajectories and selected on a never-scored calibration file.
  • Latency follows the Table 8 protocol (batch 1). Our M = 100 / 400 timings, 57 / 222 ms, match Table 8's 56 / 224 ms. Both rows are added to Table 8.
  • The plots of error against M and against ms are added as a new appendix figure.

Error reduction over PhysicsCorrect is the mean over steps 1–200, nine-cell mean (min, max):

Mms/stepNo learned termWith learned term
11.6–2.2+3.9% (−3.4, +12.9)+23.9% (+3.4, +46.4)
22.2–2.8−34.9%—
43.5–3.8−3.9%—
86.4–7.0+28.1%+58.5%
1611.4–11.7+47.8%—
3220.3–20.6+59.8%+77.5% (+69.9, +85.8)
10057+68.1% (+54.0, +78.1)+74.9% (+54.8, +88.9)
200111+70.0%—
400222+71.0% (+58.6, +79.8)+72.6% (+59.1, +81.7)

Reference costs at batch 1:

Methodms/stepError (reduction)
KS-FNO step1.0–1.6—
PhysicsCorrect1.3–1.9—
ETDRK4 at Δt, no network (the generator's scheme)0.961.2·10⁻⁵ (+99.98%)
  • Cost. Without the learned term, M = 100 costs 30–45× a PhysicsCorrect step and M = 400 120–170×. M = 2–4 is worse than PhysicsCorrect.
  • Learned term. Its gain over sub-stepping alone shrinks with M: +20 / +42 / +42 / +22 / +5.5% at M = 1 / 8 / 32 / 100 / 400. With it, M = 32 (21 ms) beats M = 100–400 without it. This is the one place where the frozen network adds value.

Horizon (Fig. 10a). The text conflated two different quantities.

  • Fig. 10a (KS-FNO, seed 0, FAPC) plots the window-mean gain: 48 / 68 / 72 / 38 / 17% at n_t = 50 / 100 / 200 / 400 / 600.
  • "≈2% at n_t = 600" in the text is the final-step error (1.38 vs 1.40). The quoted "66% at n_t = 50" is in fact the n_t = 100 value.
  • Over all nine cells:
    • The window mean over steps 1–600 is +19–21% without the learned term (M = 100–400) and +21–24% with it (M ≥ 32).
    • Pointwise, the gain at step t is 76% (t = 50), 65% (200), 45% (300), 20% (400), and ≈0 at t = 600, where all methods share a plateau (≈1.39).

We agree with the reviewer: past the Lyapunov time no method keeps the trajectory. The KS gain is a delay in saturation. The abstract now states the 200-step horizon, and the text labels both quantities.

Q7 (FAPC fit on test?)

Yes. The submitted constants were the test-best settings, and they differ per seed:

  • seed 0: (1.0, 0.6, 0.12, 0.01), K = 1;
  • seed 1: (1.0, 0.35, 0.05, 0.02), K = 8;
  • seed 2: (0.85, 0.45, 0.12, 0.005), K = 3.

We re-ran the same 3888-point grid with K ∈ {1, 2, 3, 5, 8} on a never-scored calibration file (same generator, seed 777, 64 × 200 steps) and scored test once.

SeedSubmittedRefit
01.53·10⁻²2.38·10⁻²
11.12·10⁻²1.58·10⁻²
21.71·10⁻²1.93·10⁻²
  • With matched PhysicsCorrect denominators, the reduction falls from 74.4% to 65.1%.
  • Taking the Jacobian from the test IC at inference time gives 66.3%.
  • In the paper's denominator convention the fall is 77.0% → 68.7%.
  • The refit constants are (0.85, 0.3, 0.15, 0.03) K = 1; (0.85, 0.45, 0.08, 0.01) K = 5; (0.85, 0.5, 0.12, 0.005) K = 1.
Reviewer_pXzxOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposes APIC, a PDE-class-aware inference-time correction framework that selects different numerical schemes according to the underlying equation structure while keeping pretrained neural PDE predictors frozen. Specifically, APIC employs fourth-order Numerov integration for wave equations, Strang splitting for Navier–Stokes equations, and frequency-adaptive correction or sub-step Crank–Nicolson integration for Kuramoto–Sivashinsky equations, optionally incorporating bounded neural refinement.

Critical strengths
  1. APIC achieves an average 83.48% reduction in rollout error over PhysicsCorrect across nine PDE–architecture combinations, demonstrating substantial improvements on the evaluated benchmark.

  2. Instead of applying a universal correction operator, APIC considers the distinct numerical properties of different PDE classes, providing an intuitive motivation for selecting equation-specific correction strategies.

Critical weaknesses
  1. The main numerical components, including Numerov integration, Strang splitting, and Crank–Nicolson schemes, are well-established methods. The contribution primarily consists of manually selecting and combining existing techniques for different PDEs, rather than developing a fundamentally new correction algorithm.

  2. The Navier–Stokes branch completely bypasses the pretrained neural network and directly advances the solution using a classical numerical scheme. Therefore, its substantial improvements may primarily reflect the accuracy of the numerical solver rather than the effectiveness of neural PDE correction. This raises a fundamental question about whether APIC should be characterized as a neural correction framework.

  3. Although the paper emphasizes PDE-class routing as its central contribution, the routing mechanism is a manually specified lookup table involving only three PDE classes. The experiments do not convincingly establish that routing contributes improvements beyond selecting strong numerical solvers independently for each equation.

  4. The selected analytical methods are designed with knowledge of the reference numerical schemes, particularly for Navier–Stokes. This potentially gives APIC an advantage over generic inference-time correction methods and raises concerns about whether the results reflect broadly applicable correction capabilities or close agreement with a particular reference solver.

Questions for authors

In the Navier–Stokes branch, APIC completely bypasses the pretrained neural predictor and directly evolves the state using an analytical numerical scheme. In this case, how does APIC fundamentally differ from simply replacing the neural surrogate with a conventional numerical solver?

4 comments

We thank the reviewer for the sharp questions. Two of the main concerns are correct, and we say so directly. Unless marked as submitted, every number below comes from new runs: new trajectories, selection on validation, and a single scoring of the test set.

Q. On NS, how does APIC differ from replacing the surrogate with a conventional solver?

It does not. On Navier–Stokes the branch is a conventional solver. The network is never called, and the three NS cells are one solver evaluated three times.

That solver is also close to the data generator:

  • The generator is pseudo-spectral (2/3 dealiasing, explicit-Euler advection, Crank–Nicolson diffusion, Δt = 0.01). Our Strang step differs only in using exact diffusion half-steps.
  • Measured against an independent near-exact reference (ETDRK4 at Δt/20, fp64), Strang's reduction over PhysicsCorrect falls from 93% to ≈68%.
  • A standard ETDRK4 or IMEX step at the same Δt is then 11× more accurate than Strang (1.2·10⁻⁵ vs 1.4·10⁻⁴).

We also tested the alternative implied by the question: a hybrid that keeps the frozen network in the loop, in the style of solver-in-the-loop. The update is

u ← Strang(u) + ε·tanh(g_φ(f_θ(u) − Strang(u), …)).

It was trained on newly generated trajectories and selected on validation.

Method (3 architectures × 3 seeds)Error vs generator datams/step, batch 1
Strang, no network (submitted)2.89·10⁻⁵1.2
Hybrid: Strang + bounded head on f_θ − Strang1.19–1.25·10⁻⁵3.5–7.6
Same head, network input zeroed1.17–1.29·10⁻⁵1.8
Strang + α(f_θ − Strang), α chosen on validationα = 01.2

Against the near-exact reference (ETDRK4 at Δt/20, fp64; head retrained and selected on that target, same 3 × 3 grid): Strang 1.40·10⁻⁴, hybrid 1.01–1.52·10⁻⁵, no-network control 0.86–1.16·10⁻⁵. The blend picks α ≤ 0.003 and changes the error by < 0.4%. The conclusion is the same: the head helps, the network does not.

What the table shows:

  • The head improves on Strang.
  • The network adds nothing to that improvement: the control without network information is equally good, and the zero-training blend picks α = 0.

Revisions.

  1. NS is described as a solver-replacement case, not a correction.
  2. We state that its gain comes mostly from matching the generator's scheme.
  3. Every aggregate is reported three ways:
AggregateSubmitted S2Leakage-free, no learned heads
Nine-cell mean83.48%81.18%
NS counted once80.66%77.86%
Without NS78.54%75.38%

W2. Agreed; see above.

W4 (generator knowledge). Agreed and quantified above. Against an independent reference, the NS gain drops from 93% to ≈68%. On KS the same pattern holds: one ETDRK4 step at Δt with no network (the KS generator's own scheme) is 99.98% better than PhysicsCorrect at 1 ms, far better than any corrected variant. The Limitations now state that the analytical branches benefit from knowing the generator's scheme.

W3 (does routing add anything beyond picking a strong solver per equation?). This is the right control, and we ran it on all 27 cells (3 classes × 3 architectures × 3 seeds). All arms share one candidate set:

  • PhysicsCorrect;
  • network only;
  • exact-linear splitting;
  • Crank–Nicolson with M sub-steps;
  • Numerov;
  • Verlet;
  • on NS, also ETDRK4 at Δt.

Choices are made on validation and the test set is scored once. No learned heads are used.

ArmNine-cell meanNS counted onceWithout NS
Best single family (CN, M tuned per class)+14.7%−0.5%−11.9%
Per-class choice on validation+85.3%+83.2%+81.6%
Per-cell choice on validation+85.3% (same as per class in all 27 cells)
  • The best single family loses 92% on Wave, so the update family must depend on the class.
  • Per-cell selection never departs from per-class selection, so nothing finer than the class is needed.
  • In every class the selected update is a strong classical step: sub-step CN on KS, the split step on NS, and the exact two-level propagator (no network) on Wave. On Wave, validation does not pick the Numerov branch we submitted.

We therefore agree with the reviewer's reading. The evidence supports "pick a strong solver per equation class". It does not support a learned correction mechanism.

On a new equation the class rule still transfers:

  • We froze the rule before running two held-out equations from the ANCHOR suite.
  • Validation picks the same rule for every seed. Gains over PhysicsCorrect are +96.7% on Burgers and +99.6% on Allen–Cahn.
  • The wrong class is 50–53× and 4.2× worse than PhysicsCorrect.
  • A plain ETDRK4 step is about as good, again with no network.

W1 (classical components; manual selection). Agreed. We do not claim a new numerical scheme. The contribution is rewritten as an empirical study of one question: should the correction family depend on the equation class? It is supported by the paired ablation above and stated together with the negative findings.

Where the frozen network does help. Across the three classes there is one case, sub-step CN on KS with a learned term on the network's defect. We retrained it on new trajectories and selected it on a never-scored calibration file. With the learned term, 32 sub-steps (21 ms/step) reach a 77.5% reduction over PhysicsCorrect. That beats 100 or 400 sub-steps without it (68–71%, 57–222 ms). On Wave the retrained term adds ≈0.5%. On NS it adds nothing.

Corrections from our re-audit.

  • Wave and KS heads. The submitted refinement heads were trained on part of the scored test trajectories, and the reported checkpoint was the test-best iterate.
  • FAPC. The KS-FNO FAPC constants were tuned on the test file.
  • Denominators. Two KS-FNO cells in S1 and S4 were divided by the PhysicsCorrect error of a different checkpoint. Corrected, S1 is 83.43%, below S2 (83.48%), not above it.
  • Effect. With every leaked component retrained on clean splits, S2 is unchanged at 83.48%. Its composition is now stated explicitly: solver replacement on NS, a classical step on Wave, and sub-stepping plus a learned term that helps in about half of the cells on KS.
  • Presentation. We are rewriting the method section, the setup table and the claims to match these findings.

Part 1/2

Since our first reply we have run further experiments on the reviewer's two central questions: whether routing adds anything beyond picking strong solvers (W3), and what role the network plays (W2, Q). In summary:

  • Routing transfers to new equations. On four held-out equations, two of them mixed-class, the rule fixed in advance is the one validation selects in all 12 runs. It improves on PhysicsCorrect by 95.3–99.6%.
  • APIC does not depend on the surrogate. On KS at M ≥ 32, FNO, U-Net and ViT reach the same corrected error to within 0.9%, although their own errors differ by 7–10×.
  • One correction. The learned KS term helps just as much without network input. We therefore withdraw our earlier sentence "Where the frozen network does help" (item 2).

1. Routing contributes beyond any single strong solver (W3, W1)

Within the benchmark (paired ablation, 27 cells, one candidate set, validation selection):

  • Per-class choice gives +85.3% over PhysicsCorrect, against +14.7% for the best single family. That is +70 points from routing alone.
  • Per-cell choice equals per-class choice in all 27 cells. The class label is therefore all the router needs: there is no tuning per architecture or seed.
  • Wave. PhysicsCorrect's error equals Verlet-FD4's to five significant digits in all nine cells, so the shared template does nothing on Wave. The class-specific update gives +82.8% (submitted Numerov) and +95.2% (validation-chosen).

Held-out equations. For each equation the rule was frozen, and its assignment recorded, before any run. The reference is ETDRK4 at Δt/20 in fp64. Three FNO surrogates are used, with validation selection among APIC's candidates and test scored once; plain ETDRK4 at Δt is reported as an outside reference.

Held-out equationTermsValidation picks frozen ruleGain over PhysicsCorrectWrong row (× PhysicsCorrect error)
Burgersadvection, diffusion3 / 3+96.7–96.8%50–53×
Allen–Cahndiffusion, reaction3 / 3+99.6%4.2×
u_t = −uu_x + 0.05u_xx + u − u³advection, diffusion, reaction3 / 3+98.7–98.9%13–16×
KdV–Burgers (δ = 0.002)advection, diffusion, dispersion3 / 3+95.3–96.8%36–52×
  • The rule picks the right update on every unseen equation, including the mixed ones.
  • A wrong class label costs up to two orders of magnitude, so the routing decision is what matters.
  • Comparison with ETDRK4. A plain ETDRK4 step at Δt is a strong alternative here. The frozen rule beats it on Burgers (+96.7% vs +96.0%) and on KdV–Burgers (+95.3–96.8% vs +93.0–95.1%). It is slightly behind on Allen–Cahn and on the reaction equation. Both are integrators for the same class row, which is consistent with the per-class view.
  • Scope. The revision states the limit: the table has no rule for equations outside its rows, such as non-dissipative or coupled multi-class systems.

Part 2/2

2. The network's role: APIC is surrogate-agnostic (W2, Q; one correction)

Removal test. On KS and Wave we removed the network from both places it enters, and changed nothing else:

  • the first guess of the classical step, which becomes one ETDRK4 step;
  • the input of the learned term, which is zeroed on Wave, or restricted to the classical result.

Findings:

  • KS without the learned term. At M ≥ 32 the error is the same for all three architectures to within 0.9% (0.5% at M = 100). Their network-only errors are 0.086–0.12 (FNO, U-Net) and 0.82–0.89 (ViT). Replacing the network guess with ETDRK4 changes the error by at most 0.4% at M = 100.
  • KS with the learned term. Nine-cell gain over PhysicsCorrect:
MLearned term with network inputLearned term without network
123.9%36.2%
858.5%58.4%
3277.5%73.1% (7 head seeds, median 73.9%)
10074.9%74.3%
  • Wave. The network-free learned term matches the network one: ≤ 0.4% difference over 15 steps, ≤ 3.3% over 199 steps.

What this gives a practitioner. APIC reaches the same accuracy whatever frozen surrogate it is given, including a weak one (ViT here). The surrogate does not need to be retrained, selected or even accurate.

Correction. Our earlier reply attributed the KS learned-term gain to the network. The term does help, but it works equally well without network input. Its spread over head seeds (59–86% on the FNO cells at M = 32) explains the earlier cell-to-cell pattern. We withdraw "Where the frozen network does help".

Effect on the headline.

  • S2 families plus the network-free term give 83.30 / 80.59 / 78.56% (nine cells / NS once / without NS), against the submitted 83.48%.
  • With the validation-chosen class updates instead, the same leakage-free pipeline gives 87.45 / 85.92 / 84.78%.

Answer to the Question, extended. On NS, as we said, APIC is a conventional solver. More generally, on all three classes the accuracy is set by the classical update chosen for the class. What APIC adds over "use a conventional solver" is two things:

  • it knows which solver to use for each class, and that choice is validated and frozen before it meets new equations;
  • a cheap learned term. With it, M = 32 (73–77.5%) beats M = 100–400 without it (68–71%) at about 3–11× lower cost.

3. Efficiency

  • NS. The branch is faster than the surrogate it replaces: 1.2 ms per step against 2.3–7.0 ms on the same GPU (0.25 against 0.96–2.45 ms in the paper's Table 11). Its warm-up is 0.05 s, against 8.7 s for PhysicsCorrect's Jacobian.
  • No Jacobian. APIC's branches need no Jacobian; the NS and KS linear solves are diagonal in Fourier space.

4. Presentation: the reframed contribution

Proposed central claim:

"For a frozen neural PDE surrogate, which update should run at inference? Choosing it by equation class beats every single family (+85% vs +15% over PhysicsCorrect), needs no per-cell tuning, transfers to four held-out equations, and gives the same accuracy for any of three surrogate architectures."

Structure:

  1. The question and the routing ablation.
  2. Per-class results, with NS labelled solver replacement and also scored against an independent reference.
  3. Held-out equations.
  4. Surrogate-independence controls.
  5. Cost and horizon.
  6. Limitations: knowledge of the generator, the 200-step horizon, and the scope of the lookup.
Reviewer_jQ83OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

Neural PDE simulators, simulate how physical system evolve over time described by a PDE. The errors made by these simulators can grow over time for long range predictions. Inference time correction uses a shared correction template to avoid this issue. The paper argues that shared correction template can impose restrictions and present APIC which selects analytical update according to equation's numerical structure. The objective is to reduce prediction error without retraining.

Critical strengths
  • Very good central idea, as authors use known PDE properties to select correction methods.
  • Strong benchmarking results on selected equations.
  • Useful comparisons with good diagnostics.
Critical weaknesses
  • Limited generalization as only three PDEs are tested.
  • Weak evidence for routing as a cause.
  • High computational costs and limited long-term accuracy for KS.
Questions for authors
  • Can you isolate the effect of PDE class routing?
  • Does NS solver closely match the reference data generator?
4 comments

We thank the reviewer for the clear questions. Answering them required new experiments and a re-audit of our pipeline, which changed some of our claims. We report the results as they came out.

Q1. Can you isolate the effect of PDE-class routing?

Yes. We ran a paired ablation. All arms draw from the same candidate set: PhysicsCorrect, network only, exact-linear splitting, Crank–Nicolson with M sub-steps (M ∈ {1, 10, 100}), Numerov, Verlet, and on NS also ETDRK4 at Δt. The arms differ only in how the update is chosen:

  • (i) the best single family for all classes;
  • (ii) per-class selection;
  • (iii) per-cell selection;
  • (iv) the families of our submitted lookup S2.

Every choice is made on a validation split of new trajectories from the same generator, and the test set is scored once. No arm uses a learned head, so the comparison is not affected by the selection leakage we found (Part 2).

Error reduction over PhysicsCorrect on test, 27 cells (3 classes × 3 architectures × 3 seeds):

ArmChoice (KS / NS / Wave)KSNSWaveNine-cell meanNS counted onceWithout NS
Best single familyCN (M=100 / 1 / 1)+68.0+67.7−91.7+14.7−0.5−11.9
Per classCN-100 / split / exact propagator+68.0+92.8+95.2+85.3+83.2+81.6
Per cellidentical to per class in all 27 cells+85.3+83.2+81.6
S2 familiesCN-100 / split / Numerov+68.0+92.8+82.8+81.2+77.9+75.4

The other single families are worse still. Network only averages −120%, and splitting diverges on KS.

Conclusions:

  1. Class dependence is real. No single family works on all three classes; the best one loses 92% on Wave. Choosing per class recovers +85% (+70 points).
  2. The class is what decides the choice. Per-cell selection agrees with per-class selection in all 27 cells, so the choice does not vary by architecture or seed.
  3. The selected updates are classical steps. On NS validation selects the split step, which is in the generator's family (Q2). On Wave it selects the exact two-level propagator (2cos(ωΔt), no network, 1.34·10⁻⁴), not the Numerov branch we submitted (4.85·10⁻⁴).

The evidence therefore supports "the update family should be chosen per equation class". It does not support a learned correction mechanism. We will revise the paper accordingly.

Q2. Does the NS solver closely match the reference generator?

Yes, and we now state this plainly.

The generator is the PhysicsCorrect NS script:

  • vorticity form on [0,1]², periodic, 64² grid;
  • stream function by spectral Poisson solve ψ̂ = ŵ/(4π²|k|²), 2/3 dealiasing;
  • forcing 0.1(sin 2π(x+y) + cos 2π(x+y)), ν = 10⁻³;
  • Δt = 0.01, with explicit-Euler advection and forcing and Crank–Nicolson diffusion.

Our Strang step (Eq. 3) shares all of these and differs only in using exact diffusion half-steps instead of CN.

We then changed only the reference. The test initial conditions, network and grid are fixed, and the near-exact reference is ETDRK4 at Δt/20 in fp64. Mean relative L2 over 200 steps:

Methodvs shipped datavs near-exact reference
PhysicsCorrect (3 architectures)3.99–4.01·10⁻⁴4.35–4.37·10⁻⁴
Strang (submitted)2.89·10⁻⁵1.40·10⁻⁴
Generator's own scheme1.0·10⁻⁵1.28·10⁻⁴
ETDRK4 at Δt1.28·10⁻⁴1.22·10⁻⁵
IMEX Heun–CN at Δt1.28·10⁻⁴1.26·10⁻⁵
  • The gain mostly comes from matching the generator. Against the independent reference, Strang's reduction over PhysicsCorrect falls from 93% to ≈68%, and standard schemes at the same Δt are 11× more accurate than Strang.
  • The network is not used on NS. The NS branch never calls it, so we present NS as solver replacement, not correction. Every aggregate is now also reported with NS counted once and without NS.

W1. Only three PDEs.

We added two held-out equations from the ANCHOR suite: Burgers (ν = 0.05) and Allen–Cahn (ε = 0.01).

  • Router frozen in advance. The rule "first-order dissipative → sub-step CN, M = 100" was written to the output file before any run.
  • Setup. References are ETDRK4 at Δt/20 in fp64, and the FNO surrogates were trained on a separate split. We used three surrogate seeds.
  • Same choice from validation. For every seed, validation selection over the candidate set picks the frozen rule.
  • Gains over PhysicsCorrect. Burgers +96.66 / +96.76 / +96.78%; Allen–Cahn +99.56% for all three seeds.
  • Wrong class. Routing to the NS-type splitting rule is 50–53× (Burgers) and 4.2× (Allen–Cahn) worse than PhysicsCorrect, so the class label matters.
  • Caveat. A plain ETDRK4 step at the same Δt, with no network, is about as good on Burgers (8.8·10⁻⁶ vs 7.3·10⁻⁶) and 10× better on Allen–Cahn (3.5·10⁻⁶ vs 3.3·10⁻⁵). This repeats the Q1 finding: the gain belongs to the classical step.

W2. Weak evidence for routing as a cause. See Q1.

W3. KS cost and long-horizon accuracy.

We ran sub-step CN on all nine KS cells for M = 1–400, with and without the learned term. For each M the learned term was retrained on new trajectories and selected on a never-scored calibration file. Latency follows the Table 8 protocol (batch 1, median per step); our M = 100 and M = 400 timings match Table 8 to within 2%.

Error reduction over PhysicsCorrect is the mean over steps 1–200, nine-cell mean (min, max):

Mms/stepno learned termwith learned term
11.6–2.2+3.9% (−3.4, +12.9)+23.9% (+3.4, +46.4)
22.2–2.8−34.9%—
86.4–7.0+28.1%+58.5% (+42.2, +71.8)
3220.3–20.6+59.8%+77.5% (+69.9, +85.8)
10057+68.1% (+54.0, +78.1)+74.9% (+54.8, +88.9)
400222+71.0% (+58.6, +79.8)+72.6% (+59.1, +81.7)

For reference, at batch 1:

Methodms/stepError
Network alone1.0–1.6—
PhysicsCorrect1.3–1.9—
ETDRK4 at Δt (the generator's scheme, no network)0.961.2·10⁻⁵ (+99.98%)

What this shows:

  • Cost. Without the learned term, M = 100 costs 30–45× a PhysicsCorrect step. Small M (2–4) is worse than PhysicsCorrect.
  • Where the learned term helps. With it, M = 32 (21 ms) beats M = 100–400 without it, at 3–11× lower cost. This is the one place where the frozen network adds value.
  • The strongest option uses no network. The generator's scheme beats every corrected variant.

Long horizon.

  • Window means. Over steps 1–600 the reductions are 19–21% without the head (M = 100–400) and 21–24% with it (M ≥ 32).
  • Pointwise. The nine-cell mean error at step t falls by 76% at t = 50, 65% at t = 200, 45% at t = 300, 20% at t = 400 and ≈0 at t = 600. By step 600 every method sits on the same plateau (relative L2 ≈ 1.39).
  • Interpretation. On KS the method delays saturation; it does not keep the chaotic trajectory past the Lyapunov time.

The revision adds these curves, the M = 100 / 400 costs to Table 8, and the 200-step horizon to the abstract.

Corrections found during our re-audit (relevant to the numbers above).

  • Wave and KS heads. The refinement heads were trained on part of the scored test trajectories, and the reported iterate was the test-best one.
  • FAPC. The KS-FNO FAPC constants were chosen on the test file.
  • Retraining on clean splits (new trajectories, calibration-selected, test scored once):
    • KS heads add +22% over sub-stepping, in about half of the cells.
    • Wave heads add ≈0.5%.
    • The FAPC refit lowers its cell by about 9 points.
  • The headline survives, but its composition changes. The leakage-free S2 with clean KS heads is 83.48% (submitted 83.48%): solver replacement on NS, a classical step on Wave, and sub-stepping plus a learned term on KS.

Thank you for your thorough response and adding new experiments. My concerns are now resolved. I maintain that this is a good idea with weaknesses. I retain a positive outlook towards the paper and will keep my scores.

We thank the reviewer for reading our response and the new experiments, and for the positive assessment.

We agree with the reviewer's summary: the idea is sound, but it has weaknesses. The revision states them directly:

  • What the evidence supports. The update family should be chosen per equation class. In the paired ablation, per-class choice gives +85.3%, against +14.7% for the best single family, and per-cell choice matches per-class choice in all 27 cells. The evidence does not support a learned correction mechanism, and the paper no longer claims one.
  • NS. NS is described as solver replacement. Its gain is attributed to matching the generator's scheme: against an independent reference, the reduction falls from 93% to ≈68%.
  • Where the frozen network adds value. There is one place: sub-step CN on KS with a learned term. With it, M = 32 (21 ms per step) reaches 77.5%, which beats M = 100–400 without it.
  • KS horizon. KS gains are reported as a delay in saturation, within a 200-step horizon.
  • Selection. The selection leakage is corrected throughout. Every reported number is now selected on validation or calibration data, and test is scored once.

Thank you again for the constructive questions. The routing ablation and the held-out-equation test both came directly from them.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.