Accelerating Fault-Tolerant Quantum Computation with Good qLDPC Codes

TL;DR

This work addresses the overhead bottleneck of fault-tolerant quantum computation by presenting a scheme that applies to general qLDPC codes and achieves constant qubit overhead with a reduced time overhead of $O(d^{a+o(1)})$ (and $O(d^{1+o(1)})$ for good qLDPC codes). The core approach combines code surgery with gate teleportation, introducing parallelized code surgery (PCS) and locally-testable state preparation (LTSP) to enable scalable, low-overhead logical operations. It leverages memory-code blocks, an R code ancilla, and an F code resource-state factory to realize fault-tolerant parity-check measurements and resource-state preparation with only polylogarithmic overhead in code size. The results establish a new paradigm for accelerating FTQC on qLDPC codes, offering broad applicability, asymptotic improvements over prior GM+BFB methods, and practical relevance for near-term quantum architectures.

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 = Ω(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.

Figures (27)

• Figure 1: Schematic illustration of our scheme. Each execution of the locally-testable state-preparation circuit produces $k_F$ copies of the resource state, which are then used in gate teleportation to implement parallelized code surgery (PCS). PCS applies logical operations simultaneously on $k_R$ target code blocks, using a single ancilla system shared across the $k_R$ blocks. The locally-testable state-preparation circuit has almost constant qubit and time overhead, while gate-teleportation-based PCS also maintains constant qubit and time overhead.
• Figure 2: Quantum computer and allocation of physical qubits. In the memory, the memory-code blocks are divided into four groups according to their functions. Each group contains $M$ blocks, and each block occupies $n$ physical qubits. The resource-state factory produces resource states specified by the corresponding check matrices, which are organized into three families (indicated by the dashed boxes). In each dashed box, the notation $O(A)\times O(B)$ denotes the total number of physical qubits used for generating resource states within that family: each type of resource state is prepared by a tolerated locally-testable state-preparation circuit requiring $O(B)$ physical qubits, and $O(A)$ such circuits are run in parallel. In the magic-state factory, $O(M)$ surface-code blocks are used to inject $T$-gate magic states into $O(M)$ memory-code blocks, while an additional $O(M)$ ancillary memory-code blocks are employed for magic-state distillation.
• Figure 3: Circuit for parallelized code surgery. The ancilla system is transversally initialized in the state $\vert{ + }\rangle$ and measured in the $X$ basis. The $R$ gate rotates the logical measurement basis to $Z$: for each memory-code block on which the measured Pauli operator acts as $X$, a transversal Hadamard gate is applied. The central step of code surgery is a single round of parity-check measurements of the deformed code, specifically measuring $Z$ stabilizer operators $Z(H^D_Z)$. Implemented via gate teleportation with a resource state from locally-testable state preparation, this single round suffices to guarantee fault tolerance. The feedback gate $V$ is a Pauli gate.
• Figure 4: Gate teleportation. The circuit involves three sets of qubits: the first set carries the input state, while the second and third sets encode the resource state. The diagram illustrates operations on a representative qubit from each set (black lines), with the same operations applied in parallel to the remaining qubits (gray lines). Depending on measurement outcomes, a Pauli gate $V$ is applied on the output qubit. Dashed boxes indicate Pauli errors, and white boxes denote trivial errors. Arrows trace the paths of error propagation through the circuit.
• Figure 5: Circuit for generating resource states used to measure $Z$ stabilizers. The diagram illustrates operations on selected representative qubits (black lines), with similar operations applied in parallel to the remaining qubits (gray lines). The procedure begins by applying transversal controlled-NOT gates between two sets of qubits to prepare Bell states. An ancilla qubit is then used to measure each $Z$-stabilizer operator of the code, with the illustrated example assuming a weight-four stabilizer for the representative ancilla qubit. Measurement outcomes of the ancilla qubits determine Pauli gates $V$, which are subsequently applied. Each qubit in this circuit is encoded using a F code, which has only $Z$-type stabilizers. An example Tanner graph is shown, where blue (red) squares represent $Z$ ($X$) stabilizers. Note that the depicted graph is from the $[7,4,3]$ Hamming code; in practice, the F code should be an LTC with large enough distance. Furthermore, each qubit of the F code is itself encoded in a low-distance surface code, forming a two-level encoding scheme. All operations are performed via transversal gates within both the factory and surface codes. After preparing the encoded resource states, decoding is performed to obtain unencoded resource states. This is achieved by measuring selected qubits in the $X$ and $Z$ bases as illustrated in the figure and applying Pauli gates to the remaining qubits based on the outcomes. The measurement pattern is determined by the standard form of the generator matrices. The entire decoding process can be completed in $O(1)$ time, producing $k_F$ copies of unencoded resource states per circuit run. To correct errors, parity-check measurements (PCMs) of the F code are performed before decoding. Since the F code is an LTC, measurement errors in PCMs are equivalent to low-weight Pauli errors, and a single round of PCMs suffices to reliably detect and correct $X$ errors (including measurement errors on ancilla qubits) by exploiting the propagation of F-code $Z$ stabilizers (highlighted in bold cyan and magenta lines). As a result, each resource state copy has only low-weight residual errors.

Theorems & Definitions (57)

• Theorem 1
• Lemma 1
• Lemma 2
• Lemma 3
• proof
• Definition 1
• Lemma 4
• proof
• Lemma 5
• proof