Pith. sign in

REVIEW 2 major objections 6 minor 2 cited by

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

T0 review · 2 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read Blocklet concatenation turns a code's syndrome-readout circuit into a transversal gate, yielding fault-tolerant fusion networks with constant-sized resource states and erasure thresholds up to 19.1%.

desk verdict Genuinely new blocklet concatenation construction with strong simulated thresholds, but the footprint scalings that beat surface codes rest on an unproven distance conjecture and the threshold numbers lack error bars. read the letter →

arxiv 2506.13619 v1 pith:2IBXV7ZE submitted 2025-06-16 quant-ph

Daniel Litinski This is my paper · ORCID
classification quant-ph MSC 81P6881P70 PACS 03.67.Pp03.67.Lx
keywords blockletconcatenationfusion-basedquantumcomputingerasurethresholdcodetransversalgatesphotonicPauliwebsfault-tolerantprotocols
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 introduces blocklet concatenation, a way to build fault-tolerant quantum-computing protocols by repeatedly concatenating a stabilizer code with itself while keeping the resource state fixed. In fusion-based quantum computing (FBQC), this yields fusion networks built from constant-sized resource states whose erasure thresholds can exceed those of comparable surface-code networks: the paper reports 13.8%, 19.1%, and 11.5% thresholds for 8-, 10-, and 12-qubit resource states, versus 12.0–12.7% for the surface-code baselines. The paper argues these protocols are candidates to replace surface codes in photonic FBQC because their footprint per logical qubit grows as $O(d)$, $O(d^{1.46})$, or $O(d^{0.58})$ instead of $d^2$. That footprint advantage depends on a distance-scaling conjecture that the paper states openly. The paper also provides techniques for logical operations, decoding, and photonic implementation, making the construction a full-stack recipe rather than a mere code family.

What carries the argument

The blocklet is the central object: a $2n$-qubit resource state that is a Bell pair with both ends encoded in the same $[n,k,d]$ code, represented as a box in a ZX diagram whose Pauli webs split into cups, caps, and membranes. The concatenation prescription replaces each blocklet with two layers of $n$ blocklets connected transversally, so every check and logical operator gets re-encoded while the resource state itself is unchanged. The mechanism is carried by encoded Pauli webs: cups from one layer and membranes from the other reassemble into encoded cups, caps, and product checks, which is what makes the hierarchy of checks and the distance growth possible.

What would settle it

Exhaustively search small concatenated protocols, such as $[7,1,3]^3$ or $[5,1,3]^3$, for undetectable error strings of weight below $c\cdot d^L$; finding one, or observing subthreshold logical-error-rate exponents inconsistent with $c\cdot d^L$, would refute the distance conjecture and invalidate the $O(d)$, $O(d^{1.46})$, and $O(d^{0.58})$ footprint claims.

Watch

Extended reading notes

Core claim

The central discovery is that the syndrome-readout circuit of an $[n,k,d]$ stabilizer code is itself a transversal operation of that code (for CSS codes, and specially for the five-qubit code), so executing that readout transversally across $n$ code blocks implements one level of code concatenation using only the original low-weight measurements. The corresponding $2n$-qubit resource state, called a blocklet, is an encoded Bell pair; chaining blocklets and applying the same prescription repeatedly produces $[n,k,d]^L$ protocols whose resource state stays identical at every level while the code distance grows. Encoded cups, caps, and membranes—Pauli webs of the blocklet—combine to form hierarchical checks and logical operators. Simulated erasure thresholds for the $[4,2,2]$, $[5,1,3]$, and $[6,4,2]$ families are 13.8%, 19.1%, and 11.5%, and the paper conjectures distances $c\cdot d^L$ (Appendix A) that give footprint scalings $O(d)$, $O(d^{1.46})$, and $O(d^{0.58})$.

Load-bearing premise

The claimed footprint advantage over surface codes rests on the unproved conjecture that the code distance of an $[n,k,d]^L$ blocklet protocol is $c\cdot d^L$ with $c = d_{\mathrm{prod}}/d^2$, supported by subthreshold simulation data but not proven.

Editorial extensions

If this is right

  • $[4,2,2]$ blocklet protocols use an 8-qubit resource state, have a 13.8% erasure threshold, and $O(d)$ footprint per logical qubit, exceeding the 12.0–12.7% thresholds and $d^2$ footprint of the surface-code baselines under the distance conjecture.
  • $[5,1,3]$ blocklet protocols reach a 19.1% erasure threshold with 10-qubit resource states, and their footprint scales as about $0.47 d^{1.46}$.
  • $[6,4,2]$ blocklet protocols use 12-qubit resource states, have an 11.5% threshold, and about $(1/6) d^{0.58}$ footprint, while encoding $k^L$ logical qubits per block.
  • Blocklet protocols support universal computation: logical GHZ-state preparation, Hadamard and state injection for CSS codes, special logical operations for the $[5,1,3]$ code, and selective addressing of individual logical qubits for $k>1$.
  • The hierarchical decoder decodes a distance-$d$ protocol in $O(\log d)$ parallel steps; for $[5,1,3]$ it gives a 16.7% erasure crossing versus 19.1% for the optimal decoder and a 1.7% Pauli-error crossing, and the protocols can be implemented with interleaving modules using $O(\log d)$ switchable delay lines.

Reading between the lines

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

  • If the distance conjecture is proved, the $O(d)$ footprint of the $[4,2,2]$ family would make blocklet protocols competitive with or better than surface codes on total photonic overhead; if it fails, the threshold advantages alone may not justify the non-local connectivity.
  • The author notes that any phaseless ZX diagram has cup, cap, and membrane Pauli webs, so the blocklet construction could in principle be searched systematically over stabilizer states to find better threshold–footprint trade-offs than the four families reported.
  • Because XX and ZZ erasure thresholds can be made asymmetric (e.g., 21% versus 6.7% for $[4,1,2]$), orienting the fusion network to the dominant loss channel, or applying the paper's linking procedure, could extract further effective threshold gains in hardware where correlated erasures are controlled.
  • The $O(\log d)$ delay-line count for photonic implementation suggests the practical overhead of the non-local fusion network grows slowly enough that blocklet protocols remain implementable at scales where surface-code fusion networks would need $d^2$ footprint.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

2 major / 6 minor

Summary. The paper introduces 'blocklet concatenation,' a construction for fault-tolerant quantum protocols based on repeatedly concatenating a stabilizer code with itself via its own syndrome readout circuit, interpreted as an encoded Bell pair (blocklet). The construction yields families of fusion-based quantum computing (FBQC) networks with constant-sized resource states, and the paper presents specific families based on [4,2,2], [5,1,3], [6,4,2], and [7,1,3] codes, with Monte Carlo erasure-threshold simulations, logical-operation prescriptions, a hierarchical decoder, and a photonic interleaving implementation sketch. The headline results are erasure thresholds up to 19.1% and footprint-per-logical-qubit scalings O(d) to O(d^1.77) that would improve on surface-code fusion networks.

Significance. If the conjectured distance scaling holds, this is an important conceptual advance: it demonstrates a systematic way to obtain high erasure thresholds with constant-size resource states and sub-quadratic footprint scaling, breaking the surface-code paradigm. The work is carefully presented, the ZX/Pauli-web description is rigorous, and the Monte Carlo methodology with an optimal erasure decoder is standard and appropriate. The author is transparent about the main caveat (the unproven distance-scaling conjecture) and about the decoder being a proof of principle. However, because the advertised advantage over surface codes rests on that conjecture, the result is currently conditional.

major comments (2)
  1. [Appendix A, Table 1] The footprint-per-logical-qubit scalings in Table 1 and the abstract (O(d), O(d^1.46), O(d^0.58)) are derived from the unproven distance-scaling conjecture of Appendix A, namely that the code distance of an [n,k,d]^L protocol equals d_prod·d^(L-2). The manuscript explicitly acknowledges this in the Table 1 footnote and in the Conclusion ('proving (or disproving) the distance scaling conjecture also remains an open problem'), yet the central claim that blocklet protocols are 'promising candidates to replace surface codes' rests directly on these scalings. The numerical support in Fig. 25 (subthreshold fits) is consistent with the conjecture but does not establish it; if the true distance grows more slowly, all three footprint exponents would increase and the advantage over the d^2 surface-code footprint could disappear. The paper should either provide a proof or a rigorous lower bound, or clearly condition the overhead claims on the conjecture in the abstract and conclusion.
  2. [Sec. 2.2, Fig. 8] The erasure thresholds in Table 1 are reported as the physical error rate at which the logical error-rate curves of the two largest simulated protocols intersect, without statistical uncertainties or finite-size scaling analysis. Given that the headline comparison is a threshold of 13.8% versus 12.7% for the surface code, the absence of error bars makes it impossible to assess whether the difference is significant. I recommend reporting confidence intervals from the Monte Carlo sampling and, preferably, a scaling-collapse or fit-based threshold extraction to confirm convergence of the crossing point with system size.
minor comments (6)
  1. [Sec. 2.2] The notation 'dp' is used in the caption of Fig. 8 and in Sec. 2.2 (e.g., 'dp = 16') before being formally defined; please define dp = c·d^L at first use in Sec. 2.
  2. [Sec. 2.2] The statement 'we also observe that the logical error rates indeed scale no worse than O(p^{dp}) below threshold' is ambiguous; the intended meaning is presumably that the logical error rate decays at least as fast as p^{dp}.
  3. [Sec. 4] The hierarchical decoding section would benefit from a pseudo-code description or explicit equations for the conversion matrices C_i and for the conditioning/normalization step; the current text is sufficient for a proof of principle but hard to reproduce exactly.
  4. [Sec. 5] The discussion of interleaving modules would benefit from a figure showing the resource-state labels and delay lengths for a larger L; Fig. 23 is for L=3 with n=4 and is clear, but the generalization to arbitrary n and L is stated only in a formula.
  5. [Table 1] In Table 1, the references to surface code protocols as 'cubic [1]' and 'cuboctahedral [7]' are unclear; please specify the resource-state size and the exact fusion network variant.
  6. [Sec. 6] There are minor typos, e.g., 'more granular control control' in the Conclusion.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: thresholds are obtained by direct simulation of the proposed fusion networks, and the footprint scalings in Table 1 are derived from an explicitly labeled open conjecture, which is a correctness caveat rather than a circular reduction.

full rationale

The central quantitative claims are not circular. The erasure thresholds in Table 1 are measured properties of the constructed protocols: they are read off from Monte Carlo simulations of the explicit [n,k,d]^L fusion networks under i.i.d. erasure noise, decoded with an optimal Gaussian-elimination decoder, at the crossing point of logical-error-rate curves for the two largest simulated concatenation levels (Sec. 2.2, Fig. 8). No parameter is fitted to reproduce a target threshold. The footprint-per-logical-qubit scalings in Table 1 are computed from the explicit formula O((d_p/c)^{log(n/k)/log d}), using the base code parameters n, k, d and the conjectured protocol distance d_p = c d^L (Sec. 2 and Appendix A); the prefactors c are fixed by each base code (e.g., c = 1 for [4,2,2] and [6,4,2], c = 5/9 for [5,1,3]). The distance-scaling conjecture is openly flagged: Appendix A states "a proof for this conjecture remains an open problem," Sec. 6 repeats "proving (or disproving) the distance scaling conjecture also remains an open problem," and Table 1's footnote says the footprint scaling is based on that conjecture. An open conjecture is a falsifiable assumption, not a circular definition. The paper's reliance on the author's prior ZX-calculus framework (Ref. [5]) and on interleaving/active-volume architectures (Refs. [25,26]) is for language and implementation, while the blocklet definitions, checks, logical membranes, and simulations are presented in the paper itself, and the surface-code comparisons use independent external benchmarks (Refs. [1,7]). Thus no fitted parameter is renamed as a prediction and no self-citation is load-bearing for the main quantitative results; the modest score reflects minor self-reliance on the author's prior framework, not circularity.

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

No numerical parameters are fitted to data in this paper. Thresholds and logical error rates come from Monte Carlo simulation of the described protocols. The c prefactor in the distance conjecture is computed from product-code distances found by numerical search, not fitted to match target outputs. The main unproven input is the distance scaling conjecture, which is load-bearing for the footprint claims.

assumptions (5)
  • domain assumption ZX calculus and Pauli web framework correctly describe the fault-tolerant protocols (Ref. [5]).
    Used throughout Sections 2 to 4 to construct blocklets, checks, and logical membranes.
  • ad hoc to paper The distance scaling conjecture: an [n,k,d]^L blocklet protocol has code distance c times d^L with c = d_prod/d^2.
    Load-bearing for the footprint-per-logical-qubit scalings in Table 1; stated as a conjecture in Appendix A and the conclusion, without proof.
  • domain assumption XX and ZZ fusion outcomes are erased independently and identically in the noise model.
    Used in all Monte Carlo simulations; real photonic hardware may have correlated losses, as the author notes in the linking discussion.
  • standard math The syndrome readout circuit of any CSS code is a transversal operation of that code.
    Standard stabilizer-formalism fact; the foundation of the concatenation prescription in Section 2.
  • ad hoc to paper Product-code distances d_prod found by numerical search for [7,1,3] (d_prod=7) and [5,1,3] (d_prod=5) are correct.
    These values set the c prefactor in the distance conjecture; the search method is not fully described.
invented entities (2)
  • Blocklet resource state
    purpose: Constant-sized 2n-qubit resource state representing an encoded Bell pair for use in concatenated fusion networks.
    A designed object; its utility is demonstrated only through the paper's own simulations and construction.
  • Product checks
    purpose: Additional parity checks generated by concatenation, required for fault tolerance of the blocklet protocols.
    New check type defined in the paper; correctness is argued via Pauli webs and tested through simulation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Blocklet concatenation: Low-overhead fault-tolerant protocols for fusion-based quantum computation." pith.science (2026). https://pith.science/paper/2IBXV7ZE

@misc{pith2026250613619,
  author       = {Pith},
  title        = {Pith review of: Blocklet concatenation: Low-overhead fault-tolerant protocols for fusion-based quantum computation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2IBXV7ZE}},
  note         = {Machine review of arXiv:2506.13619}
}
abstract

We introduce a construction for protocols for fault-tolerant quantum computing based on code concatenation and transversal gates. These protocols can be interpreted as families of quantum circuits of low-weight stabilizer measurements without strict locality constraints, effectively implementing concatenated codes. However, we primarily study these protocols in the context of photonic fusion-based quantum computing (FBQC), where they yield families of fusion networks with constant-sized resource states. Their high erasure thresholds relative to their resource-state cost establish them as promising candidates to replace surface codes in the context of FBQC. Examples include protocol families using 8-, 10- and 12-qubit resource states, with erasure thresholds of 13.8%, 19.1% and 11.5%, and footprint-per-logical-qubit scaling as $\mathcal{O}(d)$, $\mathcal{O}(d^{1.46})$ and $\mathcal{O}(d^{0.58})$, respectively, where $d$ is the code distance. We also present techniques for performing logical operations, decoding, and implementing the protocols in photonic hardware. Although we focus on photonic FBQC, these ideas may also be of interest in other settings.

Figures

Figures reproduced from arXiv: 2506.13619 by the authors.

Figure 1
Figure 1. Introduction to blocklets. A syndrome readout circuit (a) of a stabilizer code can be converted into a ZX diagram (b) [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Concatenated [4, 1, 2] blocklet protocols at different concatenation levels L. four physical qubits with stabilizers X1X2X3X4, Z1Z2 and Z3Z4. Its syndrome readout circuit corresponds to the logical identity gate of the code and is a sequence of stabilizer measurements. The circuit can be converted into the ZX diagram in Fig. 1b. The diagram features a repeating structure of 11 spiders. In the rest of the paper, we w… view at source ↗
Figure 3
Figure 3. Blocklet concatenation prescription. 4 [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (26 more)
Figure 4
Figure 4. Figure 4: Encoded Pauli webs are formed from combinations of Pauli webs of blocklets in a concatenation block. [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: In blocklet protocols with k > 1, each encoded web has k different variants, as shown for a [4, 2, 2] code. of [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 7
Figure 7. Figure 7: Collapsing blocklet pairs after the final level of con [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: Monte Carlo simulation results for various concatenated blocklet protocol families under erasure noise using an optimal [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Performance of the linked [4, 1, 2] blocklet protocol. bias towards one type of erasure using dynamic bias arrangement [29]. One can also apply single-qubit Clif￾ford gates to some of the qubits of the resource state prior to fusions to turn XX fusion outcomes into Y Y…
Figure 11
Figure 11. Figure 11: Examples of encoded cups, membranes, product checks and fundamental checks in a [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]
Figure 12
Figure 12. Figure 12: Performance of mixed blocklet protocols. [PITH_FULL_IMAGE:figures/full_fig_p011_12.png]
Figure 13
Figure 13. Figure 13: Fault-tolerant preparation of a logical 3GHZ with a concatenated blocklet protocol based on an [PITH_FULL_IMAGE:figures/full_fig_p012_13.png]
Figure 14
Figure 14. Figure 14: A CNOT gate implemented via the preparation of [PITH_FULL_IMAGE:figures/full_fig_p012_14.png]
Figure 15
Figure 15. Figure 15: State injection in [7, 1, 3] blocklets using a transversal encoding circuit. compared to standard type-II fusions, so they may incur some additional overhead. Single-qubit X and Z measurements are also transversal for CSS codes. The prescription for Hadamard gates wil…
Figure 17
Figure 17. Figure 17: State injection in [4, 2, 2] blocklets via single-qubit measurements. 13 [PITH_FULL_IMAGE:figures/full_fig_p013_17.png]
Figure 18
Figure 18. Figure 18: Collection of logical operations with [5, 1, 3] blocklets. Addressing individual qubits. One additional opera￾tion is required with blocklet protocols that are based on codes with k > 1. Suppose that we execute a transver￾sal GHZ-state preparation on three code blocks…
Figure 19
Figure 19. Figure 19: Example of a decoding block in a foliated [PITH_FULL_IMAGE:figures/full_fig_p015_19.png]
Figure 21
Figure 21. Figure 21: Example of an extended decoding block in a [PITH_FULL_IMAGE:figures/full_fig_p016_21.png]
Figure 20
Figure 20. Figure 20: Example of a concatenated decoding block in a [PITH_FULL_IMAGE:figures/full_fig_p016_20.png]
Figure 22
Figure 22. Figure 22: Monte Carlo simulation results of a [5, 1, 3] blocklet protocol with a hierarchical decoder. whose output webs are the encoded webs of a decoding block. An example for a concatenated [5, 1, 3] block￾let protocol is shown in [PITH_FULL_IMAGE:figures/full_fig_p017_22.png]
Figure 23
Figure 23. Figure 23: Interleaving order and interleaving modules for an [PITH_FULL_IMAGE:figures/full_fig_p018_23.png]
Figure 24
Figure 24. Figure 24: Two types of layers in an L = 2 protocol. 21 [PITH_FULL_IMAGE:figures/full_fig_p021_24.png]
Figure 25
Figure 25. Figure 25: Subthreshold behavior of blocklet protocols based on lowest-logical-error-rate points from Monte Carlo sampling. [PITH_FULL_IMAGE:figures/full_fig_p022_25.png]
Figure 26
Figure 26. Figure 26: Transformation of fundamental check through different levels of concatenation. [PITH_FULL_IMAGE:figures/full_fig_p024_26.png]
Figure 27
Figure 27. Figure 27: Examples of various fundamental and product checks in an [PITH_FULL_IMAGE:figures/full_fig_p025_27.png]
Figure 28
Figure 28. Figure 28: Product checks that are generated when concatenating [PITH_FULL_IMAGE:figures/full_fig_p026_28.png]
Figure 29
Figure 29. Figure 29: Performance of various tree blocklet protocols. [PITH_FULL_IMAGE:figures/full_fig_p027_29.png]
Figure 30
Figure 30. Figure 30: Concatenation of inner [4, 2, 2] blocklets with outer [5, 1, 3] blocklets [PITH_FULL_IMAGE:figures/full_fig_p028_30.png]
Figure 31
Figure 31. Figure 31: Fault-tolerant selective measurement of one of the logical [PITH_FULL_IMAGE:figures/full_fig_p028_31.png]
Figure 32
Figure 32. Figure 32: Lowest-weight error strings of different product codes. [PITH_FULL_IMAGE:figures/full_fig_p029_32.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

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.

  2. Growing Sparse Quantum Codes from a Seed

    quant-ph 2025-07 conditional novelty 6.0 of 10

    Conjoining only bit-flip and phase-flip repetition codes can generate any CSS code, and an iterative algorithm grows sparse subsystem codes with kd^2=O(n) worst-case scaling.

Reference graph

Works this paper leans on

31 extracted references · 14 canonical work pages · cited by 2 Pith papers

  1. [1]

    Bartolucci, P

    S. Bartolucci, P. Birchall, H. Bombin, H. Ca- ble, C. Dawson, M. Gimeno-Segovia, E. Johnston, K. Kieling, N. Nickerson, M. Pant, F. Pastawski, T. Rudolph, and C. Sparrow, Fusion-based quan- tum computation, Nature Communications 14, 912 (2023)

    work page 2023

  2. [2]

    Coecke and R

    B. Coecke and R. Duncan, Interacting quantum ob- servables: Categorical algebra and diagrammatics, New Journal of Physics 13, 043016 (2011)

    work page 2011

  3. [3]

    Backens, The ZX-calculus is complete for stabi- lizer quantum mechanics, New Journal of Physics 16, 093021 (2014)

    M. Backens, The ZX-calculus is complete for stabi- lizer quantum mechanics, New Journal of Physics 16, 093021 (2014)

    work page 2014

  4. [4]

    Coecke and A

    B. Coecke and A. Kissinger, Picturing Quantum Processes: A First Course in Quantum Theory and Diagrammatic Reasoning (Cambridge Univer- sity Press, 2017)

    work page 2017

  5. [5]

    Bombin, D

    H. Bombin, D. Litinski, N. Nickerson, F. Pastawski, and S. Roberts, Unifying fla- vors of fault tolerance with the ZX calculus, Quantum 8, 1379 (2024)

    work page 2024

  6. [6]

    A. Bolt, G. Duclos-Cianci, D. Poulin, and T. M. Stace, Foliated quantum error-correcting codes, Phys. Rev. Lett. 117, 070501 (2016)

    2016

  7. [7]

    Bombin, C

    H. Bombin, C. Dawson, T. Farrelly, Y. Liu, N. Nickerson, M. Pant, F. Pastawski, and S. Roberts, Fault-tolerant complexes, arXiv:2308.07844 (2023)

    arXiv 2023

  8. [8]

    A. Y. Kitaev, Fault-tolerant quantum computation by anyons, Ann. Phys. 303, 2 (2003)

    2003

Show all 31 references
  1. [9]

    S. B. Bravyi and A. Y. Kitaev, Quantum codes on a lattice with boundary, arXiv:quant-ph/9811052 (1998)

    1998 arXiv

  2. [10]

    Bombin and M

    H. Bombin and M. A. Martin-Delgado, Topological quantum distillation, Phys. Rev. Lett. 97, 180501 (2006)

    2006

  3. [11]

    Tillich and G

    J.-P. Tillich and G. Zemor, Quantum ldpc codes with positive rate and minimum distance propor- tional to the square root of the blocklength, IEEE Transactions on Information Theory 60, 1193–1202 (2014)

    2014

  4. [12]

    Panteleev and G

    P. Panteleev and G. Kalachev, Asymptotically good quantum and locally testable classical ldpc codes, arXiv:2111.03654 (2022)

    2022 arXiv

  5. [13]

    Bravyi, A

    S. Bravyi, A. W. Cross, J. M. Gambetta, D. Maslov, P. Rall, and T. J. Yoder,High-threshold and low-overhead fault-tolerant quantum memory, Nature 627, 778–782 (2024)

    2024

  6. [14]

    Knill and R

    E. Knill and R. Laflamme, Concatenated quantum codes, arXiv:quant-ph/9608012 (1996)

    1996 arXiv

  7. [15]

    Aharonov and M

    D. Aharonov and M. Ben-Or, Fault-tolerant quantum computation with constant error rate, arXiv:quant-ph/9906129 (1999). 20

    1999 arXiv

  8. [16]

    Aliferis, D

    P. Aliferis, D. Gottesman, and J. Preskill, Quan- tum accuracy threshold for concatenated distance-3 codes, arXiv:quant-ph/0504218 (2005)

    2005 arXiv

  9. [17]

    Yamasaki and M

    H. Yamasaki and M. Koashi, Time-efficient constant-space-overhead fault-tolerant quantum computation, Nature Physics 20, 247–253 (2024)

    2024

  10. [18]

    Yoshida, S

    S. Yoshida, S. Tamiya, and H. Yamasaki, Concate- nate codes, save qubits, arXiv:2402.09606 (2024)

    2024 arXiv

  11. [19]

    Gidney and T

    C. Gidney and T. Bergamaschi, A constant rate quantum computer on a line, arXiv:2502.16132

    arXiv

  12. [20]

    A. J. Ferris and D. Poulin, Tensor networks and quantum error correction, Phys. Rev. Lett. 113 (2014)

    2014

  13. [21]

    Cao and B

    C. Cao and B. Lackey, Quantum lego: Building quantum error correction codes from tensor net- works, PRX Quantum 3, 020332 (2022)

    2022

  14. [22]

    C. Cao, M. J. Gullans, B. Lackey, and Z. Wang, Quantum lego expansion pack: Enumerators from tensor networks, arXiv:2308.05152 (2024)

    2024 arXiv

  15. [23]

    Steinberg, J

    M. Steinberg, J. Fan, J. Eisert, S. Feld, A. Jahn, and C. Cao, Universal fault-tolerant logic with heterogeneous holographic codes, arXiv:2504.10386 (2025)

    2025 arXiv

  16. [24]

    Bartolucci, T

    S. Bartolucci, T. Bell, H. Bombin, P. Birchall, J. Bulmer, C. Dawson, T. Farrelly, S. Gartenstein, M. Gimeno-Segovia, D. Litinski, Y. Liu, R. Kneg- jens, N. Nickerson, A. Olivo, M. Pant, A. Patil, S. Roberts, T. Rudolph, C. Sparrow, D. Tuckett, and A. Veitia, Comparison of sch...

    2025 arXiv

  17. [25]

    Litinski and N

    D. Litinski and N. Nickerson, Active volume: An architecture for efficient fault-tolerant quan- tum computers with limited non-local connections, arXiv:2211.15465 (2022)

    2022 arXiv

  18. [26]

    Bombin, I

    H. Bombin, I. H. Kim, D. Litinski, N. Nicker- son, M. Pant, F. Pastawski, S. Roberts, and T. Rudolph, Interleaving: Modular architectures for fault-tolerant photonic quantum computing, arXiv:2103.08612 (2021)

    2021 arXiv

  19. [27]

    C. H. Bennett, D. P. DiVincenzo, J. A. Smolin, and W. K. Wootters, Mixed-state entanglement and quantum error correction, Phys. Rev. A 54, 3824–3851 (1996)

    1996

  20. [28]

    Laflamme, C

    R. Laflamme, C. Miquel, J. P. Paz, and W. H. Zurek, Perfect quantum error correction code, arXiv:quant-ph/9602019 (1996)

    1996 arXiv

  21. [29]

    Bomb´ ın, C

    H. Bomb´ ın, C. Dawson, N. Nickerson, M. Pant, and J. Sullivan, Increasing error tolerance in quan- tum computers with dynamic bias arrangement, arXiv:2303.16122 (2023)

    2023 arXiv

  22. [30]

    Gottesman, Theory of fault-tolerant quantum computation, Phys

    D. Gottesman, Theory of fault-tolerant quantum computation, Phys. Rev. A 57, 127–137 (1998)

    1998

  23. [31]

    T. J. Yoder, R. Takagi, and I. L. Chuang, Univer- sal fault-tolerant gates on concatenated stabilizer codes, Phys. Rev. X 6, 031039 (2016). A Conjecture about the code distance of concatenated blocklet protocols While the code distance of a repeatedly concatenated [n, k, d] co...

    2016

Pith tools

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