pith. sign in

arxiv: 2510.19442 · v3 · submitted 2025-10-22 · 🪐 quant-ph

Accelerating Fault-Tolerant Quantum Computation with Good qLDPC Codes

Guo Zhang , Yuanye Zhu , Ying Li This is my paper

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

classification 🪐 quant-ph
keywords fault-tolerant quantum computationqLDPC codescode surgeryconstant overheadtime overheadquantum error correctionresource state preparation
0
0 comments X

The pith

A fault-tolerant scheme for qLDPC codes delivers constant qubit overhead and time overhead scaling as O(d) for good codes.

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

The paper presents a new scheme for performing fault-tolerant quantum computation on quantum low-density parity-check codes. It achieves constant extra qubits while keeping the time cost at O(d to the a plus little-o of 1) for codes whose distance grows as the one-over-a power of block length. When the code is good, meaning distance linear in size, the time cost improves to nearly linear in distance. This matters because earlier approaches based on gauging measurements incurred extra factors that grew with code weight or size, slowing down computation on large systems. The speedup comes from parallelizing the surgery operations and preparing needed resource states more efficiently.

Core claim

By enabling parallelized code surgery that preserves constant qubit overhead and by using classical locally testable codes to prepare resource states efficiently, the scheme implements logical operations on any constant-rate qLDPC code with time overhead O(d^{a+o(1)}) where distance d scales as Omega of n to the 1/a; for good codes this reduces to O(d^{1+o(1)}), which is asymptotically faster than the O(d w^{1+o(1)}) cost of prior gauging-based surgery whenever a is less than 2.

What carries the argument

Parallelized code surgery under constant qubit overhead, combined with classical locally testable codes for resource state preparation.

If this is right

  • Any constant-rate qLDPC code with distance Omega of n to the 1/a inherits time overhead O(d to the a plus little-o of 1).
  • Good qLDPC codes reach the lowest reported time overhead of O(d to the 1 plus little-o of 1).
  • The scheme remains asymptotically faster than gauging-measurement surgery for every code with a less than 2.
  • Constant qubit overhead is preserved while the time scaling improves.

Where Pith is reading between the lines

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

  • Practical quantum processors could reach useful logical gate counts sooner if good qLDPC codes become available.
  • The method highlights that advances in classical locally testable codes could directly accelerate quantum fault tolerance.
  • Similar parallelization ideas might apply to other families of quantum codes that currently suffer high time overhead.

Load-bearing premise

The parallelized surgery operations stay at constant qubit overhead and the classical locally testable codes prepare resource states without introducing error rates or overheads that grow with system size.

What would settle it

A concrete implementation of the parallelized surgery step that requires qubit count growing with block size, or a resource-state preparation circuit whose logical error rate grows with code size, would falsify the claimed overheads.

Figures

Figures reproduced from arXiv: 2510.19442 by Guo Zhang, Ying Li, Yuanye Zhu.

Figure 1
Figure 1. Figure 1: FIG. 1. Schematic illustration of our scheme. Each execution of the locally-testable state-preparation circuit produces [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: FIG. 2. Quantum computer and allocation of physical qubits. In the memory, the memory-code blocks are divided into four [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: FIG. 3. Circuit for parallelized code surgery. The ancilla sys [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: FIG. 5. Circuit for generating resource states used to mea [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: FIG. 6. Code surgery schemes. Each orange circle represents [PITH_FULL_IMAGE:figures/full_fig_p010_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: FIG. 7. (a) Transversal initialization that prepares each qubit in the state [PITH_FULL_IMAGE:figures/full_fig_p014_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: FIG. 8. Logical operations. (a) Initialization. (b) Measurement [PITH_FULL_IMAGE:figures/full_fig_p015_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: FIG. 9. (a) Preparation of the [PITH_FULL_IMAGE:figures/full_fig_p016_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: FIG. 10. Circuit that defines the resource state for the [PITH_FULL_IMAGE:figures/full_fig_p023_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: FIG. 11. Locally-testable state preparation. The outcome of the transversal measurement on [PITH_FULL_IMAGE:figures/full_fig_p025_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: FIG. 12. Operations on surface-code logical qubits. (a) Initialization in the state [PITH_FULL_IMAGE:figures/full_fig_p030_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: FIG. 13. (a) Measurement of [PITH_FULL_IMAGE:figures/full_fig_p031_13.png] view at source ↗
Figure 14
Figure 14. Figure 14: FIG. 14. Code surgery [PITH_FULL_IMAGE:figures/full_fig_p034_14.png] view at source ↗
Figure 15
Figure 15. Figure 15: FIG. 15. Illustration of partial circuit reduction. The green shaded regions indicate locations in the circuit where faults may [PITH_FULL_IMAGE:figures/full_fig_p040_15.png] view at source ↗
Figure 16
Figure 16. Figure 16: FIG. 16. Circuit reducibility applied to the resource state preparation circuit. The figure shows the equivalent circuit obtained [PITH_FULL_IMAGE:figures/full_fig_p042_16.png] view at source ↗
Figure 17
Figure 17. Figure 17: FIG. 17. Reducibility of the [PITH_FULL_IMAGE:figures/full_fig_p043_17.png] view at source ↗
Figure 18
Figure 18. Figure 18: FIG. 18. Reducibility of the Bell state preparation circuit in resource state preparation. (a) Original Bell state gadget with red [PITH_FULL_IMAGE:figures/full_fig_p044_18.png] view at source ↗
Figure 19
Figure 19. Figure 19: FIG. 19. Reducibility of the error correction gadget [PITH_FULL_IMAGE:figures/full_fig_p045_19.png] view at source ↗
Figure 20
Figure 20. Figure 20: FIG. 20. Effective error models for the [PITH_FULL_IMAGE:figures/full_fig_p048_20.png] view at source ↗
Figure 21
Figure 21. Figure 21: FIG. 21. Effective [PITH_FULL_IMAGE:figures/full_fig_p049_21.png] view at source ↗
Figure 22
Figure 22. Figure 22: FIG. 22. Effective [PITH_FULL_IMAGE:figures/full_fig_p050_22.png] view at source ↗
Figure 23
Figure 23. Figure 23: FIG. 23. Error correction involving sequential [PITH_FULL_IMAGE:figures/full_fig_p052_23.png] view at source ↗
read the original abstract

We propose a fault-tolerant quantum computation scheme that is broadly applicable to quantum low-density parity-check (qLDPC) codes. The scheme achieves constant qubit overhead and a time overhead of $O(d^{a+o(1)})$ for any $[[n,k,d]]$ qLDPC code with constant encoding rate and distance $d = \Omega(n^{1/a})$. For good qLDPC codes, the time overhead is minimized and reaches $O(d^{1+o(1)})$. In contrast, code surgery based on gauging measurement and brute-force branching requires a time overhead of $O(dw^{1+o(1)})$, where $d\leq w\leq n$. Thus, our scheme is asymptotically faster for all codes with $a < 2$. This speedup is achieved by developing techniques that enable parallelized code surgery under constant qubit overhead and leverage classical locally testable codes for efficient resource state preparation. These results establish a new paradigm for accelerating fault-tolerant quantum computation on qLDPC codes, while maintaining low overhead and broad applicability.

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

3 major / 1 minor

Summary. The manuscript proposes a fault-tolerant quantum computation scheme broadly applicable to quantum low-density parity-check (qLDPC) codes. It claims constant qubit overhead together with a time overhead of O(d^{a+o(1)}) for any [[n,k,d]] qLDPC code possessing constant encoding rate and distance d = Ω(n^{1/a}); for good qLDPC codes the time overhead improves to O(d^{1+o(1)}). The improvement over prior gauging-plus-branching surgery (O(d w^{1+o(1)})) is obtained by parallelized code surgery performed under constant qubit overhead and by classical locally testable codes for resource-state preparation.

Significance. If the constructions are valid, the result would meaningfully accelerate fault-tolerant computation on qLDPC codes while preserving constant qubit overhead, offering a new route to lower time overhead for good codes. The work does not supply machine-checked proofs or reproducible code, but the explicit asymptotic comparison with existing surgery methods and the broad applicability to arbitrary constant-rate qLDPC codes constitute clear strengths if the central claims hold.

major comments (3)
  1. [Abstract] Abstract: the headline O(d^{a+o(1)}) time-overhead claim for codes with d = Ω(n^{1/a}) rests on two unverified steps—parallelized code surgery under constant qubit overhead and classical-LTC resource preparation—yet the abstract supplies neither explicit protocol, error-propagation analysis, nor concrete code example. Without these, it is impossible to confirm that ancilla overhead and failure probability remain independent of n (or at most polylog in d).
  2. [Parallelized code surgery] Section describing parallelized code surgery: the assertion that surgery on an arbitrary [[n,k,d]] qLDPC code can be executed while keeping total qubits O(n) and time O(d^{a+o(1)}) requires a concrete bound showing that error propagation and ancilla count do not introduce an Ω(1/poly(n)) term; if sequentialization or size-dependent errors appear, the claimed scaling collapses to the slower O(d w^{1+o(1)}) regime already known from gauging methods.
  3. [Resource state preparation] Section on classical locally testable codes for resource preparation: the query complexity and failure probability of the LTC-based preparation must be shown not to add an extra n^ε factor that would spoil the O(d^{1+o(1)}) scaling for good codes; the current text provides no such quantitative bound.
minor comments (1)
  1. [Introduction] The parameters a and w should be defined explicitly in the introduction with a short reminder of their relation to code distance and weight.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for their thorough review and valuable comments on our manuscript. We address each of the major comments point by point below, providing clarifications and indicating revisions made to the manuscript.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the headline O(d^{a+o(1)}) time-overhead claim for codes with d = Ω(n^{1/a}) rests on two unverified steps—parallelized code surgery under constant qubit overhead and classical-LTC resource preparation—yet the abstract supplies neither explicit protocol, error-propagation analysis, nor concrete code example. Without these, it is impossible to confirm that ancilla overhead and failure probability remain independent of n (or at most polylog in d).

    Authors: We appreciate the referee's concern regarding the abstract. The abstract is meant to provide a high-level overview, with detailed protocols, error analyses, and bounds presented in the main text (specifically Sections 3 and 4). To address this, we have revised the abstract to briefly mention that the parallelized surgery maintains constant overhead via block-wise parallel operations and that LTCs enable resource preparation with polylog(d) query complexity. We also added a reference to the error propagation analysis in the abstract for clarity. revision: yes

  2. Referee: [Parallelized code surgery] Section describing parallelized code surgery: the assertion that surgery on an arbitrary [[n,k,d]] qLDPC code can be executed while keeping total qubits O(n) and time O(d^{a+o(1)}) requires a concrete bound showing that error propagation and ancilla count do not introduce an Ω(1/poly(n)) term; if sequentialization or size-dependent errors appear, the claimed scaling collapses to the slower O(d w^{1+o(1)}) regime already known from gauging methods.

    Authors: In the section on parallelized code surgery, we argue that by performing surgeries in parallel across multiple logical qubits using a constant number of ancilla patches, the total qubit overhead stays O(n) and the time scales as O(d^{a+o(1)}). Error propagation is controlled by the low-density property of the code, limiting error spread to O(1) per operation. However, we acknowledge that a more explicit lemma bounding the failure probability and ancilla count would strengthen the presentation. We have added such a bound in the revised version, proving that the overhead remains constant independent of n. revision: yes

  3. Referee: [Resource state preparation] Section on classical locally testable codes for resource preparation: the query complexity and failure probability of the LTC-based preparation must be shown not to add an extra n^ε factor that would spoil the O(d^{1+o(1)}) scaling for good codes; the current text provides no such quantitative bound.

    Authors: We have included an analysis of the LTC-based preparation in the relevant section, demonstrating that the query complexity is O(d^{1+o(1)}) using the local testability property, and the failure probability is 2^{-Ω(d)} without introducing polynomial factors in n. This preserves the desired scaling for good codes. To make this quantitative bound more prominent, we have added a dedicated proposition with the explicit bounds in the revision. revision: yes

Circularity Check

0 steps flagged

No circularity: overhead bounds derived from external code parameters via new constructions

full rationale

The claimed O(d^{a+o(1)}) time overhead (and O(d^{1+o(1)}) for good codes) follows from the externally defined parameters of any [[n,k,d]] qLDPC code with constant rate and d=Ω(n^{1/a}), combined with two novel techniques: parallelized code surgery under constant qubit overhead and classical LTC-based resource preparation. These steps are presented as independent constructions rather than reductions to fitted inputs, self-definitions, or prior self-citations. No equations or claims in the provided text reduce the target overheads to the inputs by construction; the comparison to the slower O(d w^{1+o(1)}) baseline is external. The derivation is therefore self-contained.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The central claim rests on the existence of good qLDPC codes with the stated distance scaling and on the correctness of the parallel surgery and classical LTC resource preparation techniques, none of which are derived from first principles in the abstract.

axioms (2)
  • domain assumption Good qLDPC codes exist with constant rate and distance d = Ω(n^{1/a}) for the relevant a.
    Invoked in the statement of the main result for the time overhead bound.
  • ad hoc to paper Parallelized code surgery can be performed under constant qubit overhead.
    Stated as the mechanism achieving the speedup but not justified in the abstract.

pith-pipeline@v0.9.0 · 5709 in / 1352 out tokens · 22581 ms · 2026-05-18T05:11:54.001282+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.

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

70 extracted references · 70 canonical work pages · 2 internal anchors

  1. [1]

    11, the F code can only correctXerrors, andZerrors may accumulate and damage the prepared resource states

    Surface code in the state preparation If we prepare resource states with the circuit in Fig. 11, the F code can only correctXerrors, andZerrors may accumulate and damage the prepared resource states. To solve this problem, we protect each qubit in the circuit with a surface code. We simulate the circuit in Fig. 11 using the surface code. Now, each qubit i...

    work page

  2. [2]

    11 involves 2n D +r D Z F-code blocks, so the number of data qubits is (2nD +r D Z )nF

    Overhead in the state preparation The state preparation circuit shown in Fig. 11 involves 2n D +r D Z F-code blocks, so the number of data qubits is (2nD +r D Z )nF . Additionally, we requirer F ancilla qubits to implement parity-check measurements on each F-code block, and such measurements are applied to 2nD blocks. Thus, the total number of qubits is (...

    work page

  3. [3]

    Measurements X (EnD ) Deformed-code block - ADeformed-code block - BDeformed-code block - C X Z Input stateResource state Output state µX µZ X(µZ ) Z(µX ) First column Second column Third column X (EnD ) X Z Input stateResource state Output state µX µZ X(µZ ) Z(µX ) (a) (b) FIG. 13. (a) Measurement ofZ(H D Z ) based on the resource state. Outcomes of tran...

    work page

  4. [4]

    Code surgery Memory system Deformed-code block X|+⟩ Z(HD Z ) Ancilla system X( ˜HX ) First column Second column Third column Fourth column µ Z { µ ˜βT(˜φr ⊥ T ˜JZ ) ) FIG. 14. Code surgery. The circuit of code surgery is illustrated in Fig. 14, which is applied onk F blocks of the code (H X , HZ, JX , JZ), called memory system. Check and generator matrice...

    work page

  5. [5]

    Quantum LDPC codes.A quantum CSS codeQ= CSS(H X , HZ) is said to be an (r, c)-qLDPC code if the row weight of bothH X andH Z is at mostr, and the column weight of both is at mostc

    Noise Model Definition 2. Quantum LDPC codes.A quantum CSS codeQ= CSS(H X , HZ) is said to be an (r, c)-qLDPC code if the row weight of bothH X andH Z is at mostr, and the column weight of both is at mostc. To protect an original quantum circuitCagainst noise during implementation, we encode it into a fault-tolerant circuitC FT using quantum LDPC (qLDPC) ...

    work page

  6. [6]

    This procedure enables the replacement of certain faulty portions of the circuit with equivalent error-free subcircuits, as is shown in FIG

    Partial circuit reduction Partial circuit reductionis based on propagating Pauli errors through each layer of the Clifford-gate circuit, thereby pushing these errors toward the layer boundaries. This procedure enables the replacement of certain faulty portions of the circuit with equivalent error-free subcircuits, as is shown in FIG. 15. In what follows, ...

    work page

  7. [7]

    For any probability distribution ofF∈2 C satisfying ∀A⊆C,P[F⊇A]≤ Y i∈A pi,(H2) 40 Input Output (a) Input Output (b) FIG. 15. Illustration of partial circuit reduction. The green shaded regions indicate locations in the circuit where faults may occur. (a) Error propagation through the Clifford-gate circuit: the arrows indicate how Pauli errors move after p...

    work page

  8. [8]

    Lemma 20.(Lemma

    For any setF⊆Cof faulty locations inCwithm(F) = 0, and any assignment of Pauli errors inF, there exists an assignment of Pauli errors in the set Γ(F)⊆C ′ of faulty locations inC ′ such thatCwith the errors inF andC ′ with the errors in Γ(F) are equivalent. Lemma 20.(Lemma. 15 in [17]) If(C,{p i}i∈C)isδ-reducible to(C ′,{q j}j∈C ′), then for any(C 0,{r k}k...

    work page

  9. [9]

    It holds that Γ(A) = [ i∈A Γ({i}),(H7) Γ(∅) =∅.(H8)

    work page

  10. [10]

    For alli∈C, |Γ({i})| ≤c fw.(H9)

    work page

  11. [11]

    For allj∈C ′, |{i∈C 1 :j∈Γ({i})}| ≤c (1) bw ,(H10) |{i∈C 2 :j∈Γ({i})}| ≤c (2) bw .(H11) 41

    work page

  12. [12]

    Define C ′ faulty := [ i∈C:p i̸=0 Γ({i}).(H12) For allj∈C ′ faulty, qj ≥2 c(2) bw 1 + p(1) p(2) c(1) bw (p(2))1/cfw + 2c(1) bw (p(1))1/cfw; (H13) and for allj∈C ′ \C ′ faulty, qj = 0.(H14)

    work page

  13. [13]

    Lemma 22

    For any setA⊆Cof faulty locations inCand any assignment of Pauli errors inA, there exists an assignment of Pauli errors in the setΓ(A)⊆C ′ such thatCwith the errors inAandC ′ with the errors inΓ(A)are equivalent. Lemma 22. Wait operation.In a quantum circuitC, two sequential idle operation layers, each exhibiting a local stochastic Pauli error with parame...

    work page

  14. [14]

    errors in both layers: probability≤p 1p2,

    work page

  15. [15]

    errors only in the first layer: probability≤p 1,

    work page

  16. [16]

    errors only in the second layer: probability≤p 2. Ifiqubits fall into case (1),jinto case (2), andk−i−jinto case (3), then Pr[S⊆F]≤ Y l∈S pl ≤(p 1p2)i pj 1 pk−i−j 2 =p i+j 1 pk−j 2 .(H15) Summing over all possible such configurations, we obtain Pr[S⊆F]≤ kX i=0 k−iX j=0 k i k−i j pi+j 1 pk−j 2 (H16) = (p1 +p 2 +p 1p2)k.(H17) which corresponds to a single i...

    work page

  17. [17]

    The first is the preparation of resource states, which serve as essential inputs for both logical operations and error correction

    Applications of circuit reducibility The circuit primarily consists of two main components. The first is the preparation of resource states, which serve as essential inputs for both logical operations and error correction. These resource states are subsequently consumed during the second component,gate teleportation, which uses them to implement logical g...

    work page

  18. [19]

    a syndrome measurement circuitC synd of depth at mosts 1, wheres 1 ≥w max andw max denotes the maximum row (or column) weight of the parity-check matrixH D Z

    work page

  19. [20]

    a final wait layerC wait 2 of depth 1. Thus, C Z(H D Z ) =C wait 1 ∪C synd ∪C wait 2 ,(H18) For all locationsi∈C wait 1 ∪Csynd∪Cwait 2 , the physical error rate satisfiespi ≤p phy.We consider Pauli error propagation from faulty locations inC synd to those inC wait 2 . To apply Lemma 21, we setC 1 =C synd andC 2 =C wait 2 . After propagation, we partitionC...

    work page

  20. [21]

    an initial wait layerC wait 1 of depth 1,

    work page

  21. [22]

    a syndrome measurement circuitC synd 1 of depth at mosts 2,

    work page

  22. [23]

    Thus, C Z(H F ) =C wait 1 ∪C synd 1 ∪C wait 2 .(H30) For alli∈C wait 1 ∪C synd 1 ∪C wait 2 , the physical error rate satisfiesp i ≤p phy

    a final wait layerC wait 2 of depth 1. Thus, C Z(H F ) =C wait 1 ∪C synd 1 ∪C wait 2 .(H30) For alli∈C wait 1 ∪C synd 1 ∪C wait 2 , the physical error rate satisfiesp i ≤p phy. 45 (a) (b) (D) FIG. 19. Reducibility of the error correction gadgetC Z(HF ) for the local testable code.(a) Original the error correction gadget C Z(HF ) (b) Equivalent reduced cir...

    work page

  23. [24]

    Threshold theorem analysis In this section, we analyze the probability of logical errors and the residual errors that remain uncorrected after the error correction procedure for both logical Clifford gates (e.g.,H,S, and CNOT) and non-Clifford gates (e.g., CCZ) implemented via code surgery. Before proceeding with the analysis, we introduce the notationQ= ...

    work page

  24. [25]

    Fewer thant L Pauli errors, each acting on a distinct physical qubit

    work page

  25. [26]

    n ze X s≥dD (2ze)s(qEC (1) )s/2−3tL + n ze X s≥dD (2ze)s(qEC (2) )s/2−4tL # ≤n R

    Subjected to a wait-operation circuit inducingλp phy-local stochastic Pauli errors. b. Error analysis during code surgery In this section, we use Lemmas 19, 18, 17, and 16 to analyze the error probability of efficient errors at every location during the code surgery process. We first analyze theZ(H D Z ) measurement circuit, and then consider the case of ...

    work page

  26. [27]

    Fewer thant S Pauli errors, each acting on a distinct physical qubit

    work page

  27. [28]

    n ze X s≥dS (2ze)s(qEC (1) )s/2−3tS + n ze X s≥dS (2ze)s(qEC (2) )s/2−4tS # ≤n R

    Subjected to a wait-operation circuit inducingλp phy-local stochastic Pauli errors. For magic state injection, we require a noisyT-gate magic state| ¯Tnoisy⟩that has already been encoded in a surface code of distanced S. Its density matrix can be expressed as ρT,S = (1−p err)| ¯T⟩ S⟨ ¯T| S +ϵ noisy ρerror,S.(H60) where: •| ¯T⟩ S is the ideal logicalT-gate...

    work page

  28. [29]

    P. W. Shor, Scheme for reducing decoherence in quantum computer memory, Physical Review A52, R2493 (1995)

    work page 1995

  29. [30]

    A. Y. Kitaev, Quantum computations: algorithms and error correction, Russian Mathematical Surveys52, 1191 (1997)

    work page 1997

  30. [31]

    Gottesman, Theory of fault-tolerant quantum compu- tation, Physical Review A57, 127 (1998)

    D. Gottesman, Theory of fault-tolerant quantum compu- tation, Physical Review A57, 127 (1998)

    work page 1998

  31. [32]

    Gaitan,Quantum Error Correction and Fault Tolerant Quantum Computing(CRC Press, 2018)

    F. Gaitan,Quantum Error Correction and Fault Tolerant Quantum Computing(CRC Press, 2018)

    work page 2018

  32. [33]

    Knill, R

    E. Knill, R. Laflamme, and W. H. Zurek, Resilient quan- tum computation, Science279, 342 (1998)

    work page 1998

  33. [34]

    Aharonov and M

    D. Aharonov and M. Ben-Or, Fault-tolerant quantum computation with constant error rate, SIAM Journal on Computing38, 1207 (2008)

    work page 2008

  34. [35]

    A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Surface codes: Towards practical large-scale quantum computation, Physical Review A86, 032324 (2012)

    work page 2012

  35. [36]

    Horsman, A

    D. Horsman, A. G. Fowler, S. Devitt, and R. V. Meter, Surface code quantum computing by lattice surgery, New J. Phys.14, 123011 (2012)

    work page 2012

  36. [37]

    Tillich and G

    J.-P. Tillich and G. Zemor, Quantum ldpc codes with positive rate and minimum distance proportional to the square root of the blocklength, IEEE Transactions on Information Theory60, 1193 (2014)

    work page 2014

  37. [38]

    Panteleev and G

    P. Panteleev and G. Kalachev, Degenerate quantum LDPC codes with good finite length performance, Quan- tum5, 585 (2021)

    work page 2021

  38. [39]

    N. P. Breuckmann and J. N. Eberhardt, Balanced prod- uct quantum codes, IEEE Transactions on Information Theory67, 6653 (2021)

    work page 2021

  39. [40]

    N. P. Breuckmann and J. N. Eberhardt, Quantum low- density parity-check codes, PRX Quantum2, 040101 (2021)

    work page 2021

  40. [41]

    Panteleev and G

    P. Panteleev and G. Kalachev, Asymptotically good quantum and locally testable classical ldpc codes, inPro- ceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, STOC ’22 (ACM, 2022)

    work page 2022

  41. [42]

    Dinur, M.-H

    I. Dinur, M.-H. Hsieh, T.-C. Lin, and T. Vidick, Good quantum ldpc codes with linear time decoders (2022), arXiv:2206.07750 [quant-ph]

    work page arXiv 2022

  42. [43]

    Gottesman, Fault-tolerant quantum computation with constant overhead, Quantum Information and Computa- tion14, 1339 (2014)

    D. Gottesman, Fault-tolerant quantum computation with constant overhead, Quantum Information and Computa- tion14, 1339 (2014)

    work page 2014

  43. [44]

    Yamasaki and M

    H. Yamasaki and M. Koashi, Time-efficient constant- space-overhead fault-tolerant quantum computation, Na- ture Physics20, 247 (2024)

    work page 2024

  44. [45]

    Tamiya, M

    S. Tamiya, M. Koashi, and H. Yamasaki, Polylog- time- and constant-space-overhead fault-tolerant quan- tum computation with quantum low-density parity-check codes (2024), arXiv:2411.03683 [quant-ph]

    work page arXiv 2024

  45. [46]

    Q. T. Nguyen and C. A. Pattison, Quantum fault toler- ance with constant-space and logarithmic-time overheads (2025), arXiv:2411.03632 [quant-ph]

    work page arXiv 2025

  46. [47]

    L. Z. Cohen, I. H. Kim, S. D. Bartlett, and B. J. Brown, Low-overhead fault-tolerant quantum computing using long-range connectivity, Science Advances8, 10.1126/sci- adv.abn1717 (2022)

    work page doi:10.1126/sci- 2022

  47. [48]

    Cross, Z

    A. Cross, Z. He, P. Rall, and T. Yoder, Improved qldpc surgery: Logical measurements and bridging codes 57 (2024), arXiv:2407.18393 [quant-ph]

    work page arXiv 2024

  48. [49]

    Cowtan and S

    A. Cowtan and S. Burton, CSS code surgery as a univer- sal construction, Quantum8, 1344 (2024)

    work page 2024

  49. [50]

    Zhang and Y

    G. Zhang and Y. Li, Time-efficient logical operations on quantum low-density parity check codes, Physical Review Letters134, 070602 (2025)

    work page 2025

  50. [51]

    B. Ide, M. G. Gowda, P. J. Nadkarni, and G. Dauphi- nais, Fault-tolerant logical measurements via homological measurement, Physical Review X15, 021088 (2025)

    work page 2025

  51. [52]

    D. J. Williamson and T. J. Yoder, Low-overhead fault- tolerant quantum computation by gauging logical opera- tors (2024), arXiv:2410.02213 [quant-ph]

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  52. [53]

    Zhang, Y

    G. Zhang, Y. Zhu, X. Yuan, and Y. Li, Constant- overhead magic state injection into qldpc codes with error independence guarantees (2025), arXiv:2505.06981 [quant-ph]

    work page arXiv 2025

  53. [54]

    Z. He, A. Cowtan, D. J. Williamson, and T. J. Yoder, Extractors: Qldpc architectures for efficient pauli-based computation (2025), arXiv:2503.10390 [quant-ph]

    work page arXiv 2025

  54. [55]

    Swaroop, T

    E. Swaroop, T. Jochym-O’Connor, and T. J. Yoder, Universal adapters between quantum ldpc codes (2025), arXiv:2410.03628 [quant-ph]

    work page arXiv 2025

  55. [56]

    Parallel Logical Measurements via Quantum Code Surgery

    A. Cowtan, Z. He, D. J. Williamson, and T. J. Yoder, Parallel logical measurements via quantum code surgery (2025), arXiv:2503.05003 [quant-ph]

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  56. [57]

    Baspin, L

    N. Baspin, L. Berent, and L. Z. Cohen, Fast surgery for quantum ldpc codes (2025), arXiv:2510.04521 [quant-ph]

    work page arXiv 2025

  57. [58]

    Dinur, T.-C

    I. Dinur, T.-C. Lin, and T. Vidick, Expansion of high- dimensional cubical complexes: with application to quan- tum locally testable codes, in2024 IEEE 65th An- nual Symposium on Foundations of Computer Science (FOCS)(IEEE, 2024) pp. 379–385

    work page 2024

  58. [59]

    Leverrier, V

    A. Leverrier, V. Londe, and G. Z´ emor, Towards local testability for quantum coding, Quantum6, 661 (2022)

    work page 2022

  59. [60]

    Lin and M.-H

    T.-C. Lin and M.-H. Hsieh,c 3-locally testable codes from lossless expanders (2022), arXiv:2201.11369 [cs.IT]

    work page arXiv 2022

  60. [61]

    Litinski, A game of surface codes: Large-scale quan- tum computing with lattice surgery, Quantum3, 128 (2019)

    D. Litinski, A game of surface codes: Large-scale quan- tum computing with lattice surgery, Quantum3, 128 (2019)

    work page 2019

  61. [62]

    Throughout this paper, when discussing devised sticking, we refer specifically to the case where the logical opera- tors to be measured are (i) expressed in standard form, and (ii) have logical thickness one, meaning they act on mutually disjoint sets of logical qubits [22]

    work page

  62. [63]

    Leverrier and G

    A. Leverrier and G. Zemor, Quantum tanner codes, in 2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS)(IEEE, 2022) pp. 872–883

    work page 2022

  63. [64]

    Lin and M.-H

    T.-C. Lin and M.-H. Hsieh, Good quantum ldpc codes with linear time decoder from lossless expanders (2022), arXiv:2203.03581 [quant-ph]

    work page arXiv 2022

  64. [65]

    Sipser and D

    M. Sipser and D. Spielman, Expander codes, IEEE Trans- actions on Information Theory42, 1710 (1996)

    work page 1996

  65. [66]

    Tanner, A recursive approach to low complexity codes, IEEE Transactions on Information Theory27, 533 (1981)

    R. Tanner, A recursive approach to low complexity codes, IEEE Transactions on Information Theory27, 533 (1981)

    work page 1981

  66. [67]

    Li, A magic state’s fidelity can be superior to the operations that created it, New Journal of Physics17 (2014)

    Y. Li, A magic state’s fidelity can be superior to the operations that created it, New Journal of Physics17 (2014)

    work page 2014

  67. [68]

    In a discussion with Armands Strikis (unpublished data, 2024)

    work page 2024

  68. [69]

    D. B. West,Introduction to graph theory, 2nd ed. (Pren- tice Hall, Upper Saddle River, NJ, 2001) includes biblio- graphical references (p. 533 - 568) and indexes

    work page 2001

  69. [70]

    M. A. Tremblay, N. Delfosse, and M. E. Beverland, Constant-overhead quantum error correction with thin planar connectivity, Physical Review Letters129, 050504 (2022)

    work page 2022

  70. [71]

    Arjomandi, An efficient algorithm for colouring the edges of a graph withδ+ 1 colours, INFOR: Information Systems and Operational Research20, 82 (1982)

    E. Arjomandi, An efficient algorithm for colouring the edges of a graph withδ+ 1 colours, INFOR: Information Systems and Operational Research20, 82 (1982)

    work page 1982