🔢 mathematics

Entanglement-assisted Quasi-cyclic Quantum Low-density Parity-check Codes over Qubits

This paper presents scalable families of entanglement-assisted quasi-cyclic quantum LDPC codes constructed via structured permutation matrix tilings that achieve high error-correction performance against both random and burst errors using a resource-efficient single Bell pair and an improved quaternary block-layered normalized min-sum decoder.

Original authors: Pavan Kumar, Abhi Kumar Sharma, Karthik Bharadwaj, Shayan Srinivasa Garani

Published 2026-07-28

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Pavan Kumar, Abhi Kumar Sharma, Karthik Bharadwaj, Shayan Srinivasa Garani

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 send a secret message across a stormy ocean. In the world of quantum computing, this "ocean" is the fragile state of a qubit, and the "storm" is noise that can scramble your information in an instant. To survive this, scientists use Quantum Error Correcting Codes. Think of these codes as a magical safety net: they spread your single piece of information across many physical particles (qubits) so that if a few get knocked out by the storm, the original message can still be reconstructed.

However, building this safety net is tricky. Traditional methods often require checking the particles against each other in complex ways, which can accidentally create "shortcuts" or loops in the logic. These shortcuts are like traffic jams in a city; they confuse the system and make it harder to fix errors. To solve this, researchers sometimes use entanglement, a spooky quantum connection where two particles act as one, even when far apart. It's like having a trusted friend on the other side of the ocean holding half of a secret key; if you lose your half, they can help you reconstruct it. This paper dives into how to build these nets more efficiently, making them faster, stronger, and less likely to get confused by the storm.

The Paper's Big Idea: Building Better Quantum Safety Nets

This paper introduces a new way to build Entanglement-Assisted Quasi-Cyclic Quantum Low-Density Parity-Check (EA-QC-QLDPC) codes. If that sounds like a mouthful, think of it as a blueprint for constructing a super-efficient, loop-free safety net for quantum information. The authors, a team from the Indian Institute of Science, propose several families of these codes by arranging "permutation matrices" (which are just fancy grids of numbers) in a structured, tiled pattern, much like laying down floor tiles in a bathroom.

The main problem they are tackling is the existence of 4-cycles. In the mathematical map (called a Tanner graph) that the computer uses to find errors, a 4-cycle is a tiny, closed loop of four connections. These loops are bad news because they confuse the decoder, making it think there's an error when there isn't, or missing an error that is actually there. The paper shows that by using two different classical codes to build their quantum code, they can completely eliminate these 4-cycles from the part of the system that doesn't rely on entanglement. It's like redesigning a city's road network to ensure there are no tiny, confusing roundabouts that cause traffic jams.

One of the most exciting findings is that one of their new code families is incredibly resource-efficient. It requires only a single shared Bell pair (one entangled link) between the sender and receiver. This is a huge deal because entangled pairs are expensive and hard to maintain; needing just one makes the system much more practical.

How They Did It: The Construction and The Decoder

The authors didn't just dream up these codes; they built them using specific mathematical recipes.

Tiling the Matrices: They used "tiling" techniques with permutation matrices of both prime and composite orders. Imagine taking a specific pattern and repeating it over and over to cover a large area. This structure allows the codes to be scalable and easier to implement in hardware.
Girth Matters: They also created codes where the "girth" (the length of the shortest loop in the map) is greater than 6. In the world of error correction, a larger girth is like having a wider, clearer road with no dead ends, which helps the decoder figure out the truth much faster.
The Decoder Upgrade: Perhaps just as important as the code itself is how they read it. The paper tests different "decoders" (the software that figures out what went wrong). They found that a Quaternary Block-Layered Normalized Min-Sum (QBLNMS) decoder works best.
- Analogy: A standard binary decoder looks at errors one by one, like checking if a light switch is "on" or "off." But in quantum physics, errors can be a mix of things happening at once (like a light switch that is flickering, dim, or buzzing). A quaternary decoder looks at all these possibilities together as a single unit. The "block-layered" part means it processes the information in chunks, updating its understanding immediately as it goes, rather than waiting for a full round to finish. This is like a detective who updates their theory of the crime as soon as they find a new clue, rather than waiting until they've looked at every single piece of evidence before making a guess.

What the Simulations Showed

The authors ran extensive computer simulations to see how these new codes perform under different types of "storms" (noise models).

Random vs. Burst Errors: They tested the codes against random errors (like raindrops hitting randomly) and burst errors (like a sudden, massive wave hitting a whole section of the net at once). The results showed that their codes are excellent at handling both.
The Performance Gap: When compared to older codes, the new EA-QC-QLDPC codes showed a massive improvement. In some cases, the error rate dropped by more than two orders of magnitude (meaning if the old code failed 100 times, the new one failed less than once).
The Role of Entanglement: Even though the new codes sometimes use more entangled pairs than older designs, they transmit more actual information (higher coding rate) and still perform better. It's a win-win: you get more data through with fewer mistakes.
The Decoder Wins: The simulations confirmed that the QBLNMS decoder was the star of the show, outperforming older binary decoders by nearly an order of magnitude. This suggests that treating quantum errors as a single, correlated entity (quaternary) rather than separate parts (binary) is the key to unlocking better performance.

The Bottom Line

This paper doesn't just suggest a theoretical idea; it provides concrete constructions, efficient encoding schemes (how to put the data into the net), and decoding algorithms (how to read it out). The authors demonstrate that by carefully designing the structure of the code to avoid confusing loops and by using a smarter, quaternary-based decoder, we can build quantum communication systems that are significantly more robust against noise.

While the results are currently based on simulations and mathematical proofs, the findings are strong enough to suggest that these codes could be the blueprint for future, practical quantum computers and communication networks. The work highlights that with the right mathematical "tiles" and a smart "decoder," we can build safety nets that are not only strong but also efficient enough to be used in the real world.

Technical Summary: Entanglement-assisted Quasi-cyclic Quantum Low-density Parity-check Codes over Qubits

1. Problem Statement

Quantum information is inherently susceptible to decoherence and gate faults, necessitating Quantum Error Correcting Codes (QECCs). While classical Low-Density Parity-Check (LDPC) codes offer near-capacity performance and efficient decoding, their quantum counterparts (QLDPC) face significant challenges. Specifically, standard constructions based on the Calderbank-Shor-Steane (CSS) framework often require the dual-containment property, which inevitably introduces 4-cycles into the joint Tanner graph. These short cycles degrade decoding performance, particularly under correlated $X$ and $Z$ errors, leading to high error floors. Furthermore, existing Entanglement-Assisted (EA) quantum codes often lack structured designs that eliminate these short cycles in the "entanglement-unassisted" portion of the graph, or they rely on unstructured encoders with prohibitive computational complexity for large block lengths.

2. Methodology

The authors propose a structured approach to constructing Entanglement-Assisted Quasi-Cyclic Quantum LDPC (EA-QC-QLDPC) codes using tiling of permutation matrices. The methodology is divided into three core components:

A. Code Construction

The paper constructs several families of EA-QC-QLDPC codes using two distinct strategies:

Two-Distinct-Classical-Codes Approach: By selecting two different classical QC-LDPC codes ( $C_1$ and $C_2$ ) derived from permutation matrices of prime and composite orders, the authors construct EA codes where the entanglement-unassisted portion of the joint Tanner graph is free of 4-cycles. This is achieved by ensuring the degree matrices of the underlying classical codes satisfy specific difference conditions (Proposition 1). Notably, one family requires only a single shared Bell pair (ebit) between transmitter and receiver.
Single-Classical-Codes Approach: The authors also construct families derived from a single classical QC-LDPC code. In these constructions, the underlying classical code is designed to have a girth greater than 6, ensuring the resulting quantum code's Tanner graph has a girth greater than 6.

The constructions utilize degree matrices populated via specific algorithms (Algorithms 1 and 2) to guarantee the absence of short cycles (4-cycles and 6-cycles) and to analytically determine code parameters such as rank, dimension, and the number of required ebits ( $c$ ).

B. Efficient Encoding Scheme

To address the complexity of encoding, the paper proposes a structured encoding algorithm tailored to the quasi-cyclic nature of the stabilizer generators.

Procedure: The method involves transforming the extended parity-check matrices ( $H_{ex}$ and $H_{ez}$ ) into row-reduced echelon forms (RREF) using Gaussian elimination.
Gate Complexity: The authors derive an encoding circuit composed of Clifford gates (CNOT, Hadamard, Phase). The gate complexity is analytically determined to be $O(n(\rho_1 + \rho_2) - \rho_1^2)$ , where $n$ is the code length and $\rho_1, \rho_2$ are the number of stabilizer generators for $H_x$ and $H_z$ . This represents an improvement over general stabilizer-based encoders which typically have $O(n(\rho_1 + \rho_2))$ complexity.
Architecture: The scheme supports both one-way communication (consuming Bell pairs) and two-way catalytic communication (recycling Bell pairs), as well as applications in quantum computing where EPR pairs are part of the payload.

C. Decoding Strategy

The paper evaluates performance using four decoder configurations, emphasizing the handling of correlated errors:

Binary Layered Sum-Product (BLSP): Treats $X$ and $Z$ errors independently on separate Tanner graphs.
Quaternary Min-Sum (QMS) and Normalized Min-Sum (QNMS): Operates on a joint Tanner graph over $\mathbb{F}_4$ , treating the $Y$ error as a single entity to capture correlations.
Quaternary Block-Layered Normalized Min-Sum (QBLNMS): The proposed optimal decoder. It combines quaternary processing with block-layered scheduling and syndrome-driven adaptation of normalization ( $\alpha$ ) and damping ( $\beta$ ) parameters. This approach accelerates convergence and mitigates oscillations, making it suitable for hardware implementation.

3. Key Contributions

Cycle-Free Constructions: The paper presents the first families of EA-QC-QLDPC codes where the entanglement-unassisted portion of the joint Tanner graph is explicitly free of 4-cycles when constructed from two distinct classical codes.
Resource Efficiency: One proposed family achieves these properties with only a single pre-shared Bell pair, highlighting high resource efficiency.
High-Girth Codes: Two families are derived from single classical codes with girth $>6$ , further enhancing error-correcting capabilities.
Analytical Parameter Derivation: Exact code rates and parameters (dimension, number of ebits) are analytically derived for the proposed constructions.
Efficient Encoding: A low-complexity encoding scheme is developed, reducing gate complexity compared to existing general methods.
Advanced Decoding: The proposal and simulation of the QBLNMS decoder, which demonstrates superior performance in handling correlated Pauli errors compared to binary decoders.

4. Simulation Results

The performance of the proposed codes was assessed under random depolarizing noise and Markovian burst error models.

Decoder Performance: The QBLNMS decoder consistently outperformed the BLSP and other quaternary variants. Specifically, it showed nearly a one-order-of-magnitude improvement over the BLSP decoder on depolarizing channels.
Comparison with Prior Works:
- Compared to the $[[42, 4]]_2$ CSS code [27], the proposed $[[42, 10; 6]]_2$ code (with 4-cycle-free unassisted graph) achieved more than two orders of magnitude improvement in Logical Error Rate (LER) at $p_d = 10^{-3}$ .
- Compared to the $[[128, 58; 18]]_2$ EA code [40], the proposed $[[121, 70; 51]]_2$ code (higher rate and column weight) showed more than one order of magnitude improvement at $p_d = 10^{-2}$ .
Impact of Girth and Weight: Codes with girth $>6$ outperformed those with girth $>4$ despite shorter block lengths. Increasing column weight (from 3 to 8) significantly improved error correction performance, albeit at the cost of code rate.
Burst Error Correction: The codes demonstrated the ability to correct a constant number of burst errors, with performance improving as the permutation matrix size increased.

5. Significance and Claims

The authors claim that their work provides a scalable and practical blueprint for quantum communication and computing systems. The significance lies in:

Mitigating Correlated Errors: By eliminating 4-cycles in the unassisted portion of the Tanner graph and utilizing quaternary decoding, the codes effectively handle correlated $X$ and $Z$ errors, a known weakness of standard CSS codes.
Hardware Feasibility: The quasi-cyclic structure and the proposed efficient encoding/decoding architectures (including the QBLNMS hardware layout) make these codes amenable to hardware implementation, addressing the parallelization and sparsity challenges of quantum LDPC codes.
Resource Optimization: The ability to construct high-performance codes with minimal entanglement resources (e.g., single ebit) or to recycle them in catalytic modes makes the approach viable for near-term quantum networks.
Performance Gains: The simulation results demonstrate that these structured constructions significantly outperform existing benchmarks in terms of Logical Error Rate, offering a path toward more robust quantum information processing.

The paper concludes that these constructions are not only theoretically sound but also practically relevant, offering a systematic approach to designing quantum codes that balance rate, complexity, and error correction performance.