{"id":"079f9116-f38b-4e1c-9c41-28a2ba573d47","arxiv_id":"2504.14338","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":5,"one_line_summary":"A tutorial-style paper that details and demonstrates a fully distributed implementation of Operator Inference for building reduced-order models from datasets too large for a single computer.","lead":"This paper is a step-by-step tutorial for a distributed version of Operator Inference, an algorithm that learns cheap reduced-order models from large simulation datasets. It explains how to parallelize each stage and demonstrates the workflow on a 2D flow past a cylinder benchmark with runnable code.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The 'all elements scalable' claim is regime-dependent: Step III.D replicates an O(n_t^3) eigendecomposition on every rank and an O(n_t^2) Allreduce of the Gram matrix, so scalability is only supported when n_t is small.","rationale":"The reader's weakest_assumption targets exactly the tall-and-skinny Gram-matrix bottleneck in Step III.D, and I agree that it is the most load-bearing condition for the paper's central scalability claim. The mathematical derivation of dOpInf is correct, and the tutorial's cylinder experiment is a legitimate demonstration of the algorithm in the n_t << n regime. The concern is not that the method is wrong, but that the abstract's blanket 'all elements scalable' is supported only for small snapshot counts and for scaling evidence in a self-cited companion paper; the benchmark itself shows declining efficiency by p=8. This is exactly the kind of issue that justifies CONDITIONAL rather than REJECT: the core method is sound, but the advertised scope of scalability is broader than what the paper demonstrates. The probe-index and energy-threshold inconsistencies are secondary and further support the conditional verdict, but they are not the main load-bearing issue. I would keep the reader's CONDITIONAL verdict unchanged.","tokens_in":18845,"tokens_out":9492,"duration_ms":87347,"concrete_test":"Instrument Step III separately and run dOpInf on the cylinder data with n_t increased from 600 to 1,200, 2,400, and 4,800, or on a synthetic tall matrix with the same n and those snapshot counts, for p=1, 2, 4, and 8. Record wall time for Gram assembly, Allreduce, and eigh separately, plus end-to-end speedup. If the Step III share grows superlinearly in n_t on each rank and strong-scaling efficiency at p=8 drops substantially relative to the n_t=600 case, the 'all elements scalable' claim is confined to the tall-and-skinny regime. A minimal version: rerun the released code with target_ret_energy matching the code and verify that r=10 and the reported probe predictions are reproduced.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that dOpInf is a complete distributed procedure whose elements are scalable to thousands of cores. Within the paper, the operation most vulnerable to the global snapshot count n_t is Step III.D. Each rank forms a local Gram matrix D_rank = Q_rank.T @ Q_rank, a collective Allreduce assembles D_global, and every rank then computes a full dense eigendecomposition of D_global via numpy.linalg.eigh. This requires O(n_t^2) memory per rank, O(n_t^2) communication, and O(n_t^3) redundant serial work on every rank. The manuscript itself limits the claim by saying these computations are cheap only when n_t << m. The benchmark uses n_t=600 and n=292,678, so the tall-and-skinny condition holds, but the abstract's unconditional 'All elements of dOpInf are scalable' and 'scale to thousands of processors' are not established by this paper. The strong-scaling experiment stops at p=8 and reports roughly 4.85x speedup with deteriorating efficiency; the leadership-scale claim is deferred to the self-cited companion paper Ref. [1]. This does not undermine the tutorial's correctness, but it makes the headline scalability claim conditional on n_t being small and on external evidence. Secondary reproducibility issues, including the probe-index mismatch between the Sec. III.F text and code and the retained-energy threshold inconsistency (0.9995 in the text versus 0.9996 in the code), further support a conditional rather than unconditional acceptance.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents dOpInf, a distributed implementation of Operator Inference for constructing physics-based reduced-order models from large-scale snapshot data, in a tutorial format illustrated on two-dimensional transient flow past a cylinder. The algorithm is described in five steps: parallel training-data loading, parallel data transformations, parallel dimensionality reduction via the method of snapshots with a distributed Gram matrix, parallel reduced-operator learning through regularized least squares, and parallel postprocessing of the reduced solution. The numerical experiment trains a 10-dimensional ROM on the time interval [4,7] seconds and evaluates it on [7,10] seconds, reporting accurate probe predictions and strong-scaling measurements up to 8 cores. The paper claims that all elements of dOpInf are scalable and that the approach can scale to thousands of processors, with the large-scale scalability evidence deferred to a companion paper.","tokens_in":19166,"tokens_out":3784,"duration_ms":34378,"significance":"The tutorial is potentially valuable as a practical guide for the model-reduction community: it provides a complete, reproducible implementation with a publicly available repository, and the distributed method-of-snapshots derivation in Eqs. (5)-(8) is correct and elegant. The out-of-sample evaluation on a time horizon beyond the training interval is a genuine test of predictive performance. The strength of the paper lies in its didactic clarity and the availability of working code. However, the paper's headline scalability claims go beyond what the presented experiments and the algorithm design can support, and the hyperparameter-selection procedure partly uses the evaluation horizon, which tempers the force of the out-of-sample claim.","major_comments":[{"comment":"The abstract and §I state that 'all elements of dOpInf are scalable' and that the approach 'can scale to the thousands of processors available on leadership HPC platforms', but this is not established by the manuscript. In §III.D, Step III assembles the n_t-by-n_t Gram matrix via an Allreduce and then every rank performs a full dense eigendecomposition of that matrix (code lines 79-82); this requires O(n_t^2) memory per rank, O(n_t^2) communication, and O(n_t^3) redundant serial work. The manuscript correctly notes in the text that these computations are cheap only when n_t is small relative to the state dimension m, but the abstract and introduction state the scalability claim without this tall-and-skinny qualifier. The strong-scaling experiment stops at p=8 and shows deteriorating efficiency, with the leadership-scale claim deferred to Ref. [1]. I recommend qualifying the scalability claims explicitly to the tall-and-skinny regime and adding a complexity analysis that spells out the O(n_t^2) communication and O(n_t^3) per-rank eigendecomposition costs.","section":"Abstract, §I, §III.D, §IV"},{"comment":"The regularization selection in Step IV filters candidate (beta1, beta2) pairs using a bounded-growth criterion over a trial horizon that is stated to be the same as the full target horizon [4,10] seconds (code lines 197-202 and the associated text). Therefore, the ROM that is evaluated on [7,10] seconds was selected using information from that same evaluation interval. This does not make the training/evaluation split circular in the standard sense, because the operators are learned only from [4,7], but it does mean that the reported prediction accuracy is partly a consequence of hyperparameter filtering on the test horizon. I recommend selecting the regularization pair using only the training interval (or a validation subinterval), or explicitly reporting the sensitivity of the results to this choice, so that the out-of-sample claim in §IV is clean.","section":"§III.E, §IV"},{"comment":"The probe locations are inconsistent between the text and the code. The text in §III.F states that the three probe locations are (0.40, 0.20), (0.60, 0.20), and (1.00, 0.20) with grid-point indices {16,992; 48,250; 130,722}, while the code at lines 323-325 sets target_probe_indices = [48250, 77502, 130722]. Since the paper is a tutorial whose primary purpose is reproducibility, this mismatch is material and should be corrected in one place, or an explanation of the intended mapping should be provided.","section":"§III.F, code lines 323-325"},{"comment":"The retained-energy threshold is stated as 99.95% in Eq. (9) and the surrounding text, but the code sets target_ret_energy = 0.9996 (line 90) and §IV reports '99.96%'. This inconsistency should be fixed so that the threshold quoted in the mathematical description, the code, and the results section agree.","section":"§III.D, code line 90, §IV"}],"minor_comments":[{"comment":"The text says the singular values are in 'non-decreasing order' while writing sigma_1 >= sigma_2 >= ...; this should be 'non-increasing order'.","section":"§III.D, Eq. (4)"},{"comment":"The phrase 'In dOpinf' uses inconsistent capitalization; it should be 'dOpInf' for consistency with the rest of the paper.","section":"§III.A, Remark 2"},{"comment":"The speed-up discussion would be easier to interpret if the parallel efficiency (speedup divided by p) were reported alongside the CPU times, since the p=8 point corresponds to roughly 60% efficiency and the paper's phrase 'excellent up to p=4' is fine but should be quantified.","section":"§IV, Figure 4"},{"comment":"The implementation solves the OpInf least-squares problem via the normal equations with np.linalg.solve; the text mentions alternatives such as SVD or QR, but it would be helpful to add a sentence noting that the normal equations can be ill-conditioned when the data matrix is poorly conditioned, particularly because the quadratic terms can have widely varying magnitudes.","section":"§III.E, code line 262"},{"comment":"The caption of Figure 3 does not state which velocity component (u_x or u_y) is plotted at the three probe locations; the text should specify this, since the two components have different characteristic behavior.","section":"§IV, Figure 3"}],"recommendation":"major_revision","confidential_remarks":"The paper is a tutorial and code companion, and its greatest strengths are didactic clarity and reproducible implementation. The main concern is that the abstract and introduction overstate scalability beyond what the algorithm description and the presented benchmarks demonstrate; the paper itself correctly identifies the tall-and-skinny condition in §III.D but does not carry that qualification into the headline claims. The reproducibility mismatches (probe indices, retained-energy threshold) are the kind of issues that should be caught by a code check and would strengthen the tutorial. The companion paper Ref. [1] appears to contain the large-scale scalability results, but the present manuscript should still stand on its own with appropriately qualified claims."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Read this paper if you want to see how Operator Inference is actually wired up in parallel. It's a tutorial-style follow-up to the same group's dOpInf paper [1], and the genuine contribution is the teaching artifact: a Jupyter notebook, the downsampled 2D cylinder-flow dataset, MPI code snippets, and a clean out-of-sample test (train [4,7]s, predict [7,10]s). The math in Eqs (5)-(8) is standard method-of-snapshots and it's correct. The distributed centering, Gram-matrix reduction, and Allreduce-based operator inference are clearly explained. This is the kind of paper that saves a graduate student a week of reading.\n\nWhere it wobbles: (1) The abstract says 'all elements of dOpInf are scalable' and mentions thousands of processors, but the strong-scaling data here stops at p=8 and already shows deteriorating efficiency. The paper itself admits the example is small and points to Ref [1] for large-scale behavior. The scalability claim is fine for tall-and-skinny snapshot counts (n_t << m), where the replicated n_t x n_t eigendecomposition is cheap, but it is not demonstrated for large n_t or for the leadership-scale regime. That should be softened in the abstract. (2) There are reproducibility mismatches: the probe indices in Sec. III.F text ({16,992; 48,250; 130,722}) don't match the code ([48250, 77502, 130722]), and the retained-energy threshold is 0.9995 in the text but 0.9996 in code and results. Minor and fixable, but they undermine the 'just run it' promise. (3) The regularization selection in Step IV filters candidates by a bounded-growth criterion over the full target horizon, which is a mild form of lookahead; it's a practical heuristic, not a prediction, and the out-of-sample statement remains honest because the ROM prediction for [7,10] uses operators chosen with that criterion. I'd want that stated plainly.\n\nOverall: the tutorial is sound, honest about its own limitations, and the code is a real asset. It is not a new algorithm, but it doesn't claim to be. I'd send it to review — a competent referee can fix the text/code mismatches and request a tempered abstract. The core method holds up.","headline":"A useful, well-written tutorial for the existing dOpInf algorithm, with correct math and working code, but the scalability claims in the abstract outrun the evidence presented.","tokens_in":19717,"tokens_out":2752,"would_cite":true,"duration_ms":23524,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["65Y05","65F15","65F20","68W10"],"pacs":[],"model":"deepseek-v4-flash","headline":"A fully parallelized Operator Inference procedure builds physics-based reduced-order models from snapshot data with state dimensions too large for a single computer, demonstrated on a 2D cylinder-flow benchmark where a 10-mode ROM trained…","keywords":["distributed Operator Inference","reduced-order modeling","proper orthogonal decomposition","method of snapshots","parallel algorithms","tall-and-skinny data","regularized least squares","MPI"],"falsifier":"Construct a dataset with $n_t$ large enough that each rank's copy of $\\mathbf{D}$ approaches its memory limit (say $n_t=10^5$, requiring an 80 GB dense matrix in double precision), and run the dOpInf steps: the Allreduce of local Gram matrices and the redundant symmetric eigendecomposition will dominate the runtime, removing the speedup and disproving the claim that all elements are scalable.","tokens_in":18649,"feed_emoji":"🖥️","tokens_out":8897,"duration_ms":70547,"temperature":0.7,"pith_summary":"The paper describes Distributed Operator Inference (dOpInf), a complete parallel pipeline for turning high-dimensional simulation data into cheap physics-based reduced-order models. Its central claim is that every stage—loading data, transformations, dimensionality reduction, operator learning, and postprocessing—can be distributed so that datasets with millions of degrees of freedom, too large for one computer, can be processed on many cores. The algorithm avoids ever constructing the full reduced basis: it builds an $n_t \\times n_t$ Gram matrix, diagonalizes it, and forms the projected snapshots from that small matrix alone. In the paper's benchmark, a 10-dimensional quadratic ROM trained on 600 snapshots over $[4,7]$ seconds predicts the 2D cylinder wake over $[7,10]$ seconds, with measured speedups up to $p=8$ cores. If the claims hold, dOpInf makes tasks like design exploration, risk assessment, and uncertainty quantification feasible for simulations that currently cannot be reduced on a workstation.","feed_headline":"Builds reduced models from data too big for one computer","feed_subtitle":"A 10-mode model trained on 600 snapshots forecasts cylinder flow 3 seconds beyond the training window","key_machinery":"The load-bearing object is the Gram-matrix eigen-decomposition identity $\\mathbf{D}=\\mathbf{Q}^\\top\\mathbf{Q}=\\mathbf{W}\\boldsymbol{\\Sigma}^2\\mathbf{W}^\\top$, combined with $\\hat{\\mathbf{Q}}=\\mathbf{T}_r^\\top\\mathbf{D}$ where $\\mathbf{T}_r=\\mathbf{U}_r\\boldsymbol{\\Lambda}_r^{-1/2}$. It lets the algorithm compute the low-dimensional projected snapshots and the local POD-basis components $\\mathbf{V}_{r,i}=\\mathbf{Q}_i\\mathbf{T}_r$ using only dense matrix-matrix products and a symmetric eigendecomposition of size $n_t\\times n_t$, never the $n\\times n_t$ SVD. All data-dependent operations act on row blocks (loading, centering, scaling, local Gram matrices, local basis components), so communication is confined to one Allreduce of the Gram matrix and one Allreduce for the optimal regularization pair.","core_discovery":"The central discovery is an identity that removes the large state dimension from the expensive part of data-driven model reduction. Starting from the snapshot matrix $\\mathbf{S}\\in\\mathbb{R}^{n\\times n_t}$, each rank forms a local Gram matrix $\\mathbf{D}_i=\\mathbf{Q}_i^\\top\\mathbf{Q}_i$; a single Allreduce sums them into $\\mathbf{D}=\\mathbf{Q}^\\top\\mathbf{Q}$. Because $\\mathbf{D}=\\mathbf{W}\\boldsymbol{\\Sigma}^2\\mathbf{W}^\\top$, the eigenvectors of $\\mathbf{D}$ are the right singular vectors and its eigenvalues are the squared singular values, so the rank-$r$ POD basis need never be formed explicitly. Instead the projected data are $\\hat{\\mathbf{Q}}=\\mathbf{T}_r^\\top\\mathbf{D}$ with $\\mathbf{T}_r=\\mathbf{U}_r\\boldsymbol{\\Lambda}_r^{-1/2}$, a product of two small $n_t\\times r$ and $n_t\\times n_t$ matrices. The paper then learns the reduced operators of a discrete quadratic ROM by solving a regularized least-squares problem in the reduced space, and reconstructs solutions at probe locations without ever lifting the full state. The claim is that this is a complete, scalable distributed procedure: in the example, 600 downsampled snapshots of a $292{,}678$-dimensional flow yield a 10-mode ROM whose forecast matches the reference at three probe locations.","pith_inferences":["The same Gram-matrix identity transfers to other data-driven reduced-modeling methods that the paper names as compatible—DMD, quadratic manifolds, parametric ROMs—so the parallel strategy is not tied to Operator Inference alone.","The tall-and-skinny assumption is the real boundary: if $n_t$ grows so the $n_t\\times n_t$ Gram matrix cannot be stored or Allreduced on every rank, the redundant eigendecomposition and $O(n_t^2)$ communication will dominate; a testable extension is a distributed eigendecomposition or randomized low-rank approximation of $\\mathbf{D}$.","Because the projected snapshots are formed from $\\mathbf{D}$ alone, the algorithm could be adapted to streaming or incremental updates: new snapshots only update local Gram matrices, then one Allreduce."],"forward_implications":["Training data with state dimension $n\\sim 10^6$–$10^9$ can be processed on distributed-memory machines, since no single rank ever stores the full snapshot matrix or forms the full POD basis.","Because the reduced model is quadratic and inferred from data, predictions beyond the training horizon are possible; in the demonstration a 10-mode ROM trained on $[4,7]$ s accurately tracks the cylinder wake through $[7,10]$ s.","Regularized least squares with a grid search over two hyperparameters keeps the inferred operators from overfitting, and the grid search parallelizes over ranks.","Measured strong scaling on the small benchmark is nearly linear up to $p=4$ and degrades at $p=8$; the paper reports near-ideal speedups up to $2{,}048$ cores in the larger rotating-detonation application [1]."],"supporting_citations":[{"why":"Introduces the dOpInf algorithm and supplies the large-scale rotating detonation rocket engine demonstration with near-ideal speedups up to 2,048 cores.","marker":"[1]"},{"why":"Establishes data-driven Operator Inference, the nonintrusive projection-based reduced-modeling approach that dOpInf parallelizes.","marker":"[2]"},{"why":"Provides the Operator Inference formulation and the symmetry reduction for quadratic operators that Step IV uses to remove redundant degrees of freedom.","marker":"[3]"},{"why":"Supplies the method of snapshots for POD, whose Gram-matrix eigendecomposition the distributed algorithm exploits.","marker":"[4]"},{"why":"Describes regularized Operator Inference with hyperparameter grid search and bounded-growth selection, which Step IV parallelizes.","marker":"[27]"},{"why":"Introduces the fully discrete Operator Inference formulation that avoids time-derivative approximation for downsampled snapshots.","marker":"[33]"}],"fun_headline_variants":["Parallel reduced models for data too big for one computer","Scaling data-driven ROMs to leadership HPC","Distributed Operator Inference tackles million-DoF flows","Avoids forming huge POD basis via Gram matrix trick","Parallel ROMs from snapshots without ever lifting full state"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole procedure assumes tall-and-skinny data: the number of snapshots $n_t$ is small enough that every MPI rank can store, Allreduce, and eigendecompose the $n_t\\times n_t$ Gram matrix, and that all data transformations act pointwise on row blocks without communication.","fun_headline_variants_meta":{"raw":{"variants":["Parallel reduced models for data too big for one computer","Scaling data-driven ROMs to leadership HPC","Distributed Operator Inference tackles million-DoF flows","Avoids forming huge POD basis via Gram matrix trick","Parallel ROMs from snapshots without ever lifting full state"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000699,"raw_usage":{"total_tokens":3210,"prompt_tokens":1050,"completion_tokens":2160,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":666,"completion_tokens_details":{"reasoning_tokens":2083}},"tokens_in":666,"tokens_out":2160,"duration_ms":14021,"temperature":1.0,"reasoning_tokens":2083,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T11:50:35.963033+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a dataset with $n_t$ large enough that each rank's copy of $\\mathbf{D}$ approaches its memory limit (say $n_t=10^5$, requiring an 80 GB dense matrix in double precision), and run the dOpInf steps: the Allreduce of local Gram matrices and the redundant symmetric eigendecomposition will dominate the runtime, removing the speedup and disproving the claim that all elements are scalable.","supporting_citations":[{"cited_title":"Distributed computing for physics-based data-driven reduced modeling at scale: Application to a rotating detonation rocket engine,","cited_arxiv_id":null,"evidence_quote":"Introduces the dOpInf algorithm and supplies the large-scale rotating detonation rocket engine demonstration with near-ideal speedups up to 2,048 cores."},{"cited_title":"Learning Nonlinear Reduced Models from Data with Operator Inference,","cited_arxiv_id":null,"evidence_quote":"Provides the Operator Inference formulation and the symmetry reduction for quadratic operators that Step IV uses to remove redundant degrees of freedom."},{"cited_title":"Turbulenceandthedynamicsofcoherentstructuresparti: Coherentstructures,","cited_arxiv_id":null,"evidence_quote":"Supplies the method of snapshots for POD, whose Gram-matrix eigendecomposition the distributed algorithm exploits."},{"cited_title":"On filtering in non-intrusive data-driven reduced-order modeling,","cited_arxiv_id":null,"evidence_quote":"Introduces the fully discrete Operator Inference formulation that avoids time-derivative approximation for downsampled snapshots."}],"review_version":1}