Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Tensor Network Structure Search Via Canonical Dimension Tree Enumeration

T0 review · 3 major / 5 minor · reviewed 2026-08-09 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that enumerating canonical dimension trees and scoring them from precomputed singular values makes tree tensor network structure search up to 10x faster and scales to 6D tensors of 1–2 GB.

desk verdict Interesting method and experiments, but Theorem 3.7 is false—the metadata-only rank search lacks a sound upper bound. read the letter →

arxiv 2502.02711 v5 pith:SFMARC4A submitted 2025-02-04 cs.CE cs.PL

Zheng Guo , Aditya Deshpande , Brian Kiedrowski , Xinyu Wang , Alex Gorodetsky This is my paper · ORCID
classification cs.CEcs.PL MSC 15A69
keywords tensornetworksnetworkstructuresearchcanonicaldimensiontreesoutput-directedsplitsprogramsynthesisrankassignmentsingularvaluedecompositiontree
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Tensor network structure search has been slow because every candidate topology has to be compressed to judge it. This paper claims that the search can be split into two halves: first enumerate candidate topologies as canonical dimension trees, represented as sequences of output-directed splits with ranks left unnamed, and then score every candidate without decomposing the tensor, using an archived map of singular values of all matricizations of the input tensor. Ranking becomes a small integer-programming problem that picks ranks to satisfy the error bound and minimize the resulting network size. Only the single best candidate is actually decomposed and rounded. If this holds, structure search no longer needs to sample and compress hundreds of networks, and bigger tensors become searchable.

What carries the argument

The load-bearing mechanism is the canonical dimension tree, encoded as a sketch program $S = \mathrm{OSplit}(I_1, ??_1); \ldots; \mathrm{OSplit}(I_n, ??_n)$, where each output-directed split names the set of free indices it wants on one side of the new edge and leaves the rank as a hole to be filled later. These split programs rule out redundant and suboptimal topologies by construction and make program equivalence trivial to check, which shrinks the enumeration from tens of thousands to dozens of sketches. Cost and rank assignment are obtained by solving a binary integer program whose objective is the final network size and whose constraint is $\sum_{i} \sum_{j > r_i} \sigma_{i,j}^2 \le (\varepsilon \|T\|_F)^2$, with $\sigma_{i,j}$ read from the precomputed singular-value map $\Omega$ rather than recomputed after each split. Only the top-$k$ sketches are run through actual decomposition and tree rounding, so the expensive SVD work happens once.

What would settle it

Enumerate every canonical dimension tree for a small tensor whose exact optimal tree network is known by brute force, run the paper's constraint-based rank assignment on each sketch, and check whether the top-ranked sketch, after actual decomposition and rounding, is the minimum-size network within the error bound. If any instance yields a strictly smaller feasible network that the method ranked below its top-$k$, the near-optimality claim is falsified; a cheaper check is to recompute intermediate singular values exactly and look for any split sequence where $\sigma_j(N(G_{i-1})_{(I_s)}) > \sigma_j(T_{(I_s)})$, which would directly contradict Theorem 3.7.

Watch

Extended reading notes

Core claim

The paper's central claim is that near-optimal tree tensor networks for a target error bound can be discovered by enumerating canonical dimension trees—nested index partitions encoded as programs of output-directed splits—rather than by sampling arbitrary networks. The completeness argument shows that every optimal tree network is reachable by such a program, because in an optimal network no two edges induce the same free-index partition and each unique partition corresponds to one split. The ranking engine is built on the singular-value upper bound $\sigma_j(N(G_{i-1})_{(I_s)}) \le \sigma_j(T_{(I_s)})$: intermediate split networks never have larger singular values than the original tensor's matricization, so the squared truncation error of each split can be budgeted additively from precomputed singular values. Empirically the paper reports up to 10x faster search than existing structure-search tools, compression ratios 1.5x to 3x better, and the first reported search results on 6D tensors of 1–2 GB that previous tools cannot finish.

Load-bearing premise

The ranking shortcut rests on the theorem that intermediate split networks never have singular values larger than the original tensor's matricizations, and on the completeness proof's assumption that the target network can be rebuilt without information loss by executing split programs; if either fails, the top-ranked sketch is not the optimal structure.

Editorial extensions

If this is right

  • Structure search and rank search separate cleanly: topologies are enumerated symbolically and ranks are assigned by constraint solving, so tensor decompositions are needed only for the final candidate (the experiments use $k=1$).
  • The number of candidates shrinks dramatically: on a $30\times12\times120\times120$ tensor, output-directed splits produce 63 sketches while input-directed splits produce 35,727, a reduction that makes large tensors feasible.
  • On real data the approach matches or beats state-of-the-art structure search tools in compression while being at least 10x faster, and beats fixed tensor-train and hierarchical-Tucker baselines by up to 10x in compression.
  • A topology discovered once transfers to new batches of similar data: test batches reach nearly the training-batch compression ratio with only about 110 seconds of decomposition time per batch.
  • The constraint-based rank allocation beats a fixed equal-error-budget policy in both compression ratio and speed, showing that per-sketch rank search is worth doing even when decomposition is skipped. The method explicitly targets tree structures, and the paper notes that the lack of cycle support limits compression ratios in some cases.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because ranking relies on an upper bound, the method is likely to be conservative: it may over-estimate ranks, and the rounding step repairs that. An editor-level extension would test whether replacing the bound with actual intermediate singular values changes the top-1 choice often enough to justify the extra decompositions.
  • The sketch-ranking pattern is not tied to trees: with new partition rules to handle cycles, the same precomputed-singular-value ranking could be extended to tensor rings and chains, which the paper explicitly leaves as future work.
  • The 110-second generalization result suggests a practical two-phase deployment: invest the expensive search once on a representative tensor, then reuse the topology as a cheap fixed structure for subsequent data from the same source.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes a tensor network structure search (TN-SS) method that decouples topology enumeration from rank assignment. Topologies are represented as sequences of output-directed splits (OSplits), and the cost of a candidate is estimated by solving an integer program whose error budget uses singular values of the original tensor that are precomputed for all matricizations. Only the top-k sketches are actually executed and rounded. The authors report large speedups over prior baselines, better compression ratios, scaling to 6D tensors, and generalization of discovered topologies to new data batches.

Significance. The program-synthesis view of TN-SS and the idea of scoring sketches without decomposing them is attractive and could make structure search practical for larger tensors. The experimental study is extensive, includes ablations for the two main design choices, and evaluates generalization to unseen batches, which is a useful contribution. The central claim, however, rests on Theorem 3.7, whose proof is not currently valid as written, and the abstract's '110 seconds' search-time claim is contradicted by the paper's own full-search timings. These issues are fixable, so the result is promising but needs substantial revision.

major comments (3)
  1. [Section A.2, Lemma A.7 / Theorem 3.7] The proof of Lemma A.7, Case II, is incorrect. It asserts that sigma_i(eT(It)) = sigma_i((eU eSigma)(It)), but eT(It) is formed by contracting eU with (eSigma eV) over all modes not in It, so the equality does not follow. This lemma is load-bearing because Section 3.6 uses Theorem 3.7 to replace the singular values of every later split by the precomputed singular values of the original tensor. The statement is plausibly correct and can be repaired: for an exact rank-r truncation, write T(Is) = sum_i sigma_i u_i v_i^T and observe that for It subset of Is, the orthonormality of the v_i gives ||T(It)^T x||^2 = sum_i sigma_i^2 ||U_i^{(It)T} x||^2, so the truncated version is a partial sum and is bounded by the original; the other cases can be handled similarly. Please replace the current proof with a correct argument.
  2. [Section A.1, Lemma A.1] The completeness proof claims that a constructed program satisfies EXEC(P, G0, eps) = (G, eps) 'without any information loss.' This contradicts Algorithm 4, which always performs a delta-truncated SVD with delta = eps ||T(Is)||_F and then may adjust the rank. For eps > 0 the execution is lossy, so the claimed exact recovery of an arbitrary optimal tree tensor network is not established. The lemma and Theorem A.2 should be restated either for full-rank splits (equivalently eps = 0) or as a completeness statement up to the truncation introduced by the execution procedure.
  3. [Abstract and Section 4.4, Table 2] The abstract and Section 1 state that the approach has 'a search time of approximately 110 seconds for 6D tensors of 1-2GB disk size.' Table 2 reports 4591.64 seconds for the BigEarthNet training-batch search and 2141.85 seconds for the PDEBench training-batch search; the approximately 110 seconds is only the average decomposition time for test batches after the topology has been fixed. The wording should be corrected to distinguish the full structure search from the reuse of a discovered topology on new data.
minor comments (5)
  1. [Section 3.6, ILP constraint] The constraint shown in Section 3.6 accumulates squared truncation errors from the precomputed singular values; it should state explicitly that this is an upper bound on the true accumulated error and that sketches for which an executed split fails (Algorithm 4, line 5) are discarded.
  2. [Section 4.4, Table 2] The 'Time (s)' column mixes full search (training batch), topology reuse plus rank search (test batches), and a baseline HT run; clarify which operations are included in each timing.
  3. [Appendix C.4, TnALE settings] The statement that the TnALE boundary ranks 'are chosen to cover the ranks discovered by our algorithm' gives that baseline information derived from the method under evaluation; report sensitivity to these boundaries or select them without using the proposed algorithm's output.
  4. [Theorem 3.7] The statement quantifies over i and s but omits the range of j in sigma_j; add 'for all 1 <= j <= min(rank(N(G_{i-1})(Is)), rank(T(Is)))'.
  5. [Author affiliations] The footnote has a typo: 'Neuclear Engineering' should be 'Nuclear Engineering.'

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central search-and-rank derivation is self-contained, and final structures are obtained by actual decompositions.

full rationale

The central claim—that enumerating output-directed split programs and ranking them with an ILP over precomputed singular values finds near-optimal tree tensor networks—is not circular. The precomputed singular value map is input metadata computed from the original tensor; the ILP in Section 3.6 uses it only to propose rank assignments and costs, and Section 3.7 then actually executes the selected complete program and rounds the resulting network, so the reported compression ratios are measured from realized decompositions rather than re-read from the ILP objective. Theorem 3.7 is offered with a proof from SVD and Poincaré-type lemmas; even if that proof were disputed, an incorrect bound would be a soundness flaw, not a definitional equivalence between input and output. The completeness theorem for OSplits (Theorem A.2) is a formal representation result: a tree's edge partitions are mapped to OSplit arguments, which is an encoding equivalence rather than a fitted prediction. The only self-citation with author overlap, Ref. [1], is background on incremental tensor trains and is not load-bearing. The choice of baseline boundary ranks with knowledge of our results (Appendix C.4) and per-dataset hyperparameter c are benchmark-fairness concerns, not circularity of the central derivation.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

No new physical or conceptual entities are postulated; OSplit is a program operation, not an entity. The main dependencies are standard linear algebra, the tree-structure restriction, the additive error budget, and the completeness of laminar OSplit programs, together with three hand-set search hyperparameters.

free parameters (3)
  • rank-candidate sampling step c = 0.05 for light field data, 0.1 for other datasets
    Controls which truncation-error levels become ILP rank candidates; hand-set per dataset in Appendix B.
  • number of retained sketches k = 1
    Only the single lowest-cost sketch is decomposed; chosen in experiments and affects the quality/time trade-off.
  • maximum number of splits searched = up to 6 splits
    Search budget; the authors state good results for d less than or equal to 6 and c less than or equal to 6, so the practical scope depends on this choice.
assumptions (5)
  • standard math Poincare separation theorem and standard SVD properties
    Used to prove Lemma A.6 and Theorem 3.7, which provide the upper bounds on singular values that make sketch scoring cheap.
  • domain assumption Tree tensor networks without cycles are the target class
    The problem definition in Definition 3.4 restricts to arbitrary tree structures; cyclic structures are explicitly left as future work.
  • domain assumption Sequential split truncation errors add in squared Frobenius norm within the error budget
    The ILP constraint in Section 3.6 sums per-split truncation errors to enforce the global error bound, relying on a projection-error additivity property that is not fully proved.
  • domain assumption Every optimal tree topology has no two edges inducing the same index partition
    Used in Theorem A.2 to claim OSplit programs can express every optimal tree; the proof assumes merging same-partition edges always reduces size.
  • domain assumption Singular values of intermediate networks are bounded by original tensor matricizations
    Theorem 3.7 is load-bearing for avoiding decompositions; its proof depends on the laminar (nested or disjoint) structure of OSplit index sets.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Tensor Network Structure Search Via Canonical Dimension Tree Enumeration." pith.science (2026). https://pith.science/paper/SFMARC4A

@misc{pith2026250202711,
  author       = {Pith},
  title        = {Pith review of: Tensor Network Structure Search Via Canonical Dimension Tree Enumeration},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SFMARC4A}},
  note         = {Machine review of arXiv:2502.02711}
}
read the original abstract

Tensor networks provide a powerful framework for compressing multi-dimensional data. The optimal tensor network structure for a given data tensor depends on both data characteristics and specific optimality criteria, making tensor network structure search a challenging problem. Existing solutions typically rely on sampling and compressing numerous candidate structures; these procedures are computationally expensive and therefore limiting for practical applications. We address this challenge by decoupling topology enumeration from rank assignment search. We first represent the search space using canonical dimension trees, which encode potential network topology through nested index partitions and inherently rule out redundant and suboptimal topologies by construction. To mitigate the assessment bottleneck, we introduce a mechanism powered by the precomputation of a singular value map. By archiving the singular values of all feasible tensor matricizations, we transform the evaluation of any candidate dimension tree into a constraint-solving problem. This formulation yields an empirically near-optimal rank assignment via simple metadata lookups, allowing us to compute structural costs and bypass expensive tensor decompositions for all but the final selected candidate. Experimental results show that our approach accelerates the structure search by up to 10x while achieving highly competitive compression ratios, outperforming standard tensor trains and hierarchical tuckers by up to 10x, and matching or exceeding state-of-the-art structure search tools. Notably, our approach scales to larger tensors that are unattainable by prior work. Furthermore, the discovered topologies generalize well to similar data; they achieve compression ratios up to 2.4x better than tensor trains or hierarchical tuckers, while maintaining a search time of approximately 110 seconds for 6D tensors of 1-2GB disk size.

Figures

Figures reproduced from arXiv: 2502.02711 by the authors.

Figure 1
Figure 1. The overall workflow. We use green for inputs, purple for preprocess, orange for sketch [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. (a) An example transformation program. (b) The tensor network produced by the program [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. The suboptimal resulting structure of input-directed splits. [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: The problem of redundancy in input-directed splits: two different sequences of input [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Comparison of compression ratio vs time on real datasets. The datasets from left to [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Comparison of compres￾sion ratios for random generated data. Result Analysis [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]
Figure 7
Figure 7. Figure 7: These structures showcase that our tool can discover non-standard structures other than TT, [PITH_FULL_IMAGE:figures/full_fig_p019_7.png]
Figure 8
Figure 8. Figure 8: These two structures are similar to tensor trains but they have clustered and reordered [PITH_FULL_IMAGE:figures/full_fig_p019_8.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Hierarchical Search of Tree Tensor Networks for High-Dimensional Data

    cs.CE 2026-03 conditional novelty 5.5 of 10

    A hierarchical, entropy-guided search algorithm automatically rewires tree tensor networks and reshapes their indices, delivering 2.5–100× better compression than fixed Tensor Train/Hierarchical Tucker formats on phys...

Reference graph

Works this paper leans on

46 extracted references · 34 canonical work pages · cited by 1 Pith paper

  1. [1]

    Gorsich, Shravan Veerapaneni, and Alex A

    Doruk Aksoy, David J. Gorsich, Shravan Veerapaneni, and Alex A. Gorodetsky. An incremental tensor train decomposition algorithm. SIAM Journal on Scientific Computing, 46(2):A1047– A1075, 2024. doi: 10.1137/22M1537734. URL https://doi.org/10.1137/22M1537734

    work page doi:10.1137/22m1537734 2024

  2. [2]

    Tensor network algorithms: A route map

    Mari Carmen Bañuls. Tensor network algorithms: A route map. Annual Review of Condensed Matter Physics, 14(1):173–191, 2023

    work page 2023

  3. [3]

    Multi-modal synthesis of regular expressions

    Qiaochu Chen, Xinyu Wang, Xi Ye, Greg Durrett, and Isil Dillig. Multi-modal synthesis of regular expressions. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2020, page 487–502, New York, NY , USA, 2020. Association for Computing Machinery. ISBN 9781450376136. doi: 10.1145/3385412.3385988. URL http...

    work page arXiv 2020

  4. [4]

    A multilinear singular value decomposition

    Lieven De Lathauwer, Bart De Moor, and Joos Vandewalle. A multilinear singular value decomposition. SIAM Journal on Matrix Analysis and Applications, 21(4):1253–1278, 2000. doi: 10.1137/S0895479896305696. URL https://doi.org/10.1137/S0895479896305696

    doi:10.1137/s0895479896305696

  5. [5]

    A note on tensor chain approxima- tion

    Mike Espig, Kishore Kumar Naraparaju, and Jan Schneider. A note on tensor chain approxima- tion. Computing and Visualization in Science, 15:331–344, 2012

    work page 2012

  6. [6]

    G. Evenbly. Algorithms for tensor network renormalization. Phys. Rev. B, 95:045117, Jan

    work page

  7. [7]

    Tree-based tensor formats

    Antonio Falcó, Wolfgang Hackbusch, and Anthony Nouy. Tree-based tensor formats. SeMA Journal, 78:159–173, 2021

    work page 2021

  8. [8]

    Yu Feng, Ruben Martins, Yuepeng Wang, Isil Dillig, and Thomas W. Reps. Component-based synthesis for complex apis. SIGPLAN Not., 52(1):599–612, January 2017. ISSN 0362-1340. doi: 10.1145/3093333.3009851. URL https://doi.org/10.1145/3093333.3009851

    work page arXiv 2017

Show all 46 references
  1. [9]

    Approximately optimal core shapes for tensor decompositions

    Mehrdad Ghadiri, Matthew Fahrbach, Gang Fu, and Vahab Mirrokni. Approximately optimal core shapes for tensor decompositions. In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett, editors, Proceedings of the 40th Internationa...

    2023

  2. [10]

    Hierarchical singular value decomposition of tensors

    Lars Grasedyck. Hierarchical singular value decomposition of tensors. SIAM Journal on Matrix Analysis and Applications, 31(4):2029–2054, 2010. doi: 10.1137/090764189. URL https://doi.org/10.1137/090764189

    2010 doi

  3. [11]

    Hyperoptimized approximate contraction of tensor networks with arbitrary geometry

    Johnnie Gray and Garnet Kin-Lic Chan. Hyperoptimized approximate contraction of tensor networks with arbitrary geometry. Phys. Rev. X, 14:011009, Jan 2024. doi: 10.1103/PhysRevX. 14.011009. URL https://link.aps.org/doi/10.1103/PhysRevX.14.011009

    2024 doi

  4. [12]

    Nouy, and G

    Cécile Haberstich, A. Nouy, and G. Perrin. Active learning of tree tensor networks using optimal least squares. SIAM/ASA Journal on Uncertainty Quantification, 11(3):848–876, 2023. doi: 10.1137/21M1415911. URL https://doi.org/10.1137/21M1415911

    2023 doi

  5. [13]

    A new scheme for the tensor representation

    Wolfgang Hackbusch and Stefan Kühn. A new scheme for the tensor representation. Journal of Fourier analysis and applications, 15(5):706–722, 2009

    2009

  6. [14]

    Numerical methods in tensor networks

    Stefan Handschuh. Numerical methods in tensor networks. PhD thesis, Dissertation, Leipzig, Universität Leipzig, 2015, 2015

    2015

  7. [15]

    Adaptive learning of tensor network structures

    Meraj Hashemizadeh, Michelle Liu, Jacob Miller, and Guillaume Rabusseau. Adaptive learning of tensor network structures. arXiv preprint arXiv:2008.05437, 2020. 11

    2008 arXiv

  8. [16]

    Automatic structural optimization of tree tensor networks

    Toshiya Hikihara, Hiroshi Ueda, Kouichi Okunishi, Kenji Harada, and Tomotoshi Nishino. Automatic structural optimization of tree tensor networks. Phys. Rev. Res., 5:013031, Jan 2023. doi: 10.1103/PhysRevResearch.5.013031. URL https://link.aps.org/doi/10.1103/ PhysRevResearch.5.013031

    2023 doi

  9. [17]

    Kolda and Brett W

    Tamara G. Kolda and Brett W. Bader. Tensor decompositions and applications. SIAM Re- view, 51(3):455–500, 2009. doi: 10.1137/07070111X. URL https://doi.org/10.1137/ 07070111X

    2009 doi

  10. [18]

    Stochastic gradients for large-scale tensor decomposition

    Tamara G Kolda and David Hong. Stochastic gradients for large-scale tensor decomposition. SIAM Journal on Mathematics of Data Science, 2(4):1066–1095, 2020

    2020

  11. [19]

    Speeding-up convolutional neural networks using fine-tuned cp-decomposition

    Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014

    2014 arXiv

  12. [20]

    Evolutionary topology search for tensor network decomposition

    Chao Li and Zhun Sun. Evolutionary topology search for tensor network decomposition. In Proceedings of the 37th International Conference on Machine Learning , page 5947–5957. PMLR, November 2020. URL https://proceedings.mlr.press/v119/li20l.html

    2020

  13. [21]

    Permutation search of tensor network structures via local sampling

    Chao Li, Junhua Zeng, Zerui Tao, and Qibin Zhao. Permutation search of tensor network structures via local sampling. In Proceedings of the 39th International Conference on Machine Learning, page 13106–13124. PMLR, June 2022. URL https://proceedings.mlr.press/ v162/li22y.html

    2022

  14. [22]

    Caiafa, and Qibin Zhao

    Chao Li, Junhua Zeng, Chunmei Li, Cesar F. Caiafa, and Qibin Zhao. Alternating local enumeration (tnale): Solving tensor network structure search with fewer evaluations. In Proceedings of the 40th International Conference on Machine Learning, page 20384–20411. PMLR, July 2023....

    2023

  15. [23]

    Approximate contraction of arbitrary tensor networks with a flexible and efficient density matrix algorithm

    Linjian Ma, Matthew Fishman, Edwin Miles Stoudenmire, and Edgar Solomonik. Approximate contraction of arbitrary tensor networks with a flexible and efficient density matrix algorithm. Quantum, 8:1580, 2024

    2024

  16. [24]

    Position: Tensor networks are a valuable asset for green ai

    Eva Memmel, Clara Menzen, Jetze Schuurmans, Frederiek Wesel, and Kim Batselier. Position: Tensor networks are a valuable asset for green ai. arXiv preprint arXiv:2205.12961, 2022

    2022 arXiv

  17. [25]

    On algorithms for and computing with the tensor ring decomposition

    Oscar Mickelin and Sertac Karaman. On algorithms for and computing with the tensor ring decomposition. Numerical Linear Algebra with Applications, 27(3):e2289, 2020

    2020

  18. [26]

    Introduction to Tensor Network Methods: Numerical simulations of low-dimensional many-body quantum systems

    Simone Montangero. Introduction to Tensor Network Methods: Numerical simulations of low-dimensional many-body quantum systems. Springer International Publishing, 2018. ISBN 978-3-030-01408-7. doi: 10.1007/978-3-030-01409-4. URL http://link.springer.com/ 10.1007/978-3-030-01409-4

    2018 doi

  19. [27]

    Tensorizing neural networks

    Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P Vetrov. Tensorizing neural networks. Advances in neural information processing systems, 28, 2015

    2015

  20. [28]

    I. V . Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 33(5): 2295–2317, January 2011. ISSN 1064-8275. doi: 10.1137/090752286

    2011 doi

  21. [29]

    Stable low-rank tensor decomposition for compression of convolutional neural network

    Anh-Huy Phan, Konstantin Sobolev, Konstantin Sozykin, Dmitry Ermilov, Julia Gusak, Petr Tichavsk`y, Valeriy Glukhov, Ivan Oseledets, and Andrzej Cichocki. Stable low-rank tensor decomposition for compression of convolutional neural network. In Computer Vision–ECCV 2020: 16th E...

    2020

  22. [30]

    Scalable bayesian low-rank decomposition of incomplete multiway tensors

    Piyush Rai, Yingjian Wang, Shengbo Guo, Gary Chen, David Dunson, and Lawrence Carin. Scalable bayesian low-rank decomposition of incomplete multiway tensors. In Eric P. Xing and Tony Jebara, editors, Proceedings of the 31st International Conference on Machine Learning, volume ...

    2014

  23. [31]

    Solving high-dimensional parabolic pdes using the tensor train format

    Lorenz Richter, Leon Sallandt, and Nikolas Nüsken. Solving high-dimensional parabolic pdes using the tensor train format. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learnin...

    2021

  24. [32]

    Adaptive rank selection for tensor ring decomposition

    Farnaz Sedighin, Andrzej Cichocki, and Anh-Huy Phan. Adaptive rank selection for tensor ring decomposition. IEEE Journal of Selected Topics in Signal Processing, 15(3):454–463, 2021. doi: 10.1109/JSTSP.2021.3051503

    2021

  25. [33]

    Programming by sketching for bit-streaming programs

    Armando Solar-Lezama, Rodric Rabbah, Rastislav Bodík, and Kemal Ebcio˘glu. Programming by sketching for bit-streaming programs. InProceedings of the 2005 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’05, page 281–294, New York, NY , USA, 2005....

    2005

  26. [34]

    Sketching stencils

    Armando Solar-Lezama, Gilad Arnold, Liviu Tancau, Rastislav Bodik, Vijay Saraswat, and Sanjit Seshia. Sketching stencils. In Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 167–178, 2007

    2007

  27. [35]

    Bigearthnet: A large- scale benchmark archive for remote sensing image understanding

    Gencer Sumbul, Marcela Charfuelan, Begüm Demir, and V olker Markl. Bigearthnet: A large- scale benchmark archive for remote sensing image understanding. In IGARSS 2019-2019 IEEE International Geoscience and Remote Sensing Symposium, pages 5901–5904. IEEE, 2019

    2019

  28. [36]

    PDEBench Datasets, 2022

    Makoto Takamoto, Timothy Praditia, Raphael Leiteritz, Dan MacKinlay, Francesco Alesiani, Dirk Pflüger, and Mathias Niepert. PDEBench Datasets, 2022. URL https://doi.org/10. 18419/darus-2986

    2022

  29. [37]

    PDEBench: An Extensive Benchmark for Scientific Machine Learning

    Makoto Takamoto, Timothy Praditia, Raphael Leiteritz, Dan MacKinlay, Francesco Alesiani, Dirk Pflüger, and Mathias Niepert. PDEBench: An Extensive Benchmark for Scientific Machine Learning. In 36th Conference on Neural Information Processing Systems (NeurIPS 2022) Track on Dat...

    2022 arXiv

  30. [38]

    Some mathematical notes on three-mode factor analysis

    Ledyard R Tucker. Some mathematical notes on three-mode factor analysis. Psychometrika, 31 (3):279–311, 1966. doi: 10.1007/BF02289464

    1966 doi

  31. [39]

    Matrix product states, projected entangled pair states, and variational renormalization group methods for quantum spin systems

    Frank Verstraete, Valentin Murg, and J Ignacio Cirac. Matrix product states, projected entangled pair states, and variational renormalization group methods for quantum spin systems. Advances in physics, 57(2):143–224, 2008

    2008

  32. [40]

    Sqlizer: query synthesis from natural language

    Navid Yaghmazadeh, Yuepeng Wang, Isil Dillig, and Thomas Dillig. Sqlizer: query synthesis from natural language. Proc. ACM Program. Lang., 1(OOPSLA), October 2017. doi: 10.1145/ 3133887. URL https://doi.org/10.1145/3133887

    2017 doi

  33. [41]

    Loop optimization for tensor network renormalization

    Shuo Yang, Zheng-Cheng Gu, and Xiao-Gang Wen. Loop optimization for tensor network renormalization. Physical review letters, 118(11):110504, 2017

    2017

  34. [42]

    Batude: Budget-aware neural network compression based on tucker decomposition

    Miao Yin, Huy Phan, Xiao Zang, Siyu Liao, and Bo Yuan. Batude: Budget-aware neural network compression based on tucker decomposition. Proceedings of the AAAI Conference on Artificial Intelligence, 36(8):8874–8882, Jun. 2022. doi: 10.1609/aaai.v36i8.20869. URL https://ojs.aaai....

    2022 doi

  35. [43]

    tngps: Discovering unknown tensor network structure search algorithms via large language models (llms)

    Junhua Zeng, Chao Li, Zhun Sun, Qibin Zhao, and Guoxu Zhou. tngps: Discovering unknown tensor network structure search algorithms via large language models (llms). In Forty-first International Conference on Machine Learning, 2024

    2024

  36. [44]

    Tensor ring decomposition

    Qibin Zhao, Guoxu Zhou, Shengli Xie, Liqing Zhang, and Andrzej Cichocki. Tensor ring decomposition. arXiv preprint arXiv:1606.05535, 2016

    2016 arXiv

  37. [45]

    Svdinstn: A tensor network paradigm for efficient structure search from regularized modeling perspective

    Yu-Bang Zheng, Xi-Le Zhao, Junhua Zeng, Chao Li, Qibin Zhao, Heng-Chao Li, and Ting-Zhu Huang. Svdinstn: A tensor network paradigm for efficient structure search from regularized modeling perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Rec...

    2024

  38. [2017]

    URL https://link.aps.org/doi/10.1103/ PhysRevB.95.045117

    doi: 10.1103/PhysRevB.95.045117. URL https://link.aps.org/doi/10.1103/ PhysRevB.95.045117

    doi

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.