{"id":"14ddfb48-1e5b-4783-91f9-1b27f0b11c59","arxiv_id":"2412.16544","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"high","formal_verification":"none","parameter_count":0,"one_line_summary":"The paper presents BHT-l2r, a batch hierarchical Tucker decomposition, and HT-RISE, its incremental update, with error bounds and experiments showing improved compression and generalization on PDE and image datasets.","lead":"This paper introduces two algorithms for compressing streaming batches of multidimensional data using hierarchical Tucker networks, including an incremental update scheme that never stores all data. It offers a way to keep a low-rank representation accurate as new scientific or image data arrives, with reported gains over existing tensor-train streaming methods.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"HT-RISE's provable error guarantee is not established: Theorem 5 is unstated and its proof sketch omits the key inequality needed for greedy residual updates.","rationale":"After reading the paper in good faith, the algorithms are well-motivated and the empirical study is broad. The BHT-l2r error bound (Corollary 4) is stated and plausibly follows from the literature. The main weakness is exactly the HT-RISE error guarantee. The reader's concern about residual orthogonality is on the right track but can be sharpened. The residuals at different nodes are not necessarily mutually orthogonal in the full tensor space; a 2x2 matrix example shows that row- and column-residual truncation errors can coincide. However, the global error bound does not require orthogonality; it requires the inequality ||E_total||^2 <= sum ||E_{ℓ,j}||^2, which holds for commuting projections in the one-shot case. For HT-RISE, the greedy, nested updates may still satisfy this inequality, but the paper does not prove it. Theorem 5 is literally empty: no statement, only a proof sketch that leaps from per-node residual bounds to the global bound via Grasedyck's lemmas, without verifying the hypotheses. This is a load-bearing gap because the 'provable error bounds' and 'first incremental HT algorithm' are the headline contributions. The empirical results would remain useful, but the central theoretical claim is unsupported. Therefore CONDITIONAL is the right verdict, provided a rigorous theorem and proof are supplied. Our proposed check is to derive the missing theorem and verify the sum-of-squares inequality, with a numerical sanity check on synthetic streams.","tokens_in":44412,"tokens_out":25410,"duration_ms":203579,"concrete_test":"Formally state Theorem 5 and prove the inequality ||E_total||_F^2 <= sum_{ℓ,j} ||E_{ℓ,j}||_F^2, where E_total is the reconstruction error of the new batch Y^k after HT-RISE's updates and E_{ℓ,j} are the residual SVD truncation errors (Equation 15). Concretely, express the updated approximation as a composition of nested orthogonal projections and verify that the squared error is bounded by the sum of squared per-node errors, following Grasedyck's Lemma 3.10. As a numerical companion check, run HT-RISE on an ensemble of synthetic 4-way and 6-way tensor streams (random low-rank factors with controlled noise), and verify in every increment that the relative error of each batch, ||Y^ℓ - Ŷ^ℓ||_F / ||Y^ℓ||_F, stays below eps_rel; any violation would falsify the guarantee, while a complete proof would settle it.","verdict_should_be":"UNCHANGED","load_bearing_attack":"HT-RISE's central claim is a guaranteed per-batch relative error. Appendix A states 'Theorem 5 (HT-RISE approximation error)' with no formal claim; the 'proof' asserts that each residual SVD error E_{ℓ,j} is bounded and that 'accumulate layerwise upper bounds' via Grasedyck's Theorem 3 yields the total error. This is exactly the load-bearing step. In the one-shot HOSVD, the global error satisfies ||E_total||^2 <= sum ||E_n||^2 because mode-wise projections commute and the inequality follows from contractivity. For HT-RISE, residuals R_{ℓ,j} are computed by projecting the new batch onto the orthogonal complement of *old* cores; after appending new singular vectors and zero-padding parents, the resulting projections are greedy and nested. The errors are not necessarily orthogonal (a rank-1 2x2 example can give identical row- and column-truncation errors), so orthogonality is not the right hypothesis. What must be proved is the inequality ||E_total||^2 <= sum ||E_{ℓ,j}||^2 for the global reconstruction error of the new batch. The sketch does not provide this: it never states what E_{ℓ,j} is in the full tensor space, nor how the nested projections compose. Without a rigorous statement of the theorem and this inequality, the claimed 'provable error bounds' are unsupported. In addition, the per-batch tolerance eps_des = eps_rel ||Y^k||_F is used to set the node-wise tolerance; the proof must show that the sum-of-squares bound holds after the early-exit condition (line 16) and after the root-only update path, neither of which is addressed.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes two algorithms for hierarchical Tucker (HT) decompositions of tensor streams: BHT-l2r, a leaves-to-root construction of a 'batch hierarchical Tucker' format in which the batch dimension is stored only in the root core, and HT-RISE, an incremental algorithm that updates an existing batch-HT representation when new batches arrive. The authors claim that HT-RISE is the first incremental HT algorithm, that both algorithms are rank-adaptive, and that HT-RISE provides guaranteed per-batch error bounds while never storing or reconstructing the full accumulation. The numerical section compares HT-RISE with the incremental tensor-train algorithm TT-ICE* on four datasets (PDEBench, self-oscillating gels, MineRL, BigEarthNet) and reports compression ratios, reduction ratios, wall time, and relative test error, with claims of up to 6.2x compression and 3.7x time reduction for BHT-l2r over one-shot HT, and up to 3.1x compression and 3.2x time reduction for HT-RISE over TT-ICE*.","tokens_in":44726,"tokens_out":8762,"duration_ms":77848,"significance":"If the stated theoretical guarantees were rigorously established, the paper would fill a real gap: incremental algorithms exist for CP, Tucker, and TT formats, and an incremental HT format with provable per-batch error control would be a useful contribution for streaming high-dimensional scientific and image data. The batch hierarchical Tucker modification is simple and clearly motivated, and the empirical study is broad, covering four realistic datasets and comparing against a strong TT baseline. The claim that HT-RISE generalizes with fewer training batches than TT-ICE* is interesting and supported by the reported test-error trajectories. However, the central proof of the incremental error guarantee is a sketch that omits the key inequality, and without Theorem 5 being formally stated and proved, the paper's main theoretical selling point is not yet established. The experimental sections also lack variance information despite averaging over seeds, which weakens the quantitative claims.","major_comments":[{"comment":"Theorem 5 is presented as a heading with no formal statement: there is no stated bound, no specification of the norm or the tolerance, and no list of hypotheses. A theorem that is never stated cannot be verified. The heading 'Theorem 5 (HT-RISE approximation error)' is followed directly by a proof sketch, but the reader cannot tell what exactly is claimed (per-batch error? accumulated error? worst-case or expected?). This is a load-bearing omission because the abstract and Section 3.2 promise 'provable error bounds' for HT-RISE.","section":"Appendix A, Theorem 5"},{"comment":"The proof sketch asserts that the residual SVD errors accumulate via Theorem 3 (Grasedyck's Lemma 3.10), but Theorem 3 applies to a one-shot leaves-to-root HOSVD of a single tensor with orthonormal transfer cores. In HT-RISE the updates are greedy: new basis vectors computed from the residual of one node are appended to existing cores, and parent cores are zero-padded (Eqs. (14)-(17)). The residuals at different layers and nodes are not orthogonal in the full tensor space, and the proof never establishes the key inequality ∥Y^k - \\tilde{Y}^k∥_F^2 ≤ Σ_{ℓ,j} ∥E_{R,ℓ,j}∥_F^2 for the final reconstructed batch. Eq. (29) only decomposes the mode-ℓ unfolding of the intermediate core; it does not show how the truncation errors propagate through the subsequent contractions up to the root concatenation (Eq. (19)). Without this step, the central claim that HT-RISE maintains a per-batch error bounded by ε_des is unsupported.","section":"Appendix A, proof of Theorem 5, Eqs. (29)-(33)"},{"comment":"The early-exit condition in Algorithm 2 (line 16) skips all core updates except the root when the projection error is below ε_des. The proof of Theorem 5 does not treat this branch. A complete proof must show that the early-exit update also satisfies the claimed error bound, since the root is updated with the projection C̄^k_1 (line 46) rather than with a full residual-corrected representation. The theorem should cover both the early-exit and the full-update paths.","section":"Algorithm 2, line 16; Theorem 5"},{"comment":"Problem 2 asks for a guaranteed bound on the accumulated tensor error ∥X^k - \\hat{X}^k∥_F at every step k, but the theoretical discussion in Appendix A concerns only the error for a new batch Y^k relative to ε_des = ε_rel ∥Y^k∥_F. No theorem in the appendix states how per-batch guarantees combine into an accumulation-level bound. Theorem 6 only shows that past slices are reconstructed identically after later updates; it does not address whether the squared errors of all slices sum to a bound on the full accumulated error. The gap between Problem 2 and the provided theory should be closed or the problem statement should be amended to match what is actually proved.","section":"Problem 2 and Appendix A"}],"minor_comments":[{"comment":"The manuscript contains numerous typos and spelling errors, including 'univerally' (Section 1), 'Summmary' (Section 4.3.2 and Appendix D), 'intersting' (Appendix D.1), 'normalziation' (Appendix D.5), and 'likekly' (Appendix D.2). A careful proofreading pass is needed.","section":"Section 1 and various appendices"},{"comment":"The cross-referencing of results is inconsistent: Section 3.1 refers to 'Theorem 4' in Appendix A, but the appendix labels the statement as 'Corollary 4'. Additionally, Theorem 5 is numbered but has no statement, which is unusual and confusing; the numbering should be cleaned up as part of the revision.","section":"Section 3.1 and Appendix A"},{"comment":"Theorem 1 (adapted from Kressner and Tobler) prescribes a node-wise tolerance ε_nw = ε_abs/√(2d−3), while Corollary 4 uses ε_nw = ε_abs/√(2d−2). The manuscript should clarify why the batch construction has one more truncating SVD than the standard HT construction, or correct the constants if they are inconsistent.","section":"Theorem 1 vs. Corollary 4"},{"comment":"The experiments are averaged over five seeds (PDEBench, MineRL, BigEarthNet), but the tables and figures report only point estimates with no standard deviations or confidence intervals. Since several comparisons are close (e.g., BigEarthNet at ε_rel = 0.10), reporting variance is important for assessing whether the observed differences are meaningful.","section":"Section 4, Tables 2-4 and 6"},{"comment":"Figure 12's left panel y-axis label reads 'Total Time' while the text consistently refers to 'Compression Time' elsewhere; please make the terminology uniform. In Table 3, the entry '4581,78' should be '4581.78'.","section":"Figure 12 and Table 3"},{"comment":"The proof of Theorem 6 contains a confusing sentence: 'the entries of G^t_{1,1}(i1,i2,: r^k_{1,1}) are all zero for any i_j > r^k_{2,j}'. The condition should presumably involve the index range of the padded mode (i.e., i1 > r^k_{2,1} or i2 > r^k_{2,2}), not a generic i_j. This should be rephrased for clarity.","section":"Appendix A, proof of Theorem 6"}],"recommendation":"major_revision","confidential_remarks":"This is a promising paper from a group that has already published credible work on incremental tensor trains (Aksoy et al., 2024a). The experimental study is extensive and the proposed batch-HT format is a natural and potentially useful extension. My main concern is that the central theoretical guarantee, which is prominently advertised in the abstract and introduction, is not actually established: Theorem 5 is never stated, and the proof sketch omits the core inequality needed for greedy residual updates. This is a fixable problem only if the authors can supply a rigorous proof (or honestly weaken the claimed guarantee). I would not recommend rejection because the algorithms may well be correct and the empirical evidence is substantial, but the revision must contain a complete, formal statement and proof of the error bound for HT-RISE, including the early-exit branch and the accumulation-level bound required by Problem 2. The authors should also add variance information to the experimental tables."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things you should know. The paper delivers a genuinely new incremental hierarchical Tucker algorithm, and the batch-HT format that puts the batch dimension in the root node is a clever idea that seems to pay off in the experiments. But the advertised error guarantee for HT-RISE is not actually demonstrated: Theorem 5 in Appendix A has no statement, just a proof sketch, and the sketch does not prove the inequality that carries the argument.\n\nWhat is new and good: BHT-l2r and HT-RISE are real algorithms, they fill a known gap (no incremental HT existed), and the experiments are broad and honest — they report cases where their own TT-ICE beats them on simpler data. The comparison to TT-ICE is fine, since it is their prior work and is a reasonable state-of-the-art baseline. The idea of keeping the batch dimension in the root core, rather than adding a leaf, is simple and appears to compress better on the tested image data.\n\nThe soft spot is load-bearing. The proof of Theorem 5 is not a proof. It asserts that per-node residual SVD errors can be accumulated layerwise using Grasedyck's one-shot bounds, but the greedy residual updates in HT-RISE do not obviously satisfy the required sum-of-squares inequality. Residuals computed against old cores are not orthogonal to each other in the full tensor space, and the early-exit condition and the root-only update path are not covered. The abstract and intro promise \"provable error bounds,\" so this is not a minor gap — it is the central theoretical claim. The stress-test note is right.\n\nMinor concerns: experiments are averaged over five seeds but no standard deviations are reported; the walltime limit confounds some comparisons. Those are fixable and not fatal.\n\nWho is this for: researchers working on streaming tensor compression and latent representations from tensor networks. The algorithms may well work in practice, and the batch format is a useful contribution independently of the proof. But I would not cite the paper for a guaranteed error bound until that theorem is actually stated and proven.\n\nRecommendation: send it to peer review, but with the expectation of major revision. The proof gap is real but plausibly repairable, and the empirical evidence is substantial enough to justify referee time. If the authors can either prove the inequality or honestly weaken the guarantee to an empirical claim, the paper would be much stronger.","headline":"Genuinely first incremental HT algorithm with a clever batch format, but the promised error bound is not actually proven; worth a serious referee with major revision.","tokens_in":45224,"tokens_out":2333,"would_cite":true,"duration_ms":24352,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["15A69","65F55"],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper presents the first incremental hierarchical Tucker decomposition algorithm for streaming tensor batches, with guaranteed error bounds and no full-data storage or reconstruction.","keywords":["hierarchical Tucker decomposition","incremental tensor algorithms","streaming data compression","tensor networks","low-rank approximation","online latent representation","rank-adaptive algorithms","tensor streams"],"falsifier":"Construct a small two-layer HT, stream a batch that has shared energy across two sibling nodes, truncate each residual at exactly the node-wise tolerance, and compare the true reconstruction error to the claimed bound. If the observed error exceeds the bound, or if an earlier tensor's reconstruction changes after a later update, the residual-orthogonality premise is violated.","tokens_in":44220,"feed_emoji":"🧮","tokens_out":9829,"duration_ms":81749,"temperature":0.7,"pith_summary":"Tensor streams — sequences of multidimensional arrays — are normally compressed with incremental versions of CP, Tucker, or tensor-train formats, but the hierarchical Tucker (HT) format had no incremental update rule. This paper claims to close that gap with HT-RISE, an online algorithm that updates an existing batch-HT representation by projecting each new batch onto the current cores, computing the residual, and appending only the missing directions revealed by that residual. Because the new directions are orthogonal to the existing cores, old data never needs to be stored or reconstructed, and previously streamed tensors keep their exact reconstructions after every update. The paper also introduces BHT-l2r, a one-shot batch decomposition that carries the batch dimension in the root core rather than as a leaf; experiments report up to 6.2x compression and 3.7x time savings over standard HT compression and up to 3.1x compression and 3.2x time savings over an incremental tensor-train baseline.","feed_headline":"First streaming hierarchical Tucker decomposition algorithm","feed_subtitle":"New batches expand a tensor network's cores without ever storing the full stream.","key_machinery":"The load-bearing object is the projection residual used to expand each HT core. When a new batch is contracted against the existing orthonormal cores, the part that is not representable is $R_{\\ell,j} = \\Pi_{\\ell,j}^{k-1} C_{\\ell,(j)}$ with $\\Pi_{\\ell,j}^{k-1} = I - U_{\\ell,j}^{k-1}(U_{\\ell,j}^{k-1})^T$. An error-truncated SVD of this residual yields new left singular vectors $U_R$, and the updated core is the concatenation $U^k = [U^{k-1}, U_R]$, which is orthonormal by construction; parent cores are zero-padded so tensor-network dimensions stay consistent. This residual-expansion step is what makes the update incremental (only missing directions are added), makes it memory-safe (the full stream is never formed), and lets the proof decompose the global error into layerwise SVD truncation errors.","core_discovery":"The paper's central claim is that a hierarchical Tucker decomposition can be maintained incrementally, updating all cores of the dimension tree as new batches arrive while keeping the accumulation tensor under a prescribed relative error tolerance. The batch hierarchical Tucker format is the key reformulation: instead of treating the batch index as one more leaf dimension, the batch is absorbed into the root core, so a batch of similar tensors shares the whole hierarchy of transfer cores and only the root grows with the sample count. HT-RISE updates layer by layer from leaves to root: it projects the new batch onto the existing orthonormal cores, forms the residual $R_{\\ell,j}$, truncates its SVD at a node-wise tolerance, and concatenates the new left singular vectors onto the existing basis. The paper argues that this update adds only the genuinely new information, that the node-wise truncation errors combine into the same global bound as the one-shot decomposition, and that padding parent cores with zeros leaves the reconstruction of every previously streamed tensor unchanged.","pith_inferences":["The residual-expansion update is a generic mechanism: the same project-residual-append step should transfer to n-ary dimension trees or to time-varying tree topologies, since each node update only needs its own orthonormal basis and its children's ranks.","Because each layer is updated independently after the previous layer's projection, the per-layer SVDs could be replaced by randomized or streaming SVDs to trade a little accuracy for much lower per-batch cost on very large streams.","The paper's own experiments suggest the advantage is domain-dependent: on simple, globally low-rank data the extra HT hierarchy is overhead, so the method is best matched to multi-scale or locally structured data.","A direct test of the invariance claim is to partition one fixed dataset into different batch orders and check whether each original tensor's slice reconstruction is identical across orderings; this would exercise the past-stream guarantee without needing ground truth."],"forward_implications":["HT-RISE gives the HT format the same streaming capability that already existed for CP, Tucker, and tensor-train formats, so online applications can keep an HT representation under a bounded error.","Updates are non-destructive: reconstructing any tensor that arrived in an earlier batch from the current representation gives exactly the same result it gave before the new batch was seen.","Moving the batch dimension to the root core makes the batch format more economical than standard HT for batches of similar tensors; the reported gains reach 6.2x compression and 3.7x time reduction on image data.","Compared with an incremental tensor-train method, HT-RISE reaches the target test-set error after far fewer training batches on multi-scale data, and completes streams the baseline does not finish within the wall-time limit.","The resulting latent representation is a matrix slice in the root core, so its size is governed by the complexity of the data rather than capped by the number of accumulated tensors."],"supporting_citations":[{"why":"Supplies the leaves-to-root hierarchical Tucker decomposition and the layerwise/total approximation-error lemmas (3.8 and 3.10) that the paper adapts for its error bounds.","marker":"Grasedyck (2010)"},{"why":"Provides the reference HT decomposition toolbox and the node-wise truncation error bound (adapted as Theorem 1) that BHT-l2r and HT-RISE inherit.","marker":"Kressner and Tobler (2014)"},{"why":"Introduces the incremental tensor-train algorithm TT-ICE*, the paper's main baseline, and the residual-based expansion idea that HT-RISE carries over to the HT format.","marker":"Aksoy et al. (2024a)"},{"why":"Defines the higher-order SVD used as the per-node truncation primitive inside BHT-l2r and HT-RISE.","marker":"De Lathauwer et al. (2000b)"},{"why":"Introduces the tree-Tucker/hierarchical Tucker representation whose incremental update is the paper's subject.","marker":"Oseledets and Tyrtyshnikov (2009)"}],"fun_headline_variants":["Streaming HT decomposition without full storage","Online tensor streams: incremental HT updates on the fly","Incremental hierarchical Tucker: stream without reconstructing all data","HT-RISE: batch-by-batch tensor decomposition, no full storage","Compress tensor streams 6.2x with incremental HT"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The error guarantee depends on the assumption that each node's SVD truncation error can be summed independently, because the residuals from projecting a new batch onto different cores are orthogonal; if truncating one layer's rank interferes with another layer's residual, the stated worst-case bound can fail.","fun_headline_variants_meta":{"raw":{"variants":["Streaming HT decomposition without full storage","Online tensor streams: incremental HT updates on the fly","Incremental hierarchical Tucker: stream without reconstructing all data","HT-RISE: batch-by-batch tensor decomposition, no full storage","Compress tensor streams 6.2x with incremental HT"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001049,"raw_usage":{"total_tokens":4395,"prompt_tokens":923,"completion_tokens":3472,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":539,"completion_tokens_details":{"reasoning_tokens":3391}},"tokens_in":539,"tokens_out":3472,"duration_ms":20813,"temperature":1.0,"reasoning_tokens":3391,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T10:28:26.263751+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a small two-layer HT, stream a batch that has shared energy across two sibling nodes, truncate each residual at exactly the node-wise tolerance, and compare the true reconstruction error to the claimed bound. If the observed error exceeds the bound, or if an earlier tensor's reconstruction changes after a later update, the residual-orthogonality premise is violated.","supporting_citations":[{"cited_title":"Hierarchical singular value decomposition of tensors","cited_arxiv_id":null,"evidence_quote":"Supplies the leaves-to-root hierarchical Tucker decomposition and the layerwise/total approximation-error lemmas (3.8 and 3.10) that the paper adapts for its error bounds."},{"cited_title":"Algorithm 941: Htucker---a matlab toolbox for tensors in hierarchical tucker format","cited_arxiv_id":null,"evidence_quote":"Provides the reference HT decomposition toolbox and the node-wise truncation error bound (adapted as Theorem 1) that BHT-l2r and HT-RISE inherit."},{"cited_title":"Breaking the curse of dimensionality, or how to use svd in many dimensions","cited_arxiv_id":null,"evidence_quote":"Introduces the tree-Tucker/hierarchical Tucker representation whose incremental update is the paper's subject."}],"review_version":1}