⚛️ quantum physics

High-Rate Quantum Codes with Proven Distance and Low-Weight Measurements

This paper introduces a family of high-rate quantum subsystem codes defined on rectangular grids that achieve proven dressed distances of 16, 32, and 64 with low-weight measurements and high encoding rates, while providing formal verification of their properties via Lean code.

Original authors: Kishor Bharti, Tobias Haug, Runzhou Tao, Kevin Ye

Published 2026-10-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kishor Bharti, Tobias Haug, Runzhou Tao, Kevin Ye

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 tension between protection and efficiency. Quantum information is incredibly fragile; the slightest disturbance can corrupt the data stored within. To guard against this, researchers use error-correcting codes that spread a single piece of information, called a logical qubit, across many physical particles. The strength of this protection is measured by the code's distance: the minimum number of physical errors required to go unnoticed and ruin the calculation. However, checking for these errors requires measuring the particles, and the act of measurement itself can introduce new errors. If the measurement involves too many particles at once, the risk of introducing a mistake grows. Therefore, the ideal quantum memory must protect a large amount of information while using measurements that touch as few particles as possible. This paper tackles the difficult math of finding the best balance between how much information can be stored, how well it is protected, and how simple the measurements need to be.

A team of researchers has discovered a new family of quantum codes that achieves a remarkably high storage capacity while keeping the measurements relatively light. They designed these codes on a grid-like structure, placing a quantum bit at every intersection of lines in a multi-dimensional space. The key innovation is how they check for errors. Instead of measuring complex groups of bits, they measure only the bits that lie along straight lines running through the grid. This approach allows them to prove, with absolute mathematical certainty, exactly how many errors the code can catch without needing to run computer simulations to guess the answer. The researchers showed that the strength of the protection depends entirely on the number of dimensions in the grid, while the amount of data stored and the size of the measurements depend on the length of the sides of the grid.

The team tested their design under a strict limit of ten thousand data bits, a realistic budget for near-future quantum machines. They found that by adjusting the grid's dimensions, they could create codes that protect thousands of logical bits. For instance, at a protection level where sixteen errors are needed to cause a failure, their design can store over four thousand logical bits using only ten-bit measurements. At higher protection levels, where thirty-two or sixty-four errors are required to break the code, the system still manages to store over one thousand and two hundred logical bits respectively, using measurements that touch only six bits at a time. These results are not just theoretical possibilities; the researchers provided a complete list of the best possible designs for these specific protection levels, showing exactly how many bits can be stored for any given measurement size.

What makes this work particularly significant is the rigorous proof behind the numbers. In many areas of quantum coding, scientists rely on computer searches to estimate how well a code works, but these searches can miss subtle flaws or fail to find the true limit. Here, the researchers used a formal method of mathematical verification, a process akin to a computer checking every single step of a logical argument to ensure no error exists. They proved that the distance of their codes is fixed by the geometry of the grid and cannot be improved or degraded by the specific choices made during the construction. This certainty allows engineers to select a code with confidence, knowing the exact trade-off between storage capacity and measurement complexity.

The study also reveals an interesting trade-off hidden within the design. While the measurements used to check for errors are light and touch only a few bits, the underlying mathematical rules that define the code's stability are much heavier. The researchers showed that any single rule that guarantees the code's integrity involves a large number of bits, far more than the individual measurements. This means that the system relies on the collective effect of many light measurements to enforce a heavy, robust structure. It is a bit like a suspension bridge: the individual cables holding the road are light and manageable, but together they create a massive, unyielding structure capable of holding immense weight. The researchers clarified that while the measurements are simple, the system still requires careful handling to ensure that errors in the measurement process do not spread to the data.

By mapping out the complete range of possibilities for these grid-based codes, the paper provides a clear roadmap for building efficient quantum memories. It demonstrates that high storage rates are achievable without sacrificing protection, provided the grid dimensions are chosen correctly. The work does not claim to have solved all the problems of building a quantum computer, such as how to handle the noise that occurs during the actual operation of the machine. However, it establishes a solid foundation of proven parameters, removing the guesswork from the initial design phase. For engineers looking to build the next generation of quantum devices, this work offers a set of precise, verified blueprints that maximize the amount of usable information while keeping the physical requirements of the error-checking process within manageable limits.

Technical Summary: High-Rate Quantum Codes with Proven Distance and Low-Weight Measurements

Problem Statement
The paper addresses the fundamental tradeoff in quantum error correction between three critical parameters: the encoding rate (number of protected logical qubits relative to data qubits), the code distance (minimum weight of an undetectable logical error), and the measurement weight (the number of data qubits touched by a single measured operator). While subsystem codes offer a mechanism to replace heavy stabilizer measurements with lighter, non-commuting gauge measurements, determining the exact distance of such codes—specifically the "dressed" distance, which accounts for multiplication by gauge operators—often requires numerical searches or lacks rigorous proofs for general families. The authors seek a construction that provides explicit, proven parameters for high-rate codes with low-weight measurements on rectangular grids.

Methodology
The authors study a family of quantum subsystem codes, denoted RLG( $q_1, \dots, q_L$ ), defined on rectangular coordinate grids of dimension $L$ with even side lengths $q_i \ge 4$ .

Construction: The code is defined by measuring "coordinate-line" gauge operators. For each axis $i$ , operators acting as $X$ or $Z$ along every line parallel to that axis are included in the gauge group.
Algebraic Framework: The analysis utilizes the binary symplectic description of Pauli operators. The code is of Calderbank–Shor–Steane (CSS) type, where the gauge group is generated by pure $X$ and pure $Z$ operators. The authors employ tensor-product calculations over $\mathbb{F}_2$ to determine the ranks of the gauge and stabilizer groups.
Formal Verification: A significant portion of the methodology involves formal verification using Lean, an interactive theorem prover. The authors provide Lean modules (e.g., RLG.lean, GridLines.lean) that define the code structure and formally prove the distance lower bounds via induction on the number of axes. This approach avoids numerical distance searches for the general case.
Optimization: For a fixed data-qubit budget (specifically $N \le 10,000$ ), the authors perform an exact finite enumeration of even rectangular tuples to identify the Pareto frontier between encoding rate and maximum measurement weight for specific distances ( $D=16, 32, 64$ ).

Key Contributions

Exact Parameter Formulas: The paper derives closed-form expressions for the number of data qubits ( $N$ $N$ ), protected logical qubits ( $K$ $K$ ), gauge qubits ( $g$ $g$ ), and dressed distance ( $D$ $D$ ) for any valid tuple of side lengths:
- $N = \prod q_i$
- $K = \prod (q_i - 2)$
- $D = 2^L$ (where $L$ is the number of axes)
- The maximum measurement weight is $w = \max_i q_i$ .
Proven Dressed Distance: Unlike many subsystem code analyses that rely on heuristics or numerical checks, this work provides a rigorous proof that the dressed distance is exactly $2^L$ . The proof demonstrates that any non-trivial logical operator (even after multiplying by gauge operators) must have a support size of at least $2^L$ .
Bare vs. Dressed Distance: The authors prove that for this family, the bare distance (minimum weight of a logical operator commuting with all gauges) is also $2^L$ , matching the dressed distance.
Stabilizer Weight Analysis: The paper establishes that while the measured gauge operators have low weight ( $w$ ), the non-identity stabilizers (which are products of gauge lines) have a minimum weight of $2^{L-1} \min_i q_i$ . This highlights that gauge freedom reduces the weight of directly measured operators but does not eliminate the heavy stabilizer constraints inherent to the code's structure.
Finite Optimization Results: Under a budget of 10,000 data qubits, the authors identify the optimal code configurations:
- Distance 16: A code with 10,000 data qubits protects 4,096 logical qubits ( $K/N \approx 41\%$ ) using weight-10 measurements.
- Distance 32: A code with 7,776 data qubits protects 1,024 logical qubits ( $K/N \approx 13.2\%$ ) using weight-6 measurements.
- Distance 64: A code with 9,216 data qubits protects 256 logical qubits ( $K/N \approx 2.8\%$ ) using weight-6 measurements.

Results and Claims
The paper claims to provide a "complete tradeoff" between encoding rate and measurement weight for this specific family of codes at distances 16, 32, and 64. The results show that high rates are achievable at moderate distances (e.g., $D=16$ ) with relatively low measurement weights. However, as distance increases, the rate drops significantly, and the number of axes ( $L$ ) must increase, which inherently increases the distance ( $D=2^L$ ) but reduces the rate for a fixed $N$ .

The authors explicitly state that these results concern the static parameters of the code family. They do not claim to establish fault-tolerant circuit distance, logical error rates, or specific decoding performance under circuit-level noise. The paper notes that while the construction extends "many-hypercube" codes, it treats all even rectangular tuples in a unified algebraic description, allowing for mixed side lengths which were previously less explored.

Significance
The significance of the work lies in its ability to separate the choice of distance from the remaining finite optimization problem. By proving that distance depends only on the number of axes ( $L$ ) while rate and measurement weight depend on the side lengths ( $q_i$ ), the authors provide a clear design space for selecting codes based on hardware constraints (measurement weight) and logical requirements (distance and rate).

The paper emphasizes that the "gauge freedom" allows information carried by heavy stabilizers to be accessed via lighter measurements, but it also clarifies the cost: the stabilizer constraints themselves remain heavy (weight $\ge 2^{L-1} \min q_i$ ). Consequently, the authors note that this family is not a conventional Quantum Low-Density Parity-Check (QLDPC) stabilizer family in the asymptotic sense (constant rate and linear distance with bounded weights), but rather a family offering exact finite parameters and a specific optimization landscape. The inclusion of Lean formalization ensures that the distance proofs are machine-checked, providing a high degree of rigor for the claimed parameters without relying on numerical search.

Technical Summary: High-Rate Quantum Codes with Proven Distance and Low-Weight Measurements

More like this