⚛️ quantum physics

Quantum LDPC codes with design rate 1/5 and good performance below 1000 physical qubits

This paper introduces a new family of constant-rate quantum LDPC codes with design rate 1/5 and check weight 9, constructed via balanced products of classical codes with non-abelian symmetries, which achieve high-performance fault tolerance below 1000 physical qubits under realistic noise conditions using tailored syndrome extraction and efficient decoding.

Original authors: Yifan Hong

Published 2026-07-31

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yifan Hong

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

Imagine you are trying to build a library that never loses a single book, even if the shelves are shaking, the lights are flickering, and the librarians are occasionally dropping their clipboards. This is the dream of fault-tolerant quantum computing. The "books" are quantum bits (qubits), which are incredibly fragile; a tiny breeze of heat or a stray magnetic field can scramble their information. To save them, scientists use Quantum Error Correction. Think of this like a magical spell where you don't just write a book once; you write it out in a giant, intricate pattern across many physical pages. If one page gets torn or smudged, the spell can look at the surrounding pages, figure out what the original text was supposed to be, and fix the mistake without ever reading the book directly (which would destroy the magic).

The challenge is that these "spells" usually require a massive amount of extra pages. For a long time, the most popular spell, called the Surface Code, was like a very safe but extremely wasteful library: to store one useful piece of information, you might need hundreds of physical pages. Scientists have been hunting for a better spell—one that is just as safe but uses far fewer pages, a concept known as a constant-rate code. They also need these spells to work on real machines, like those using trapped ions or floating atoms, which have specific rules about how they can move their parts around. The big question has been: Can we find a spell that is efficient enough to fit in a small room (under 1,000 pages) but strong enough to handle the messy reality of a real lab?

This paper introduces a new family of these magical spells, called ZSZ-LP codes, designed specifically to fit into that "small room" while still being incredibly tough. The authors, working at NVIDIA, didn't just dream up a theory; they built specific examples of these codes and tested them in computer simulations to see how well they hold up against noise. They found that with just a few hundred physical qubits, their new codes can store information with an error rate so low that it potentially opens the door to the "teraquop" regime—a term for performing a trillion reliable quantum operations. This is a significant step toward running massive, world-changing calculations (like breaking complex encryption or simulating new medicines) that were previously thought to require millions of qubits.

The secret sauce of these new codes is a clever mathematical trick involving non-abelian groups. To understand this, imagine a dance floor. In the old, simpler codes (abelian), the dancers follow a strict rule: if Alice moves left and then Bob moves forward, it's the same as Bob moving forward and then Alice moving left. It's predictable, but it limits how complex the dance can be. The new codes use a "twisted" dance floor (non-abelian) where the order matters: Alice-then-Bob is different from Bob-then-Alice. This extra twist allows the code to be much more efficient and compact. The authors used this twist to create codes with a design rate of 1/5, meaning for every 5 physical qubits, they can store 1 useful logical qubit. This is a huge improvement over older methods that might need 10 or 20 physical qubits for just one.

The paper shows that these codes work remarkably well in simulations. Under a noise level of 0.1% (which represents the errors happening in the machine), the new codes can reach a state where they are potentially ready for the "teraquop" regime. Specifically, a code called ZSZ-LP-550, which uses 550 physical qubits (plus a few more for checking errors), showed a logical error rate of about 7 × 10⁻¹⁴ per round in a memory benchmark. This is incredibly low; it suggests that if you built a computer with these codes, it could hold information for a very long time without it getting corrupted. The authors also designed a way to "read" the errors using a greedy scheduler that moves atoms around in 30–60 milliseconds, a speed that fits well with current neutral-atom hardware.

However, the authors are careful to note that these results come from simulations, not a physical machine built in a lab. They used a powerful GPU to run a decoding algorithm called Relay-BP, which acts like a super-fast detective solving the puzzle of where the errors happened. The simulations suggest the codes are robust, with a "pseudothreshold" around 0.5%, meaning if the machine's error rate stays below that, the code gets better and better as it grows. But the paper also points out a trade-off: because these codes use this complex "twisted" math, they are harder to wire up physically than the simpler, older codes. The connections between the qubits are more complicated, which makes building the actual hardware a bigger challenge.

The researchers also discovered that these codes have a special symmetry that allows them to perform certain logical operations (like flipping bits or changing phases) very efficiently, almost like folding a piece of paper to align the edges perfectly. This could make the "surgery" needed to connect different parts of a quantum computer much easier. While they didn't find a code that is perfect in every way (some versions had slightly lower distances or required more complex wiring), they proved that codes under 1,000 qubits can indeed reach the high-performance levels needed for the next generation of quantum computers.

In short, this paper is a major step forward in proving that we don't need a quantum computer the size of a city to do big things. By using a clever mathematical twist, the authors showed that a machine the size of a small server rack could potentially hold the key to solving problems that are impossible for today's supercomputers. The path from this simulation to a real, working machine is still long and full of engineering hurdles, but the map they've drawn looks very promising.

Technical Summary: Quantum LDPC Codes with Design Rate 1/5 and Good Performance Below 1000 Physical Qubits

Problem Statement

While constant-rate quantum low-density parity-check (qLDPC) codes promise fault-tolerant quantum computation (FTQC) with constant spatial overhead in the asymptotic limit, discovering finite-length code instances with good practical performance remains a significant challenge. Existing high-rate qLDPC codes often require thousands of physical qubits to reach useful error-correction thresholds, or they suffer from low minimum distances when constructed using abelian groups. Furthermore, bridging different error-correcting codes in heterogeneous architectures via code surgery is non-trivial, and the trade-off between code parameters (rate, distance) and implementation constraints (check weight, connectivity) is acute for near-term hardware like trapped-ion and neutral-atom processors. The specific challenge addressed is constructing qLDPC codes with a design rate of at least 1/5, good finite-length performance (approaching the "teraquop" memory regime), and manageable physical overhead (<1000 qubits) under realistic circuit-level noise.

Methodology

The authors introduce a new family of quantum LDPC codes, termed ZSZ-LP codes, constructed via the balanced product of classical LDPC codes sharing non-abelian "ZSZ" group symmetries.

1. Code Construction

Group Structure: The construction utilizes the ZSZ group ( $Z_{\ell_1} \rtimes_q Z_{\ell_2}$ ), a metacyclic group defined by a semidirect product. The non-abelian "twist" factor $q$ is crucial; the authors demonstrate theoretically that abelian groups lead to low (constant) minimum distances in this 5-block construction due to low-weight syzygies, whereas non-abelian groups circumvent this obstacle.
Classical Seeds: The process begins by selecting pairs of classical (3, 6)-regular LDPC codes (design rate 1/2) based on the ZSZ group algebra. These are constructed as two-block group-algebra (2BGA) codes using left-regular and right-regular representations of trinomials ( $a, b$ for the left code; $c, d$ for the right).
Balanced Product: The quantum code is formed by taking the balanced product of these classical seed codes. This results in a 5-block CSS structure with parity-check matrices $H_X$ and $H_Z$ of size $5\ell \times 5\ell$ (where $\ell = \ell_1 \ell_2$ ). The design rate is $1/5$ .
Search Strategy: A filtered random search is employed to select trinomials. The pipeline filters candidates based on Tanner graph girth (avoiding short cycles) and minimum distance (estimated via QDistEvol and exact SAT solvers). The authors specifically avoid symmetric choices ( $a=c, b=d$ ) to prevent unavoidable 4-cycles.

2. Logical Operators and Surgery

Equivariant Bases: Leveraging the group symmetries of the classical seeds, the authors construct One-Generator-Minimal (OGM) logical bases (all operators have minimum weight $d$ ) and One-Generator-Symplectic (OGS) bases (symplectic but potentially higher weight).
Code Surgery: The equivariant nature of the logical operators allows for the construction of efficient "surgery gadgets" to measure logical Pauli operators. Two types are demonstrated: a random graph ancilla for single logical measurements and a hypergraph product (HGP) ancilla for parallel measurements.

3. Hardware Adaptation

Syndrome Extraction: The paper proposes syndrome extraction schedules tailored for reconfigurable atom arrays. Data qubits are held stationary in a grid, while syndrome qubits are moved via acousto-optic deflectors (AODs). A greedy scheduler minimizes the routing cost (AOD channels and rearrangement time) required to align syndrome atoms with data atoms for CNOT gates.
Decoding: The codes are decoded using a GPU-accelerated Relay-Belief-Propagation (Relay-BP) algorithm.

Key Contributions

New Code Family (ZSZ-LP): Introduction of a family of qLDPC codes with design rate 1/5 and check weight 9, constructed over non-abelian ZSZ groups.
Finite-Length Performance: Demonstration that these codes achieve high memory efficiency ( $kd^2/n$ ) and low logical error rates (LER) with block lengths $n < 1000$ . Specifically, codes like ZSZ-LP-320 and ZSZ-LP-550 approach the gigaquop and teraquop regimes, respectively, at physical error rates of $p \le 0.1\%$ .
Theoretical Insights:
- Proof that abelian groups in this 5-block construction lead to low minimum distances, motivating the use of non-abelian groups.
- Derivation of upper bounds on Tanner girths and minimum distances for both classical and quantum variants.
- Identification of residual center automorphisms in the quantum codes, which are smaller than the full group symmetry but still useful.
Implementation Roadmap:
- Construction of explicit syndrome extraction schedules for reconfigurable atom arrays, with rearrangement times estimated at 30–60 ms per round.
- Demonstration of low-latency decoding (1–2 ms average) on modern GPUs, suggesting feasibility for real-time decoding in near-term architectures.
Classical Coding Advances: The classical seed codes (ZSZ-2BGA) are shown to have statistically higher minimum distances and better error-floor performance than standard (3, 6)-regular ensembles (like PEG or configuration models) under AWGN channels.

Results

Memory Efficiency: The $kd^2/n$ metric for ZSZ-LP codes significantly exceeds that of the surface code and is competitive with or superior to other high-rate qLDPC proposals (BB, GB, QC-LP) for block lengths $n < 1000$ .
Error Correction: Under idling-free circuit-level depolarizing noise ( $p=0.1\%$ ), the ZSZ-LP-550 code (550 data qubits, 440 ancilla qubits) achieves an extrapolated per-qubit-round LER of $\approx 7 \times 10^{-14}$ , potentially reaching the teraquop regime.
Thresholds: A pseudothreshold of approximately 0.5% is observed for the ZSZ-LP codes under the tested noise model.
Decoding Latency: GPU Relay-BP decoding achieves average latencies of 1–2 ms for codes up to 550 qubits, well within the timing constraints of neutral-atom and trapped-ion systems.
Surgery: The paper benchmarks graph-based and HGP surgery gadgets, showing that equivariant logical bases enable low-overhead measurement of logical operators.

Significance and Claims

The paper positions ZSZ-LP codes as a practical step toward realizing fault-tolerant quantum computers with constant spatial overhead in the near term. The authors claim that these codes are the first quantum LDPC codes with rate $\ge 10\%$ and under 1000 physical qubits to approach the gigaquop and teraquop memory regimes under idling-free circuit-level noise.

The work emphasizes a trade-off: by sacrificing the large automorphism groups found in abelian constructions (which facilitate easy transversal gates), the authors gain significantly improved finite-length distance and memory efficiency. The paper modestly notes that the code search is not exhaustive and that better instances may exist. It highlights that while the current construction requires more complex connectivity and rearrangement overhead compared to abelian analogues (like BB codes), the performance gains in memory efficiency and distance make them a compelling candidate for architectures with movable qubits. The authors conclude that these results advance the practicality of constant-rate qLDPC codes, providing a concrete path for near-term FTQC architectures, particularly those based on reconfigurable atom arrays.