- 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
-
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?
-
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.
-
Why do Figure 6c and Figure 10b give different slopes for the same Verlet and Numerov sweeps? Which fit matches the saved logs?
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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
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).
| Method | Error vs generator data | ms/step |
|---|---|---|
| Network alone | — | 2.3 / 7.0 / 2.5 |
| Strang, full replacement (submitted) | 2.89·10⁻⁵ | 1.2 |
| Strang + bounded head on f_θ − Strang | 1.19–1.25·10⁻⁵ | 4.1 / 7.6 / 3.5 |
| Same head, network input zeroed | 1.17–1.29·10⁻⁵ | 1.8 |
| Strang + α(f_θ − Strang), α chosen on val | α = 0 | 1.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)
| Policy | Nine-cell | NS counted once | Without NS |
|---|---|---|---|
| S1 submitted / denominator matched | 83.73 / 83.43 | 80.97 / 80.60 | 78.91 / 78.47 |
| S2 | 83.48 | 80.66 | 78.54 |
| S3 | 72.56 | 73.94 | 74.97 |
| S4 submitted / denominator matched | 81.68 / 81.27 | 78.34 / 77.82 | 75.84 / 75.23 |
| S2 families, no learned heads (leakage-free) | 81.18 | 77.86 | 75.38 |
| Same + KS heads retrained on clean splits | 83.48 | 80.82 | 78.82 |
Raw-error means for S2 vs PhysicsCorrect:
| S2 | PhysicsCorrect | Reduction | |
|---|---|---|---|
| KS | 1.68·10⁻² | 6.44·10⁻² | −74% |
| NS | 2.66·10⁻⁵ | 4.00·10⁻⁴ | −93% |
| Wave | 4.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):
| M | ms/step | No learned term | With learned term |
|---|---|---|---|
| 1 | 1.6–2.2 | +3.9% (−3.4, +12.9) | +23.9% (+3.4, +46.4) |
| 2 | 2.2–2.8 | −34.9% | — |
| 4 | 3.5–3.8 | −3.9% | — |
| 8 | 6.4–7.0 | +28.1% | +58.5% |
| 16 | 11.4–11.7 | +47.8% | — |
| 32 | 20.3–20.6 | +59.8% | +77.5% (+69.9, +85.8) |
| 100 | 57 | +68.1% (+54.0, +78.1) | +74.9% (+54.8, +88.9) |
| 200 | 111 | +70.0% | — |
| 400 | 222 | +71.0% (+58.6, +79.8) | +72.6% (+59.1, +81.7) |
Reference costs at batch 1:
| Method | ms/step | Error (reduction) |
|---|---|---|
| KS-FNO step | 1.0–1.6 | — |
| PhysicsCorrect | 1.3–1.9 | — |
| ETDRK4 at Δt, no network (the generator's scheme) | 0.96 | 1.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.
| Seed | Submitted | Refit |
|---|---|---|
| 0 | 1.53·10⁻² | 2.38·10⁻² |
| 1 | 1.12·10⁻² | 1.58·10⁻² |
| 2 | 1.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.
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
Q1 (NS generator; change the time scheme)
Generator. It is the PhysicsCorrect NS script:
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:
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.