© 2026 Aqora Quantum S.A.S.

Terms Privacy Legal Notice

arXiv:2611.02339

Achievability of CSS codes performance limits over Pauli channels under separate ML decoding with bounded graphical complexity

Gulnihal Mercanoglu, Achilleas Anastasopoulos, S. Sandeep Pradhan

cs.ITquant-phSubmitted Nov 2, 2026• Announced Nov 3, 2026

Abstract

Capacity-approaching quantum error correction faces a fundamental tension: the required parity-check matrices need to become increasingly dense, while practical decoding and syndrome extraction favor sparse, bounded-degree structures. Reconciling these competing requirements remains an important open problem in quantum code design. We construct Calderbank-Shor-Steane (CSS) code ensembles that approach the CSS rate over memoryless Pauli channels under maximum-likelihood decoding while retaining sparse, bounded-degree graphical representations. The construction separates parity-check density from graphical complexity: although capacity-approaching components may require dense parity-check matrices, they are represented by sparse concatenated factor graphs. We first study a construction combining low-density parity-check (LDPC) and low-density generator-matrix (LDGM) component codes and numerically analyze the average weight distributions of the resulting codes. Motivated by these results, we introduce a second construction based on concatenated LDPC and LDGM codes and generalized irregular repeat-accumulate (GIRA) codes. We derive bounds on the average weight distribution of the resulting sum ensemble and use the Miller-Burshtein framework to prove simultaneous reliability of the two CSS decoding components. Consequently, the proposed ensemble achieves rates arbitrarily close to the CSS hashing bound under separate bit- and phase-error correction, while maintaining bounded graphical complexity, thus providing a foundation for future iterative decoders and indirect syndrome-extraction architectures.

Comments: 45 pages, 9 figures

Related papers

Approach for the construction of non-Calderbank-Steane-Shor low-density-generator-matrix–based quantum codes

Patricio Fuentes, Josu Etxezarreta Martínez, Pedro M. Crespo +1 more

Quantum low-density generator matrix (QLDGM) codes based on Calderbank-Steane-Shor (CSS) constructions have shown unprecedented error correction capabilities, displaying much improved performance in comparison to other sparse-graph codes. However, the nature of CSS designs and the manner in which they must be decoded limit the performance that is attainable with codes that are based on this construction. This motivates the search for quantum code design strategies capable of avoiding the drawbacks associated with CSS codes. In this article, we introduce non-CSS quantum code constructions based on classical LDGM codes. The proposed codes are derived from CSS QLDGM designs by performing specific row operations on their quantum parity check matrices to modify the associated decoding graphs. The application of this method results in performance improvements in comparison to CSS QLDGM codes, while also allowing for greater flexibility in the design process. The proposed non-CSS QLDGM scheme outperforms the best quantum low-density parity check codes that have appeared in the literature.

Physical Review A•Jul 22, 2020•15 citations

Design of near-optimum quantum error-correcting codes based on generator and parity-check matrices of LDGM codes

Javier Garcia‐Frias, Kejing Liu

We study the design of near-optimum quantum error correcting codes based on the use of sparse matrices. The basic idea is to construct a Calderbank-Shor-Steane (CSS) code based on the generator and parity-check matrices of a classical channel code with low density generator matrix (LDGM code), which is designed with a specific structure inspired in the parallel concatenation of regular LDGM codes. Then, row operations are performed in both matrices to achieve the desired quantum rate. Decoding is performed in an iterative manner, by applying message passing over the corresponding graphs. The proposed codes allow greater flexibility and are easier to design than existing sparse-graph quantum codes, while leading to better performance.

Conference on Information Sciences and Systems•Mar 1, 2008•13 citations

Quantum CSS LDPC Codes based on Dyadic Matrices for Belief Propagation-based Decoding

Alessio Baldelli, Massimo Battaglioni, Jonathan Mandelbaum +2 more

Quantum low-density parity-check (QLDPC) codes provide a practical balance between error-correction capability and implementation complexity in quantum error correction (QEC). In this paper, we propose an algebraic construction based on dyadic matrices for designing both classical and quantum LDPC codes. The method first generates classical binary quasi-dyadic LDPC codes whose Tanner graphs have girth 6. It is then extended to the Calderbank-Shor-Steane (CSS) framework, where the two component parity-check matrices are built to satisfy the compatibility condition required by the recently introduced CAMEL-ensemble quaternary belief propagation decoder. This compatibility condition ensures that all unavoidable cycles of length 4 are assembled in a single variable node, allowing the mitigation of their detrimental effects by decimating that variable node.

cs.ITCross-listedarXiv:2601.08636•IEEE International Symposium on Information Theory (ISIT)•Jan 14, 2026•0 citations

Partially Concatenated Calderbank-Shor-Steane Codes Achieving the Quantum Gilbert-Varshamov Bound Asymptotically

Jihao Fan, Jun Li, Ya Wang +3 more

In this paper, we utilize a concatenation scheme to construct new families of quantum error correction codes achieving the quantum Gilbert-Varshamov (GV) bound asymptotically. Weconcatenate alternant codes with any linear code achievingthe classical GV bound to construct Calderbank-Shor-Steane (CSS) codes. We show that the concatenated code can achieve the quantum GV bound asymptotically and can approach the Hashing bound for asymmetric Pauli channels. By combing Steane’s enlargement construction of CSS codes, we derive a family of enlarged stabilizer codes achieving the quantum GV bound for enlarged CSS codes asymptotically. Asapplications, we derive two families of fast encodable and decodable CSS codes with parameters$\mathscr {Q}_{1}=[[N,\Omega (\sqrt {N}),\Omega (\sqrt {N})]]$, and$\mathscr {Q}_{2}=[[N,\Omega (N/\log N),\Omega (N/\log N)/\Omega (\log N)]]$. We show that$\mathscr {Q}_{1}$can be encoded very efficiently by circuits of size$O(N)$and depth$O(\sqrt {N})$. For an input error syndrome,$\mathscr {Q}_{1}$can correct any adversarial error of weight up to half the minimum distance bound in$O(N)$time.$\mathscr {Q}_{1}$can also be decoded in parallel in$O(\sqrt {N})$time by using$O(\sqrt {N})$classical processors. For an input error syndrome, we proved that$\mathscr {Q}_{2}$can correct a linear number of${X}$-errors with high probability and an almost linear number of${Z}$-errors in$O(N)$time. Moreover,$\mathscr {Q}_{2}$can be decoded in parallel in$O(\log (N))$time by using$O(N)$classical processors.

arXiv:2107.05174•IEEE Transactions on Information Theory•Aug 24, 2022•5 citations

LDGM-Based Quantum Codes for Fault-Tolerant Quantum Computation

Yumin Li, Kejing Liu, Hanqing Lou +1 more

We construct a new family of Calderbank-Shor-Steane (CSS) codes using the generator and parity-check matrices of Low-Density Generator Matrix (LDGM) codes, with row operations applied to both matrices in order to achieve the desired quantum rate. Decoding is performed in an iterative manner, by applying message passing over the associated graph, and discrete Density Evolution (DDE) is used to optimize performance in the depolarizing channel. The proposed construction offers high flexibility and easiness in the design, producing quantum codes that possess excellent error correction capabilities. By properly designing the structure of the code, we are able to control and bound the weight of the stabilizer generators to a small value, which results in codes particularly well suited for fault-tolerant quantum computation. At the same time, these codes achieve very good performance in terms of error correction capability.

quant-pharXiv:2607.15159•Jul 17, 2026•0 citations

On the Application of Error-Correcting Codes with Low-Density Generator Matrix over Different Quantum Channels

Hanqing Lou, Javier Garcia‐Frias

We propose the use of linear codes with low-density generator matrix in the context of error correction over different quantum channels. The basic idea is to construct a Calderbank-Shor-Steane (CSS) code based on the generator matrix and the parity-check matrix of an LDGM code, applying row operations in both matrices to achieve the desired quantum rate. Decoding is performed in an iterative manner, using message passing over the corresponding graphs. The proposed codes allow greater flexibility and are easier to design than existing sparse-graph quantum codes, while leading to better performance.

•Apr 3, 2006•23 citations

Capacity-approaching quantum error correction faces a fundamental tension: the required parity-check matrices need to become increasingly dense, while practical decoding and syndrome extraction favor sparse, bounded-degree structures. Reconciling these competing requirements remains an important open problem in quantum code design. We construct Calderbank-Shor-Steane (CSS) code ensembles that approach the CSS rate over memoryless Pauli channels under maximum-likelihood decoding while retaining sparse, bounded-degree graphical representations. The construction separates parity-check density from graphical complexity: although capacity-approaching components may require dense parity-check matrices, they are represented by sparse concatenated factor graphs. We first study a construction combining low-density parity-check (LDPC) and low-density generator-matrix (LDGM) component codes and numerically analyze the average weight distributions of the resulting codes. Motivated by these results, we introduce a second construction based on concatenated LDPC and LDGM codes and generalized irregular repeat-accumulate (GIRA) codes. We derive bounds on the average weight distribution of the resulting sum ensemble and use the Miller-Burshtein framework to prove simultaneous reliability of the two CSS decoding components. Consequently, the proposed ensemble achieves rates arbitrarily close to the CSS hashing bound under separate bit- and phase-error correction, while maintaining bounded graphical complexity, thus providing a foundation for future iterative decoders and indirect syndrome-extraction architectures.

Quantum low-density generator matrix (QLDGM) codes based on Calderbank-Steane-Shor (CSS) constructions have shown unprecedented error correction capabilities, displaying much improved performance in comparison to other sparse-graph codes. However, the nature of CSS designs and the manner in which they must be decoded limit the performance that is attainable with codes that are based on this construction. This motivates the search for quantum code design strategies capable of avoiding the drawbacks associated with CSS codes. In this article, we introduce non-CSS quantum code constructions based on classical LDGM codes. The proposed codes are derived from CSS QLDGM designs by performing specific row operations on their quantum parity check matrices to modify the associated decoding graphs. The application of this method results in performance improvements in comparison to CSS QLDGM codes, while also allowing for greater flexibility in the design process. The proposed non-CSS QLDGM scheme outperforms the best quantum low-density parity check codes that have appeared in the literature.

We study the design of near-optimum quantum error correcting codes based on the use of sparse matrices. The basic idea is to construct a Calderbank-Shor-Steane (CSS) code based on the generator and parity-check matrices of a classical channel code with low density generator matrix (LDGM code), which is designed with a specific structure inspired in the parallel concatenation of regular LDGM codes. Then, row operations are performed in both matrices to achieve the desired quantum rate. Decoding is performed in an iterative manner, by applying message passing over the corresponding graphs. The proposed codes allow greater flexibility and are easier to design than existing sparse-graph quantum codes, while leading to better performance.

Quantum low-density parity-check (QLDPC) codes provide a practical balance between error-correction capability and implementation complexity in quantum error correction (QEC). In this paper, we propose an algebraic construction based on dyadic matrices for designing both classical and quantum LDPC codes. The method first generates classical binary quasi-dyadic LDPC codes whose Tanner graphs have girth 6. It is then extended to the Calderbank-Shor-Steane (CSS) framework, where the two component parity-check matrices are built to satisfy the compatibility condition required by the recently introduced CAMEL-ensemble quaternary belief propagation decoder. This compatibility condition ensures that all unavoidable cycles of length 4 are assembled in a single variable node, allowing the mitigation of their detrimental effects by decimating that variable node.

In this paper, we utilize a concatenation scheme to construct new families of quantum error correction codes achieving the quantum Gilbert-Varshamov (GV) bound asymptotically. Weconcatenate alternant codes with any linear code achievingthe classical GV bound to construct Calderbank-Shor-Steane (CSS) codes. We show that the concatenated code can achieve the quantum GV bound asymptotically and can approach the Hashing bound for asymmetric Pauli channels. By combing Steane’s enlargement construction of CSS codes, we derive a family of enlarged stabilizer codes achieving the quantum GV bound for enlarged CSS codes asymptotically. Asapplications, we derive two families of fast encodable and decodable CSS codes with parameters

\mathscr {Q}_{1}=[[N,\Omega (\sqrt {N}),\Omega (\sqrt {N})]]

, and

\mathscr {Q}_{2}=[[N,\Omega (N/\log N),\Omega (N/\log N)/\Omega (\log N)]]

. We show that

\mathscr {Q}_{1}

can be encoded very efficiently by circuits of size

O(N)

and depth

O(\sqrt {N})

. For an input error syndrome,

\mathscr {Q}_{1}

can correct any adversarial error of weight up to half the minimum distance bound in

O(N)

time.

\mathscr {Q}_{1}

can also be decoded in parallel in

O(\sqrt {N})

time by using

O(\sqrt {N})

classical processors. For an input error syndrome, we proved that

\mathscr {Q}_{2}

can correct a linear number of

{X}

-errors with high probability and an almost linear number of

{Z}

-errors in

O(N)

time. Moreover,

\mathscr {Q}_{2}

can be decoded in parallel in

O(\log (N))

time by using

O(N)

classical processors.

We construct a new family of Calderbank-Shor-Steane (CSS) codes using the generator and parity-check matrices of Low-Density Generator Matrix (LDGM) codes, with row operations applied to both matrices in order to achieve the desired quantum rate. Decoding is performed in an iterative manner, by applying message passing over the associated graph, and discrete Density Evolution (DDE) is used to optimize performance in the depolarizing channel. The proposed construction offers high flexibility and easiness in the design, producing quantum codes that possess excellent error correction capabilities. By properly designing the structure of the code, we are able to control and bound the weight of the stabilizer generators to a small value, which results in codes particularly well suited for fault-tolerant quantum computation. At the same time, these codes achieve very good performance in terms of error correction capability.

We propose the use of linear codes with low-density generator matrix in the context of error correction over different quantum channels. The basic idea is to construct a Calderbank-Shor-Steane (CSS) code based on the generator matrix and the parity-check matrix of an LDGM code, applying row operations in both matrices to achieve the desired quantum rate. Decoding is performed in an iterative manner, using message passing over the corresponding graphs. The proposed codes allow greater flexibility and are easier to design than existing sparse-graph quantum codes, while leading to better performance.