{"id":"91c2bac8-964b-401e-ae02-c55859a4bdab","arxiv_id":"2509.08071","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"Tensor-train and quantized tensor-train operator inference learn polynomial operators directly in compressed TT format, with accuracy comparable to standard OpInf on three test problems.","lead":"The paper recasts operator inference, a data-driven way to learn polynomial dynamical models, using tensor-train compression so snapshots and operators stay in compact form. It claims this makes large datasets and high-dimensional systems tractable, and demonstrates the approach on heat, Burgers, and cylinder flow benchmarks.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Unverified TT pseudoinverse and contraction algorithms are load-bearing: if Algorithm 1 or 2 is wrong, the claim of solving OpInf in compressed form fails.","rationale":"The reader's weakest assumption matches the main concern: the correctness of the TT pseudoinverse and contraction algorithms is unproved. I read the paper in good faith: the tensor formulation is coherent, the small-grid benchmarks show accuracy comparable to standard OpInf, and the reduced-order TT-ROM idea of using the final TT core as a reduced representation is plausible. However, the central novelty is the claim that Algorithms 1 and 2 solve the least-squares problem entirely in TT format. Since no proof, no independent numerical check, and no released code accompany these algorithms, the paper's strongest claim is not supported. This is an addressable issue rather than a demonstrated fatal flaw, so the reader's CONDITIONAL verdict is appropriate; no adjustment is needed. My concrete test would settle whether the algorithms are correct or whether they introduce hidden approximations or rank growth.","tokens_in":13130,"tokens_out":9807,"duration_ms":121589,"concrete_test":"Implement Algorithms 1 and 2 in Python/MATLAB on random TT tensors with small modes (e.g., modes (4,4,4,1,6) or the analogous 9D layout) and small TT ranks (2–3). Compare tt_pinv(D, split=8, gamma) against the dense truncated-SVD pseudoinverse of the matricized D for gamma=0 and gamma>0, using Frobenius norm. Then compare the O_TT from Algorithm 2 to D^†R. Also monitor TT ranks of the transposed factors before and after the 'exchange input/output dimensions' step. If the relative error is not at rounding level, or if ranks grow superlinearly, the compressed-algorithm claim fails.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central claim is that Algorithms 1 and 2 (Section II.D.3) compute a regularized pseudoinverse of the matricized data tensor and contract it with R_TT entirely in TT format. This is the mechanism that avoids forming dense matrices, so it is load-bearing. No proof or independent numerical verification is given for these algorithms. Two steps are especially fragile. First, Step 4 of Algorithm 1 treats the SVD of the interface product R_l R_r as the SVD of the full matricized tensor; this identity is nontrivial and depends on the specific orthogonalization conventions, which are not stated or justified. Second, Steps 8–9 say to 'transpose by exchanging input and output dimensions in its mode ordering'; mode permutation is not a local TT operation in general, and the required TT-rounding can cause rank growth, so the claim that all computations remain compressed is not established. Algorithm 2 then assembles O_TT by contracting R's last core with D's first cores and copying the remaining cores, but no dimensional/contraction analysis shows that this equals D†R. Since these algorithms are the core novelty, a hidden approximation or rank blow-up would invalidate the central scalability claim. The benchmarks use grids of only 20x20 and 3,280 cells, which are too small to expose such issues.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a tensor-train (TT) framework for nonintrusive operator inference (OpInf), with three variants: full-order TT-OpInf, full-order quantized TT (QTT)-OpInf, and reduced-order TT-ROM. The central idea is to represent the snapshot data as a TT tensor and solve the regularized least-squares problem for the polynomial operators directly in compressed form, avoiding the formation of dense snapshot and operator matrices. The key claimed novelty is an algorithm for computing a regularized pseudoinverse of a matricized TT tensor and for contracting it with the right-hand side to construct the learned operator in TT format. Numerical experiments on the 2D heat equation, 2D viscous Burgers' equation, and compressible laminar flow over a cylinder compare the TT methods against standard ROM-OpInf and a full-tensor formulation, reporting timings, ranks, and (for the first two problems) relative errors.","tokens_in":13491,"tokens_out":21427,"duration_ms":243464,"significance":"If the TT pseudoinverse and contraction algorithms are correct and the scalability claim holds, this would be a valuable contribution: it would extend operator inference to settings where the state dimension is too large for dense matrix operations, and the use of TT-cross interpolation to avoid forming full snapshot tensors is an attractive idea. The paper is clearly written in its problem statement and experiments are presented for three nontrivial benchmarks. However, the central algorithmic steps are not proven or independently verified, and the numerical evidence for the headline scalability and memory advantages is incomplete. The significance is therefore conditional on closing these gaps.","major_comments":[{"comment":"The central novelty is the claim that tt_pinv computes the regularized pseudoinverse of the matricized TT tensor entirely in compressed form. This is not proven, and the algorithm as stated is underspecified. Steps 8–9 say to 'transpose by exchanging input and output dimensions in its mode ordering'; mode permutation is not a local TT operation in general and can cause rank growth, yet no rounding is applied. The input tolerance tt_tol is never used. The combination step ('Combine the transposed tensors...') is not specified. Algorithm 2's contraction is also not verified; the paper does not show that the assembled cores equal D†R. Since these algorithms are the claimed enabler of scalable compressed OpInf, a rigorous derivation or an independent numerical check (e.g., comparing against dense pseudoinverse on small tensors) is required.","section":"II.D.3, Algorithms 1 and 2"},{"comment":"The tensor formulation is self-inconsistent in its index labels. Eq. (14) defines D_{i,j,k,q,i',j',k',q',n}, with the first four modes labeled i,j,k,q. In Eq. (15) the contraction uses D_{i',j',k',q',i'',j'',k'',q'',n} and O_{i,j,k,q,i',j',k',q',i'',j'',k'',q''}. These labelings are shifted by one prime level and do not match the stated dimensions of O (Eq. after (15)). As written, the tensor indices in Eq. (15) cannot be contracted to reproduce the least-squares objective. This is a load-bearing inconsistency in the formulation and must be corrected.","section":"II.C, Eqs. (14)–(15)"},{"comment":"The claim that 'with G_i for i=1,...,4 being orthogonalized, the reduced snapshot matrix \\hat{X} in the standard OpInf method is equivalent to G5' is not correct as stated: G5 is of size r4×K, whereas \\hat{X} in Section II.A is K×n. Even accounting for transposition, TT-SVD truncation of a 5D tensor is not equivalent to POD truncation of the flattened N×K snapshot matrix. If TT-ROM is intended to use the last TT core as a reduced coordinate matrix, this is a choice of subspace and should be stated as such, not as equivalence to POD. The comparison with standard ROM in Tables 1–3 may still be meaningful, but the claimed equivalence needs to be clarified or removed.","section":"II.E"},{"comment":"For the cylinder test case, no quantitative relative error is reported. The text only states that the predicted pressure fields are 'nearly identical' or show 'minor differences'. Given that the paper's accuracy claims rest on these results, a quantitative error measure (e.g., relative L2 error of the predicted field over the full domain or at the monitoring points) is required. Also, the regularization parameters for the cylinder case (10^5 for ROM/TT-ROM and 5×10^9 for QTT) are extremely large, and no justification (e.g., L-curve or cross-validation) is given; with such strong regularization the learned operators may be dominated by the penalty term, which would undermine the claim of learning the true dynamics.","section":"III.C, Table 3"},{"comment":"The paper repeatedly claims 'memory efficiency' and 'scalability', but no memory measurements are reported, only timings. The grid sizes used (20×20 and 3,280 cells) are far too small to demonstrate asymptotic scalability of TT methods; for such small problems TT overhead can dominate and the advantages only appear at larger scales. A memory comparison (e.g., snapshot storage and operator storage for each method) and/or a scaling experiment with increasing grid size is necessary to support the central claim.","section":"III, Tables 1–3"}],"minor_comments":[{"comment":"There are numerous typos and spacing issues: 'the the' in Section II, 'Labarotory', 'tt_left_orthogonolize' (spelling), inconsistent use of 'TT' vs 'tt', and inconsistent comma placement. The manuscript would benefit from a careful proofreading pass.","section":"Throughout"},{"comment":"The finite-difference derivative on the last TT core is said to be described in [16,17]; however, those references are about tensor-train mimetic finite differences and Boltzmann transport, not about time-derivative computation in OpInf. Please provide a description or a more specific reference.","section":"II.D.2"},{"comment":"The quadratic term F(x⊗x) uses a Kronecker product; later the tensor formulation uses elementwise products. This is fine under the full-order tensor interpretation, but the connection between the Kronecker-structured F in Eq. (1) and the tensor operator F in Eq. (16) should be made explicit.","section":"II.A.1, Eq. (1)"},{"comment":"The text says that the TT method operates on a 5-dimensional tensor X_{i,j,k,q,n}, but for a 2D heat equation N_z=1 and N_q=1; this is fine, but the notation is slightly confusing. Clarify that singleton modes are retained for uniformity.","section":"III.A, Table 1"}],"recommendation":"major_revision","confidential_remarks":"The paper's core idea is interesting and the authors are clearly experienced with tensor methods, but the manuscript as submitted does not yet provide enough evidence for the central algorithmic claim. The lack of a proof or verification for Algorithms 1 and 2 is the most serious issue; I would encourage the editor to request a revision that includes a derivation or a small-scale numerical validation against dense pseudoinverse computation, along with the missing memory measurements. If the authors cannot provide such verification, the central scalability claim would remain unsubstantiated."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nQuick take on arXiv:2509.08071: the TT-OpInf idea is genuine and worth engaging, but the paper's center of gravity—the compressed TT pseudoinverse and the contraction that builds the operator—is unverified, and the advertised memory/scalability advantage is never actually measured. I'd send it to review rather than reject, with a clear ask for verification.\n\nWhat's actually new: the full-order TT/QTT reformulation of operator inference, and the reduced-order variant that replaces POD with TT compression (the G5-as-reduced-coordinates observation is a clean trick). The tensor least-squares setup in Section II.C is coherent, and the heat and Burgers benchmarks are clean: all methods land on the same relative error, and the timings are reported honestly, including that TT prediction is slower than the alternatives. That last point matters—they're not overselling.\n\nThe soft spots are real and proportionate to the claims being made. The stress-test note is right that Algorithm 1 is load-bearing and unproved; left-and-right orthogonalization with an SVD of the interface matrix is a plausible identity, but the 'transpose by exchanging mode ordering' steps are not local TT operations in general and can grow ranks. More troubling, Algorithm 2 as printed doesn't obviously do the contraction the text describes: it contracts the time core of R (core 5) with the first core of D†, then copies D† cores 3–9—including the time core—into the operator tensor. Either the core ordering convention is nonstandard and unexplained, or the pseudocode has an indexing bug. That's exactly the kind of thing a referee needs to chase, and there is no code, data, or independent numerical check to help them. I should also flag that 'memory efficiency' is asserted, not demonstrated: there are no memory measurements anywhere, and the biggest grid is 3,280 cells. Table 3, the cylinder case, has no error column at all—just timings and a picture.\n\nWho should read this: people in model reduction and tensor methods, especially ones working on nonintrusive learning at scale. The direction is sensible and the unresolved issues are addressable—a proof or a rank-growth check for the pseudoinverse, memory numbers, a quantitative cylinder error, and released code would close most of the gap.\n\nMy recommendation: send it to a serious referee. Conditional acceptance is the right frame. I'd hold off citing it until the algorithms are verified, but I'd bring it to the reading group now—the pseudoinverse question is a good discussion.","headline":"Plausible tensorized OpInf with a real bottleneck target, but the compressed pseudoinverse at the core of the paper is unproved as printed and the headline memory claim is unmeasured; worth referee time, not desk reject.","tokens_in":13925,"tokens_out":9355,"would_cite":false,"duration_ms":98158,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["15A69","65F20"],"pacs":[],"model":"deepseek-v4-flash","headline":"Tensor-train compressed operator inference matches standard accuracy while cutting memory, the paper claims, with algorithms for pseudoinverses in TT format and validation on heat, Burgers, and cylinder flow.","keywords":["tensor-train decomposition","operator inference","model reduction","pseudoinverse","TT-cross interpolation","quantized tensor-train","data-driven dynamics","CFD benchmarks"],"falsifier":"Take a small random tensor with a known TT representation, compute its pseudoinverse by Algorithm 1, and compute the dense SVD pseudoinverse of the matricized tensor; the entrywise relative difference should be near machine precision. If the two disagree, or if the TT transpose steps produce rank blow-up, the central identity is refuted.","tokens_in":13072,"feed_emoji":"🧮","tokens_out":5588,"duration_ms":63350,"temperature":0.7,"pith_summary":"This paper sets out to make operator inference—learning polynomial dynamical-system operators from snapshots—work entirely in the tensor-train (TT) compressed format. The central move is a compressed least-squares solve: compute a regularized pseudoinverse of the data tensor and contract it against the derivative tensor, all in TT cores. Three variants are proposed: full-order TT, quantized TT for unstructured grids, and a reduced-order version where the TT decomposition itself replaces the POD/SVD projection. On the heat equation, viscous Burgers, and laminar cylinder flow, the compressed methods match standard OpInf accuracy while storing far less and scaling to larger data. The load-bearing identity is that the core-wise SVD of the TT representation yields the pseudoinverse of the matricized data tensor.","feed_headline":"Tensor-train solver learns operators without forming dense matrices","feed_subtitle":"Compressed operator inference matches full-order accuracy on heat, Burgers, and cylinder flow while using far less memory.","key_machinery":"The central object is the tensor-train decomposition, in which a high-dimensional tensor is stored as a chain of low-rank cores. The key algorithm, tt_pinv, orthogonalizes the TT cores from both sides, performs a compact SVD on the product of the two interface factors, applies Tikhonov regularization to the singular values, and reassembles a transposed TT representation of the pseudoinverse. A second algorithm contracts this pseudoinverse with the right-hand-side tensor to form the learned operator. Snapshot compression uses TT-SVD or TT-cross interpolation, and the QTT variant uses prime-factorization reshaping to impose tensor structure on unstructured-mesh data.","core_discovery":"The paper claims that the least-squares operator inference problem can be solved without ever expanding the data into dense matrices. Given a snapshot tensor X, the method builds a data tensor D containing linear and quadratic terms, computes D† in TT form via left/right orthogonalization of cores, an SVD of the interface core, regularization of singular values, and TT-mode transposition, then contracts D† with the derivative tensor R to obtain the operator tensor O. The learned O is sliced to extract the linear operator A and quadratic operator F, and predictions are made by time-integrating the tensorized ODE directly in TT format. If this works, full-order and reduced-order polynomial ope","pith_inferences":["If the TT pseudoinverse identity holds generally, the same compressed least-squares machinery could serve other tensor regression and inverse problems, not only operator inference.","The success of TT-cross for snapshot compression suggests a possible streaming or online variant of OpInf where snapshots are sampled adaptively rather than stored wholesale; the paper demonstrates only the offline setting.","The practical ceiling is likely TT-rank growth during time integration, so testing rank-controlled integrators beyond the adaptive Runge–Kutta scheme used here could extend prediction horizons."],"forward_implications":["Full-order TT and QTT OpInf can learn full discretization operators for high-dimensional grids where dense SVD or Kronecker-product formation is infeasible.","Reduced-order TT-ROM obtains its reduced coordinates directly from a TT core, removing the POD SVD projection step.","With TT-cross compression, operator learning can proceed without ever loading the full snapshot dataset into memory.","Memory and per-operation cost scale with TT ranks rather than with the full grid size, extending OpInf to much larger snapshot tensors.","Regularization can be applied within the compressed pseudoinverse, so ill-conditioned data can be handled without leaving the TT format."],"supporting_citations":[{"why":"Introduces the operator inference least-squares problem whose tensorized analogue is the paper's core target.","marker":"[4]"},{"why":"Defines the tensor-train decomposition and TT-SVD, the compression format and reduction algorithm all methods build on.","marker":"[12]"},{"why":"Supplies the TT-cross approximation algorithm used to compress snapshots without storing the full tensor.","marker":"[9]"},{"why":"Provides the adaptive cross-interpolation heuristic used to build TT cores from selected tensor entries.","marker":"[10]"},{"why":"Establishes quantized tensor-train (QTT) reshaping, which the paper uses to handle unstructured-mesh data.","marker":"[8]"},{"why":"Supplies the high-fidelity CFD solver and problem setup that generates the cylinder-flow validation snapshots.","marker":"[18]"},{"why":"Shows how finite-difference stencils can be applied directly on TT cores, used here to compute the time-derivative tensor.","marker":"[16]"}],"fun_headline_variants":["Operator inference without dense matrices, via tensor-train","Tensor-train operator inference: skip the dense matrix","Learn operators in tensor-train format, no dense expansion","Tensor-train operator inference: less memory, same accuracy"],"cache_read_input_tokens":2688,"weakest_assumption_plain":"The compressed pseudoinverse built from core-wise orthogonalization and an interface SVD exactly equals the pseudoinverse of the full data tensor, with no uncontrolled rank growth during the TT transposes.","fun_headline_variants_meta":{"raw":{"variants":["Operator inference without dense matrices, via tensor-train","Tensor-train operator inference: skip the dense matrix","Learn operators in tensor-train format, no dense expansion","Tensor-train operator inference: less memory, same accuracy"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000783,"raw_usage":{"total_tokens":3244,"prompt_tokens":642,"completion_tokens":2602,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":386,"completion_tokens_details":{"reasoning_tokens":2537}},"tokens_in":386,"tokens_out":2602,"duration_ms":20710,"temperature":1.0,"reasoning_tokens":2537,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-04T21:20:40.024421+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a small random tensor with a known TT representation, compute its pseudoinverse by Algorithm 1, and compute the dense SVD pseudoinverse of the matricized tensor; the entrywise relative difference should be near machine precision. If the two disagree, or if the TT transpose steps produce rank blow-up, the central identity is refuted.","supporting_citations":[{"cited_title":"Tensor-train decomposition,","cited_arxiv_id":null,"evidence_quote":"Defines the tensor-train decomposition and TT-SVD, the compression format and reduction algorithm all methods build on."},{"cited_title":"TT-cross approximation for multidimensional arrays,","cited_arxiv_id":null,"evidence_quote":"Supplies the TT-cross approximation algorithm used to compress snapshots without storing the full tensor."},{"cited_title":"Fast adaptive interpolation of multi-dimensional arrays in tensor train format,","cited_arxiv_id":null,"evidence_quote":"Provides the adaptive cross-interpolation heuristic used to build TT cores from selected tensor entries."},{"cited_title":"O(dlogN)-quanticsapproximationofN-dtensorsinhigh-dimensionalnumericalmodeling,","cited_arxiv_id":null,"evidence_quote":"Establishes quantized tensor-train (QTT) reshaping, which the paper uses to handle unstructured-mesh data."},{"cited_title":"A new direct discontinuous Galerkin method with interface correction for two-dimensional compressible Navier-Stokes equations,","cited_arxiv_id":null,"evidence_quote":"Supplies the high-fidelity CFD solver and problem setup that generates the cylinder-flow validation snapshots."},{"cited_title":"Tensor networks for solving the time-independent Boltzmann neutron transport equation,","cited_arxiv_id":null,"evidence_quote":"Shows how finite-difference stencils can be applied directly on TT cores, used here to compute the time-derivative tensor."}],"review_version":1}