acceptodds
Under review as a conference paper at ICLR 2027

Learning Inside Finite-Volume Computations with Effective Interface States

Abstract

Finite-volume methods provide a powerful framework for physical simulation by expressing conservation laws through local exchanges on a mesh. Building directly on their reconstruction–flux–update structure, we introduce the Finite-Volume Graph Neural Operator (FV-GNO), which learns the interface approximation within a prescribed numerical update rather than the full state transition. A graph network decodes effective two-sided interface states, while prescribed numerical fluxes, source treatment, and geometric assembly advance the solution. Trained end-to-end on state observations alone, these interfaces are optimized for prediction over the observation interval, without requiring interface or flux labels. The paired formulation inherits local balance for arbitrary network parameters, while a constructive analysis illustrates how retaining known nonlinear computation can provide a representation advantage beyond conservation alone. Experiments across diverse nonlinear equations on regular and irregular meshes demonstrate improved prediction over the evaluated neural baselines. On regular grids, FV-GNO also achieves higher accuracy and lower rollout cost than the tested second-order finite-volume schemes. Coarse-grid pretraining further enables accurate fine-grid prediction with few target trajectories.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Neural operator, Graph neural network, Finite-Volume Method

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_EqFXOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes a hybrid data-driven approach to solve PDE problems that combines finite-volume computations and flux updates with a GNN backbone that provides intermediate features, from which the states at the interacting surfaces and, subsequently, the final updates are computed. By following conservative flux updates, the model is consistent with the underlying equations, provided the state values at the surfaces are consistent.

Results indicate the effectiveness of the model against some classical baselines for PDE problems. Additionally, the authors experiment with pretraining a model and fine-tuning it on some higher-resolution trajectories, achieving great results when testing on such finer meshes.

Critical strengths
  • Although not completely new, the main idea of the paper is sound, as it is based on a well-established classical methodology for solving PDEs combined with neural methods for intermediate calculations. How to calculate these intermediate quantities is often a difficult design choice and strongly influences the final results. Hence, the problem is relevant.
  • The results on fine-tuning to finer meshes are very interesting and good.
Critical weaknesses

There are several critical issues in this paper:

  • The methodology is not completely new and, given the currently writing of the paper, it is difficult to really isolate the different to existing methods that combine finite-volume with GNNs or other neural networks. For example, there are [1,2]. The authors should provide more comparisons with these methods, both from a methodological and experimental point of view. Especially, I am interested in the comparison with [1], which does not seem substantially different but has way worse results.
  • Furthermore, the methods that the authors compare to FV-GNO are very few, with many different methods being developed after the introduction of the FNO and U-Net. For example, GINO, which the authors cite, is a more comparable baseline for irregular meshes. Since the model loss is also physics-inspired, other such methods informed by the equations (for example, [3]) should be compared. Furthermore, MeshGraphNetworks and their derivatives are also cited but not really evaluated, and have shown great performance lately. For example, see [4].
  • It is not clear what is the method used to calculate the reference solution, as it simply referred to as DG. Furthermore, I am not convinced by the time comparison with this method, as they report "no GPU time". It is still interesting to see the time comparison with the reference solution, in any way it was calculated.
  • Almost every section is too succint and feels like a summary of what it should contain. The authors sometimes provide very specific details on not-so-relevant choices, and then almost no detail on the main architecture. For example, what GNN backbone is used? What is RθR_{\theta} in Eq. 2? (Almost no detail on the latter equations is given. What does it mean that "Additional irregular-mesh neighbors provide context but do not add physical exchange faces."? The terminology is also not common for a paper in the field of AI. The "efficient graph execution" paragraph is very difficult to get the head around. Overall, the paper is very difficult to understand with no detail.
  • I am not convinced by the claim related to "The reference solver may take multiple internal steps between two observations, whereas one learned update spans their full interval Δt\Delta t" (lines 239-240). Looking at Section 3.2, the employed GNN also stacks multiple layers to calculate an update.
  • The theoretical analysis is very hard to follow: short sentences with no interpretation, every detail is left to the appendix, the main propositions introduce a lot of terms without further explanations, and they have no clear interpretation of the methods.

Overall, the paper is really hard to follow and does not provide much information as it is.

[1] Masanobu and Mitsune, "Graph Neural PDE Solvers with Conservation and Similarity-Equivariance", ICML 2024.

[2] Li et al., "Predicting unsteady incompressible fluid dynamics with finite volume informed neural network", 2024.

[3] Li et al., "Physics-Informed Neural Operator for Learning Partial Differential Equations", 2021

[4] Hoang et al., "Improving Long-Range Interactions in Graph Neural Simulators via Hamiltonian Dynamics", ICLR 2026.

Questions for authors

See the weaknesses above. Furthermore:

  • In the caption of Table 1: what does it mean that "five-state models score after context"? What are five-state models?
  • Please add the computational times of the reference solution, and comment on possible advantages of the model.
  • What is a direct nodal predictor (line 439)? Is it a simple GNN or something closer to a MeshGraphNet?
8 comments
AuthorsOpenReview ↗

Methodological Distinctions, Additional Experiments, and Presentation Improvements

Thank you for the suggestions. We removed less essential details and clarified the method and theory. W1-W6 follow your six weaknesses; Q1-Q3 denote your additional questions.

W1. Differences from FLUXGNN and FVGN. FLUXGNN evolves conservative latent states with linear encoding and left-inverse decoding (DE=IDE=I); our task adaptation retains this structure. FV-GNO decodes effective left/right physical states from nonlinear graph features, then applies prescribed fluxes, sources, coefficients, and geometry. Observed transitions train these states over the saved interval. Regular-grid balance is imposed by shared physical fluxes in the final assembly.

Sharp-front capture motivates the two-sided design. Rusanov uses Φ=Fn(U−)+Fn(U+)2−α2(U+−U−),\Phi=\frac{F_n(U^-)+F_n(U^+)}{2}-\frac{\alpha}{2}(U^+-U^-), where Fn=F⋅nF_n=F\cdot n and α\alpha estimates wave speed. Separate states retain jumps for transport and dissipation; shared fluxes enter neighboring updates with opposite signs. Sharp-region results:

TaskRMSE reduction vs. FLUXGNN
Burgers67.4%
KPP82.8%
Flat SWE63.7%

Topographic SWE requires pressure-flux/bed-source balance; small depths can amplify velocity errors. This may help explain FLUXGNN's large errors on this task.

On the FLUXGNN authors' released 1D convection-diffusion data, we use their training setup, replacing only the model. FV-GNO achieves MSE 1.578×10−81.578\times10^{-8}. The original FLUXGNN paper reports test MSE 3.080×10−53.080\times10^{-5}.

FVGN learns face velocity, pressure, and flux compensation with spatial integration and face supervision. We retain prescribed flux/source calculations with state-only supervision.

W2. Additional baselines and loss. We train with normalized state MSE, with physics built into the forward update. We added GINO and an independent MeshGraphNet (full-rollout Macro-RMSE):

TaskFV-GNOGINOMeshGraphNet
Burgers0.0120.0720.028
KPP0.0360.1510.061
Flat SWE0.0120.0400.022
SWE + topo.0.0040.0360.010
Euler0.1010.1560.215

All use original splits, one input frame, the same boundary data, and full horizons. The revised Related Work also clarifies our relation to PINO and IGNS.

W3 / Q2. Reference solver and cost. Reference trajectories use Trixi shock-capturing DG: degree four for Burgers, three otherwise (Appendix B.1). DG2 is a separate degree-two comparator. Its implementation lacks a GPU backend, explaining "no GPU time." DG2 uses an eight-thread Xeon Gold 6459C/Float64; FV-GNO uses RTX 5090/FP32. The table reports full-test Macro-RMSE and warmed rollout times:

TaskDG2 RMSECPU (s)FV-GNO RMSEGPU (s)
Burgers0.01056.7700.0120.675
KPP0.08112.3710.0350.661
Flat SWE0.00730.7090.0120.741
SWE + topo.0.00457.1980.0040.497

Under matched GPU settings, FV-GNO is more accurate and 2.1-9.7 times faster than the tested FV2 schemes.

W4 / Q3. Architecture, assembly, and nodal controls. The GNO processor has ten width-120 blocks: ziℓ+1=σ(LN[Wℓziℓ+∣Ni∣−1∑j∈NiKℓ(ξijℓ)⊙Hℓzjℓ]).z_i^{\ell+1}=\sigma(\mathrm{LN}[W_\ell z_i^\ell+|\mathcal N_i|^{-1}\sum_{j\in\mathcal N_i}K_\ell(\xi_{ij}^\ell)\odot H_\ell z_j^\ell]). σ\sigma is GELU; LN is layer normalization; Wℓ,HℓW_\ell,H_\ell are linear maps; Ni\mathcal N_i is the context neighborhood. Kernels use endpoint features, their differences, and geometry. The decoder outputs (qf−,qf+)(q_f^-,q_f^+); Eq. (2)'s PP is Pi=−ΔtVi∑f∈∂iAfsifΦf+ΔtSi.P_i=-\frac{\Delta t}{V_i}\sum_{f\in\partial i}A_fs_{if}\Phi_f+\Delta tS_i. Af,Vi,sifA_f,V_i,s_{if} are face measure, volume, and orientation; Φf,Si\Phi_f,S_i are flux and source. Context edges pass features; physical faces exchange flux. Execution optimizations cache geometry and combine equivalent operations while preserving the update.

Nodal controls use our processor to predict increments; projection enforces global conservation during training. MeshGraphNet is evaluated separately as an external baseline.

W5. Layers versus physical time steps. Layers transform features at one physical time; assembly advances by Δt\Delta t. Solver substeps advance physical states through intermediate times. Runtime includes all network layers.

W6. Interpretation of theory. Paired assembly preserves local balance for any reconstruction. Proposition 4.1 shows a representation benefit of known nonlinear computation over a specified capacity-limited direct class. Under closed-domain assumptions, Eq. (6) gives an error floor when an invariant excludes the target. Together, these results motivate retaining known physics and choosing constraints compatible with observations.

Q1. Five-state inputs. Five-state models use frames 0-4 as context, scoring 75 subsequent frames (46 for topography). Single-frame models score 79 (50).

Thank you. We would be happy to discuss any further questions.

I wanted to offer a somewhat different read of this paper, in case it’s useful for the discussion. I agree the original submission was dense, but I think the revised PDF may address several of the concerns in your review.

GINO, MeshGraphNet, and Kochkov’s learned interpolation have been added (Tables 1–2). On the regular grids, FV-GNO’s margins over all baselines are well beyond the seed-to-seed variation (Table 7). On FLUXGNN specifically, the gap is large (roughly 60–80% lower error on the homogeneous tasks), and FLUXGNN was unstable on topographic shallow water. The revision also names the reference solver (Trixi DG, §5.1), reports DG2 CPU timings (Table 3), and spells out the architecture and the update operator (§3.2–3.3).

I don’t think the paper is without issues. The Euler margin over GNOT is modest, and as Reviewer YaA9 noted, the learned-flux and MPNN ablations perform comparably. Presentation could still be improved. To me, though, these feel like questions about scope and writing rather than reasons for rejection. Since we both see the core idea as sound, I lean toward thinking the contribution clears the bar.

I’d value your perspective on whether the revision changes your view, and I’m happy to be corrected if I’ve missed something.

Thank you for the authors' responses and the new additions to the manuscript, which improve on the previous version. In particular, the methodological description is now clearer, and the additional experimental comparisons are appreciated.

  • The comparison with FluxGNN is now clearer, although I am concerned about the results obtained. Given the fact that FV-GNO decodes the physical states from the graph features, and there are 10 layers of GNN, is the comparison fair? What is the computational burden compared to FluxGNN? Are the two methods compared fairly? I am also surprised by the results, especially those on the original task from the FluxGNN paper, where FV-GNO performs more than 1000x better. Please provide the setups and a comparison of the number of parameters and inference cost for both the FluxGNN task and the ones from FV-GNO. If they are very different, it would be beneficial to provide a parameter-matched comparison. This is not a blocking issue, but it is important to understand whether the models were evaluated equally or whether the difference in performance is solely due to the better architecture.
  • On a related note, the newly added baselines do not have a description of the training budget and their setups. Given the difficulty of these tasks, and the possible complexity and dimensionality of the models, this is an important comparison to make. The revised manuscript should also include their setups for these tasks to understand if it is correct and where the gap lies.
  • The comparison with FVGN is very short, and the authors do not provide further results on this methodology. I would have liked an experimental comparison with this method as well, but I understand now that time is limited, so this is not necessary now and can be skipped. However, the similarity between the models was dismissed with a very short explanation, which is not satisfactory to me. Both methods predict interface-related quantities from graph features and use them in a finite-volume-inspired numerical update. The authors should explain why decoding two physical interface states instead of velocity, pressure, and flux compensation constitutes a substantive methodological advance.

There is also an important question that has not been solved from the initial W1: the authors claim that a key contribution is the fact that predicting the two-side interface states and combining them in a prescribed flux provides an advantage over the fully learned one. However, Ablations in Table 14 show that, in general, this advantage is not clear and the two possibilities are comparable. This is also particularly important for novelty and the comparison with previous methods and to understand where the major contribution lies (either in the learned two-side interface state, the prescribed flux, or the finite-volume style update).

On a final note, could the authors highlight the changes in the manuscript in a different color? Given the paper's density and the substantial new information, I would like to clearly see how the paper has changed and which parts have been adapted to provide a complete evaluation.

Reviewer_D5ZiOpenReview ↗
Rating
4
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper presents the Finite-Volume Graph Neural Operator (FV-GNO), a framework for modeling spatiotemporal PDEs by integrating graph neural networks into a classical finite-volume update scheme. The graph neural network reconstructs two-sided interface state, which is passed into prescribed, domain-specific numerical flux adapters. The authors evaluate FV-GNO across benchmark systems - Viscous Burgers, non-convex KPP, flat Shallow Water, topographic Shallow Water, and compressible Euler, demonstrating improved rollout accuracy over neural baselines.

Critical strengths

This is a clearly articulated, well-motivated paper that provides a formulation for imparting principled inductive biases into learned neural simulators, derived from finite volume techniques. The work advances a line of research that bridges conventional solvers with neural techniques, leveraging best-of-both scenarios.

The authors provide theoretical grounding for their work that characterizes the error modes.

While graph based architectures incur computational costs associated message passing, they can also enable discretization convergence, with the ability to generalize to new resolutions.

The authors provide a very thorough and rigorous experimental section that covers a broad range of settings. Their baseline includes more recent SOTA models such as GNOT and Transolver.

Critical weaknesses

While the paper demonstrates few-shot cross-resolution transfer, they seem to mainly consider grid based datasets. It would be good to include irregular meshes to show whether the proposed approach can generalize. Showcasing generalization to unseen geometries can strengthen the paper further.

Some of the cost-accuracy comparisons require more explanation. The authors do not report the run-time for the CPU solvers. While apples-to-apples comparison may not be possible, a discussion on the computational requirements may help place the work appropriately among classical solvers. Similarly, the paper lacks a limitation section and a visual presentation of results in the main text. It would be helpful to show pointwise error heatmaps compared to classical solvers and highlight where the model is able to beat other baselines.

Questions for authors

Please refer to the weaknesses above.

2 comments
AuthorsOpenReview ↗

Irregular Meshes, Zero-Shot Transfer, and Computational Cost

Thank you for the positive assessment and the suggestions.

Irregular meshes. Our Euler experiments already evaluate performance on irregular bump-channel graphs. In addition to GNOT and Transolver, we have added two baselines: GINO and an independent MeshGraphNet. The table reports Macro-RMSE on all 20 test trajectories over the full prediction horizon. All methods use one initial state and the same prescribed boundary sequence.

MethodMacro-RMSE
FV-GNO0.101
GNOT0.128
Transolver0.493
GINO (added)0.156
MeshGraphNet (added)0.215

FV-GNO achieves the lowest error among all five models, further supporting its predictive advantage on this irregular-mesh benchmark. Broader unseen-geometry and zero-shot remeshing evaluations are future work.

Zero-shot resolution transfer. We evaluated 642→128264^2\to128^2 transfer without any target-grid fine-tuning, keeping the source-model weights and normalization fixed. The following Macro-RMSE values are measured on target test trajectories disjoint from source training:

TaskZero-shot Macro-RMSE
Burgers0.028
KPP0.187
Flat SWE0.065

Zero-shot refinement is challenging because changing cell size changes the geometric scaling and the effective interface approximation required by the update. Although errors increase relative to fine-tuning, they remain reasonably low in these tests, and FV-GNO retains good predictive performance without target-grid training. These results concern regular-grid resolution transfer, rather than generalization to unseen geometries.

Accuracy and deployment cost. The table gives full-test macro-RMSE and warmed rollout times. The original no GPU time entry meant that the DG implementation used here does not support GPU execution. DG2 is therefore timed on an eight-thread Xeon Gold 6459C in Float64; FV-GNO uses an RTX 5090 in FP32:

TaskDG2 RMSEDG2 CPU (s)FV-GNO RMSEFV-GNO GPU (s)
Burgers0.01056.7700.0120.675
KPP0.08112.3710.0350.661
Flat SWE0.00730.7090.0120.741
SWE + topo.0.00457.1980.0040.497

GPU timings retain their earlier aggregation. Loading and I/O are excluded.

Visual results. Given the main-text page limit and the breadth of the experiments, we assign the additional heatmaps to the final part of the paper's appendix.

Limitations. Paired balance does not guarantee stability or refinement convergence. Wider geometry generalization is future work.

Thank you again for your time and feedback. We would be happy to discuss any remaining questions.

AuthorsOpenReview ↗

Acknowledgement of the Reviewer’s Constructive Feedback and Support

We sincerely thank you for your positive assessment, constructive suggestions, and support for our work. Your thoughtful feedback has helped us improve the clarity and presentation of the paper. We greatly appreciate your careful review and the time and attention you have devoted to our work.

Reviewer_YaA9OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes FV-GNO, a method to predict various nonlinear equations on regular and irregular meshes by learning the finite volume update rather than the full state transition. A graph network predicts the solution values of both sides of the interface states, while prescribed numerical fluxes perform the standard finite volume update advances the solution. As each face flux is shared by its two cells, this method preserves local balance for any network parameters. Training uses only next state MSE. The authors evaluate FV-GNO on several 2D periodic problems and one Euler problem on irregular meshes, reporting better accuracy than neural baselines.

Critical strengths

The authors clearly differntiate between the learned and fixed components and the results in Section 5.5 are interesting, evaluating whether local structure matters over a global invariant.

Critical weaknesses

The main weakness of the paper is its novelty and related work. For example, Bar-Sinai et al. and Kochkov et al. learn face interpolation inside a FV solver and train end to end, similar to FV-GNO. Joo et al. also predict the interface values that feed a numerical flux on unstructured meshes. None of these works are cited. In particular, Kochkov et al. is cited only to motivate solver cost, when their work also constrains face values depending on the neighboring cells.

Another concern is that the experiments don't show that the two main components are important:

  1. learning the face values is beneficial compared to learning the flux directly. In Table 14, the variant that learns the flux directly works just as well on all 4 regular grid tasks.
  2. using a GNO: replacing a GNO with a MPNN gives the same or better results on all regular tasks (Table 18).

References:

  • Bar-Sinai, Y., Hoyer, S., Hickey, J., & Brenner, M. P. (2019). Learning data-driven discretizations for partial differential equations. Proceedings of the National Academy of Sciences, 116(31), 15344–15349. https://doi.org/10.1073/pnas.1814058116
  • Kochkov, D., Smith, J. A., Alieva, A., Wang, Q., Brenner, M. P., & Hoyer, S. (2021). Machine learning–accelerated computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21), e2101784118. https://doi.org/10.1073/pnas.2101784118
  • Joo, J., Kim, D., You, H., & Kim, C. (2024). A data-driven reconstruction for unstructured finite volume method on multi-dimensional compressible flows. Communications in Computational Physics, 36(5), 1307–1338. https://doi.org/10.4208/cicp.OA-2024-0063
Questions for authors
  1. Can you test zero-shot resolution transfer without fine tuning, e.g. 64^2 -> 128^2? Why is finetuning required for a GNO?
3 comments
AuthorsOpenReview ↗

Novelty, Component Analysis, and Cross-Resolution Transfer

Response to Reviewer 1

Thank you for the questions on novelty, components, and transfer.

W1. Novelty, related methods, and sharp fronts. Finite-volume methods are an influential, widely used foundation for solving conservation and balance laws, so it is natural for different learning methods to draw on them. A shared finite-volume foundation still leaves substantial room for innovation in the learned representation, its coupling to physics, and its training. Bar-Sinai et al. learn discretization coefficients; Kochkov et al. learn constrained interpolation weights with end-to-end training. FV-GNO instead directly decodes effective left/right physical interface states from graph context, rather than stencil weights. Joo et al. improve conventional finite-volume solvers through learned spatial reconstruction using analytic-function examples, rather than train a neural operator for PDE evolution from trajectories. FV-GNO instead learns an observation-interval evolution operator from state transitions, optimizing interface states end-to-end through prescribed updates without interface labels. Unlike FLUXGNN's conservative latent propagation, our regular-grid balance is imposed in physical-state assembly, leaving the graph processor flexible. Our contribution is the integrated interface parameterization, physics coupling, and observation-interval training, rather than finite-volume methods alone. The revised Introduction and Related Work clarify these distinctions.

Our two-sided predictor--Riemann-solver design targets shocks and sharp fronts. The prescribed solver uses state jumps and equation-specific wave speeds for transport and dissipation, e.g., −α(U+−U−)/2-\alpha(U^+-U^-)/2 in Rusanov. Shared fluxes enter neighboring updates with opposite signs, preserving regular-grid local balance. Appendix C.3 reports front recall within one grid cell of 0.998, 0.989, and 0.920 for Burgers, KPP, and flat SWE, respectively.

We added a task-adapted Kochkov learned-interpolation baseline (Macro-RMSE):

TaskFV-GNOKochkov interpolation
Burgers0.0120.023
KPP0.0360.253
Flat SWE0.0120.017

W2.1. Prescribed versus learned fluxes. Both variants belong to our finite-volume framework and first decode effective left/right interface states. One then applies a prescribed numerical flux; the other replaces this calculation with a neural network. Both retain regular-grid geometry and paired assembly. Thus, the ablation compares how fluxes are computed, not whether interface states are learned. Table 14 shows similar regular-grid accuracy. Prescribed fluxes lower Euler mean Macro-RMSE from 0.133 to 0.114 and reduce variation across training runs. Mass and energy reference-integral discrepancies decrease by 40.220% and 36.869% (Appendix D.5), while long-horizon equilibrium retention improves (Appendix D.6). These results motivate learning interface states while retaining prescribed numerical fluxes.

W2.2. GNO versus MPNN. Strong MPNN results support processor flexibility. The replacement retains our interface decoder and numerical update, showing that the formulation works with different processors. The independent MeshGraphNet baseline instead predicts nodal increments.

Q1. Zero-shot transfer and short fine-tuning. For 642→128264^2\to128^2, zero-shot evaluation freezes source weights and normalization. Source training, target training, and target testing use disjoint trajectories. Errors are Macro-RMSE:

TaskZero-shot16-shot FTFull FT (3+1)Full scratch
Burgers0.0280.0170.0160.028
KPP0.1870.0490.0430.105
Flat SWE0.0650.0160.0130.022

FT denotes fine-tuning. Full FT uses three one-step epochs followed by one three-step autoregressive epoch. Scratch comparisons use matched target data and optimizer steps.

Fine-tuning improves accuracy; it is not required to run GNO on the finer grid. Parameter dimensions remain unchanged, but cell size changes the interface approximation and ΔtAf/Vi\Delta t A_f/V_i. Although zero-shot errors increase relative to fine-tuning, they remain reasonably low, with good prediction without target-grid training. With 16 target trajectories, pretraining reduces error versus matched 16-shot scratch by 62.8%, 66.1%, and 63.5%; all three also beat full-data scratch. Full-data 3+1 fine-tuning further improves all three tasks.

This supports coarse-grid pretraining followed by brief fine-grid adaptation. The 64264^2 graph has one quarter as many cells as 1282128^2, allowing most optimization on smaller graphs and offering potential training-time savings alongside reduced target-data requirements.

Thank you again for your feedback. We look forward to your response.

I thank the authors for the detailed response and new experiments. The revised related work positions this work better and cleraly states the differences. The new Kochkov learned-interpolation baseline does seem to support the proposed method as well and seems to be a better baseline comparison. There are still some questions, e.g. why is KPP worse than FV2-MM1 on the same grid, the zero-shot results are 2-6x worse than the 128^2 models in Table 1. I think there is still some work to be done on presentation and clarity but I agree on that the proposed method contributes to the literature. I raise my score to a weak accept (not a strong accept as I do not have the background to fully assess the nuances).

AuthorsOpenReview ↗

Acknowledgement and Further Clarifications on KPP Results and Cross-Resolution Transfer

Kurganov, Petrova, and Popov (2007, §5.3) established KPP as a challenging test with a strongly nonconvex flux, F(u)=(sin⁡u,cos⁡u)F(u)=(\sin u,\cos u), whose convexity changes repeatedly across the relevant state range. Its composite shock–rarefaction waves are particularly sensitive to reconstruction and numerical dissipation. In their two-dimensional experiment, MM2, Superbee, and WENO5 reconstructions failed to capture the correct wave structure, while MM1 performed well. This documented sensitivity helps explain the performance differences among classical numerical schemes on KPP.

Our reference calculation explicitly incorporates the entropy treatment needed for this problem: degree-three DGSEM with an entropy-conservative KPP volume flux, local Lax–Friedrichs interface dissipation, and Hennemann–Gassner subcell shock capturing, advanced with SSPRK43 and CFL-controlled time steps. These components combine high-order approximation with entropy dissipation and sharp-front resolution. Rueda-Ramírez, Pazner, and Gassner (2022, §5.1, Fig. 2) demonstrated accurate KPP wave structures using the same key spatial ingredients at polynomial degree three. This provides direct methodological support for the accuracy and reliability of our numerical reference.

FV-GNO itself retains the standard LLF (Rusanov) flux, with the prescribed KPP physical flux and wave-speed bound, and no KPP-specific entropy fix, reconstruction limiter, or shock sensor. Without these additional corrections, it nevertheless achieves a mean KPP Macro-RMSE of 0.035413. Its learned left/right states control both transport and the dissipative jump within the fixed LLF flux. This low error suggests that the network learns effective interface behavior suited to KPP's complex wave dynamics, including an appropriate balance of transport and dissipation, directly from trajectory supervision. This is achieved using the same interface-learning framework employed for the other equations, supporting its cross-equation generality without extensive redesign of the reconstruction. For the classical numerical baselines, each scheme retains a consistent reconstruction strategy across equations, with the necessary physical flux/source adapters, to maintain a common comparison without additional KPP-specific reconstruction tuning. This also aims to avoid modifying the common reconstruction strategy specifically for KPP in ways that could adversely affect its performance on other equations.

Zero-shot 642→128264^2\rightarrow128^2 transfer is a demanding task: the frozen model must predict unseen trajectories on a different discretization without any target-resolution training. Both the models in Table 1 and the fine-tuned models benefit from target-resolution training, so an accuracy gap is expected. Nevertheless, the zero-shot results already demonstrate useful transfer. On KPP, the frozen model achieves a Macro-RMSE of 0.187233, essentially matching the strong FV2-MM1 baseline (0.187103) on the target grid. With only 16 target trajectories, fine-tuning further reduces the error to 0.049443. These results support useful prediction without target-grid training and effective adaptation when a small amount of target data becomes available.

We hope these explanations help clarify our method and the experimental results. We sincerely thank you again for your careful review and constructive feedback, and for the time and attention you have devoted to our paper.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Overview of FV-GNO’s Novelty, Manuscript Revisions, and Additional Experiments

We thank the reviewers for their careful assessment. Our central innovation is the organization of learning within the numerical computation. Finite-volume methods are an influential, widely used foundation for solving conservation and balance laws, so it is natural for different learning methods to draw on them. A shared finite-volume foundation still leaves substantial room for innovation in the learned representation, its coupling to physics, and its training.

FV-GNO introduces a distinctive combination: nonlinear graph features directly predict effective left and right interface states in physical variables, while prescribed equation-specific fluxes, sources, physical coefficients, and mesh geometry determine the state update. Inspired by the predictor–Riemann-solver organization of high-order finite-volume methods, these states serve as an effective space–time predictor trained over the saved observation interval. The Riemann solver uses their jump and equation-specific wave speeds to determine transport and numerical dissipation, producing a shared flux that changes sign when the two states are exchanged and the face normal is reversed. Retaining distinct one-sided inputs can be particularly important for capturing shocks and sharp fronts; this is a central motivation for our two-sided interface design. Paired assembly then preserves local balance on regular control volumes.

The differences from existing methods are specific: Bar-Sinai et al. learn discretization coefficients and Kochkov et al. learn constrained interpolation weights, whereas FV-GNO directly parameterizes the interface states rather than weights on a prescribed stencil. FLUXGNN combines learned interpolation with conservative encoded-space flux passing, linear encoding, and left-inverse decoding; FV-GNO imposes balance in the physical-state update, without requiring conservative latent propagation or linear/left-inverse coupling of its feature encoder and interface decoder. FVGN learns face velocity, pressure, and flux compensation with additional face supervision; we retain prescribed flux/source computations and require only observed-state labels. Unlike (U)NFV, we learn the inputs to prescribed numerical fluxes rather than the fluxes themselves. Unlike PINO, our physical prior enters the forward update without an additional PDE-residual loss. MeshGraphNets and IGNS develop graph interaction and propagation mechanisms; our contribution is how a replaceable graph processor is coupled to the numerical update.

Thus, the innovation lies in the integrated interface parameterization, physics coupling, and observation-interval training, supported by analyses and controlled experiments across nonlinear systems. We have revised the Introduction and Related Work to make these distinctions explicit.

We have revised the manuscript to clarify our contributions, improve readability, and strengthen the empirical evaluation. We have expanded the baseline comparisons to include GINO, MeshGraphNet, and the Kochkov learned-interpolation baseline. We have clarified the Method section, including the graph architecture, the learned and prescribed components, and the numerical update, while removing less essential details. We have also reorganized the theoretical analysis to make the assumptions, interpretations, and scope of the results clearer and explain their connection to the method. We have expanded the baseline comparisons by evaluating GINO and an independent MeshGraphNet on all five tasks and adding a task-adapted Kochkov learned-interpolation baseline on the four regular-grid tasks. In response to further reviewer requests, we have provided zero-shot resolution-transfer results, clarified the reference-solver setup, reported DG2 CPU costs, and included spatial error visualizations and further discussion of limitations. These revisions strengthen both the presentation and the evaluation of FV-GNO. We address each reviewer's comments below.

Area_Chair_1AoAOpenReview ↗

Requesting reviewer feedback

Dear Reviewers,

Thank you for your reviewing service. The authors have provided detailed rebuttals to the comments. Please confirm that you have read them, state which of your concerns are or are not addressed, and whether that changes your recommendations. Thank you Reviewer D5Zi for your continued engagement; requesting others to join.

Thank you,

AC

Dear Area Chair,

We sincerely appreciate your time and efforts in coordinating the discussion and encouraging reviewer engagement with our responses. Thank you for overseeing the review process.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.