⚛️ quantum physics

Check-weight-constrained quantum codes: Bounds and examples

This paper establishes strong analytical and numerical upper bounds on the parameters of quantum low-density parity-check codes with constrained check weights, demonstrating that weight-three stabilizer codes lack nontrivial distance while proving tight rate-distance tradeoffs for broader families of codes without relying on geometric locality assumptions.

Original authors: Lily Wang, Andy Zeyi Liu, Ray Li, Aleksander Kubica, Shouzhen Gu

Published 2026-01-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lily Wang, Andy Zeyi Liu, Ray Li, Aleksander Kubica, Shouzhen Gu

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 super-secure vault to protect a precious secret (your quantum information). To keep the vault safe, you need a team of guards (called checks) who constantly patrol the perimeter.

In the world of quantum computers, these guards have a specific job: they check for errors without looking directly at the secret itself (because looking at it would destroy it). However, there's a catch: these guards are tired and easily overwhelmed. If you ask a guard to watch over too many doors at once (a "high-weight" check), they might make mistakes or get confused by the noisy environment of the quantum hardware. So, engineers want to limit each guard to watching only a few doors at a time (a "low-weight" check).

This paper is like a group of architects and mathematicians asking: "If we force our guards to only watch a very small number of doors (say, 2, 3, or 4), how big and secure can our vault actually be?"

Here is what they discovered, broken down into simple concepts:

1. The "Too Small" Problem (Weight 3)

The researchers found that if you limit your guards to watching only 3 doors at a time, you hit a hard wall.

The Analogy: Imagine trying to build a fortress where every guard only patrols a tiny 3-door hallway. The paper proves that with such small patrols, you simply cannot build a fortress that is both large enough to hold a secret and strong enough to stop intruders.
The Result: If you force the checks to be weight 3, your vault either collapses (it can't store any secrets) or it's so weak that a single intruder can get in (the "distance" is at most 2). You can't have a useful quantum computer with this specific constraint.

2. The "Just Right" Limit (Weight 4)

When the guards are allowed to watch 4 doors at a time, things get interesting.

The Analogy: This is like the "Surface Code," a famous design that looks like a grid on a flat floor. The researchers showed that if you stick to weight-4 checks, your vault's security grows, but only slowly. To make the vault twice as secure, you have to make the building four times bigger.
The Result: There is a strict tradeoff. You can't have a massive, super-secure vault with weight-4 checks unless you are willing to use a huge number of physical qubits (the building blocks of the computer). The paper proves that for this specific weight, the relationship between size and security is mathematically locked.

3. The "Two-Door" Subsystem Codes

The paper also looked at a special type of vault called a "subsystem code," which is a bit more flexible. They asked: "What if guards only watch 2 doors?"

The Analogy: This is like having guards who only check if two specific doors are locked together.
The Result: Even with this flexibility, there is a hard limit. If the guards only watch 2 doors, the vault's security cannot grow faster than the square root of its size. If you want to double the security, you need to quadruple the size of the vault. The paper confirms that the best designs we already know for this scenario are actually the best we can possibly do.

4. The "Blueprint" Search (Finite Size)

So far, we've talked about theoretical, infinite-sized vaults. But real quantum computers today are small—they have maybe 50 to 100 qubits.

The Analogy: The researchers used a powerful computer program (Linear Programming) to act like a "blueprint optimizer." They asked the computer: "Given we have exactly 100 bricks and guards who can only watch 4 doors, what is the strongest vault we can build?"
The Result: They created a map (visualized in the paper's figures) showing the absolute best possible performance for small quantum computers. They found that:
- Allowing guards to watch slightly more doors (increasing the weight from 3 to 4 to 5) significantly improves the vault's strength.
- They found specific, real-world examples of vault designs that come very close to these theoretical limits.

The Big Takeaway

The paper draws a clear line in the sand for quantum engineers:

Weight 3 is a dead end for useful quantum computers.
Weight 4 and 5 offer a path forward, but there are strict mathematical limits on how much security you get for the size of your machine.
No "Magic" Shortcuts: You cannot bypass these limits just by arranging the qubits in a clever way or using special connections. The limit comes purely from the fact that the guards (checks) are only allowed to look at a few qubits at a time.

In short, if you want to build a quantum computer that can correct its own errors, you generally need to let your "guards" watch at least 4 or 5 qubits. If you force them to watch fewer, the math says your computer simply won't work well enough to be useful.

Title: Check-weight-constrained quantum codes: Bounds and examples

Problem Statement
Quantum low-density parity-check (qLDPC) codes are central to the development of noise-resilient quantum computers because they can be implemented by measuring only low-weight checks, which is compatible with current noisy quantum hardware. A fundamental open question is how constraints on the weight of these checks limit the achievable parameters (number of physical qubits $n$ , logical qubits $k$ , and distance $d$ ) of quantum codes. While asymptotically good qLDPC codes exist, their construction often relies on weight reduction techniques that may sacrifice parameters. Furthermore, existing bounds often assume geometric locality or specific graph connectivity. This work investigates the theoretical limits of stabilizer and subsystem codes under strict check-weight constraints without assuming geometric locality, bridging the gap between asymptotic theory and finite-size practical regimes (tens to hundreds of qubits).

Methodology
The authors employ a dual approach combining analytical proofs for asymptotic regimes and numerical optimization for finite-size codes:

Analytical Bounds: The paper derives asymptotic upper bounds on code parameters for stabilizer and subsystem codes with restricted check weights ( $w$ ).
- For stabilizer codes, the authors use a "minimal code" argument. They assume the existence of a code exceeding the proposed bounds and analyze the structure of its stabilizer generators (checks). By examining how checks overlap (coinciding or mismatching) and applying local Clifford rotations, they reduce general stabilizer codes to CSS codes or identify disentangled subsystems, leading to contradictions regarding the code's distance or dimension.
- For CSS codes with weight 4, they demonstrate that codes where each qubit is in exactly two X and two Z checks correspond to generalized surface codes (homological codes on a manifold). They leverage existing bounds on these surface codes to derive parameter constraints.
- For subsystem codes with weight 2, they establish a correspondence between the code parameters and the properties of an associated binary matrix $A$ . The code's distance and dimension are characterized by the row and column distances and rank of this matrix.
Numerical Bounds (Linear Programming): For finite-size codes, the authors formulate linear programming (LP) problems to find the maximum possible logical dimension $k$ for given $n$ , $d$ , and check weight $w$ .
- They utilize weight distributions (the number of stabilizers and logical operators of specific weights) as variables.
- Constraints include the MacWilliams identities (relating a code to its dual), the definition of distance (no nontrivial logical operators below weight $d$ ), and new constraints derived specifically from the check-weight limit (bounding the number of low-weight stabilizers generated by products of checks).
- They implement these LPs using Gurobi to compute upper bounds for $n$ up to 300.

Key Contributions and Results

Stabilizer Codes with Weight 3: The authors prove that any stabilizer code with check weight at most 3 cannot have a nontrivial distance greater than 2. Specifically, if the distance $d > 2$ , the code must have dimension $k=0$ (encoding no logical qubits). This holds regardless of the qubit degree.
CSS Stabilizer Codes with Weight 4: For CSS codes where each qubit participates in exactly two X and two Z checks, the authors prove the tradeoff $kd^2 = O(n)$ . This implies that such codes are essentially generalized surface codes.
Subsystem Codes with Weight 2: For CSS subsystem codes with check weight 2, the authors prove tight bounds: $d \le \sqrt{n}$ and $kd \le n$ . These bounds are saturated (up to constant factors) by existing constructions (e.g., Ref. [Bra11]), indicating that weight-2 checks cannot support asymptotically good subsystem codes.
Finite-Size Landscape: Using LP techniques, the authors provide numerical upper bounds on $k$ for codes with $n \le 300$ and check weights up to 20. They identify that higher check weights allow for better parameters.
Explicit Constructions: The paper identifies explicit code constructions (including quantum Tanner codes) that approach these numerical limits. The parity-check matrices for these finite instances are made available.

Significance
The paper establishes that check-weight constraints alone, independent of geometric locality or specific graph connectivity, impose severe limitations on quantum code parameters.

It rules out the possibility of nontrivial distance for stabilizer codes with weight-3 checks.
It clarifies the tradeoffs for weight-4 CSS stabilizer codes and weight-2 subsystem codes, showing that the best achievable parameters in these regimes are limited by surface-code-like scaling ( $kd^2 \sim n$ or $kd \sim n$ ).
It provides a rigorous framework for evaluating practical qLDPC codes in the finite-size regime (relevant for near-term experiments with tens or hundreds of qubits), delineating the theoretical ceiling for performance given specific hardware constraints on check weight.
The results distinguish themselves from prior work by not relying on assumptions of geometric locality, making the bounds applicable to general qLDPC codes, including those enabled by nonlocal interaction platforms like trapped ions or neutral atoms.

1. The "Too Small" Problem (Weight 3)

2. The "Just Right" Limit (Weight 4)

3. The "Two-Door" Subsystem Codes

4. The "Blueprint" Search (Finite Size)

The Big Takeaway

More like this