Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

Growing Sparse Quantum Codes from a Seed

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read By conjoining only 2-qubit bit-flip and phase-flip repetition codes, the authors show every CSS code can be built and sparse subsystem codes can be grown with distance guaranteed to increase.

desk verdict A genuinely new modular construction with nice worked examples, but the main distance theorem has a real global-pairing gap and the asymptotic claim is oversold; worth a serious referee. read the letter →

arxiv 2507.13496 v1 pith:YXK5ZOTC submitted 2025-07-17 quant-ph cond-mat.str-el

ChunJun Cao , Brad Lackey This is my paper
classification quant-phcond-mat.str-el MSC 81P7094B05 PACS 03.67.Pp
keywords quantumLDPCcodessubsystemconjoininglegorepetitionCSStensornetworkscodedistance
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

The paper tries to establish that sparse quantum codes—codes where every check acts on few qubits and every qubit participates in few checks—can be grown iteratively from tiny seed codes in the same modular spirit as concatenation, without letting check weights blow up. It claims that conjoining just two-qubit bit-flip and phase-flip repetition codes is enough to build any CSS code, and it provides a polynomial-time algorithm that increases code distance by at least one per round while keeping the Tanner graph degree bounded. In the worst case the algorithm produces codes with kd²=O(n), saturating the Bravyi-Poulin-Terhal bound for 2D codes. A sympathetic reader would care because this offers a constructive, modular pathway from simple atomic codes to sparse codes with controlled parameters, a step toward growing quantum LDPC codes with useful fault-tolerant properties.

What carries the argument

The conjoining operation on check matrices of stabilizer codes, which is the check-matrix version of tensor contraction in the quantum lego formalism, is the central object: two code blocks are glued by identifying legs (qubits), and the resulting stabilizers and logical operators are found by operator matching. The second key object is the non-isometric [[4,1,2]] lego block (ZN for Z-type and XN for X-type), built from spiders or repetition codes, which reduces two-input operators to zero or to gauge operators while preserving single-input weight. This non-isometric trace is what lets check weights shrink during growth, counteracting the weight increase that ordinary concatenation causes. The iterative algorithm combines three moves—concatenation along the support of a bare logical operator, non-isometric trace to lower check weight, and a shifting step that moves Z-checks to newly added qubits to lower qubit degree—and tracks how bare logical operators transform so that the whole process is polynomial in n.

What would settle it

Run the algorithm on a small seed such as the [[4,2,2]] code with strict weight caps and compute the true minimum distance of the output; if any round fails to increase distance by 1, or if the resulting [[684,2,12≤d≤32]] example is found to have distance below 12, the central theorem is false.

Watch

Extended reading notes

Core claim

The central claim is that sparse subsystem codes can be generated by alternating ordinary concatenation with conjoining steps that use non-isometric lego blocks, specifically tensors derived from 2-qubit repetition codes. Theorem 1 states that each round of the algorithm raises the code distance by at least 1 while leaving the number of logical qubits k and the Tanner graph degree unchanged. Theorem 2 states that the worst-case asymptotic scaling of the algorithm produces codes with kd²=O(n), which saturates the Bravyi-Poulin-Terhal bound and is therefore optimal at this level of generality. Theorem 3 states that every CSS code can be built from 2-qubit bit-flip and phase-flip repetition codes through conjoining, showing that these simple atoms are not a limitation on expressivity.

Load-bearing premise

The distance guarantee depends on the claim that, after each growth step, the newly added qubits can be paired up consistently for every X-type gauge generator so that applying a weight-reducing tensor to each pair never lets a logical operator hide its new qubits inside gauge operators.

Editorial extensions

If this is right

  • Every CSS code, however complicated, can be realized as a tensor network of the same two atomic blocks, so creative gluing of repetition codes is a universal construction method.
  • The iterative algorithm yields a concrete polynomial-time procedure for growing sparse subsystem codes with controlled distance, which can be applied to finite-size near-term codes rather than only asymptotic families.
  • The new tensor-network representations of the surface code, compass code, and 2D and 3D Bacon-Shor codes may enable more efficient tensor contractions, for example in weight-enumerator computations.
  • Asymmetric distances can be engineered by growing X and Z distances at different frequencies, as stated in Corollary 1.
  • The method offers an alternative sparsification strategy: instead of sparsifying a prebuilt code, one keeps checks thin as the code grows, which may preserve distance more directly.

Reading between the lines

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

  • The same conjoining-with-bad-codes trick might extend to non-CSS stabilizer codes or qudit codes, since the gauge-qubit decoupling argument does not obviously rely on CSS structure; running the algorithm on a non-CSS seed and checking whether distance and sparsity survive would be a direct test.
  • The worst-case kd²=O(n) bound reflects the choice of S' = supp of a bare logical operator as the set to concatenate; identifying smaller minimal-intersection sets that meet all minimal-weight logical operators could improve the scaling, possibly toward linear distance.
  • The repeated use of XN tensors correlates gauge qubits across different non-isometric blocks, and these correlations are only sketched in the paper; whether they can be harnessed for fault-tolerant code switching or fusion-based preparation is an untested direction.
  • The average-case distance scaling and constant factors are open, and the paper's own [[684,2,12≤d≤32]] example suggests that tracking true minimum distances on generated codes could provide empirical guidance for improving the algorithm.
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

4 major / 6 minor

Summary. The paper proposes an iterative procedure for growing sparse CSS-like subsystem codes from a small seed code by alternating ordinary concatenation with 2-qubit bit-flip/phase-flip repetition codes and conjoining with non-isometric [[4,1,2]] tensors (ZN and XN). The main theoretical claims are: (1) Theorem 1, that each iteration increases the distance by at least 1 while preserving the number of logical qubits and the Tanner-graph degree bounds; (2) Theorem 2, that the worst-case asymptotic scaling of the algorithm yields kd^2 = O(n); and (3) Theorem 3, that every CSS code can be built from 2-qubit bit-flip and phase-flip repetition codes by conjoining. The paper also provides explicit tensor-network constructions for the rotated surface code, the 2D compass code, and 2D and 3D Bacon-Shor codes, together with an automated example of a [[684,2,12<=d<=32]] code.

Significance. If the main theorems are correct, the paper offers a genuinely new constructive principle: sparse codes can be grown from small blocks while using non-isometric conjoining to control check weights, something ordinary concatenation cannot do. The examples and the graphical/tensor-network perspective are valuable in themselves, and the explicit algorithm is a useful step toward synthesizing qLDPC-type codes from elementary modules. The paper also gives a concrete falsifiable claim in the form of the reported [[684,2,12<=d<=32]] construction. However, the central distance-increase guarantee is not proved as written: the global pairing step in Lemma 6 is asserted rather than demonstrated, and the asymptotic accounting in the proof of Theorem 2 contains an unjustified quantitative step. These issues are load-bearing and must be repaired before the main claims can be accepted.

major comments (4)
  1. [§4.2, §4.3, and Lemma 6 (Appendix A)] Lemma 6 assumes that for each overweight X-generator, the newly added qubits can be partitioned into pairs and that applying XN to each pair reduces the generator weight while leaving the logical structure intact. The actual row operation in §4.3 ('Non-isometric trace') selects the first two nonzero entries of each overweight row independently. Since a newly added qubit can appear in up to q_X distinct X-checks, nothing in the algorithm prevents the same qubit from being chosen in two different pairs, and two XN contractions sharing a qubit cannot be realized as independent tensor contractions. The degree bound limits the number of overlaps but does not by itself imply a globally consistent pairing across all rows. Theorem 1 therefore requires either an explicit matching argument that produces disjoint pairs for all overweight generators simultaneously, or a modified row-reduction rule that is provably equivalent to a sequence of XN conjoinings.
  2. [Lemma 6 (Appendix A)] The proof asserts that the weight-2 X-checks introduced by XN are gauge operators and that multiplication by them cannot reduce a logical X operator's weight back to its pre-concatenation value. This is argued from Table 1, which describes a single XN tensor, but the weight-reduction step applies many XN insertions whose gauge qubits can become correlated through overlapping support. The parity argument ('there is no perfect pairing') is applied to the new terms in the generator representation, whereas the distance of a subsystem code is defined modulo the full gauge group, including arbitrary products of the newly introduced gauge checks. A proof that every nontrivial dressed logical X operator retains weight at least d+1 after reduction by the complete gauge group is missing.
  3. [Appendix B, Theorem 2] The proof begins with the statement that 'to add to the distance of the first set of logical operators, from Lemma 8 we need to add 2d + c sites.' This quantitative claim is not derived anywhere: Lemma 8 only bounds the increase of the bare logical distance by c, and no lemma establishes that adding 2d+c sites suffices to increase the minimum distance by 1 for all logical operators. The recurrence leading to Eq. (4) and the final asymptotic form [[n'=ckD^2, k'=k, d'=D]] are therefore not established. The claimed scaling bound kd^2=O(n) may be true for the explicit Bacon-Shor examples, but as a theorem about the worst case of the algorithm it needs a rigorous bookkeeping of how the supports of all bare logical operators grow over repeated iterations.
  4. [§4.2, Lemma 4] Lemma 4 states that concatenating the support of a bare logical Z_j increases the weight of every X-type logical operator acting nontrivially on the j-th logical qubit by at least 1, because such operators must intersect supp(Z_j) at least once. This is correct for bare logical operators, but the statement is applied to 'dressed' logical operators as well. Dressed logical operators can differ from bare ones by gauge operators, and the intersection parity with Z_j may be affected by the gauge part. The proof should state explicitly whether the distance is tracked for bare representatives or for all dressed representatives, and justify the transition in the later steps of the algorithm.
minor comments (6)
  1. [§4.3, Non-isometric trace] The description of the matrix rule is incomplete without a proof that the row operation 'subtract w_x from each row of h_x if both entries are nonzero' is equivalent to an actual tensor contraction when rows share columns; a small worked example would greatly improve readability.
  2. [Table 1] The table entries such as 'no change not permitted' are ambiguous; a legend explaining the meaning of the two columns (non-active vs active gauge qubit) and an example for at least one row would make the transformation rules easier to verify.
  3. [§5, Theorem 3] The statement 'Since any X- or Z-spider can be built from contracting the tensors of two-qubit phase and bit-flip codes' is invoked without a reference or derivation; adding a citation to the ZX-calculus literature or a short explicit construction would make the proof more self-contained.
  4. [§4.5.3] The automated construction of the [[684,2,12<=d<=32]] code is reported without code or a reproducible script; providing the final check matrices or a software artifact would substantially increase confidence in the construction, especially given the gap in the proof of Theorem 1.
  5. [Throughout] The paper alternates between 'concatenation' and 'conjoining' without always clarifying which operation is meant; a short paragraph stating that standard concatenation is a restricted case of conjoining and specifying which steps of the algorithm use which operation would help the reader.
  6. [Editorial] There are several typos and infelicities, e.g., 'fault-tolearnt' in the Discussion, 'as after conjoining must have distance' in §3, and 'an abundant supply of them' in the Introduction; these should be corrected in a revision.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular dependency found: prior Quantum Lego self-citations are foundational, not conclusion-presupposing; Theorem 1 and 2 rest on independent algebraic/parameter-count arguments.

full rationale

The derivation chain is not circular. Conjoining is imported from the authors' earlier Quantum Lego papers ([31],[34]), but that operation is defined algebraically in [31] independently of this paper's target claims, so the self-citation is background infrastructure rather than a presupposed conclusion. Theorem 1's distance growth rests on Lemma 4 (every X-logical on the j-th qubit must intersect supp(\bar Z0) odd times) and Lemma 5 (gauge generators intersect even times); these are genuine commutation arguments, not restatements of the theorem. The critical Lemma 6 does assert the existence of 'distinct pairs of added qubits' for XN reductions, and the proof only sketches why a globally consistent pairing exists across overlapping checks; I flag this as an omitted proof / correctness risk (Appendix A, Lemma 6), not as circularity, because no equation is being forced to equal its input. Theorem 3 is essentially the known phase-free ZX/CSS equivalence, which the paper explicitly credits to [30] (and [34] for details), and the proof is a tensor-network translation rather than an assumption of the result. Appendix B's kd^2=O(n) bound is a straightforward parameter count for the algorithm's own growth, not a fitted quantity or a renamed empirical pattern. Accordingly, no step reduces by construction, and the paper's main claims have independent content.

Assumptions & free parameters 2 free parameters · 4 assumptions · 1 invented entities

The central claims rest on the quantum lego formalism from the authors' prior work, plus the specific transformation rules of the newly introduced ZN/XN legos. No continuous free parameters are fitted to data; the only choices are the seed code and the weight/degree bounds.

free parameters (2)
  • weight bounds wX, wZ and degree bounds qX, qZ
    Chosen by the user to bound the Tanner graph; the distance guarantee holds for any fixed bounds, but the examples set them to small values like 2.
  • Seed code [[n0,k,d0]]
    The algorithm starts from an arbitrary sparse seed; the asymptotic guarantee depends on k and constant overlap bounds c.
assumptions (4)
  • domain assumption Conjoining operation and closure of Pauli stabilizer codes under conjoining (from [31])
    The paper uses the check matrix conjoining and operator pushing rules from the authors' prior quantum lego papers without re-deriving them.
  • domain assumption Transformation rules for ZN and XN non-isometric legos (Table 1)
    These rules are stated based on the stabilizers of the [[4,1,2]] legos; they are checkable but not proven in this paper.
  • standard math Standard stabilizer and subsystem code theory
    Definitions of gauge group, stabilizer center, bare and dressed logical operators are used throughout.
  • domain assumption Any CSS code can be prepared by measuring its checks and postselecting (Theorem 3 proof)
    The proof of Theorem 3 relies on a measurement-based state preparation protocol for CSS codes.
invented entities (1)
  • ZN and XN non-isometric [[4,1,2]] legos independent evidence
    purpose: To reduce check weights during conjoining without expanding logical operators beyond the distance bound
    These are explicitly defined finite tensors with given stabilizers and transformation tables, so their properties can be verified independently.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Growing Sparse Quantum Codes from a Seed." pith.science (2026). https://pith.science/paper/YXK5ZOTC

@misc{pith2026250713496,
  author       = {Pith},
  title        = {Pith review of: Growing Sparse Quantum Codes from a Seed},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YXK5ZOTC}},
  note         = {Machine review of arXiv:2507.13496}
}
abstract

It is generally unclear whether smaller codes can be "concatenated" to systematically create quantum LDPC codes or their sparse subsystem code cousins where the degree of the Tanner graph remains bounded while increasing the code distance. In this work, we use a slight generalization of concatenation called conjoining introduced by the quantum lego formalism. We show that by conjoining only quantum repetition codes, one can construct quantum LDPC codes. More generally, we provide an efficient iterative algorithm for constructing sparse subsystem codes with a distance guarantee that asymptotically saturates $kd^2=O(n)$ in the worst case. Furthermore, we show that the conjoining of even just two-qubit quantum bit-flip and phase-flip repetition codes is quite powerful as they can create any CSS code. Therefore, more creative combinations of these basic code blocks will be sufficient for generating good quantum codes, including good quantum LDPC codes.

Figures

Figures reproduced from arXiv: 2507.13496 by the authors.

Figure 1
Figure 1. (a) A tensor can be represented as a state or a map, depending on how one assigns the meaning of the [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. A [[25, 1, 5]] generalized Shor code by gluing together X- and Z-spiders. The top leg represents the logical input while the remaining dangling legs represent the physical qubits. (a) A stabilizer of the code can be obtained from pushing operators that act as the identity on the logical leg. (b) A representation of the logical X operator can be obtained by pushing operator X through the logical leg to the physical l… view at source ↗
Figure 3
Figure 3. (a) Z spiders (green) of valence 3 are repre [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (8 more)
Figure 5
Figure 5. Figure 5: , the non-isometries change the graph connectivity by connecting qubits in the overlap￾ping green and yellow boxes. However, these is￾8 [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Symmetries of the ZN tensor describing a [[4, 1, 2]] code where the middle leg is the logical degree of freedom. XN tensor is identical except exchanging the red and green colors and X and Z in the symmetries. viewed as non-isometric legos, we interpret legs 1, 3 as in…
Figure 7
Figure 7. Figure 7: How a 2d Bacon-Shor code can be grown using [PITH_FULL_IMAGE:figures/full_fig_p013_7.png]
Figure 8
Figure 8. Figure 8: A sequence of concatenation and non-isometric concatenations following the algorithm is used to grow the [PITH_FULL_IMAGE:figures/full_fig_p014_8.png]
Figure 9
Figure 9. Figure 9: Tanner graph and degree distribution of a [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]
Figure 10
Figure 10. Figure 10: Entangling an ancillary qubit and then postselecting for the trivial syndrome on the [PITH_FULL_IMAGE:figures/full_fig_p016_10.png]
Figure 11
Figure 11. Figure 11: A CSS code can be built as a tensor net [PITH_FULL_IMAGE:figures/full_fig_p016_11.png]
Figure 12
Figure 12. Figure 12: Left: The support of X checks (blue) have [PITH_FULL_IMAGE:figures/full_fig_p022_12.png]

Discussion (0). Sign in 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. Duality constrains optimal thresholds in quantum error correction

    quant-ph 2026-07 conditional novelty 7.0 of 10

    Zero-rate em-symmetric CSS codes are self-dual under generalized Kramers-Wannier duality, pinning their optimal code-capacity threshold (at leading order in a replica limit) to the zero-rate hashing bound p≈0.110.

Reference graph

Works this paper leans on

65 extracted references · 56 canonical work pages · cited by 1 Pith paper

  1. [1]

    Concatenated quantum codes

    Emanuel Knill and Raymond Laflamme. Concatenated quantum codes. arXiv preprint quant-ph/9608012, 1996

    arXiv 1996

  2. [2]

    Time-efficient constant-space-overhead fault-tolerant quantum computation

    Hayata Yamasaki and Masato Koashi. Time-efficient constant-space-overhead fault-tolerant quantum computation. Na- ture Physics, 20(2):247–253, January 2024

    work page 2024

  3. [3]

    Concatenate codes, save qubits

    Satoshi Yoshida, Shiro Tamiya, and Hayata Yamasaki. Concatenate codes, save qubits. arXiv preprint arXiv:2402.09606 , 2024

    arXiv 2024

  4. [4]

    A constant rate quantum computer on a line

    Craig Gidney and Thiago Bergamaschi. A constant rate quantum computer on a line. arXiv preprint arXiv:2502.16132 , 2025

    arXiv 2025

  5. [5]

    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. Journal of High Energy Physics , 2015(6), June 2015

    work page 2015

  6. [6]

    Harris, Nathan A

    Robert J. Harris, Nathan A. McMahon, Gavin K. Brennen, and Thomas M. Stace. Calderbank-shor-steane holographic quan- tum error-correcting codes. Physical Review A, 98(5), November 2018. 17

    work page 2018

  7. [7]

    Approxi- mate bacon-shor code and holography.Jour- nal of High Energy Physics , 2021(5), May 2021

    ChunJun Cao and Brad Lackey. Approxi- mate bacon-shor code and holography.Jour- nal of High Energy Physics , 2021(5), May 2021

    work page 2021

  8. [8]

    Far from perfect: Quantum error correction with (hyperinvariant) even- bly codes

    Matthew Steinberg, Junyu Fan, Robert J Harris, David Elkouss, Sebastian Feld, and Alexander Jahn. Far from perfect: Quantum error correction with (hyperinvariant) even- bly codes. arXiv preprint arXiv:2407.11926, 2024

    arXiv 2024

Show all 65 references
  1. [9]

    Overcoming the zero-rate hashing bound with holographic quantum error correction, 2024

    Junyu Fan, Matthew Steinberg, Alexander Jahn, Chunjun Cao, and Sebastian Feld. Overcoming the zero-rate hashing bound with holographic quantum error correction, 2024

    2024

  2. [10]

    Yoder, Ryuji Takagi, and Isaac L

    Theodore J. Yoder, Ryuji Takagi, and Isaac L. Chuang. Universal fault-tolerant gates on concatenated stabilizer codes.Phys. Rev. X, 6:031039, Sep 2016

    2016

  3. [11]

    Using concatenated quantum codes for universal fault-tolerant quantum gates

    Tomas Jochym-O’Connor and Raymond Laflamme. Using concatenated quantum codes for universal fault-tolerant quantum gates. Phys. Rev. Lett. , 112:010505, Jan 2014

    2014

  4. [12]

    Buildingad- dressable fault-tolerant gates with quantum lego

    ChunJunCaoandBradLackey. Buildingad- dressable fault-tolerant gates with quantum lego. In Preparation, 2025

    2025

  5. [13]

    Universal fault-tolerant logic with heterogeneous holographic codes.arXiv preprint arXiv:2504.10386, 2025

    Matthew Steinberg, Junyu Fan, Jens Eis- ert, Sebastian Feld, Alexander Jahn, and Chunjun Cao. Universal fault-tolerant logic with heterogeneous holographic codes.arXiv preprint arXiv:2504.10386, 2025

    2025 arXiv

  6. [14]

    Ferris and David Poulin

    Andrew J. Ferris and David Poulin. Ten- sor networks and quantum error correction. Physical Review Letters, 113(3), July 2014

    2014

  7. [15]

    Blocklet concatenation: Low-overhead fault-tolerant protocols for fusion-based quantum computation

    Daniel Litinski. Blocklet concatenation: Low-overhead fault-tolerant protocols for fusion-based quantum computation. arXiv preprint arXiv:2506.13619, 2025

    2025 arXiv

  8. [16]

    Nguyen and Christopher A

    Quynh T. Nguyen and Christopher A. Patti- son. Quantum fault tolerance with constant- space and logarithmic-time overheads, 2024

    2024

  9. [17]

    Polylog-time- and constant- space-overhead fault-tolerant quantum com- putation with quantum low-density parity- check codes, 2024

    Shiro Tamiya, Masato Koashi, and Hay- ata Yamasaki. Polylog-time- and constant- space-overhead fault-tolerant quantum com- putation with quantum low-density parity- check codes, 2024

    2024

  10. [18]

    Fault-tolerant quantum computation with constant overhead, 2014

    Daniel Gottesman. Fault-tolerant quantum computation with constant overhead, 2014

    2014

  11. [19]

    Cross, Jay M

    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. Nature, 627(8005):778–782, March2024

  12. [20]

    Asymp- totically good quantum and locally testable classical ldpc codes, 2022

    Pavel Panteleev and Gleb Kalachev. Asymp- totically good quantum and locally testable classical ldpc codes, 2022

    2022

  13. [21]

    Quan- tum ldpc codes with positive rate and min- imum distance proportional to the square root of the blocklength

    Jean-Pierre Tillich and Gilles Zemor. Quan- tum ldpc codes with positive rate and min- imum distance proportional to the square root of the blocklength. IEEE Transactions on Information Theory , 60(2):1193–1202, February 2014

    2014

  14. [22]

    Breuckmann and Jens Niklas Eberhardt

    Nikolas P. Breuckmann and Jens Niklas Eberhardt. Quantum low-density parity- check codes. PRX Quantum, 2:040101, Oct 2021

    2021

  15. [23]

    Weight reduction for quantum codes, 2016

    Matthew B Hastings. Weight reduction for quantum codes, 2016

    2016

  16. [24]

    On quantum weight reduction, 2021

    Matthew B Hastings. On quantum weight reduction, 2021

    2021

  17. [25]

    Gunderman, Ben- jamin Ide, Michael Vasmer, and Guil- laume Dauphinais

    Eric Sabo, Lane G. Gunderman, Ben- jamin Ide, Michael Vasmer, and Guil- laume Dauphinais. Weight-reduced stabi- lizer codes with lower overhead.PRX Quan- tum, 5:040302, Oct 2024

    2024

  18. [26]

    Flammia, Aram W

    Dave Bacon, Steven T. Flammia, Aram W. Harrow, and Jonathan Shi. Sparse Quan- tum Codes from Quantum Circuits. arXiv e-prints, page arXiv:1411.3334, November 2014

    2014 arXiv

  19. [27]

    Wire codes, 2024

    Nouédyn Baspin and Dominic Williamson. Wire codes, 2024

    2024

  20. [28]

    Quan- tum tanner codes, 2022

    Anthony Leverrier and Gilles Zémor. Quan- tum tanner codes, 2022

    2022

  21. [29]

    Xyz ruby code: Making a case for a three- colored graphical calculus for quantum er- ror correction in spacetime.PRX Quantum, 6(1):010360, 2025

    Julio C Magdalena de la Fuente, Josias Old, Alex Townsend-Teague, Manuel Rispler, Jens Eisert, and Markus Müller. Xyz ruby code: Making a case for a three- colored graphical calculus for quantum er- ror correction in spacetime.PRX Quantum, 6(1):010360, 2025

    2025

  22. [30]

    Phase-free zx diagrams are css codes (...or how to graphically grok the surface code), 2022

    Aleks Kissinger. Phase-free zx diagrams are css codes (...or how to graphically grok the surface code), 2022. 18

    2022

  23. [31]

    Quan- tum lego: Building quantum error correction codes from tensor networks.PRX Quantum, 3(2), May 2022

    ChunJun Cao and Brad Lackey. Quan- tum lego: Building quantum error correction codes from tensor networks.PRX Quantum, 3(2), May 2022

    2022

  24. [32]

    Harris, Nathan A

    Terry Farrelly, Robert J. Harris, Nathan A. McMahon, and Thomas M. Stace. Tensor- network codes. Physical Review Letters , 127(4), July 2021

    2021

  25. [33]

    Local tensor- network codes

    Terry Farrelly, David K Tuckett, and Thomas M Stace. Local tensor- network codes. New Journal of Physics , 24(4):043015, April 2022

    2022

  26. [34]

    Gullans, Brad Lackey, and Zitao Wang

    ChunJun Cao, Michael J. Gullans, Brad Lackey, and Zitao Wang. Quantum lego ex- pansion pack: Enumerators from tensor net- works. PRX Quantum, 5:030313, Jul 2024

    2024

  27. [35]

    Quantum lego and xp stabilizer codes, 2023

    Ruohan Shen, Yixu Wang, and ChunJun Cao. Quantum lego and xp stabilizer codes, 2023

    2023

  28. [36]

    Thezxcalculusisalanguageforsurfacecode lattice surgery

    Niel de Beaudrap and Dominic Horsman. Thezxcalculusisalanguageforsurfacecode lattice surgery. Quantum, 4:218, January 2020

    2020

  29. [37]

    Graphical structures for design and verification of quantum error correc- tion

    Nicholas Chancellor, Aleks Kissinger, Ste- fan Zohren, Joschka Roffe, and Dominic Horsman. Graphical structures for design and verification of quantum error correc- tion. Quantum Science and Technology , 8(4):045028, September 2023

    2023

  30. [38]

    Scalable spider nests (...or how to graph- ically grok transversal non-clifford gates)

    Aleks Kissinger and John van de Wetering. Scalable spider nests (...or how to graph- ically grok transversal non-clifford gates). Electronic Proceedings in Theoretical Com- puter Science, 406:79–95, August 2024

    2024

  31. [39]

    Graphical css code transformation using zx calculus

    Jiaxin Huang, Sarah Meng Li, Lia Yeh, AleksKissinger, MicheleMosca, andMichael Vasmer. Graphical css code transformation using zx calculus. Electronic Proceedings in Theoretical Computer Science , 384:1–19, August 2023

    2023

  32. [40]

    Quantum weight enumerators and tensor networks

    ChunJun Cao and Brad Lackey. Quantum weight enumerators and tensor networks. IEEE Transactions on Information Theory , 70(5):3512–3528, 2024

    2024

  33. [41]

    Discovery of optimal quantum error correcting codes via reinforcement learning, 2023

    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

    2023

  34. [42]

    Stabilizer codes and quantum error correction

    Daniel Gottesman. Stabilizer codes and quantum error correction . California Insti- tute of Technology, 1997

    1997

  35. [43]

    Modifying method of con- structing quantum codes from highly entan- gled states

    Zahra Raissi. Modifying method of con- structing quantum codes from highly entan- gled states. IEEE Access, 8:222439–222448, 2020

    2020

  36. [44]

    Quan- tum variational learning for quantum error- correcting codes

    Chenfeng Cao, Chao Zhang, Zipeng Wu, Markus Grassl, and Bei Zeng. Quan- tum variational learning for quantum error- correcting codes. Quantum, 6:828, October 2022

    2022

  37. [45]

    An introduction to quan- tumerrorcorrectionandfault-tolerantquan- tum computation, 2009

    Daniel Gottesman. An introduction to quan- tumerrorcorrectionandfault-tolerantquan- tum computation, 2009

    2009

  38. [46]

    Good quantum ldpc codes with linear time decoders, 2022

    Irit Dinur, Min-Hsiu Hsieh, Ting-Chun Lin, and Thomas Vidick. Good quantum ldpc codes with linear time decoders, 2022

    2022

  39. [47]

    Quan- tum ldpc codes with almost linear minimum distance

    Pavel Panteleev and Gleb Kalachev. Quan- tum ldpc codes with almost linear minimum distance. IEEE Transactions on Information Theory, 68(1):213–229, January 2022

    2022

  40. [48]

    Protecting expressive circuits with a quantum error detection code

    Chris N Self, Marcello Benedetti, and David Amaro. Protecting expressive circuits with a quantum error detection code. Nature Physics, 20(2):219–224, 2024

    2024

  41. [49]

    Entan- glement renormalization and topological or- der

    Miguel Aguado and Guifré Vidal. Entan- glement renormalization and topological or- der. Physical Review Letters, 100(7), Febru- ary 2008

    2008

  42. [50]

    Fusion-based quantum com- putation, 2021

    Sara Bartolucci, Patrick Birchall, Hector Bombin, Hugo Cable, Chris Dawson, Mer- cedes Gimeno-Segovia, Eric Johnston, Kon- rad Kieling, Naomi Nickerson, Mihir Pant, Fernando Pastawski, Terry Rudolph, and Chris Sparrow. Fusion-based quantum com- putation, 2021

    2021

  43. [51]

    Stabilizer formalism for oper- ator quantum error correction.Physical Re- view Letters, 95(23), December 2005

    David Poulin. Stabilizer formalism for oper- ator quantum error correction.Physical Re- view Letters, 95(23), December 2005

    2005

  44. [52]

    Discov- ering highly efficient low-weight quantum error-correcting codes with reinforcement learning

    Austin Yubo He and Zi-Wen Liu. Discov- ering highly efficient low-weight quantum error-correcting codes with reinforcement learning. arXiv preprint arXiv:2502.14372 , 2025

    2025 arXiv

  45. [53]

    Tradeoffs for reliable quantum in- formation storage in 2d systems

    Sergey Bravyi, David Poulin, and Barbara Terhal. Tradeoffs for reliable quantum in- formation storage in 2d systems. Physical Review Letters, 104(5), February 2010. 19

    2010

  46. [54]

    Unifying flavors of fault tolerance with the zx calculus.Quantum, 8:1379, June 2024

    Hector Bombin, Daniel Litinski, Naomi Nickerson, Fernando Pastawski, and Sam Roberts. Unifying flavors of fault tolerance with the zx calculus.Quantum, 8:1379, June 2024

    2024

  47. [55]

    Fault-tolerant complexes, 2023

    Hector Bombin, Chris Dawson, Terry Far- relly, Yehua Liu, Naomi Nickerson, Mi- hir Pant, Fernando Pastawski, and Sam Roberts. Fault-tolerant complexes, 2023

    2023

  48. [56]

    Magic- state distillation with low overhead.Physical Review A, 86(5), November 2012

    Sergey Bravyi and Jeongwan Haah. Magic- state distillation with low overhead.Physical Review A, 86(5), November 2012

    2012

  49. [57]

    Quantifying nonlocality: How outperform- ing local quantum codes is expensive.Phys

    Nouédyn Baspin and Anirudh Krishna. Quantifying nonlocality: How outperform- ing local quantum codes is expensive.Phys. Rev. Lett., 129:050505, Jul 2022

    2022

  50. [58]

    Transform arbitrary good quantum ldpc codes into good geometrically local codes in any dimension, 2024

    Xingjian Li, Ting-Chun Lin, and Min-Hsiu Hsieh. Transform arbitrary good quantum ldpc codes into good geometrically local codes in any dimension, 2024

    2024

  51. [59]

    Caroline Mauron, Terry Farrelly, and Thomas M. Stace. Optimization of tensor network codes with reinforcement learning, 2023

    2023

  52. [60]

    Simultaneous discov- ery of quantum error correction codes and encoders with a noise-aware reinforcement learning agent, 2024

    Jan Olle, Remmy Zen, Matteo Puviani, and Florian Marquardt. Simultaneous discov- ery of quantum error correction codes and encoders with a noise-aware reinforcement learning agent, 2024

    2024

  53. [61]

    Planar quantum low-density parity-check codes with open boundaries

    Zijian Liang, Jens Niklas Eberhardt, and Yu-An Chen. Planar quantum low-density parity-check codes with open boundaries. arXiv preprint arXiv:2504.08887 , 2025

    2025 arXiv

  54. [62]

    Opportunities and chal- lenges in fault-tolerant quantum computa- tion, 2022

    Daniel Gottesman. Opportunities and chal- lenges in fault-tolerant quantum computa- tion, 2022

    2022

  55. [63]

    Floquetifying stabiliser codes with distance-preserving rewrites, 2024

    BenjaminRodatz, BoldizsárPoór, andAleks Kissinger. Floquetifying stabiliser codes with distance-preserving rewrites, 2024

    2024

  56. [64]

    unchanged

    Dave Bacon. Operator quantum error- correcting subsystems for self-correcting quantum memories. Physical Review A , 73(1), January 2006. A Proof of Theorem 1 To prove the theorem, we first set up a few lem- mas. We prove the results for increasing X- distance; the proof for in...

    2006

  57. [65]

    This 22 ¯X′ 0 is a bare logicalX-operator because any pairs of qubits that pushed throughXN do not acti- vate the gauge qubit

    One representative is the operator we obtained just after concatenation, when¯X0 is increased by the amount c =|supp( ¯X0))∩ supp( ¯Z(j) 0 )|. This 22 ¯X′ 0 is a bare logicalX-operator because any pairs of qubits that pushed throughXN do not acti- vate the gauge qubit. Neither...

Pith tools

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