⚛️ quantum physics

Constant Rate Codes with Fully Addressable Transversal T: Good Codes, Sparse Checks

This paper presents constructions of asymptotically good CSS and subsystem quantum codes featuring fully addressable transversal $T$ gates that allow selective control over logical qubits, alongside related results for other non-Clifford gates and sparse check structures.

Original authors: Alexander Meiburg

Published 2026-10-01

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Alexander Meiburg

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the quest to build a practical quantum computer, scientists face a fundamental paradox. To perform calculations, these machines must manipulate delicate units of information called qubits. However, qubits are incredibly fragile; the slightest disturbance from the environment can scramble their data, causing errors. To combat this, researchers use quantum error-correcting codes, which spread a single piece of information across many physical qubits, creating a safety net that allows the computer to detect and fix mistakes without destroying the data. The holy grail of this field is a code that is both efficient and powerful: one that stores a large amount of information relative to the number of physical qubits used, while also keeping the distance between errors large enough to prevent them from spreading.

A major hurdle in this pursuit is the nature of the operations used to process information. Quantum gates, the instructions that change the state of qubits, must be applied in a way that does not accidentally spread errors from one part of the code to another. The most reliable way to do this is through "transversal" operations, where a gate is applied to each physical qubit individually and simultaneously, like a stamp pressing down on a whole page at once. For a long time, a famous theorem suggested that no single code could support a full set of these safe, transversal operations for all necessary calculations. This forced engineers to choose between safety and versatility, often resorting to complex, error-prone workarounds. The specific gate that has been the most difficult to implement safely in this manner is the T-gate, a crucial tool for unlocking the full power of quantum computing.

A new study by Alexander Meiburg addresses this challenge by constructing a family of quantum codes that can perform these essential T-gate operations safely and with a high degree of control. The researcher has developed a method to build codes that are "asymptotically good," meaning that as the system grows larger, the amount of information it can store and its ability to resist errors both grow in proportion to the size of the system. Unlike previous attempts that could only apply a T-gate to the entire system at once, these new codes allow scientists to selectively apply the gate to specific logical qubits while leaving others untouched. This is akin to having a master switch that can illuminate any single room in a vast building without affecting the rest, a level of precision that was previously out of reach for such efficient codes.

The paper presents three distinct constructions to achieve these goals, each with its own strengths and trade-offs. The first and most robust construction creates codes that are highly efficient and allow for the selective control of T-gates on individual qubits. These codes are built using a sophisticated mathematical framework involving algebraic curves, which allows the researcher to map the desired operations onto the physical hardware with high precision. The result is a system where the rate of information storage and the distance from errors remain constant and positive, even as the system scales up. Crucially, this construction works for a wide variety of specific rotation angles, not just the T-gate, provided the rotation is a rational fraction of a full circle. However, these codes do not have the simplest possible structure for checking errors; the checks required to verify the data have linear weight, meaning each check involves a number of qubits proportional to the total system size, rather than being limited to small, local groups.

To address the need for simpler error checks, the second construction offers a different approach. This method produces codes where the checks are sparse, meaning each check involves only a few qubits, and each qubit participates in only a few checks. This is a desirable feature for practical hardware implementation. However, this simplicity comes at a cost: the number of logical qubits the system can store does not grow with the size of the system. Instead, the system can only store a fixed, small number of qubits, regardless of how large the physical machine becomes. While the distance from errors grows as the system gets larger, the lack of scalable storage means this construction is not a complete solution for building a large-scale quantum computer, though it serves as a valuable proof of concept for how sparse checks can coexist with transversal gates.

The third construction attempts to bridge the gap between the first two. It creates a system that maintains sparse checks and allows for the selective application of T-gates to individual qubits, similar to the first construction. However, to achieve this, the system introduces a "protected subsystem." In this setup, the information is divided into two parts: a protected part that holds the valuable data and a gauge part that acts as a buffer. When a T-gate is applied to the protected data, it inevitably applies a known, harmless operation to the gauge part. This trade-off allows the system to keep the checks simple and sparse while still offering the ability to target specific qubits. The distance from errors in this system grows with the square root of the system size, which is a significant improvement over the fixed-distance limitations of some other approaches, though it does not reach the linear growth seen in the first construction.

The paper also clarifies what is impossible within these frameworks. The author demonstrates that it is not possible to have a code that is simultaneously asymptotically good, uses only simple local checks, and allows for the full set of transversal operations for all gates. Specifically, if a code is to be highly efficient and allow for the selective control of T-gates, it cannot rely on the simplest type of error checks known as Pauli checks. The research shows that achieving this level of control requires moving beyond standard Pauli checks to more general types of checks, or accepting that the system will not be able to store a large amount of information relative to its size. The study rules out the possibility of a "perfect" code that satisfies all desirable properties at once, pointing instead to a landscape of necessary compromises.

Ultimately, this work provides a clear map of the possibilities and limitations in the design of quantum error-correcting codes. It proves that it is possible to build efficient codes that can selectively apply the difficult T-gate, a major step forward in the field. While the most efficient codes require complex checks, and the simplest codes cannot scale their storage, the existence of these constructions opens new avenues for engineering. The researcher has shown that by carefully designing the mathematical structure of the code, one can achieve a high degree of control over quantum operations without sacrificing the fundamental ability to correct errors. The remaining challenge, as identified by the author, is to find a way to combine the best features of these constructions: a system that is efficient, has simple checks, and allows for full control, a goal that remains an open question for future research.

Technical Summary: Constant Rate Codes with Fully Addressable Transversal T

Problem Statement

The paper addresses the challenge of constructing quantum error-correcting codes that simultaneously achieve three desirable but often mutually exclusive properties:

Asymptotic Goodness: Constant rate ( $k = \Omega(n)$ ) and linear distance ( $d = \Omega(n)$ ).
Transversal Non-Clifford Gates: The ability to implement non-Clifford gates (specifically the $T$ gate and other finite-order rotations) via transversal physical operations, which are fault-tolerant by definition.
Logical Addressability: The ability to selectively apply these transversal gates to specific logical qubits within a code block without affecting others, using a physical "mask" of identity and gate operations.

Prior work by Wills [5] achieved constant-rate codes with transversal $T$ but lacked full logical addressability. Conversely, constructions with addressability often suffered from vanishing rates or lacked sparsity (LDPC properties). The Eastin-Knill theorem and related group-theoretic arguments impose strict constraints on which gates can be transversal in stabilizer codes, particularly restricting rotations to dyadic phases for binary stabilizer codes.

Methodology

The author presents three distinct constructions, each trading off different parameters (rate, distance, sparsity, and addressability) to satisfy the core requirements.

1. Asymptotically Good CSS Codes with Full Addressability (Section 3)

Core Mechanism: This construction utilizes Algebraic-Geometric (AG) codes based on Garcia–Stichtenoth towers.
Addressability via Interpolation: Logical qubits are encoded by reserving specific evaluation points on the algebraic curve. The physical gate mask is derived by interpolating the desired logical phase pattern using the remaining physical coordinates.
Phase Identity: The construction ensures that a physical layer of $I$ and $R_\ell$ gates implements a specific logical phase $R_\ell$ on a target logical qubit. This is achieved by satisfying modular overlap conditions (e.g., fourfold overlaps for $T$ ) that isolate the target logical row while canceling phases on stabilizer rows and other logical rows.
Generalization: While the primary construction targets dyadic phase gates ( $R_\ell = \text{diag}(1, e^{2\pi i/2^\ell})$ ) with CSS realizations, a "finite-clock" extension using modular arithmetic over $\mathbb{Z}_L$ extends this to any fixed finite-order one-qubit gate (e.g., $R_z(\pi/7)$ ), though this generally results in non-additive codes without guaranteed transversal logical Paulis.
Recovery: The codes support polynomial-time ideal recovery using AG decoding, correcting a linear number of errors.

2. Pauli-LDPC Codes with Growing Distance (Section 4)

Core Mechanism: This construction uses a quotient of a three-dimensional color code geometry defined on a sphere, utilizing the action of the quaternion group $Q_8$ .
Color Holonomy: By arranging a local coloring of the triangulation such that transporting colors around a closed loop permutes them (color holonomy), the construction creates a non-trivial logical sector.
Logical Structure: The resulting code encodes $k=2$ logical qubits with distance $d = \Omega(n^{1/3})$ .
Gate Implementation: A signed transversal operation (applying $T$ or $T^\dagger$ based on a sign pattern) implements a logical $T \otimes T^\dagger$ . By adjusting stabilizer signs, a uniform physical $T$ layer can implement $T \otimes T$ .
Limitations: This construction provides sparse Pauli checks and growing distance but has a vanishing rate ( $k/n \to 0$ ) and lacks individual logical addressability (it only supports collective operations).

3. Sparse Protected Subsystem with Addressability (Section 5)

Core Mechanism: This approach constructs a code on eight-level systems (qudits) using a product architecture of classical LDPC codes, then encodes each qudit into 28 physical qubits.
Protected vs. Gauge: The logical space is decomposed into a "protected" subsystem and a "gauge" subsystem. The transversal $T$ gate acts as the desired logical $T$ on the protected qubits while applying a known Clifford operation on the gauge qubits.
Sparsity: By retaining the full eight-level logical structure (rather than restricting to qubits immediately), the construction preserves the sparse commuting checks of the underlying classical LDPC code.
Parameters: The construction yields a code with constant protected rate, distance $d = \Omega(\sqrt{n})$ , and sparse (non-Pauli) commuting checks. Each protected logical $T$ is individually addressable.

Key Contributions and Results

Explicit Good Addressable Codes: The paper provides the first explicit construction of asymptotically good binary CSS codes with fully addressable transversal $T$ gates. The rate and distance are linear in the block length, and the address masks are computable in polynomial time.
Gate Compatibility Analysis: The paper establishes that for binary stabilizer codes with distance $\ge 2$ , transversal logical $X$ , $Z$ , and a rotation $U$ can coexist only if the projective group generated by them is finite. For rotations about Pauli axes, this restricts $U$ to dyadic phases. For non-dyadic rational angles (e.g., $\pi/7$ ), the construction requires non-additive codes and sacrifices guaranteed transversal logical Paulis.
Quaternion Pauli-LDPC Family: A new family of Pauli-LDPC codes is constructed with $k=2$ and $d = \Omega(n^{1/3})$ , implementing coupled $T$ gates transversally. This demonstrates that sparse Pauli checks and transversal non-Clifford gates are compatible, albeit at the cost of rate.
Sparse Protected Addressability: A construction is given that achieves constant protected rate, $\Omega(\sqrt{n})$ distance, and full addressability with sparse commuting checks, utilizing a protected subsystem framework.
Magic State Distillation: The good codes (Section 3) are shown to support efficient magic-state distillation with constant overhead, using native noisy resource states and ideal Clifford operations.

Significance and Claims

The paper claims to resolve the tension between constant rate, transversal non-Clifford gates, and logical addressability for a specific class of gates (dyadic phases) using AG codes. It extends the frontier of transversal gate sets to include arbitrary fixed finite-order rotations via modular clock codes.

The author explicitly notes that the remaining open challenge is the construction of asymptotically good Pauli-LDPC codes that possess fully addressable transversal non-Clifford gates. The current constructions either lack LDPC properties (Section 3), lack addressability (Section 4), or lack the Pauli-check structure (Section 5).

The paper also highlights a concurrent work by San-José [10] which overlaps in the construction of good binary CSS codes with addressable dyadic gates. The author distinguishes their work by providing a direct interpolation-based proof for selectors (avoiding higher-level commutator descent), extending addressability to all finite-order gates via modular clocks, and providing the distinct quaternion and sparse protected constructions.

The work is presented as a theoretical advancement in quantum coding theory, providing explicit families of codes and rigorous proofs of their parameters, rather than an experimental proposal. The "Generative AI Statement" notes that the core ideas were conceived by the author, with AI assistance used for development, validation, and drafting, but the author takes full responsibility for the correctness of the claims.