Pith. sign in

REVIEW 3 major objections 5 minor 61 references

Learning to Rank Tensor Network Contraction Plans for GPU-Accelerated Quantum Circuit Simulation

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

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

Pith's one-line read A learned ranker can pick a fast tensor-network contraction plan before it runs on a GPU.

desk verdict First real LTR-for-contraction-plan paper, and the evaluation is careful enough that the central claim holds within its stated scope; generalization to new generators is untested and acknowledged. read the letter →

arxiv 2608.05819 v1 pith:4XXDEQ5P submitted 2026-08-06 cs.LG cs.DCcs.PFquant-ph

Alfred M. Pastor , Maribel Castillo , Jose M. Badia This is my paper · ORCID
classification cs.LGcs.DCcs.PFquant-ph
keywords learningtoranktensornetworkcontractionquantumcircuitsimulationGPUaccelerationplanselectiongradientboostingNDCGzero-shottransfer
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

Quantum circuit simulation via tensor networks costs far less when tensors are contracted in a good order, but finding that order is NP-hard and heuristics produce many plausible plans. This paper claims that a learning-to-rank model trained on GPU measurements can order candidate contraction plans so that the fastest plan is usually near the top, without executing any of them first. The input is a structural description of each plan computed from its contraction sequence; the labels are measured runtimes on a GPU. On a held-out in-distribution test, the best model placed the fastest plan first in 60% of circuits and in its top three in 96%, with tiny decision regret. The paper also shows the ordering transfers reasonably to a different GPU without retraining, though with measurable loss.

What carries the argument

The central object is a fixed-size feature vector built from the sequence of pairwise contractions in a plan. Each contraction step is described by four exponents: $c_i$ for the work it performs, $p_i$ for the output size it produces, $k_i$ for the size of the reduction dimension, and $d_i$ for the shape imbalance of the equivalent dense kernel, all defined through a GEMM-like $(M\times K)\cdot(K\times N)\to(M\times N)$ view of the contraction. Plan-level aggregations of these primitives, such as bottleneck cost, total work, near-critical tail, output parallelism at the bottleneck, reduction richness, and geometry, feed gradient-boosted rankers, so the model ranks plans without needing any timing measurements at inference time.

What would settle it

A concrete check: take a circuit family never seen during training, generate candidate plans with a new heuristic that contributed none of the original candidates, and measure whether the ranker's Top-1 and Top-3 performance beats random selection from that pool; if it does not, the claim that the structural features generalize across plan generators is falsified.

Watch

Extended reading notes

Core claim

The central claim is that contraction plans for quantum-circuit simulation on GPUs can be ranked by gradient-boosted tree models using structural features computed from the plan alone, and that this ranking is good enough to serve as a pre-execution selection stage. The NDCG-oriented model achieves Top-1 60% and Top-3 96% on the locked in-distribution test, with Regret1 0.0141, and retains 92% Top-3 when the same model is evaluated against runtime measurements from a second GPU architecture. Under circuit-family shift to the QFT-based family, Top-3 drops to 62.9%, so the representation generalizes but not for free.

Load-bearing premise

The ranker's practical value depends on the pool of candidate plans it is asked to order: the method only selects among the plans it is given, so if that pool is not diverse or contains mostly poor plans, a good ranking still leaves the user with a poor plan to run.

Editorial extensions

If this is right

  • Placing the ranker between plan generation and execution turns contraction-plan selection into a cheap Top-1 or Top-3 step, cutting the number of plans that must actually be timed on the GPU.
  • Because the features are derived solely from the contraction plan and the labels come from measured runtimes, the same model can be evaluated on any backend where runtimes are available, making zero-shot GPU transfer a testable property.
  • The NDCG-oriented objective, which emphasizes the top of the ranking, yields lower decision regret than the pairwise objective in this setting, so the choice of training objective matters for the practical goal of picking one plan to run.
  • The Top-3 drop from 96% in-distribution to 62.9% on the held-out QFT family shows the approach degrades under circuit-family shift, implying that broader training distributions and multiple held-out families are needed before reliable deployment.
  • The feature construction extends beyond binary tensor networks: replacing rank counts with logarithms of dimension products generalizes the same design to heterogeneous bond dimensions.

Reading between the lines

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

  • If structural plan features carry this much signal for GPU performance, the same plan-only-to-backend-label pattern could be applied to other autotuning decisions, such as choosing linear-algebra kernels or loop orders, where the input is a sequence of operations and the label is measured runtime.
  • The 96% Top-3 rate suggests the model's real value is shortlisting: a user willing to run three candidate plans will almost always test the fastest one, so the ranker effectively concentrates GPU time on the most promising options.
  • A natural stress test, which the paper itself plans, is to withhold complete heuristic families during training; that would reveal whether the model learns general properties of good plans or merely calibrates to the specific pool of candidate generators.
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 learning-to-rank (LTR) approach for selecting tensor-network contraction plans for GPU-accelerated quantum circuit simulation. Each contraction plan is represented by a fixed-size set of structural features computed directly from its sequence of pairwise contractions, and gradient-boosted XGBoost models are trained with either a listwise (rank:ndcg) or pairwise (rank:pairwise) objective. The training labels are measured GPU runtimes on an RTX A6000, converted to MinFill-relative speedups and graded relevance scores. The dataset consists of 225 circuit groups, split into 138 development groups, 25 locked in-distribution (ID) test groups, and 62 out-of-distribution (OOD) groups from a held-out QFT-based family. The authors compare against random and MinFill-based baselines, report Top-1/Top-3, regret, and win-rate metrics, and also study cross-GPU stability and zero-shot transfer to a Tesla V100. The main results are that the NDCG-oriented model achieves 60% Top-1 and 96% Top-3 on the ID test, with Regret1 0.0141, while the OOD Top-3 drops to 62.9%, and that rankings remain substantially stable across the two GPUs (same-best-plan rate 84%, mean Kendall tau_b 0.845).

Significance. If the reported results hold, the paper makes a useful contribution: it provides a practical, low-cost selection stage between contraction-plan generation and GPU execution, with a feature representation that requires no timing or profiling at inference time. The evaluation protocol is a clear strength: grouped partitioning prevents circuit-level leakage, the ID and OOD splits are locked during development, sanity checks with shuffled labels are reported, and hyperparameter optimization is performed only on development folds. The cross-GPU analysis includes bootstrap confidence intervals at the group level, which is more careful than typical practice in this area. The significance is tempered, however, by the small ID test set (25 groups), the single-family OOD split, and the fact that all plans come from the same fixed set of seven generators; the practical search-reduction claim is therefore conditional on the candidate pool and on the backend. The paper is honest about most of these limitations, but some load-bearing points need additional analysis before the central claim can be accepted at face value.

major comments (3)
  1. [§5.1 (Dataset construction and relevance labels)] The protocol excludes all plans that hit the 10-minute timeout or out-of-memory condition ('and T those plans were excluded'), but the paper never reports how many plans failed, which heuristics failed, or how the number of valid candidates per group is distributed. The random-baseline Top-3 values in Tables 6 and 7 (58.4% and 54.7%) imply mean group sizes of roughly four to five valid candidates, not the nominal seven. The ranker is therefore evaluated only on the feasible subset of the intended pool, and the search-cost reduction claim for the original seven candidates is untested: a plan that is ranked first but would OOM/timeout is not scored, and every failure is a real cost in practice. Please report failure counts by generator and circuit family, and either score failed plans as a distinct outcome or restrict the practical claim to plans that complete.
  2. [§6.2.2 and §8 (Circuit-family shift)] The OOD split holds out the QFT circuit family but uses the same seven plan-generation heuristics in training and test. The features most likely to be informative—n_steps, max_cost, costw_red_rank, and the geometry block—are all functions of the plan's structure, and plan structure is strongly determined by which heuristic produced the plan. The OOD experiment therefore cannot distinguish a model that learned general plan quality from one that learned the characteristic fingerprints of the seven generators. Section 8 correctly lists 'complete plan-generation methods or heuristic families are withheld from training and validation' as future work, but this is precisely the experiment needed to support the conclusion that the method reduces contraction-plan search in the general setting users face. Please add a leave-one-heuristic-family-out evaluation, or rewrite the abstract and conclusion claims to state that the ranker has been validated only for a fixed candidate pool.
  3. [§6.2, Tables 6 and 7 (ID and OOD evaluation)] The locked ID test contains only 25 circuit groups, and Tables 6, 7, and 11 report Top-1/Top-3/regret without confidence intervals or significance tests. One circuit group is 4 percentage points of Top-1, so the differences between opt_ndcg and opt_pair (96% vs 92% Top-3, Regret1 0.0141 vs 0.0211) and the cross-GPU changes in Table 11 are of the same magnitude as a one- or two-circuit flip; the paper itself notes this for the Top-1 increase from 60% to 64%. The central qualitative hierarchy (learned rankers beat random and MinFill) is plausible, but the more fine-grained comparative claims need uncertainty quantification. Please add bootstrap or permutation confidence intervals for the main decision metrics.
minor comments (5)
  1. [§5.1] The sentence describing failed plans contains the stray fragment 'and T those plans were excluded'; the stray 'T' should be removed.
  2. [Appendix A and Table 2] The parameter q in topq_mean_cost is never assigned a numerical value, the epsilon in Eq. (9) is only specified as 'epsilon << 1', and tau in frac_tiny_steps is only given with 'e.g. tau=6'; for reproducibility, please fix all feature parameters in one place.
  3. [§5.5] The paper states that package versions and environment manifests 'will be provided in the accompanying repository', but no repository link is included; please supply the environment manifest or a link at submission time.
  4. [§6.2, Tables 6 and 7] The random baseline is described as assigning the plan order uniformly at random, but the tables give values to two decimals without saying whether these are averages over multiple random seeds or a single fixed seed; please specify the protocol.
  5. [§5.3 and Table 2] The feature-selection step removed four of eighteen features based on Gain and Shapley importance, but the paper does not report the importance values or an ablation; a short table or paragraph would make the selection reproducible.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: labels are measured runtimes, predictions are evaluated on locked held-out groups, and no target quantity is defined in terms of the model's own parameters.

full rationale

The paper's derivation chain is a standard supervised-learning pipeline whose supervision comes from measured execution times. The relevance label in Eq. (13), y_i = log(1 + T(P_mf)/T(P_i)), is a monotone transform of the target runtime, and although MinFill serves both as a candidate and as the normalization reference, this does not force any ranking result: comparing any two candidates reduces to comparing their measured runtimes. Features are computed entirely from the contraction plan (Section 4), so no test-time runtime enters the model input, and the model selection protocol uses group-aware five-fold cross-validation on the development set with final evaluation on locked in-distribution and held-out QFT-family sets (Section 5.2). The MinFill-fixed baselines have a 50% win rate by construction, but this is an explicit baseline definition, not a model prediction. The self-citations [28], [52], and [53] appear only as general background about tensor-network simulation and GPU contraction; no load-bearing uniqueness theorem or ansatz is imported from prior work by the same authors. The acknowledged dependence on the diversity of the candidate plan pool (Section 8) is an external-validity limitation, not a circularity, because the ranker's objective and evaluation remain anchored to measured plan quality rather than to its own fitted values.

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

The paper does not introduce new physical entities or conserved quantities. It relies on measured GPU runtimes as ground truth, on a hand-designed structural feature space, and on the representativeness of the generated candidate plan pool. The free parameters are all ML hyperparameters and feature-engineering constants rather than physical constants.

free parameters (5)
  • XGBoost hyperparameters = eta 0.01, max_depth 6, subsample 0.7 (opt_ndcg); eta 0.05, max_depth 5, subsample 0.5, colsample_bytree 0.5…
    Selected by randomized search on grouped dev folds; these are model capacity and regularization constants, not physical parameters, but they affect the learned ranking.
  • frac_tiny_steps threshold tau = 6
    Appendix A.6 defines a tiny step as c_i <= c_max - tau with tau = 6; hand-chosen threshold.
  • topq fraction q for topq_mean_cost = not specified precisely
    Appendix A.5 defines topq_mean_cost over the ceil(q*S) largest c_i but does not specify q; under-specified feature.
  • epsilon in geometry descriptor d_i = epsilon << 1
    Eq. (9) uses epsilon to avoid division by zero; value not specified.
  • feature selection choice = 13 features retained per final model
    Four of 18 features removed based on Gain and Shapley importance on the dev set; a modeling choice that affects the final models.
assumptions (5)
  • standard math Every pairwise contraction can be expressed in GEMM-like form (Eq. 5) with M, K, N as powers of 2 for binary tensor networks.
    Standard decomposition used by tensor libraries; analytical and well-established.
  • domain assumption Measured mean runtime over 50 repetitions is a stable ground truth for plan ranking.
    Section 5.1 reports only means, without variance; bootstrap intervals in Section 7.1 explicitly exclude timing-measurement uncertainty.
  • domain assumption The structural feature set captures the runtime-relevant aspects of GPU contraction execution.
    Core modeling hypothesis in Section 4 and Appendix A; not proven, only validated empirically on the tested datasets.
  • domain assumption The held-out QFT-based family is a meaningful out-of-distribution proxy.
    Section 6.2.2 uses one family; the authors note generalization depends on which family is excluded.
  • domain assumption The seven candidate plans per circuit are representative of practical contraction-plan pools.
    Section 5.1 and the conclusions state the method only ranks supplied candidates, and failed plans are dropped from groups.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Learning to Rank Tensor Network Contraction Plans for GPU-Accelerated Quantum Circuit Simulation." pith.science (2026). https://pith.science/paper/4XXDEQ5P

@misc{pith2026260805819,
  author       = {Pith},
  title        = {Pith review of: Learning to Rank Tensor Network Contraction Plans for GPU-Accelerated Quantum Circuit Simulation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4XXDEQ5P}},
  note         = {Machine review of arXiv:2608.05819}
}
read the original abstract

Classical simulation remains essential for developing and validating quantum algorithms, but its cost grows rapidly with circuit size. Tensor-network contraction can reduce this cost by exploiting circuit structure, although its efficiency depends strongly on the chosen contraction plan. On GPUs, plans with similar theoretical complexity may perform very differently because execution also depends on parallelism, reduction structure, memory traffic, and contraction geometry. We present a learning-to-rank framework for selecting efficient contraction plans before executing them. Each plan is represented by structural features derived directly from its sequence of pairwise contractions, and gradient-boosted rankers are trained from GPU measurements using listwise and pairwise objectives. We evaluate the resulting models on diverse circuit families, using separate in-distribution and circuit-family-shift test sets, and compare them with random and MinFill-based baselines. The learned rankers generally identify better plans, with the listwise model providing the strongest overall decision quality. We also study backend shift by comparing empirical plan orderings on two GPU architectures and evaluating the source-trained models on the second device without retraining. The rankings remain substantially, though not perfectly, stable across GPUs, and the models retain useful decision quality. These results support Learning to Rank as a practical way to reduce contraction-plan search, while showing that performance remains partly backend dependent.

Figures

Figures reproduced from arXiv: 2608.05819 by the authors.

Figure 1
Figure 1. Learning curves for the two optimized models. Each subfigure reports training and validation [PITH_FULL_IMAGE:figures/full_fig_p014_1.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

61 extracted references · 54 canonical work pages

  1. [1]

    Simulating quantum computation by contracting tensor networks

    Igor L. Markov and Yaoyun Shi. “Simulating quantum computation by contracting tensor networks”. SIAM Journal on Computing38, 963–981 (2008)

    work page 2008

  2. [2]

    A practical introduction to tensor networks: Matrix product states and projected entangled pair states

    Román Orús. “A practical introduction to tensor networks: Matrix product states and projected entangled pair states”. Annals of Physics349, 117–158 (2014)

    work page 2014

  3. [3]

    Hyper- optimized tensor network contraction

    Johnnie Gray and Stefanos Kourtis. “Hyper- optimized tensor network contraction”. Quantum5, 410 (2021)

    2021

  4. [4]

    Faster identifica- tion of optimal contraction sequences for tensor networks

    Robert N. C. Pfeifer, Jutho Haegeman, and Frank Verstraete. “Faster identifica- tion of optimal contraction sequences for tensor networks”. Physical Review E90, 033315 (2014)

    work page 2014

  5. [5]

    Alineartimealgorithmforminimum fill-in and treewidth for distance hereditary graphs

    Hajo J. Broersma, Elias Dahlhaus, and Ton Kloks. “Alineartimealgorithmforminimum fill-in and treewidth for distance hereditary graphs”. Discrete Applied Mathematics99, 367–400 (2000)

    work page 2000

  6. [6]

    Community structure in social and biolog- ical networks

    Michelle Girvan and Mark E. J. Newman. “Community structure in social and biolog- ical networks”. Proceedings of the National Academy of Sciences99, 7821–7826 (2002)

    work page 2002

  7. [7]

    Graph bisection with pareto optimization

    Michael Hamann and Ben Strasser. “Graph bisection with pareto optimization”. ACM Journal of Experimental Algorithmics23, 1– 34 (2018)

    work page 2018

  8. [8]

    cuQuantum ten- sor network contraction documentation

    NVIDIA Corporation. “cuQuantum ten- sor network contraction documentation”. (2024). url:https://docs.nvidia. com/cuda/cuquantum/24.11/python/ tensornet-contraction.html

    work page 2024

Show all 61 references
  1. [9]

    cuTENSOR user guide

    NVIDIA Corporation. “cuTENSOR user guide”. (2025). url:https: //docs.nvidia.com/cuda/cutensor/ latest/user_guide.html

    2025

  2. [10]

    Learning to rank for informa- tion retrieval

    Tie-Yan Liu. “Learning to rank for informa- tion retrieval”. Volume 3 of Foundations and Trends in Information Retrieval, pages 225–

  3. [11]

    Learning to rank quantum circuits for hardware-optimized performance en- hancement

    Gavin S. Hartnett, Aaron Barbosa, Pranav S. Mundada, Michael Hush, Michael J. Biercuk, and Yuval Baum. “Learning to rank quantum circuits for hardware-optimized performance en- hancement”. Quantum8, 1542 (2024). arXiv:2404.06535

    2024 arXiv

  4. [12]

    XG- Boost: A scalable tree boosting system

    Tianqi Chen and Carlos Guestrin. “XG- Boost: A scalable tree boosting system”. In Proceedings of the 22nd ACM SIGKDD In- ternational Conference on Knowledge Dis- covery and Data Mining (KDD). Pages 785–

  5. [13]

    Machine learning with quantum comput- ers

    Maria Schuld and Francesco Petruccione. “Machine learning with quantum comput- ers”. Volume 676 of Quantum Science and Technology. Springer. Cham, Switzer- land (2021). 1st edition

    2021

  6. [14]

    A survey on quantum machine learning: Current trends, challenges, op- portunities, and the road ahead

    Kamila Zaman, Alberto Marchisio, Muham- mad Abdullah Hanif, and Muhammad Shafique. “A survey on quantum machine learning: Current trends, challenges, op- portunities, and the road ahead” (2023). arXiv:2310.10315

    2023 arXiv

  7. [15]

    Learning high-accuracy error decod- ing for quantum processors

    Johannes Bausch, Andrew W. Senior, Fran- cisco J. H. Heras, Thomas Edlich, Alex Davies, Michael Newman, Cody Jones, Kevin Satzinger, Murphy Yuezhen Niu, Sam Blackwell, George Holland, Dvir Kafri, Juan Atalaya, Craig Gidney, Demis Hassabis, Ser- gio Boixo, Hartmut Neven, and Pu...

    2024

  8. [16]

    Support vector machines for 19 quantum state tomography

    M. S. Kazemi, Z. Bakhshinezhad, and A. T. Rezakhani. “Support vector machines for 19 quantum state tomography”. Physical Re- view A101, 042307 (2020)

    2020

  9. [17]

    Support vector machine classification of topological phase transitions

    Y. Wang, L. Zhang, Q. Wang, and Z. Liu. “Support vector machine classification of topological phase transitions”. Physical Re- view B99, 115105 (2019)

    2019

  10. [18]

    Predicting good quantum cir- cuit compilation options

    Nils Quetschlich, Lukas Burgholzer, and Robert Wille. “Predicting good quantum cir- cuit compilation options”. In Proceedings of the 2023 IEEE International Conference on Quantum Software (QSW). Pages 43–53. IEEE (2023). arXiv:2210.08027

    2023 arXiv

  11. [19]

    Neural-network quantum state tomogra- phy

    G. Torlai, G. Mazzola, J. Carrasquilla, M. Troyer, R. Melko, and G. Carleo. “Neural-network quantum state tomogra- phy”. Nature Physics14, 447–450 (2018)

    2018

  12. [20]

    Learning to learn with quantum neural networks via classical neural networks

    Guillaume Verdon, Michael Broughton, and Jacob Biamonte. “Learning to learn with quantum neural networks via classical neural networks” (2019). arXiv:1907.05415

    2019 arXiv

  13. [21]

    Methods, applications, and directions of learning-to- rank in NLP research

    Justin Lee, Gabriel Bernier-Colborne, Tegan Maharaj, and Sowmya Vajjala. “Methods, applications, and directions of learning-to- rank in NLP research”. In Kevin Duh, He- lena Gomez, and Steven Bethard, editors, Findings of the Association for Computa- tional Linguistics: NAACL ...

    2024

  14. [22]

    A survey on e-commerce learning to rank

    Md. Ahsanul Kabir, Mohammad Al Hasan, Aritra Mandal, Daniel Tunkelang, and Zhe Wu. “A survey on e-commerce learning to rank” (2024). arXiv:2412.03581

    2024 arXiv

  15. [23]

    Unified learning-to-rank for multi-channel retrieval in large-scale e-commerce search

    Aditya Gaydhani, Guangyue Xu, Dhanush Kamath, Ankit Singh, and Alex Li. “Unified learning-to-rank for multi-channel retrieval in large-scale e-commerce search” (2026). arXiv:2602.23530

    2026

  16. [24]

    Efficient and effec- tive tree-based and neural learning to rank

    Sebastian Bruch, Claudio Lucchese, and Franco Maria Nardini. “Efficient and effec- tive tree-based and neural learning to rank”. Foundations and Trends in Information Re- trieval17, 1–131 (2023)

    2023

  17. [25]

    Re- cent advances in the foundations and appli- cations of unbiased learning to rank

    Shashank Gupta, Philipp Hager, Jin Huang, Ali Vardasbi, and Harrie Oosterhuis. “Re- cent advances in the foundations and appli- cations of unbiased learning to rank”. In Pro- ceedings of the 46th International ACM SI- GIR Conference on Research and Develop- ment in Information...

  18. [26]

    A literature review on methods for learning to rank

    Junior Zilles, Giancarlo Lucca, and Ed- uardo Nunes Borges. “A literature review on methods for learning to rank”. In Proceed- ings of the 24th International Conference on Enterprise Information Systems, Volume 1 (ICEIS). Pages 545–552. INSTICC- SciTePress (2022)

    2022

  19. [27]

    Empowering quantum serverless circuit de- ployment optimization via graph contrastive learning and learning-to-rank co-designed approaches

    Tingting Li, Ziming Zhao, and Jianwei Yin. “Empowering quantum serverless circuit de- ployment optimization via graph contrastive learning and learning-to-rank co-designed approaches”. In Proceedings of the Thirty- Fourth International Joint Conference on Artificial Intelligen...

  20. [28]

    Efficient quantum cir- cuit contraction using tensor decision dia- grams

    Vicente Lopez-Oliva, Jose M. Badia, and Maribel Castillo. “Efficient quantum cir- cuit contraction using tensor decision dia- grams”. The Journal of Supercomputing81, 354 (2025)

    2025

  21. [29]

    Parameterization of ten- sor network contraction

    Bryan O’Gorman. “Parameterization of ten- sor network contraction”. In 14th Con- ference on the Theory of Quantum Com- putation, Communication and Cryptogra- phy (TQC 2019). Volume 135 of Leib- niz International Proceedings in Informatics (LIPIcs), pages 10:1–10:19. Schloss Da...

    2019

  22. [30]

    Design of a high-performance GEMM-like tensor- tensor multiplication

    Paul Springer and Paolo Bientinesi. “Design of a high-performance GEMM-like tensor- tensor multiplication”. ACM Transactions on Mathematical Software44, 1–29 (2018)

    2018

  23. [31]

    High-performance tensor contraction without transposition

    Devin A. Matthews. “High-performance tensor contraction without transposition”. SIAM Journal on Scientific Computing40, C1–C24 (2018)

    2018

  24. [32]

    A flexible high-performance simulator for ver- ifying and benchmarking quantum circuits implemented on real hardware

    Benjamin Villalonga, Sergio Boixo, Bron Nelson, Christopher Henze, Eleanor Rieffel, Rupak Biswas, and Salvatore Mandrà. “A flexible high-performance simulator for ver- ifying and benchmarking quantum circuits implemented on real hardware”. npj Quan- tum Information5, 86 (2019)

    2019

  25. [33]

    Benchmarking treewidth as a practical component of tensor network simulations

    Eugene F. Dumitrescu, Allison L. Fisher, Timothy D. Goodrich, Travis S. Humble, Blair D. Sullivan, and Andrew L. Wright. “Benchmarking treewidth as a practical component of tensor network simulations”. PLOS ONE13, e0207827 (2018)

    2018

  26. [34]

    Computing tree decomposi- 20 tions with FlowCutter: PACE 2017 submis- sion

    Ben Strasser. “Computing tree decomposi- 20 tions with FlowCutter: PACE 2017 submis- sion” (2017). arXiv:1709.08949

    2017 arXiv

  27. [35]

    Finding and evaluating community struc- ture in networks

    Mark E. J. Newman and Michelle Girvan. “Finding and evaluating community struc- ture in networks”. Physical Review E69, 026113 (2004)

    2004

  28. [36]

    Learning to rank us- ing gradient descent

    Chris Burges, Tal Shaked, Erin Renshaw, Ari Lazier, Matt Deeds, Nicole Hamilton, and Greg Hullender. “Learning to rank us- ing gradient descent”. In Proceedings of the 22nd International Conference on Machine Learning (ICML). Pages 89–96. New York, NY, USA (2005). ACM

    2005

  29. [37]

    From RankNet to LambdaRank to LambdaMART: An overview

    Christopher J. C. Burges. “From RankNet to LambdaRank to LambdaMART: An overview”. Technical Report MSR-TR-2010-

    2010

  30. [38]

    Minimal triangulations of graphs: A survey

    Pinar Heggernes. “Minimal triangulations of graphs: A survey”. Discrete Mathematics 306, 297–317 (2006)

    2006

  31. [39]

    An introduction to chordal graphs and clique trees

    Jean R. S. Blair and Barry W. Peyton. “An introduction to chordal graphs and clique trees”. In Alan George, John R. Gilbert, and Joseph W. H. Liu, editors, Graph Theory and Sparse Matrix Computation. Volume 56 of The IMA Volumes in Mathematics and its Applications, pages 1–29....

    1993

  32. [40]

    MQT Bench: Benchmark- ing software and design automation tools for quantum computing

    Nils Quetschlich, Lukas Burgholzer, and Robert Wille. “MQT Bench: Benchmark- ing software and design automation tools for quantum computing”. Quantum7, 1062 (2023)

    2023

  33. [41]

    The PACE 2017 Parameterized Algorithms and Computational Experiments Challenge: The Second Iteration

    Holger Dell, Christian Komusiewicz, Nim- rod Talmon, and Mathias Weller. “The PACE 2017 Parameterized Algorithms and Computational Experiments Challenge: The Second Iteration”. In Daniel Lokshtanov and Naomi Nishimura, editors, 12th Interna- tional Symposium on Parameterized a...

    2018

  34. [42]

    Intro- duction to machine learning with python: A guide for data scientists

    Andreas C. Müller and Sarah Guido. “Intro- duction to machine learning with python: A guide for data scientists”. O’Reilly Media. Sebastopol, CA, USA (2016). 1st edition. url:https://www.oreilly.com/library/ view/introduction-to-machine/ 9781449369880/

    2016

  35. [43]

    Accelerating the XGBoost algo- rithm using GPU computing

    Rory Mitchell, Eibe Frank, and Geoffrey Holmes. “Accelerating the XGBoost algo- rithm using GPU computing”. PeerJ Com- puter Science3, e127 (2018)

    2018

  36. [44]

    Feature interactions in XGBoost

    Kshitij Goyal, Sebastijan Dumančić, and Hendrik Blockeel. “Feature interactions in XGBoost” (2020). arXiv:2007.05758

    2020 arXiv

  37. [45]

    A uni- fied approach to interpreting model predic- tions

    Scott M Lundberg and Su-In Lee. “A uni- fied approach to interpreting model predic- tions”. In I. Guyon, U. Von Luxburg, S. Ben- gio, H.Wallach, R.Fergus, S.Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30. Pages 4765–4774. Curran Ass...

    2017

  38. [46]

    QXTools: A Julia framework for distributed quantum circuit simula- tion

    John Brennan, Lee O’Riordan, Kenneth Hanley, Myles Doyle, Momme Allalen, David Brayford, Luigi Iapichino, and Niall Moran. “QXTools: A Julia framework for distributed quantum circuit simula- tion”. Journal of Open Source Software7, 3711 (2022)

    2022

  39. [47]

    XG- Boost.jl: Julia interface to XGBoost

    XGBoost.jl Contributors. “XG- Boost.jl: Julia interface to XGBoost”. https://github.com/dmlc/XGBoost.jl/ releases/tag/v2.5.3(2026). Version 2.5.3, accessed 5 August 2026

    2026

  40. [48]

    Rankcor- relation methods

    M.G.KendallandJ.D.Gibbons. “Rankcor- relation methods”. Oxford University Press. New York (1990). 5th edition. url:https:// search.worldcat.org/title/21195423

    1990

  41. [49]

    Efficient parallelization of tensor network contraction for simulating quantum computation

    Cupjin Huang, Fang Zhang, Michael New- man, Xiaotong Ni, Dawei Ding, Junjie Cai, Xun Gao, Tenghui Wang, Feng Wu, Gengyan Zhang, Hsiang-Sheng Ku, Zhengx- iong Tian, Junyin Wu, Haihong Xu, Huan- jun Yu, Bo Yuan, Mario Szegedy, Yaoyun Shi, Hui-Hai Zhao, Chunqing Deng, and Jianxin...

    2021

  42. [50]

    Jet: Fast quan- tum circuit simulations with parallel task- based tensor-network contraction

    Trevor Vincent, Lee J. O’Riordan, Mikhail Andrenkov, Jack Brown, Nathan Killoran, Haoyu Qi, and Ish Dhand. “Jet: Fast quan- tum circuit simulations with parallel task- based tensor-network contraction”. Quan- tum6, 709 (2022)

    2022

  43. [51]

    Efficient quantum cir- 21 cuit simulation by tensor network methods on modern GPUs

    Feng Pan, Hanfeng Gu, Lvlin Kuang, Bing Liu, and Pan Zhang. “Efficient quantum cir- 21 cuit simulation by tensor network methods on modern GPUs”. ACM Transactions on Quantum Computing5, 26:1–26:25 (2024)

    2024

  44. [52]

    Parallel tensor network con- traction for efficient quantum circuit simu- lation on multicore CPUs and GPUs

    Alfred M. Pastor, Maribel Castillo, and Jose M. Badia. “Parallel tensor network con- traction for efficient quantum circuit simu- lation on multicore CPUs and GPUs”. In Proceedings of the 1st International Confer- ence on Quantum Software (IQSOFT 2025). Pages 120–127. SCITEPRE...

    2025

  45. [53]

    A community detection-based parallel algorithm for quantum circuit simu- lation using tensor networks

    Alfred M. Pastor, Jose M. Badia, and Mari- bel Castillo. “A community detection-based parallel algorithm for quantum circuit simu- lation using tensor networks”. The Journal of Supercomputing81, 450 (2025)

    2025

  46. [54]

    Tensor networks for quan- tum computing

    Aleksandr Berezutskii, Minzhao Liu, Atithi Acharya, et al. “Tensor networks for quan- tum computing”. Nature Reviews Physics7, 581–593 (2025)

    2025

  47. [55]

    Roofline: An insightful visual performance model for multicore ar- chitectures

    Samuel Williams, Andrew Waterman, and David Patterson. “Roofline: An insightful visual performance model for multicore ar- chitectures”. Communications of the ACM 52, 65–76 (2009)

    2009

  48. [56]

    TensorOpera- tions.jl documentation

    QuantumKitHub. “TensorOpera- tions.jl documentation”. (2025). url:https://quantumkithub.github. io/TensorOperations.jl/stable/. A Detailed cost model and feature-block definitions This appendix provides the technical detail underlying the feature design summarized in Section 4...

    2025

  49. [82]

    Microsoft Research (2010)

    2010

  50. [331]

    Now Publishers. (2009)

    2009

  51. [794]

    New York, NY, USA (2016). ACM

    2016

  52. [3443]

    arXiv:2305.02914

    ACM (2023). arXiv:2305.02914

    2023 arXiv

  53. [9258]

    International Joint Conferences on Ar- tificial Intelligence Organization (2025)

    2025

Pith tools

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