⚛️ quantum physics

Quantum Block Turbo Codes

This paper introduces the theory of quantum block turbo codes as the quantum analog of classical turbo product codes, detailing their iterative decoding algorithm and evaluating their performance on a depolarizing channel through simulations.

Original authors: Khaled Jebari, Luiz Anet Neto, Ramesh Pyndiah, Jean-Louis de Bougrenet de la Tocnaye

Published 2026-09-01

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Khaled Jebari, Luiz Anet Neto, Ramesh Pyndiah, Jean-Louis de Bougrenet de la Tocnaye

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 fragile world of quantum computing, information is stored in states that are incredibly sensitive to their surroundings. Unlike the stable bits in a standard laptop, these quantum bits, or qubits, can easily lose their data through a process called decoherence or through simple manipulation errors. To build a machine capable of solving problems that are currently impossible, scientists must protect this delicate information. They do this by spreading a single piece of data across many physical particles, creating a safety net known as an error-correcting code. If one particle gets corrupted, the system can detect the mistake and fix it without destroying the information it holds. For decades, researchers have relied on classical methods to design these safety nets, but the unique rules of quantum physics require a different approach. One promising strategy involves using "stabilizer codes," which act like a set of rules that the quantum state must follow, allowing scientists to check for errors without looking directly at the data and collapsing it.

Building on this foundation, a team of researchers has introduced a new method called Quantum Block Turbo Codes. This approach takes inspiration from a successful technique used in classical communication known as turbo codes, which revolutionized how data is sent over noisy channels by using an iterative process to refine error corrections. The researchers adapted this idea for the quantum realm, creating a system that arranges qubits in a two-dimensional grid. Instead of checking for errors just once, the system checks the rows and then the columns, feeding the results of one check into the next in a continuous loop. This back-and-forth exchange of information allows the system to gradually improve its understanding of where errors have occurred, much like solving a complex puzzle by repeatedly checking different angles until the picture becomes clear.

The team demonstrated how this system works by simulating its performance on a computer, testing it against a common type of quantum noise where errors happen randomly. They began with a simple setup using small building blocks, specifically a five-qubit code, arranged in a grid to form a larger code. In these initial tests, the new method showed a significant advantage over older techniques that simply looked for the most likely single error. When the researchers increased the complexity by using larger building blocks that could hold more information, the system began to show a distinct "turbo effect." This means that with each round of checking and correcting, the accuracy improved dramatically. After five rounds of this iterative process, the system reduced the chance of a failure to a level as low as six in ten million for a specific error rate, a performance that rivals or exceeds other leading quantum error-correcting methods while using fewer physical resources.

What makes this discovery particularly notable is its flexibility. The researchers showed that they could mix and match different types of small quantum codes to build larger systems, allowing them to balance the amount of data stored against the number of physical particles required. This is a crucial distinction because many current quantum codes require a massive number of physical particles to protect just a few pieces of data, making them expensive and difficult to build. The new method manages to maintain high performance with a more efficient use of space. The simulations suggest that by stacking these blocks together, scientists could create systems capable of handling thousands of logical qubits with a manageable number of physical components. The researchers also noted that this structure could potentially be expanded into three dimensions or combined with other advanced techniques to further boost performance, though these more complex versions remain to be tested.

The work presented is a simulation, meaning the results were generated by mathematical models running on classical computers rather than on a physical quantum machine. However, the underlying logic relies on well-established principles of quantum mechanics and coding theory. The researchers confirmed that their method works by comparing their results against known theoretical limits and other established decoding strategies. They found that while some specialized codes perform better under very specific conditions, their new approach offers a robust and versatile alternative that performs well across a broad range of error scenarios. By proving that this iterative, grid-based approach can effectively correct errors in a simulated environment, the study provides a strong blueprint for future hardware designs. It suggests that the path to reliable quantum computing may not require a single, perfect code, but rather a flexible framework that can adapt and refine its own corrections through repeated, intelligent checks.

Technical Summary: Quantum Block Turbo Codes

Problem Statement

Quantum error correction (QEC) is a fundamental prerequisite for scalable quantum computation, yet it faces unique challenges compared to classical error correction. Quantum states are fragile and susceptible to decoherence, requiring codes that can correct errors without collapsing the encoded state. While surface codes offer high error thresholds, they suffer from asymptotically vanishing code rates and high overhead ( $O(d^2)$ per logical qubit). Conversely, quantum LDPC (qLDPC) codes promise constant code rates and better scalability but often face complex decoding challenges and non-local connectivity constraints.

Furthermore, classical error correction was revolutionized in the 1990s by Turbo Codes, which utilize iterative decoding of concatenated codes (convolutional or product codes) to approach the Shannon limit. While Quantum Serial Turbo Codes (based on convolutional codes) have been explored, a formal theory for Quantum Block Turbo Codes (QBTC)—the quantum analog of Pyndiah's classical Block Turbo Codes (BTC)—has been lacking. The challenge lies in adapting the iterative, soft-information exchange mechanism of classical BTCs to the quantum domain, which must account for degeneracy (where different physical errors produce the same syndrome) and the inability to directly observe the received quantum state.

Methodology

The authors propose a framework for QBTCs, defined as product codes constructed from two constituent stabilizer codes, $C_1$ and $C_2$ , with parameters $(n_1, k_1)$ and $(n_2, k_2)$ .

1. Encoding Structure

Unlike classical product codes where rows and columns form independent codewords, quantum stabilizer codes impose constraints: row and column stabilizers may anticommute. The authors address this by establishing a specific encoding/decoding order:

Encoding: $k_1$ rows of logical qubits are encoded using constituent code $C_2$ . The resulting matrix is transposed, and the $n_2$ columns are encoded using constituent code $C_1$ .
Constraint: If encoding proceeds row-then-column, decoding must proceed column-then-row to respect the stabilizer commutation relations.

2. Iterative Decoding Algorithm

The core of the QBTC framework is an iterative Soft-Input Soft-Output (SISO) decoding scheme that exchanges probabilistic information between row and column decoders.

SISO Units: The decoding involves "Inner" (column) and "Outer" (row) SISO blocks. Each block takes syndromes and prior probabilities as input and outputs updated logical and physical error probabilities.
Degeneracy Handling: The algorithm explicitly accounts for degeneracy by summing probabilities over all physical error sequences that map to the same logical operator and syndrome. This is formulated as a maximum-likelihood (ML) decision on the logical operator $L$ given the syndrome $S_x$ :
$L_{ML}(S_x) = \arg \max_L P(L | S_x)$
Marginalization & Reorganization (M&R): A critical step involves "transposing" probabilities. Since the inner decoder outputs column-wise logical probabilities and the outer decoder requires row-wise physical probabilities, the algorithm performs a probabilistic transposition. This involves marginalizing over positions to extract extrinsic information (removing a priori information) and reorganizing it to serve as input for the next half-iteration.
Decoding Flow: The process iterates between SISO INNER and SISO OUTER blocks. After a fixed number of iterations, the most probable logical error sequence is estimated, and the corresponding Pauli correction is applied.

3. Simulation Setup

The authors simulated QBTCs over a depolarizing channel with perfect syndrome measurements. They utilized C++ for Monte Carlo simulations, testing various constituent codes including:

The [[5, 1, 3]] code (5-qubit code).
The [[8, 3, 3]] code.
Combinations such as [[5, 1, 3]] $\times$ [[5, 1, 3]] and [[8, 3, 3]] $\times$ [[8, 3, 3]].

Key Contributions

Formalization of QBTCs: The paper presents a theory for Quantum Block Turbo Codes, establishing the exact quantum analog of classical block turbo codes using stabilizer codes.
Iterative ML Decoding: The authors develop an iterative maximum-likelihood decoding technique specifically for product codes using small constituent stabilizer codes. This includes the derivation of SISO units and the probabilistic transposition (M&R) procedure required for quantum product codes.
Flexibility in Constituent Codes: The framework allows for the combination of any pair of stabilizer codes with known seed transformations, offering flexibility in choosing code rates ( $k/n$ ) and distances without the rigid constraints often found in other quantum code constructions.
Demonstration of the Turbo Effect: The paper demonstrates that the iterative exchange of soft information between row and column decoders yields performance improvements (the "turbo effect") that exceed simple concatenation or minimum weight decoding, particularly when multiple logical qubits are involved.

Results

Single Logical Qubit Performance: For the QBTC [[5, 1, 3]] $\times$ [[5, 1, 3]], the iterative decoder outperformed Minimum Weight (MW) decoding of a [[25, 1, 9]] code. At a depolarizing rate of $10^{-2}$ , the QBTC showed an approximate 6.25-fold improvement in Word Error Rate (WER) compared to the MW [[25, 1, 9]] decoder. The performance was comparable to topological codes and reinforcement learning methods for toric codes, though the XZZX surface code (distance 9) still outperformed it under biased noise.
Multi-Logical Qubit Performance (Turbo Effect): The QBTC [[8, 3, 3]] $\times$ [[8, 3, 3]] (equivalent to [[64, 9, 9]]) demonstrated a clear turbo decoding effect. As iterations increased, the WER decreased significantly. After 5 iterations at a depolarizing rate of $10^{-2}$ , the extrapolated WER was $6 \times 10^{-7}$ .
Scalability and Overhead: In a scalability analysis targeting 1080 logical qubits, the QBTC [[64, 9, 9]] required 7,680 physical qubits to achieve a global logical error rate of $7.2 \times 10^{-5}$ . This was more efficient than several compared qLDPC codes, which required nearly twice or three times as many physical qubits to achieve similar or slightly better error rates.
Comparison to Concatenation: The iterative QBTC decoder significantly outperformed a reference concatenated code decoder (which matched the QBTC's performance only at the first iteration), confirming the value of the iterative exchange.

Significance and Claims

The authors claim that QBTCs offer a general quantum decoding framework that balances high code rates, high performance, and manageable complexity.

Efficiency: By using small constituent blocks in a product structure, QBTCs can achieve high code rates and strong error correction without the massive physical qubit overhead typical of surface codes or the complex decoding requirements of some qLDPC codes.
Parallelism: The structure enables parallel decoding of rows and columns, potentially speeding up processing while keeping qubits physically close for syndrome computation.
Future Potential: The paper posits that the "turbo effect" can be further enhanced by increasing the number of logical qubits (using larger constituent codes like [[15, 7, 3]]) or by extending the framework to multi-dimensional product codes.
Practicality: The authors suggest that the framework can be adapted for physical-level correction using measurement circuits (inspired by the Shor code) to handle noisy syndrome measurements, paving the way for fault-tolerant implementations.

The work establishes QBTCs as a viable alternative in the landscape of quantum error correction, offering a flexible trade-off between code rate, distance, and decoding complexity.