⚛️ quantum physics

Constant-rate quantum codes with low-weight stabilizers and full logical Clifford actions via transversal and fold-transversal gates

This paper introduces a family of constant-rate quantum codes with sublogarithmically growing stabilizer weights that support the entire logical Clifford group using only transversal and fold-transversal gates, thereby enabling low-space-overhead fault-tolerant quantum computation.

Original authors: Takaya Matsuura, Yohji Chin, Shohei Kiryu, Kosuke Fukui

Published 2026-09-30

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Takaya Matsuura, Yohji Chin, Shohei Kiryu, Kosuke Fukui

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

To build a computer that can solve problems far beyond the reach of today's machines, scientists are trying to harness the strange rules of quantum physics. These machines use quantum bits, or qubits, which can exist in multiple states at once, offering immense power. However, this power comes with a fragile cost: qubits are incredibly sensitive to noise and errors. A single mistake can corrupt the entire calculation. To fix this, researchers use quantum error-correcting codes, which spread information across many physical qubits to create a single, stable "logical" qubit. The goal is to find a way to protect this information without using so many extra physical parts that the machine becomes too large to build. Furthermore, the machine must be able to perform calculations on this protected information without breaking the protection. This requires a delicate balance: the code must be efficient enough to fit on a chip, yet robust enough to survive the inevitable errors of the real world, while still allowing the computer to do useful work.

For years, a major hurdle has been finding a code that is both highly efficient and capable of performing a full range of necessary operations without needing extra helper parts. Some existing methods work well for error correction but require complex, time-consuming measurements that introduce new risks. Others allow for easy operations but fail to protect enough information or require so many physical components that they become impractical. The central challenge has been to construct a system that combines a high rate of information storage with a complete set of logical tools, all while keeping the physical connections between parts simple and the error-correction process fast.

In a new study, researchers have constructed a family of quantum codes that achieves this difficult balance. They developed a system that can store a constant amount of information relative to its size, meaning it does not waste space as it grows larger. Crucially, this system can perform every necessary logical operation using only simple, direct interactions between physical parts, without needing any additional helper qubits. However, to achieve the full range of these operations, the system requires at least two code blocks working together, rather than just one. The researchers named their creation PRISM codes. These codes are built by combining two copies of a specific type of classical code derived from the symmetries of geometric shapes known as buildings in mathematics. By linking these structures together, the team created a quantum system where the connections between parts remain relatively simple, even as the system scales up.

The key innovation lies in how these codes handle errors and operations. The researchers designed the system so that the connections between physical qubits, which are used to check for errors, do not become overwhelmingly complex. While the number of connections does grow as the system gets larger, it grows very slowly—so slowly that for any practical size of computer, the connections remain manageable, similar to those found in the most advanced error-correcting systems currently available. This allows the system to maintain high performance even in small, early versions. The team demonstrated through simulations that these codes can correct errors effectively, outperforming other known methods when using the same number of logical qubits and similar error protection levels.

To make the computer work, the researchers showed that they can perform all the necessary logical operations using two specific types of gates. The first type acts independently on individual physical qubits, ensuring that a mistake in one place does not spread to others. The second type involves swapping the positions of qubits and applying simple operations, a method that allows the system to access a much wider range of logical actions than previously thought possible with such simple tools. By combining these two methods, the team proved that they can generate the entire set of logical operations required for complex calculations. This is a significant step forward because previous systems either lacked the ability to perform all these operations or required extra resources that defeated the purpose of having an efficient code.

The study also addressed a common misconception that high-performance codes must rely on complex, high-density connections. The researchers showed that by using the mathematical properties of their specific code family, they could achieve a complete set of logical tools while keeping the connections sparse. They explicitly noted that while their codes are not strictly the simplest possible type in a theoretical sense, they behave almost like the simplest types for any realistic computer size. The work provides a clear path toward building fault-tolerant quantum computers that are both space-efficient and capable of performing the full range of operations needed for universal computing, without the heavy overhead of extra helper parts.

Technical Summary: Constant-Rate Quantum Codes with Low-Weight Stabilizers and Full Logical Clifford Actions

Problem Statement
The pursuit of low-space-overhead fault-tolerant quantum computation requires quantum error-correcting codes that simultaneously achieve high encoding rates ( $k/n$ ), large code distances ( $d$ ), and space-efficient implementations of logical operations. While transversal gates offer intrinsic fault tolerance by limiting error propagation without ancillary qubits, they are typically insufficient to generate a universal gate set or even the full logical Clifford group for high-rate codes. Previous approaches, such as "surgery" (requiring ancillas and repeated syndrome extraction) or specific code families (e.g., quantum Reed–Muller, SHYPS, or phantom codes), often fail to satisfy all desirable criteria simultaneously. Specifically, existing constructions that support the full logical Clifford group via transversal and fold-transversal gates generally suffer from vanishing encoding rates, rapidly growing stabilizer weights (high-density stabilizers), or distance constraints that prevent scalability. The central challenge is to construct a code family that maintains a constant encoding rate, growing distance, sublogarithmically growing stabilizer weight, and a complete logical Clifford action generated entirely by transversal and fold-transversal gates.

Methodology
The authors introduce a new family of quantum CSS codes, termed PRISM codes (Product codes from Irreducible Steinberg Modules). The construction proceeds in three main stages:

Base Classical Codes (Steinberg Codes): The construction begins with a family of classical binary codes derived from the top-dimensional homology of spherical Tits buildings associated with Chevalley groups (specifically $SL_{r+1}(q)$ ). These codes, called Steinberg codes, utilize the Steinberg representation of the group. A critical property leveraged is that for specific parameters (where the field size $q$ is a power of 2), the Steinberg module is absolutely irreducible. This ensures that the code space is a representation space where the group action is rich enough to generate the full matrix algebra.
Hypergraph Product (HGP): The quantum codes are constructed by taking the hypergraph product of two copies of a Steinberg code. The authors focus on the Left-Sector HGP (LS-HGP), which retains the left-sector logical qubits while gauging out the right-sector ones. This construction inherits the constant encoding rate and the automorphism properties of the seed classical codes.
Gate Synthesis via Symmetries: The logical Clifford group is generated using:
- Transversal Gates: Physical transversal CNOT gates between code blocks induce logical parallel CNOTs.
- Fold-Transversal Gates: Exploiting the ZX-duality inherent in HGP codes, the authors utilize fold-transversal Hadamard ( $H_{fd}$ ) and phase ( $S_{fd}$ ) gates. These gates involve physical qubit permutations (swaps across a diagonal) combined with transversal single-qubit gates.
- Code Automorphisms: The automorphisms of the underlying Steinberg codes (Tanner-graph automorphisms) are lifted to the quantum level. Due to the absolute irreducibility of the Steinberg representation, these automorphisms generate a dense set of logical operations.

The authors demonstrate that for code blocks greater than one, the combination of inter-block transversal CNOTs, local fold-transversal gates, and code automorphisms is sufficient to synthesize any logical Clifford operation. This is proven by showing that the symplectic representations of these primitive gates generate the entire binary symplectic group $Sp_{2m}(\mathbb{F}_2)$ .

Key Contributions and Results

New Code Family (PRISM): The paper presents the first known construction of a quantum code family that simultaneously achieves:
- Constant Encoding Rate: The rate $k/n$ remains non-vanishing as the code size $n$ increases.
- Growing Distance: The code distance $d$ grows subpolynomially with $n$ (specifically $d \sim \exp[(\log n)^{1/2+o(1)}]$ ).
- Sublogarithmic Stabilizer Weight: The stabilizer weight $w$ grows as $(\log n)^{1/2-o(1)}$ . For practical code sizes (e.g., $n \lesssim 10^{18}$ ), the stabilizer weights are $\lesssim 10$ , comparable to state-of-the-art qLDPC codes, despite the code not being strictly qLDPC in the asymptotic limit.
- Full Logical Clifford Action: The entire logical Clifford group is generated using only transversal and fold-transversal gates, requiring no ancillary qubits or magic state injection for Clifford operations.
Theoretical Framework: The work establishes finite-group representation theory, specifically the Steinberg representation, as a mechanism for jointly engineering quantum code parameters and fault-tolerant logical gates.
Performance: Memory simulations for small instances of PRISM codes show high error-correcting performance compared to rotated surface-code blocks with similar logical qubit counts and code distances.
Trade-offs: The construction requires at least two code blocks to generate the full logical Clifford group (unlike single-block phantom codes). Additionally, synthesizing arbitrary logical Clifford operations may incur greater time overhead (gate depth) compared to existing constructions, as it involves decomposing symplectic matrices into sequences of the primitive gates.

Significance
The paper claims to provide a path toward fault-tolerant quantum computation with low space overhead. By combining high-rate codes with a rich native logical gate set that requires no ancillas, PRISM codes address the "addressability" obstacle that has hindered high-rate codes. While the stabilizer weight grows with code size (preventing them from being strict qLDPC codes asymptotically), the growth is sufficiently slow (sublogarithmic) that for practically relevant code sizes, they behave effectively as low-weight stabilizer codes. This work demonstrates that sublogarithmic stabilizer weights can coexist with a complete native Clifford action generated by code symmetries, offering a new paradigm for designing fault-tolerant architectures.

Technical Summary: Constant-Rate Quantum Codes with Low-Weight Stabilizers and Full Logical Clifford Actions

More like this