⚛️ quantum physics

Heuristic Search for Minimum-Distance Upper-Bound Witnesses in Quantum APM-LDPC Codes

This paper presents a unified heuristic framework for constructing and certifying low-weight non-stabilizer logical operators in affine-permutation-matrix-based quantum LDPC codes, thereby establishing rigorous upper bounds on their minimum distance.

Original authors: Kenta Kasai

Published 2026-04-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kenta Kasai

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 building a digital fortress designed to protect secret messages from the chaos of the universe (noise). In the world of quantum computing, this fortress is called a Quantum Error-Correcting Code.

The size of the "moat" around your fortress is called the Minimum Distance.

Small moat: A tiny mistake (like a single flipped bit) can break the whole code.
Large moat: The code can survive many mistakes before the secret is lost.

The big question in this field is: "How big is the moat?"

Usually, mathematicians try to prove, "The moat is at least this big" (a lower bound). But this paper takes a different, more detective-like approach. Instead of trying to prove the moat is huge, the author, Kenta Kasai, asks: "Can we find a tiny hole in the wall?"

If he finds a hole, he can say, "The moat is at most this big." This is called an Upper Bound. If you find a hole, you know the fortress isn't as strong as you hoped.

Here is how the paper works, broken down into simple analogies:

1. The Blueprint: The "Affine Permutation" (APM)

The author is studying a specific type of blueprint for these fortresses called APM-LDPC codes.

Think of the blueprint as a giant grid of switches.
Some switches are Active (they do the real work of protecting the data).
Some switches are Latent (they are hidden in the background, like spare parts in a warehouse).

The paper focuses on a specific rule for building these grids: they must be "girth-8." Imagine the grid as a city map. "Girth-8" means the smallest loop you can walk in the city has 8 blocks. This prevents short, confusing shortcuts that usually cause errors.

2. The Detective Work: Finding the "Holes"

The author doesn't just guess where the holes are. He uses a Heuristic Search.

The Analogy: Imagine you are looking for a leak in a massive dam. You can't check every single inch of concrete. Instead, you use a metal detector (the search algorithm) to scan for "weird signals."
When the detector beeps, you don't just assume it's a leak. You go there, dig a hole, and verify it.
The Verification: The paper insists on two strict tests before claiming a hole exists:
1. The Kernel Test: Does this "leak" actually let water through? (Mathematically: Does it satisfy the parity checks?)
2. The Stabilizer Test: Is this leak just a known, harmless crack that we already fixed? (Mathematically: Is it outside the "stabilizer row space"?)

Only if a candidate passes both tests does the author say, "Aha! The moat is no bigger than this weight."

3. The Four Ways to Find Holes

The paper describes four different "search strategies" to find these leaks:

The "Latent" Search (The Warehouse):
The author looks in the "spare parts" section (the latent rows). Sometimes, the spare parts accidentally form a pattern that creates a hole. The paper finds a specific pattern here that creates a hole of size 48 (for one code).
The "Restricted Lift" (The Zoom Lens):
Imagine the fortress is huge. Instead of looking at the whole thing, the author uses a "compression" trick.
- Block-Compression: He shrinks the fortress by grouping 4 blocks into 1. If he finds a hole in the shrunken version, he knows there's a hole in the big one (just 4 times bigger).
- Fiber-Quotient: He only looks at specific "stripes" of the fortress, ignoring the rest.
- CRT-Stripe: He uses a mathematical trick (Chinese Remainder Theorem) to look at the fortress through a specific "lens" that reveals hidden patterns.
- Result: By using these zoom lenses, he found a hole of size 24 in one code, which is much smaller (and worse for the fortress) than the latent search found.
The "Cycle-8" Search (The Loop):
Since the city map has no loops smaller than 8 blocks, the author looks for patterns made of connected 8-block loops. He found a specific arrangement of 10 blocks that forms a perfect leak. This is the smallest hole found so far (size 10).
The "Decoder Failure" (The Simulation):
The author simulates a storm (random noise) and tries to fix the damage with a robot (a decoder). Sometimes the robot fails and leaves a "residual" mess. If that mess is a valid hole, it counts. He found a residual of size 10.

4. The Big Picture: Why This Matters

In the past, people hoped these quantum codes had a "super-moat" that would grow infinitely large as the code got bigger.

This paper says: "Hold on. We found holes of size 10, 24, and 48."

The Good News: The author has provided certified proof that the moat is at most these sizes. This is a solid, mathematical fact. No more guessing.
The Bad News: It suggests the moat might not be as deep as we hoped. It might be "plateauing" (stopping growing) around a small number like 30.

Summary

Think of this paper as a building inspector for quantum computers.

Instead of trying to prove the building is a skyscraper (which is hard), the inspector walks around with a tape measure.
He finds a crack in the foundation (a low-weight logical operator).
He measures the crack, double-checks that it's a real crack and not a scratch, and writes it down.
He says, "This building is at most 10 stories tall, because here is a hole on the 10th floor."

The paper updates the "height limit" for several famous quantum codes, showing that while they are clever, they have specific, measurable weaknesses that we now know exactly how big they are. This helps engineers know exactly how much protection they need to add to make these codes safe for real-world use.

1. Problem Statement

The paper addresses the challenge of evaluating the minimum distance ( $d$ ) of a specific family of quantum Low-Density Parity-Check (LDPC) codes constructed from Affine Permutation Matrices (APM). These are Calderbank-Shor-Steane (CSS) codes where the parity-check matrices are derived from affine permutations.

The Gap: While lower bounds (guaranteeing error correction capability) are often difficult to prove for these specific constructions, establishing upper bounds is crucial to determine the actual limit of the code's performance.
The Challenge: Finding the exact minimum distance is computationally hard. The paper focuses on finding certified upper bounds by explicitly constructing low-weight logical operators (witnesses) that are:
1. In the kernel of the opposite parity-check matrix (satisfying the syndrome condition).
2. Outside the row space of the stabilizer matrix (ensuring they are non-trivial logical operators).
Context: The codes considered have active Tanner graphs with girth 8. The construction relies on a specific split between "active" rows (used for the stabilizer) and "latent" rows (which may contain low-weight logical representatives).

2. Methodology

The author proposes a unified framework that combines mathematical certification with heuristic search. The core philosophy is that search algorithms are used only to generate candidate vectors; the final upper-bound claim is valid only after the candidates pass rigorous algebraic tests.

A. Theoretical Framework

The paper defines a decomposition of the code distance into two components:

Latent Distance ( $d^{(lat)}$ ): Logical operators contained within the row space of the "latent" (unused in the stabilizer) matrices.
Non-Latent Distance ( $d^{(nlat)}$ ): Logical operators outside the latent row spaces.

The total distance is $d = \min(d^{(lat)}, d^{(nlat)})$ . The paper provides sufficient conditions for vectors in specific subspaces to be valid logical representatives.

B. Search and Verification Strategies

The paper categorizes upper-bound methods into several distinct classes, each with a specific search space and verification protocol:

Latent Upper Bounds:
- Method: Search for coefficient vectors $\lambda$ in the kernel of the mixed product of active and latent matrices ( $H_Z \tilde{H}_X^T \lambda = 0$ ).
- Certification: If $\lambda^T \tilde{H}_X$ is not in the stabilizer row space, it is a valid witness.
- Exactness: The paper provides a criterion (via block-constant compression) under which the latent lower bound matches the upper bound, making the latent distance certification exact.
Restricted-Lift Upper Bounds:
These methods restrict the search to specific subspaces to reduce complexity, then lift the results back to the full code length.
- Block-Compression (Full-Fiber): Assumes the solution is constant on blocks of size $m$ . The problem is reduced to a quotient code of length $P/m$ .
- Fiber-Quotient (Selected-Fiber): A generalization where the lift is restricted to a subset of fibers (selected indices), allowing for more flexible, lower-weight candidates.
- CRT-Stripe: Utilizes the Chinese Remainder Theorem to define a stripe subspace based on coprime factors of the block size $P$ .
Direct and Structural Methods:
- Direct CSS Search: Heuristic search directly in the kernel of the parity-check matrix without structural constraints, followed by row-space exclusion.
- Cycle-8 ETS (Elementary Trapping Sets): Constructs candidates by connecting 8-cycles in the Tanner graph. If the "odd-check boundary" is empty, the support vector is in the kernel.
- Decoder-Failure Residuals: Uses residuals ( $\Delta = e + \hat{e}$ ) from failed decoding simulations. If the residual is pure X or Z and non-stabilizer, it serves as a witness.

3. Key Contributions

Unified Certification Framework: The paper establishes a rigorous protocol where search is decoupled from proof. Candidates are generated heuristically, but the final bound is mathematically certified via kernel and row-space exclusion tests.
Exact Latent Certification: It introduces a rank-test (using block-constant compression) that allows for exact determination of the latent distance component, rather than just an upper bound, for specific parameter sets.
New Upper Bound Methods: The introduction of Fiber-Quotient and CRT-Stripe restricted lifts provides new avenues to find lower-weight logical operators that standard block-compression might miss.
Refined Bounds for APM-LDPC Codes: The paper updates the known upper bounds for the family of APM-LDPC codes proposed in previous work (e.g., [20]), providing concrete, verified values for codes with block lengths up to $n=9216$ ( $P=768$ ).

4. Results

The paper applies these methods to a representative set of codes ( $C_1$ through $C_{10}$ ) with block sizes $P$ ranging from 216 to 768.

Sharpened Bounds: The methods successfully identified logical operators with weights significantly lower than previously reported bounds.
- Example: For code C9 ( $P=768$ ), the previous bound was $d \le 48$ . The Selected-Fiber method found a witness with weight 24, and the Block-Compression method found one with weight 32.
- Example: For code C1 ( $P=216$ ), the Cycle-8 ETS method found a witness of weight 10, and the Decoder-Failure method found a Z-type witness of weight 10.
Asymptotic Observation: The data suggests that the best recorded upper bounds grow roughly linearly with the blocklength in the explored range. However, the author cautions that this is not a proof of asymptotic growth, as the computational difficulty of finding witnesses increases with block length.
Latent Exactness: For the $P=768$ code, the latent distance was certified exactly as $d^{(lat)} = 48$ using the block-constant kernel hypothesis. The improvement to $d \le 24$ came entirely from the non-latent (restricted-lift) searches.

5. Significance

Practical Impact: By providing concrete, certified upper bounds, the paper helps engineers and theorists understand the true limitations of APM-LDPC codes. If the minimum distance is low, these codes may not be suitable for high-reliability quantum memory or communication, regardless of their excellent decoding thresholds.
Methodological Advancement: The separation of "search" from "verification" offers a robust template for analyzing other quantum code families where exact distance calculation is intractable.
Clarification of Code Structure: The paper clarifies the role of the "latent" space in APM constructions. It demonstrates that while the active part ensures orthogonality, the latent part is a primary source of low-weight logical errors, and that specific algebraic structures (like block-constant kernels) can be exploited to certify these distances exactly.
Resource for Future Work: The supplementary website mentioned in the paper serves as a living database of the best-known upper bounds, acting as a benchmark for future code constructions and decoding algorithm development.

In summary, this paper does not prove a general lower bound for the minimum distance of APM-LDPC codes. Instead, it provides a powerful, systematic toolkit to disprove high-distance claims by finding explicit, certified low-weight logical operators, thereby tightening the known performance limits of this promising family of quantum codes.