Low-overhead fault-tolerant quantum computation by gauging logical operators

TL;DR

The paper tackles the overhead barrier in fault-tolerant quantum computation for good quantum LDPC codes by introducing a gauging measurement, which treats a logical operator as a symmetry and enforces it via a gauge construction. It develops a general procedure that maps the original code space to a deformed, gauged code through Gauss's law operators, enabling fault-tolerant measurement of a logical operator with overhead scaling as $O(W \log^{2} W)$ for a weight $W$ operator (up to polylogarithmic factors), and extending to arbitrary stabilizer/qLDPC codes. The approach relies on constructing a graph $G$ with edge qubits to control distance and LDPC properties, and leverages cycle-sparsification and the Freedman-Hastings decongestion lemma to achieve a sparse, scalable implementation; it also includes generalizations to hypergraphs, qudits, and nonabelian groups, linking to lattice-surgery-like techniques. Overall, the method offers a flexible, low-overhead route to fault-tolerant, measurement-based quantum computation with broad applicability to high-distance codes and near-term implementations.

Abstract

Quantum computation must be performed in a fault-tolerant manner to be realizable in practice. Recent progress has uncovered quantum error-correcting codes with sparse connectivity requirements and constant qubit overhead. Existing schemes for fault-tolerant logical measurement do not always achieve low qubit overhead. Here we present a low-overhead method to implement fault-tolerant logical measurement in a quantum error-correcting code by treating the logical operator as a symmetry and gauging it. The gauging measurement procedure introduces a high degree of flexibility that can be leveraged to achieve a qubit overhead that is linear in the weight of the operator being measured up to a polylogarithmic factor. This flexibility also allows the procedure to be adapted to arbitrary quantum codes. Our results provide a new, more efficient, approach to performing fault-tolerant quantum computation, making it more tractable for near-term implementation.

Figures (5)

• Figure 1: The Tanner graph of the deformed code can be represented compactly by creating ordered subsets of qubits (circles) and checks (squares) of $X$, $Z$, or mixed (unlabeled) type. Each edge connecting an $X$ or $Z$ check set $\mathcal{P}$ and qubit set $\mathcal{Q}$ is labeled by a binary matrix $H$ with $|\mathcal{P}|$ rows and $|\mathcal{Q}|$ columns, where $H_{ij}=1$ if and only if the $i^\text{th}$ check in $\mathcal{P}$ acts non-trivially on the $j^\text{th}$ qubit in $\mathcal{Q}$. Edges from mixed type check sets are instead labeled with a symplectic matrix $[H_X|H_Z]$ where $H_X$ indicates qubits acted on by $X$ and $H_Z$ those acted on by $Z$. The original code may not be CSS, but we assume without loss of generality that $L$, the operator being measured, is $X$-type and its qubit support is $\mathcal{L}$. Set $\mathcal{C}$ contains checks from the original code that do not have $Z$-type support on $\mathcal{L}$, while set $\mathcal{S}$ contains checks that do. Also, $\mathcal{A}$ is the set of Gauss's law operators $A_v$, $\mathcal{B}$ is the set of flux operators $B_p$, and $\mathcal{E}$ is the set of edge qubits. Matrix $N$ specifies a cycle basis of $G$ and $M$ indicates how original stabilizers are deformed by perfect matching in $G$ (see Remark \ref{['rem:WorstCaseG']}).
• Figure 2: The Tanner graph of the complete construction including decongestion and cellulation to guarantee the deformed code is LDPC. We use the same notation as explained in Fig. \ref{['fig:thin_Tanner']}. Additionally, $(B_1\text{\space}B_2)$ indicates a block matrix constructed from submatrices $B_1$ and $B_2$. We use block matrices where qubits of the left block are those on edges of the expanding graph $G$ and qubits of the right block are those added to cellulate cycles. Depending on the layer $i=1,2,\dots,R$, this cellulation is done to different elements of the cycle basis of $G$. Using $R=O(\log^2W)$ layers ensures the deformed code is LDPC by the decongestion lemma freedman2021building.
• Figure 3: Applying the gauging measurement procedure to a product of $X$-type logicals on a pair of surface codes (blue edges) and choosing the graph $G$ to be a ladder (red edges) results in a standard surface code lattice surgery procedure.
• Figure 4: Cellulating a weight-six cycle (black) into a union of triangles by adding additional edges (red).
• Figure : Gauging measurement procedure

Theorems & Definitions (61)

• Remark 1: Circuit implementation
• Theorem 1: Gauging measurement
• proof
• Remark 2
• Remark 3: Desiderata for $G$
• Remark 4: Construction of a suitable $G$
• Remark 5: Parallelization
• Remark 6: Generalizations
• Remark 7: Replacing $G$ with a hypergraph
• Theorem 2: Fault-tolerance