pith. sign in

arxiv: 2510.08210 · v4 · submitted 2025-10-09 · 🪐 quant-ph

Hyper-optimized Quantum Lego Contraction Schedules

Balint Pato , June Vanlerberghe , Kenneth R. Brown This is my paper

Pith reviewed 2026-05-18 09:14 UTC · model grok-4.3

classification 🪐 quant-ph
keywords quantum weight enumerator polynomialtensor network contractionquantum error correctionstabilizer codescontraction schedule optimizationsparse tensorsQuantum LEGO
0
0 comments X

The pith

Optimizing contraction schedules with a sparse stabilizer tensor cost function yields orders of magnitude improvement in quantum weight enumerator calculations.

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

The paper shows that dense tensor cost functions inaccurately predict contraction costs in Quantum LEGO networks for stabilizer weight enumerator polynomials because the intermediate tensors are highly sparse. The authors introduce the Sparse Stabilizer Tensor cost function, which computes contraction cost exactly in polynomial time from the rank of parity check matrices. This cost function matches the true contraction cost with perfect correlation, in contrast to the high uncertainty of the dense tensor approach. Optimizing schedules with the new cost function produces substantial reductions in actual computational cost. It also supplies a practical metric for deciding when the Quantum LEGO method outperforms brute force for a given code layout.

Core claim

The Sparse Stabilizer Tensor (SST) cost function, which determines contraction cost from the rank of parity check matrices of intermediate tensors, provides an exact predictor for Quantum LEGO networks computing stabilizer weight enumerator polynomials. This enables hyper-optimization of contraction schedules that achieve up to orders of magnitude lower actual costs than schedules based on dense tensor cost functions.

What carries the argument

The Sparse Stabilizer Tensor (SST) cost function, which uses the rank of parity check matrices to give an exact polynomial-time estimate of contraction cost for sparse intermediate tensors.

If this is right

  • Hyper-optimized schedules using the SST cost function achieve up to orders of magnitude improvement in actual contraction cost over those using the dense tensor cost function.
  • The SST cost function exhibits perfect correlation with true contraction cost while the dense tensor cost function shows large uncertainty.
  • The precise cost estimates from the SST function supply an efficient way to decide whether a given Quantum LEGO layout is computationally superior to brute force.
  • Hyper-optimized contraction becomes a key technique for using the Quantum LEGO framework to explore the quantum error-correcting code design space.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The exact cost prediction could allow systematic testing of many different Quantum LEGO layouts to identify the most efficient one for a given code.
  • Sparsity-aware cost functions might improve contraction performance in other tensor-network tasks that involve stabilizer or parity-check structures.
  • The approach provides a concrete way to scale weight enumerator calculations to larger stabilizer code families by first checking feasibility with the SST metric.

Load-bearing premise

Intermediate tensors arising in Quantum LEGO networks for stabilizer weight enumerator polynomials are highly sparse, so the rank of their parity check matrices exactly predicts contraction cost.

What would settle it

A contraction schedule for a specific stabilizer code and Quantum LEGO layout where the actual measured contraction cost after SST-based optimization is not substantially lower than the cost after dense-tensor-based optimization.

Figures

Figures reproduced from arXiv: 2510.08210 by Balint Pato, June Vanlerberghe, Kenneth R. Brown.

Figure 1
Figure 1. Figure 1: Quantum LEGO building blocks used in the paper. Stoppers (a) are single-qubit states, sta￾bilized by Pauli-X (red) or Pauli-Z (blue) operators. The identity stopper (gray) is the “free qubit”, which is only stabilized by the I operator, and thus is a subspace LEGO. The Hadamard LEGO (b) is stabi￾lized by ⟨XZ, ZX⟩. The identity LEGO (c) or Bell￾state is stabilized by ⟨XX, ZZ⟩. The 3, 4, and 5-legged example… view at source ↗
Figure 2
Figure 2. Figure 2: Cotengra contraction tree overlayed over a 3x3 [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Concatenated layout for Shor’s code. The [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: The HaPPY [10] code with perfect encoding tensors of the [[5, 1, 3]] code. The logical legs are omit￾ted, making these LEGOs subspace LEGOs. Cao, Gullans, Lackey and Wang estimate the upper bound on contraction cost of these codes to be O(n 1+α), α > 0, where α is dependent on the exact hyperbolic tesselation [17], resulting in super-polynomial speedup compared to brute force using the QL contraction. 8 [… view at source ↗
Figure 5
Figure 5. Figure 5: The MSP network for the [[4, 2, 2]] code. Log￾ical degrees of freedom are the gray LEGOs, physical ones are the dangling legs off of the identity LEGOs (white) circles. This encoding map has a non-trivial kernel. The ZZZZ stabilizer of the encoding map is highlighted through operator pushing and matching. The MSP circuit for a stabilizer code is a stan￾dard circuit, where physical qubits are in the |0⟩ sta… view at source ↗
Figure 6
Figure 6. Figure 6: Density distribution of intermediate tensors during a contraction for the largest studied members of the [PITH_FULL_IMAGE:figures/full_fig_p010_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Contraction cost function vs true contraction [PITH_FULL_IMAGE:figures/full_fig_p011_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: The Hyper-Greedy algorithm on QL networks using the default Cotengra cost function and the sparse stabilizer tensor cost function. The red dotted bars indicate the cost required to calculate the WEP using brute￾force counting. The number above the bars indicates the ratio of dense tensor cost operations to SST operations, showing the speedup factor. For small examples, we compared the results to the output… view at source ↗
Figure 9
Figure 9. Figure 9: The Hyper-Par algorithm on QL networks using the default Cotengra cost function and the sparse stabilizer tensor cost function. The red dotted bars indicate the cost required to calculate the WEP using brute-force counting. The number above the bars indicates the ratio of dense tensor cost operations to SST operations, showing the speedup factor. For small examples, we compared the results to the output of… view at source ↗
Figure 10
Figure 10. Figure 10: Sparsity of intermediate tensors during tensor network contraction for small codes. The mean is shown [PITH_FULL_IMAGE:figures/full_fig_p019_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: The log4 of the true tensor size (using rank) vs the number of open legs for the different studied families in the main text. We can see that a lot of the intermediate tensors fall below the dense tensor line, and in many cases, choosing a tensor that has fewer open legs doesn’t imply smaller size (in contrast with the strictly monotonic dense tensor metric). 0 10 20 30 Time 0.000 0.025 0.050 0.075 0.100 … view at source ↗
Figure 12
Figure 12. Figure 12: Comparison of the computation time for the SST cost function vs the default dense cost function for the [PITH_FULL_IMAGE:figures/full_fig_p020_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Comparison of the computation time for the SST cost function vs the default dense cost function for the [PITH_FULL_IMAGE:figures/full_fig_p021_13.png] view at source ↗
Figure 14
Figure 14. Figure 14: The Hyper-Greedy algorithm on QL networks using the default dense cost function and the SST cost function with a 5-minute cutoff. The red dotted bars indicate the cost required to calculate the WEP using brute￾force counting. The number above the bars indicates the ratio of dense tensor cost operations to SST operations, showing the speedup factor. For small examples, we compared the results to the output… view at source ↗
Figure 15
Figure 15. Figure 15: The Hyper-Par algorithm on QL networks using the default dense cost function and the SST cost function with a 5-minute cutoff. The red dotted bars indicate the cost required to calculate the WEP using brute￾force counting. The number above the bars indicates the ratio of dense tensor cost operations to SST operations, showing the speedup factor. For small examples, we compared the results to the output of… view at source ↗
read the original abstract

Calculating the quantum weight enumerator polynomial (WEP) is a valuable tool for characterizing quantum error-correcting (QEC) codes, but it is computationally hard for large or complex codes. The Quantum LEGO (QL) framework provides a tensor network approach for WEP calculation, in some cases offering superpolynomial speedups over brute-force methods, provided the code exhibits area law entanglement, that a good QL layout is used, and an efficient tensor network contraction schedule is found. We analyze the performance of a hyper-optimized contraction schedule framework across QL layouts for diverse stabilizer code families. We find that the intermediate tensors in the QL networks for stabilizer WEPs are often highly sparse, invalidating the dense-tensor assumption of standard cost functions. To address this, we introduce an exact, polynomial-time Sparse Stabilizer Tensor (SST) cost function based on the rank of the parity check matrices for intermediate tensors. The SST cost function correlates perfectly with the true contraction cost, providing a significant advantage over the default cost function, which exhibits large uncertainty. Optimizing contraction schedules using the SST cost function yields substantial performance gains, achieving up to orders of magnitude improvement in actual contraction cost compared to using the dense tensor cost function. Furthermore, the precise cost estimation from the SST function offers an efficient metric to decide whether the QL-based WEP calculation is computationally superior to brute force for a given QL layout. These results, enabled by PlanqTN, a new open-source QL implementation, validate hyper-optimized contraction as a crucial technique for leveraging the QL framework to explore the QEC code design space.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper claims that intermediate tensors in Quantum LEGO (QL) networks for stabilizer weight enumerator polynomials (WEPs) are often highly sparse, invalidating dense-tensor cost assumptions. It introduces an exact, polynomial-time Sparse Stabilizer Tensor (SST) cost function based on the algebraic rank of parity-check matrices, which is asserted to correlate perfectly with true contraction cost. Hyper-optimization of contraction schedules using this SST metric yields up to orders-of-magnitude reductions in actual contraction cost compared to dense-tensor baselines, while also providing an efficient way to decide when QL-based WEP computation outperforms brute force. The work is enabled by the open-source PlanqTN implementation.

Significance. If the central claims hold, the result would be significant for practical QEC code analysis: it supplies a grounded, parameter-free cost model that directly exploits the stabilizer formalism rather than generic tensor assumptions, enabling reliable hyper-optimization and layout selection for larger codes. The open-source implementation and the explicit grounding of SST in parity-check rank are notable strengths that support reproducibility and falsifiability.

major comments (2)
  1. [Abstract / Results] Abstract and results sections: the claim that the SST cost function 'correlates perfectly with the true contraction cost' and enables 'orders of magnitude improvement' is load-bearing for the performance conclusions, yet the provided text supplies no numerical data, error bars, explicit derivation steps, or concrete contraction-cost comparisons; without these, the advantage over the dense-tensor baseline remains unverifiable.
  2. [SST cost function definition] Section introducing the SST cost function: the assertion that 'every intermediate tensor produced during contraction must remain a stabilizer tensor whose effective support and contraction complexity are fully and exactly captured by that rank' is the weakest assumption; if any contraction step produces a tensor whose sparsity pattern requires structure beyond the parity-check rank, the reported optimization advantage would not materialize. A concrete counter-example or proof that all QL contractions for stabilizer WEPs preserve this property is needed.
minor comments (2)
  1. [Abstract] The abstract states that the SST function is 'exact' and 'polynomial-time'; clarify whether the rank computation itself remains polynomial when the intermediate tensors grow during contraction, and cite the relevant complexity bound.
  2. [Results] The paper mentions 'diverse stabilizer code families' but does not list them; an explicit table or appendix enumerating the codes, their parameters, and the observed speedups would improve clarity.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive and detailed review. The comments have helped us strengthen the presentation of our results and the justification for the SST cost function. We address each major comment below and have revised the manuscript to incorporate additional numerical details, explicit derivations, and a formal proof sketch.

read point-by-point responses

  1. Referee: [Abstract / Results] Abstract and results sections: the claim that the SST cost function 'correlates perfectly with the true contraction cost' and enables 'orders of magnitude improvement' is load-bearing for the performance conclusions, yet the provided text supplies no numerical data, error bars, explicit derivation steps, or concrete contraction-cost comparisons; without these, the advantage over the dense-tensor baseline remains unverifiable.

    Authors: We acknowledge that the abstract and high-level results summary were concise in the initial submission. The full manuscript body (Section 4 and associated figures/tables) contains concrete numerical comparisons of contraction costs for multiple stabilizer codes (e.g., Steane [[7,1,3]], surface-code patches, and color codes), demonstrating perfect correlation between SST predictions and measured costs along with improvements ranging from 10x to over 1000x. To directly address verifiability, we have revised the abstract and results sections to include specific numerical examples, error bars from repeated hyper-optimization runs, and step-by-step derivation of the SST cost function from parity-check rank. These additions make the performance advantage explicit and reproducible. revision: yes

  2. Referee: [SST cost function definition] Section introducing the SST cost function: the assertion that 'every intermediate tensor produced during contraction must remain a stabilizer tensor whose effective support and contraction complexity are fully and exactly captured by that rank' is the weakest assumption; if any contraction step produces a tensor whose sparsity pattern requires structure beyond the parity-check rank, the reported optimization advantage would not materialize. A concrete counter-example or proof that all QL contractions for stabilizer WEPs preserve this property is needed.

    Authors: This is a fair critique of the central assumption. We have added a new subsection with a formal argument (now in the revised Section 2.4 and Appendix A) showing that QL contractions on stabilizer tensors for WEP computation preserve the stabilizer structure. The proof relies on the fact that each contraction corresponds to a linear map on the parity-check matrix under the symplectic inner product; the resulting effective support size is exactly 2 to the power of the rank, with no additional sparsity patterns arising due to the stabilizer formalism. We also report exhaustive empirical checks across all code families studied, with no counterexamples observed. The revised text now includes this justification and discusses the scope of the result. revision: yes

Circularity Check

0 steps flagged

No circularity: SST cost function is algebraically derived from stabilizer structure and validated against independent contraction measurements

full rationale

The paper derives the SST cost function directly from the rank of parity-check matrices of intermediate stabilizer tensors, which follows from the algebraic properties of the stabilizer formalism rather than from the optimization outcome or target contraction cost. The claimed orders-of-magnitude gains are obtained by using this independent predictor to guide hyper-optimization and then measuring the actual (non-SST) contraction cost of the resulting schedules, providing an external benchmark. No self-definitional reductions, fitted inputs renamed as predictions, or load-bearing self-citations appear in the derivation; the sparsity assumption and perfect correlation are presented as empirical observations within the QL framework, not as definitional equivalences.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 1 invented entities

The work rests on the existing Quantum LEGO tensor-network framework and the stabilizer-code representation; the main addition is the SST cost function itself.

axioms (2)
  • domain assumption Tensor networks formed from stabilizer code parity check matrices admit efficient contraction when a good schedule is chosen
    Core premise of the QL framework invoked throughout the abstract
  • domain assumption Intermediate tensors in these networks are highly sparse for stabilizer codes
    Observation used to motivate replacement of the dense-tensor cost function
invented entities (1)
  • Sparse Stabilizer Tensor (SST) cost function no independent evidence
    purpose: Exact polynomial-time estimator of contraction cost based on parity-check-matrix rank
    Newly defined metric introduced to replace dense-tensor heuristics

pith-pipeline@v0.9.0 · 5815 in / 1207 out tokens · 32112 ms · 2026-05-18T09:14:33.080552+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

  • IndisputableMonolith/Cost/FunctionalEquation.lean washburn_uniqueness_aczel unclear
    ?
    unclear

    Relation between the paper passage and the cited Recognition theorem.

    We introduce an exact, polynomial-time Sparse Stabilizer Tensor (SST) cost function based on the rank of the parity check matrices for intermediate tensors. The SST cost function correlates perfectly with the true contraction cost

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

38 extracted references · 38 canonical work pages · 3 internal anchors

  1. [1]

    Stabilizer Codes and Quantum Error Correction

    Daniel Gottesman. “Stabilizer Codes and Quantum Error Correction” (1997). arXiv:quant-ph/9705052

    work page internal anchor Pith review Pith/arXiv arXiv 1997

  2. [2]

    Cross and D

    Andrew Cross and Drew Vandeth. “Small Binary Stabilizer Subsystem Codes” (2025). arXiv:2501.17447

    work page arXiv 2025

  3. [3]

    Op- timal Resources for Topological 2D Stabi- lizer Codes: Comparative Study

    H. Bombin and M. A. Martin-Delgado. “Op- timal Resources for Topological 2D Stabi- lizer Codes: Comparative Study”. Phys. Rev. A76, 012305 (2007). arXiv:quant- ph/0703272

    work page arXiv 2007

  4. [4]

    Topological Quantum Distillation

    H. Bombin and M. A. Martin-Delgado. “Topological Quantum Distillation”. Phys. Rev. Lett.97, 180501 (2006)

    work page 2006

  5. [5]

    Quantum LDPC codes with positive rate and minimum distance proportional to n 1 2

    Jean-Pierre Tillich and Gilles Zemor. “Quantum LDPC codes with positive rate and minimum distance proportional to n 1 2”. In 2009 IEEE International Symposium on Information Theory. Pages 799–803. (2009)

    work page 2009

  6. [6]

    De- generate Quantum LDPC Codes With Good Finite Length Performance

    Pavel Panteleev and Gleb Kalachev. “De- generate Quantum LDPC Codes With Good Finite Length Performance”. Quantum5, 585 (2021)

    work page 2021

  7. [7]

    Demonstration of low-overhead quantum error correction codes

    Ke Wang, Zhide Lu, Chuanyu Zhang, Gongyu Liu, Jiachen Chen, Yanzhe Wang, Yaozu Wu, Shibo Xu, Xuhao Zhu, Feitong Jin, Yu Gao, Ziqi Tan, Zhengyi Cui, Ning Wang, Yiren Zou, Aosai Zhang, Tingt- ing Li, Fanhao Shen, Jiarun Zhong, Ze- hang Bao, Zitian Zhu, Yihang Han, Yiyang He, Jiayuan Shen, Han Wang, Jia-Nan Yang, Zixuan Song, Jinfeng Deng, Hang Dong, Zheng-Z...

    work page arXiv 2025

  8. [8]

    High-threshold and low-overhead fault-tolerant quantum mem- ory

    Sergey Bravyi, Andrew W. Cross, Jay M. Gambetta, Dmitri Maslov, Patrick Rall, and Theodore J. Yoder. “High-threshold and low-overhead fault-tolerant quantum mem- ory”. Nature627, 778–782 (2024)

    work page 2024

  9. [9]

    Time-Efficient Constant-Space-Overhead Fault-Tolerant Quantum Computation

    Hayata Yamasaki and Masato Koashi. “Time-Efficient Constant-Space-Overhead Fault-Tolerant Quantum Computation”. Nature Physics20, 247–253 (2024)

    work page 2024

  10. [10]

    Holographic quantum error-correcting codes: Toy mod- els for the bulk/boundary correspondence

    Fernando Pastawski, Beni Yoshida, Daniel Harlow, and John Preskill. “Holographic quantum error-correcting codes: Toy mod- els for the bulk/boundary correspondence”. J. High Energ. Phys.2015, 149 (2015)

    work page 2015

  11. [11]

    Approxi- mate Bacon-Shor code and holography

    ChunJun Cao and Brad Lackey. “Approxi- mate Bacon-Shor code and holography”. J. High Energ. Phys.2021, 127 (2021). 15

    work page 2021

  12. [12]

    Steinberg, et al.,Universal fault-tolerant logic with heterogeneous holographic codes(2025), arXiv:2504.10386 [quant-ph]

    Matthew Steinberg, Junyu Fan, Jens Eisert, Sebastian Feld, Alexander Jahn, and Chun- jun Cao. “Universal fault-tolerant logic with heterogeneous holographic codes” (2025) arXiv:2504.10386

    work page arXiv 2025

  13. [13]

    Quantum Lego: Building Quantum Error Correction Codes from Tensor Networks

    ChunJun Cao and Brad Lackey. “Quantum Lego: Building Quantum Error Correction Codes from Tensor Networks”. PRX Quan- tum3, 020332 (2022)

    work page 2022

  14. [14]

    Discovery of Optimal Quantum Error Correcting Codes via Reinforcement Learning

    Vincent Paul Su, ChunJun Cao, Hong-Ye Hu, Yariv Yanay, Charles Tahan, and Brian Swingle. “Discovery of Optimal Quantum Error Correcting Codes via Reinforcement Learning” (2023). arXiv:2305.06378

    work page arXiv 2023

  15. [15]

    Quan- tum Analog of the MacWilliams Identities for Classical Coding Theory

    Peter Shor and Raymond Laflamme. “Quan- tum Analog of the MacWilliams Identities for Classical Coding Theory”. Phys. Rev. Lett.78, 1600–1602 (1997)

    work page 1997

  16. [16]

    Quan- tum Weight Enumerators and Tensor Net- works

    ChunJun Cao and Brad Lackey. “Quan- tum Weight Enumerators and Tensor Net- works”. IEEE Trans. Inf. Theor.70, 3512– 3528 (2024)

    work page 2024

  17. [17]

    Quantum Lego Expansion Pack: Enumerators from Tensor Networks

    ChunJun Cao, Michael J. Gullans, Brad Lackey, and Zitao Wang. “Quantum Lego Expansion Pack: Enumerators from Tensor Networks”. PRX Quantum5, 030313 (2024)

    work page 2024

  18. [18]

    The complexity of tensor cal- culus

    Carsten Damm, Markus Holzer, and Pierre McKenzie. “The complexity of tensor cal- culus”. computational complexity11, 54– 89 (2002)

    work page 2002

  19. [19]

    The complexity of comput- ing the permanent

    L. G. Valiant. “The complexity of comput- ing the permanent”. Theoretical Computer Science8, 189–201 (1979)

    work page 1979

  20. [20]

    Hyper- optimized tensor network contraction

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

    work page 2021

  21. [21]

    Cotengra: Hyper optimized contraction trees for large tensor networks and einsums

    Johnnie Gray. “Cotengra: Hyper optimized contraction trees for large tensor networks and einsums”. GitHub (2025). url:https: //github.com/jcmgray/cotengra

    work page 2025

  22. [22]

    PlanqTN, a Python library and interactive web app implementing the quantum LEGO framework

    Balint Pato, June Vanlerberghe, ChunJun Cao, Brad Lackey, and Kenneth Brown. “PlanqTN, a Python library and interactive web app implementing the quantum LEGO framework”. Zenodo (2025)

    work page 2025

  23. [23]

    QDistRnd: A GAP package for computing the distance of quan- tum error-correcting codes

    Leonid P. Pryadko, Vadim A. Shabashov, and Valerii K. Kozin. “QDistRnd: A GAP package for computing the distance of quan- tum error-correcting codes”. J. Open Source Softw.7, 4120 (2022)

    work page 2022

  24. [24]

    Classical simulation of quantum many-body systems with a tree tensor net- work

    Y.-Y. Shi. “Classical simulation of quantum many-body systems with a tree tensor net- work”. Phys. Rev. A74(2006)

    work page 2006

  25. [25]

    Holographic Algo- rithms

    Leslie G. Valiant. “Holographic Algo- rithms”. SIAM Journal on Computing37, 1565–1594 (2008)

    work page 2008

  26. [26]

    Advances in Quantum Computation

    Kazem Mahdavi and Deborah Koslover, edi- tors. “Advances in Quantum Computation”. Volume 482 of Contemporary Mathemat- ics. American Mathematical Society. Provi- dence, Rhode Island (2009)

    work page 2009

  27. [27]

    Algebraically contractible topo- logical tensor network states

    S J Denny, J D Biamonte, D Jaksch, and S R Clark. “Algebraically contractible topo- logical tensor network states”. Journal of Physics A: Mathematical and Theoretical 45, 015309 (2011)

    work page 2011

  28. [28]

    Parameterization of Tensor Network Contraction

    Bryan O’Gorman. “Parameterization of Tensor Network Contraction”. In Wim van Dam and Laura Manˇ cinska, editors, 14th Conference on the Theory of Quantum Com- putation, Communication and Cryptogra- phy (TQC 2019). Volume 135 of Leib- niz International Proceedings in Informat- ics (LIPIcs), pages 10:1–10:19. Schloss Dagstuhl – Leibniz-Zentrum f¨ ur Infor- ...

    work page 2019

  29. [29]

    High-quality hypergraph partitioning

    Sebastian Schlag. “High-quality hypergraph partitioning”. PhD thesis. Karlsruhe Insti- tute of Technology, Germany. (2020)

    work page 2020

  30. [30]

    High- quality hypergraph partitioning

    Sebastian Schlag, Tobias Heuer, Lars Gottesb¨ uren, Yaroslav Akhremtsev, Chris- tian Schulz, and Peter Sanders. “High- quality hypergraph partitioning”. ACM J. Exp. Algorithmics (2022)

    work page 2022

  31. [31]

    Fault-tolerant quantum compu- tation

    P.W. Shor. “Fault-tolerant quantum compu- tation”. In Proceedings of 37th Conference on Foundations of Computer Science. Pages 56–65. (1996)

    work page 1996

  32. [32]

    Sparse Tensor Factorization on Many-Core Processors with High- Bandwidth Memory

    Shaden Smith, Jongsoo Park, and George Karypis. “Sparse Tensor Factorization on Many-Core Processors with High- Bandwidth Memory”. In 2017 IEEE International Parallel and Distributed Processing Symposium (IPDPS). Pages 1058–1067. (2017). 16

    work page 2017

  33. [33]

    Simple Quantum Error Correcting Codes

    Andrew Steane. “Simple Quantum Error Correcting Codes”. Phys. Rev. A54, 4741– 4751 (1996). arXiv:quant-ph/9605021

    work page internal anchor Pith review Pith/arXiv arXiv 1996

  34. [34]

    Quantum error correction for long chains of trapped ions

    Min Ye and Nicolas Delfosse. “Quantum error correction for long chains of trapped ions” (2025) arXiv:2503.22071

    work page arXiv 2025

  35. [35]

    Hyperoptimized quantum lego contraction schedules supplementary mate- rial

    Balint Pato, June Vanlerberghe, and Ken- neth Brown. “Hyperoptimized quantum lego contraction schedules supplementary mate- rial”. Zenodo (2025)

    work page 2025

  36. [36]

    A graph-based approach to entanglement entropy of quantum error correcting codes

    Wuxu Zhao, Menglong Fang, and Daiqin Su. “A graph-based approach to entangle- ment entropy of quantum error correcting codes” (2025). arXiv:2501.06407

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  37. [37]

    Efficient algorithms for max- imum likelihood decoding in the surface code

    Sergey Bravyi, Martin Suchara, and Alexan- der Vargo. “Efficient algorithms for max- imum likelihood decoding in the surface code”. Phys. Rev. A90, 032326 (2014)

    work page 2014

  38. [38]

    Parallel decoding of multiple logical qubits in tensor-network codes

    Terry Farrelly, Nicholas Milicevic, Robert J. Harris, Nathan A. McMahon, and Thomas M. Stace. “Parallel decoding of multiple logical qubits in tensor-network codes”. Phys. Rev. A105, 052446 (2022). 17 A Sparsity metrics for smaller codes As compared to Fig. 6, we see that in Fig. 10 the smaller codes are typically less sparse than the larger ones. B Compu...

    work page 2022