# On the logical error rate of sparse quantum codes

Patricio Fuentes ${}^{1,\ *}$, Josu Etxezarreta Martinez${}^{1,\ *}$, Pedro M.
Crespo  {pfuentesu, jetxezarreta<EMAIL_ADDRESS>Tecnun - University of
Navarra, 20018 San Sebastian, Spain  Javier Garcia-Frias<EMAIL_ADDRESS>University of Delaware, Newark, 19716 Delaware, USA

###### Abstract

The quantum paradigm presents a phenomenon known as degeneracy that can
potentially improve the performance of quantum error correcting codes.
However, the effects of this mechanism are sometimes ignored when evaluating
the performance of sparse quantum codes and the logical error rate is not
always correctly reported. In this paper, we discuss previously existing
methods to compute the logical error rate and we present an efficient coset-
based method inspired by classical coding strategies to estimate degenerate
errors and distinguish them from logical errors. Additionally, we show that
the proposed method presents a computational advantage for the family of
Calderbank-Shor-Steane (CSS) codes. We use this method to prove that
degenerate errors are frequent in a specific family of sparse quantum codes,
which stresses the importance of accurately reporting their performance. Our
results also reveal that the modified decoding strategies proposed in the
literature are an important tool to improve the performance of sparse quantum
codes.

Quantum error correction, quantum low density parity check codes, quantum low
density generator matrix codes, iterative decoding.

##  I Introduction

When quantum stabilizer codes built from sparse classical codes are employed
in the quantum paradigm, they are impacted by a phenomenon known as degeneracy
[1, 2, 3, 4], which has no classical equivalent. This causes stabilizer codes
to exhibit a particular coset structure in which multiple different error
patterns act identically on the transmitted information [5, 6, 7]. The
manifestation of degeneracy in the design of sparse quantum codes and its
effects on the decoding process has been studied extensively [3, 4, 8, 9, 10,
11, 12, 13, 14]. Unfortunately, although degeneracy may potentially improve
performance, limited research exists on how to quantify the true impact that
this phenomenon has on Quantum Low Density Parity Check (QLDPC) codes. This
has resulted in the performance of QLDPC codes being assessed differently
throughout the literature; while some research considers the effects of
degeneracy by computing the metric known as the logical error rate [3, 17, 15,
16, 18, 19, 20], other works employ the classical strategy of computing the
physical error rate [21, 22, 23, 24, 25, 26], a metric which provides an upper
bound on the logical error rate of these codes since it ignores degeneracy. In
the context of degenerate quantum codes, the discrepancy between results
computed based on the physical error rate and the logical error rate can
become significant. QLDPC codes (also commonly referred to as sparse quantum
codes) are famous for their degenerate nature [3, 4, 12, 14, 27, 28], which
makes it important to accurately asses their performance using the logical
error rate.

The logical error rate is a well-known metric and has been widely employed to
assess the performance of other families of Quantum Error Correction (QEC)
codes such as Quantum Turbo Codes (QTC) and quantum topological codes [10, 35,
36, 37, 38]. For these particular error correction schemes, the decoders that
are employed are sometimes capable of distinguishing between error equivalence
classes (they can account for some aspects of degeneracy), which makes it easy
to compute the logical error rate. In contrast, the classical decoding
algorithms [39, 40] that are used to decode sparse quantum codes are unable to
account for the presence of degenerate error operators, and so their logical
error rate must be computed differently.

Given the coset structure of sparse quantum codes, intuition would point
towards approaching the issue of calculating the logical error rate by finding
and comparing the stabilizer cosets of the estimated error sequences and the
stabilizer cosets of the channel errors. Unfortunately, the task of computing
stabilizer cosets has been shown to be computationally hard [4, 12, 24], which
is the reason why the performance of some sparse quantum codes [21, 22, 23,
25, 26, 24] has been assessed based on the physical error rate. This metric is
computed by comparing the error sequence estimated by the decoder,
$\hat{\mathbf{E}}\in\mathcal{\mkern
1.5mu\overline{\mkern-1.5muG\mkern-1.5mu}\mkern 1.5mu}_{N}$, to the channel
error, $\mathbf{E}\in\mathcal{\mkern
1.5mu\overline{\mkern-1.5muG\mkern-1.5mu}\mkern 1.5mu}_{N}$, where
$\mathcal{\mkern 1.5mu\overline{\mkern-1.5muG\mkern-1.5mu}\mkern 1.5mu}_{N}$
denotes the $N$-fold effective Pauli group. Essentially, if the estimation
matches the channel error, the decoder has been successful, and if not, a
decoding failure has occurred. Note, however, that because this metric ignores
the degenerate nature of stabilizer codes, the physical error rate
overestimates the number of decoding failures and actually represents an upper
bound on the performance of stabilizer codes.

Despite the use of the physical error rate in some works, other literature has
successfully computed the logical error rate of specific sparse quantum codes
[3, 17, 15, 16, 18, 19, 20]. These works succeed in computing the logical
error rate because they do not approach the issue from the perspective of
stabilizer cosets. Instead, in most of these works [3, 17, 15, 16, 18],
Gaussian elimination is used to obtain the parity check matrix of the code in
what is known as standard form [8, 41, 42], and then this matrix is used to
extract a basis for the encoded Pauli operators of the corresponding codes.
Then, this basis can be employed to distinguish between degenerate errors and
logical errors. Additionally, other research [20] employs a different, albeit
much more computationally demanding, method to compute the logical error rate.

Against this backdrop, in this article we document the methods that have
previously been used in the literature to compute the logical error rate of
sparse quantum codes. In addition, we introduce our own group theoretic
strategy to accurately assess the effects of degeneracy on sparse quantum
codes and compute their logical error rate. We also show how for sparse CSS
quantum codes the method we propose herein has a computational complexity
advantage over those that have been employed previously. Following this, we
use our strategy to analyze the frequency with which degenerate errors occur
when using a specific family of sparse quantum codes and we provide insight on
how the design and decoding of these codes can be improved.

##  II Degeneracy and stabilizer codes

Throughout this paper we assume that the reader is familiar with basic Quantum
Error Correction (QEC) concepts based on physical two-level systems (qubits)
such as stabilizer codes, their coset structure, and the different types of
possible errors. This section is meant as an introduction to the notation we
will use (that of [14]) and to provide a brief summary of some of the ideas of
[14]. For a complete overview on these preliminaries refer to [14, 27, 29].

###  II.1 Coset structure of the Pauli Group

The coherence loss suffered by quantum information over time can be
approximated as the action of operators that belong to the Pauli Group on the
qubits that store this information. In most cases, the action of these
operators is modelled by means of an abstraction known as the Pauli channel.
For single qubit quantum states, the Pauli channel will act on said states by
combining them with an element of the single-qubit Pauli group
$\mathcal{G}_{1}=(\tilde{\Pi},\times)$. The set $\tilde{\Pi}$ is given by

$\displaystyle\begin{split}\tilde{\Pi}&=\\{\Theta_{1}I,\Theta_{2}X,\Theta_{3}Y,\Theta_{4}Z\\}\\\
&=\\{\pm I,\pm iI,\pm X,\pm iX,\pm Y,\pm iY,\pm Z,\pm iZ\\}\ ,\end{split}$

where $\Theta_{l}=\\{\pm 1,\pm i\\},\\{X,Y,Z\\}$ are the Pauli matrices, $I$
is the $2\times 2$ identity matrix, and $l=1,2,3,4$. The group operation
$\times$ represents the well-known product of Pauli matrices, which is written
as

$\sigma_{a}\times\sigma_{b}=I\delta_{a,b}+i\sum_{c=1}^{3}\epsilon_{abc}\sigma_{c},$
(1)

where $\delta$ represents the Kronecker delta and

$\epsilon_{abc}=\left\\{\begin{array}[]{rl}1&\mbox{if
$(a,b,c)=\\{(1,2,3),(3,1,2),(2,3,1)\\}$},\\\ -1&\mbox{ if
$(a,b,c)=\\{(3,2,1),(1,3,2),(2,1,3)\\}$},\\\ 0&\mbox{if $a=b$ or $b=c$ or
$a=c$.}\end{array}\right.$

In (1) we have denoted the $X$ Pauli matrix as $\sigma_{1}$, the $Y$ Pauli
matrix as $\sigma_{2}$, and the $Z$ Pauli matrix as $\sigma_{3}$.

We can generalize the single qubit Pauli group so that it can be applied to
$N$-qubit quantum states based on the tensor product. The $N$-qubit Pauli
group is by $\mathcal{G}_{N}=(\tilde{\Pi}^{\otimes N},\cdot)$. The set
$\tilde{\Pi}^{\otimes N}$ is given by

$\tilde{\Pi}^{\otimes
N}=\\{\theta_{1}I,\theta_{2}X,\theta_{3}Y,\theta_{4}Z\\}^{\otimes N},$

where $\theta_{k}=\\{\pm 1,\pm i\\}$, and $\otimes$ denotes the tensor
product. For all $\mathrm{A},\mathrm{B}\in\mathcal{G}_{N}$, the group
operation $\cdot$ is defined as

$\mathrm{A}\cdot\mathrm{B}=A_{1}\times B_{1}\otimes A_{2}\times
A_{2}\otimes\ldots\otimes A_{N}\times B_{N}.$ (2)

Because it makes good physical sense to neglect the global phase of Pauli
operators [32], i.e, disregard the overall factors $\\{\pm 1,\pm i\\}$, it is
typical in the field of QEC to work with a reduced version of the Pauli Group
known as the effective Pauli Group. The $N$-qubit effective Pauli group is
denoted by $\overline{\mathcal{G}}_{N}=(\Pi^{\otimes N},\star)$, where

${\Pi}^{\otimes N}=\\{I,X,Y,Z\\}^{\otimes N},$

and $\star$ behaves as in (2) but with the operation between single Pauli
operator products defined not as in (1) but as

$\sigma_{a}\star\sigma_{b}=I\delta_{a,b}+\sum_{c=1}^{3}|\epsilon_{abc}|\sigma_{c},$
(3)

where $\epsilon_{abc}$ is the same as in (1).

Thus, against this backdrop, efficient QEC strategies for general Pauli
channels are defined as those methods that are capable of reverting the action
of elements that belong to the effective Pauli group. It is important to note,
however, that $\overline{\mathcal{G}}_{N}$ is abelian whereas
$\mathcal{G}_{N}$ is not, which means that the commutation relations that
exist between Pauli operators (see equation (2)) are lost between effective
Pauli operators (see equation (3)). Given the importance of these commutation
relations for the purposes of error correction [14, 29, 30], it is important
that they be recovered. For this purpose we define the symplectic map
$\beta:\Pi^{\otimes N}\rightarrow\mathbb{F}_{2}^{2N}$, which is an isomorphism
between the group $\overline{\mathcal{G}}_{N}=(\Pi^{\otimes N},\star$) and the
group ($\mathbb{F}_{2}^{2N},\oplus$) of $2N$ binary-tuples under the mod 2 sum
operation. For clarity, throughout the remainder of this paper, lower case
boldface romans without a subscript will be used to denote $2N$ binary-tuples
that belong to $\mathbb{F}_{2}^{2N}$, and lower case boldface romans with a
subscript will be used to denote $N$ binary-tuples that belong to
$\mathbb{F}_{2}^{N}$. The symplectic mapping $\beta$ is defined
$\forall\mathbf{A}\in\overline{\mathcal{G}}_{N}$ as

$\beta(\mathbf{A})=\mathbf{a}=(\mathbf{a}_{x}|\mathbf{a}_{z}),\;\mathbf{a}_{x},\mathbf{a}_{z}\in\mathbb{F}_{2}^{N},$

where the values of the entries of $\mathbf{a}_{x}$ and $\mathbf{a}_{z}$ at
position $i=1,\ldots,N$, are directly dependent on the single qubit Pauli
operator, $[\mathbf{A}]_{i}$, located at the $i$-th position in the tensor
product that makes up $\mathbf{A}\in\overline{\mathcal{G}}_{N}$.

Note that the commutation properties of the Pauli operators with regard to the
$\cdot$ product are not recovered by just defining the isomorphism $\beta$
(after all, ($\mathbb{F}_{2}^{2N},\oplus)$ is also an abelian group). Thus, we
define the symplectic product, $\mathbf{a}\odot\mathbf{b}\in\mathbb{F}_{2}\
\forall\ \mathbf{a},\mathbf{b}\in\mathbb{F}_{2}^{2N}$ as

$\mathbf{a}\odot\mathbf{b}\triangleq(\mathbf{a}_{x}\circledast\mathbf{b}_{z})\oplus(\mathbf{a}_{z}\circledast\mathbf{b}_{x}).$
(4)

where $\circledast$ is the standard mod 2 inner product defined on
$(\mathbb{F}_{2}^{N},\oplus)$ considered as a vector space over the field
$\mathbb{F}_{2}$. The symplectic product tells us if any two operators
$\mathbf{A},\mathbf{B}$ in $\overline{\mathcal{G}}_{N}$ will either commute or
anticommute with regard to the group operation $\cdot$ in ${\mathcal{G}}_{N}$,
if and only if the symplectic product between $\beta(\mathbf{A})=\mathbf{a}$
and $\beta(\mathbf{B})=\mathbf{b}$, i.e., $\mathbf{a}\odot\mathbf{b}$, takes
the value 0 or 1, respectively [31, 32].

###  II.2 Stabilizer Codes

Stabilizer codes are a widely extended family of QEC codes. They are
constructed based on a set of generators that define the so-called stabilizer
group $\mathcal{\overline{S}}\subset\mathcal{\overline{G}}_{N}$. The
stabilizer generators are a set of operators
$\\{\mathbf{S}_{v}\\}_{v=1}^{N-k}$ that belong to $\overline{\mathcal{G}}_{N}$
and whose sympletic representatives commute with regard to the symplectic
product. This means that the stabilizer is comprised of elements of the
effective Pauli group that commute amongst themselves with regard to $\cdot$
in $\mathcal{G}_{N}$. The stabilizer $\mathcal{\overline{S}}$ has $2^{N-k}$
distinct elements and is completely represented by its $N-k$ independent
generators (the rest of the stabilizer elements are combinations of the
elements of the minimal set). The codespace defined by the stabilizer, and
hence a stabilizer code, can be described mathematically as

$\mathcal{C}(\mathcal{\overline{S}})=\\{|\psi\rangle\in\mathcal{H}_{2}^{\otimes
N}:\mathbf{S}_{i}|\psi\rangle=|\psi\rangle,i=1\dots N-k\\},$ (5)

where $\mathbf{S}_{i}|\psi\rangle\in\mathcal{H}_{2}^{\otimes N}$ is the
evolution of state $|\psi\rangle$ under stabilizer generator $\mathbf{S}_{i}$.
Note that $\mathcal{C}(\mathcal{\overline{S}})$ is the subspace of
$\mathcal{H}_{2}^{\otimes N}$ formed by the simultaneous $+1$-eigenspaces of
all the operators in the stabilizer group $\mathcal{\overline{S}}$. Here
$\mathcal{H}_{2}^{\otimes N}$ denotes the complex Hilbert space of dimension
$2^{N}$ that comprises the state space of $N$-qubit systems.

It is also possible for elements of $\mathcal{\overline{G}}_{N}$ to commute
with regard to the symplectic product with the elements of
$\mathcal{\overline{S}}$ but not to belong to $\mathcal{\overline{S}}$. These
elements are important because they act non-trivially on encoded quantum
states (they corrupt the encoded quantum information but map the codespace to
itself). Together with the elements of $\mathcal{\overline{S}}$, these
operators define the group
${\overline{\mathcal{Z}}(\overline{\mathcal{S}})}\subset\mathcal{\overline{G}}_{N}$
known as the effective centralizer. This group is the set of all operators in
$\overline{\mathcal{G}}_{N}$ whose symplectic representatives commute with
regard to the symplectic product with all the symplectic representatives of
the stabilizer generators $\beta({\mathbf{S}_{v}})\in\mathbb{F}_{2}^{2N}$.

Based on the relationship between the stabilizer and the effective
centralizer, the effective centralizer can actually be understood as a union
of stabilizer cosets. More specifically,
${\overline{\mathcal{Z}}(\overline{\mathcal{S}})}$ can be partitioned into
$2^{2k}$ cosets of $\mathcal{\overline{S}}$, each of these cosets being
indexed by a coset representative
$\\{\mathbf{L}_{j}\\}_{j=1}^{2^{2k}}\in\mathcal{\overline{Z}(\overline{S})}$.
Throughout this paper, we will refer to these representatives as logical
operators. Whenever a representative $\mathbf{L}_{j}$ is multiplied in terms
of the group operation over the effective Pauli group, the $\star$ product, by
all the elements of $\mathcal{\overline{S}}$, the stabilizer coset,
$\mathbf{L}_{j}\star\mathcal{\overline{S}}$, is obtained. This can be written
as

$\overline{\mathcal{Z}}(\overline{\mathcal{S}})=\bigcup_{j=1}^{2^{2k}}\mathbf{L}_{j}\star\overline{\mathcal{S}}=\overline{\mathcal{S}}\bigcup\left[\bigcup_{j=2}^{2^{2k}}\mathbf{L}_{j}\star\overline{\mathcal{S}}\right].$
(6)

Based on our definition of the effective centralizer, it is easy to see that
the group $\mathcal{\overline{G}}_{N}$ also has a coset structure [14].
Knowing that $|\mathcal{\overline{G}}_{N}|=2^{2N}$ and that
$|\overline{\mathcal{Z}}(\overline{\mathcal{S}})/\overline{\mathcal{S}}|=2^{N+k}$,
then we can partition the effective Pauli group into cosets of the effective
centralizer as

$\displaystyle\begin{split}\overline{\mathcal{G}}_{N}&=\bigcup_{i=1}^{2^{N-k}}\mathbf{T}_{i}\star\overline{\mathcal{Z}}(\overline{\mathcal{S}})\\\
&=\overline{\mathcal{Z}}(\overline{\mathcal{S}})\bigcup\left[\bigcup_{i=2}^{2^{N-k}}\mathbf{T}_{i}\star\overline{\mathcal{Z}}(\overline{\mathcal{S}})\right].\end{split}$
(7)

Equation (7) shows how $\mathcal{\overline{G}}_{N}$ can be partitioned into
$2^{N-k}$ cosets of the effective centralizer, each of these centralizer
cosets being indexed by a coset representative111These coset representatives
are commonly referred to as pure error operators in the literature.
$\\{\mathbf{T}_{i}\\}_{i=1}^{2^{N-k}}$, which when multiplied in terms of the
$\star$ product by all the elements of $\mathcal{\overline{Z}(\overline{S})}$
yields the specific coset in question,
$\mathbf{T}_{i}\star\mathcal{\overline{Z}(\overline{S})}$. Finally, we can
combine the partitions of (6) and (7), respectively, to partition the entire
effective Pauli space into cosets of the stabilizer, each one indexed by a
unique $\star$ product of the $\\{\mathbf{L}_{j}\\}_{j=2}^{2^{2k}}$ and
$\\{\mathbf{T}_{i}\\}_{i=1}^{2^{N-k}}$ representatives. This can be written as

$\displaystyle\begin{split}\overline{\mathcal{G}}_{N}&=\bigcup_{i=1}^{2^{N-k}}\mathbf{T}_{i}\star\overline{\mathcal{Z}}(\overline{\mathcal{S}})=\bigcup_{i=1}^{2^{N-k}}\bigcup_{j=1}^{2^{2k}}(\mathbf{T}_{i}\star\mathbf{L}_{j})\star\mathcal{\overline{S}}.\end{split}$
(8)

###  II.3 Quantum Syndromes

In order to operate properly, QEC strategies require information regarding the
transmitted quantum state. Although the axioms of quantum mechanics establish
that direct measurement of a quantum state will result in information loss,
quantum error syndrome measurements (Hadamard Test) can be used to measure
quantum states indirectly in order to obtain sufficient information for
quantum codes to operate [29, 31, 33]. A quantum syndrome
$\mathrm{w}\in\mathbb{F}_{2}^{N-k}$ captures the commutation properties of any
error sequence $\mathbf{E}\in\overline{\mathcal{G}}_{N}$ induced by the Pauli
channel with regard to the stabilizer generators
$\\{\mathbf{S}_{v}\\}_{v=1}^{N-k}$ of the code. This can be written as

$\mathrm{w}=\mathbf{e}\odot(\mathbf{s}_{1},\ldots,\mathbf{s}_{N-k}),$ (9)

where $\mathbf{e}=\beta(\mathbf{E})$ and
$\\{\mathbf{s}_{v}\\}_{v=1}^{N-k}=\\{\beta(\mathbf{S}_{v})\\}_{v=1}^{N-k}$,
respectively. From (9) we can discern that the syndrome is a length $N-k$
binary vector whose components express the commutation relations with regard
to the $\cdot$ product between $\mathbf{E}$ and each of the generators of the
stabilizer code. In other words, the entries of $\mathrm{w}$ will be $0$ if
the specific error operator and stabilizer generator commute and $1$ if they
do not. Recall that the elements of $\mathcal{\overline{Z}(\overline{S})}$
commute with the stabilizer generators, which means that all the elements of
the same effective centralizer coset will be associated to the same syndrome.
For instance, if a given error pattern $\mathbf{E}^{\prime}$ is associated to
syndrome $\mathrm{w}_{1}$, all the effective Pauli sequences that belong to
$\mathbf{E}^{\prime}\star\mathcal{\overline{Z}(\overline{S})}$ will also be
associated to syndrome $\mathrm{w}_{1}$. Thus, the information provided by the
syndrome $\mathrm{w}$ can be used to locate the centralizer coset
$\mathbf{T}_{i}\star\mathcal{\overline{Z}(\overline{S})}$ of a given error
operator $\mathbf{E}$, where $i=1,\ldots,2^{N-k}$. Note, however, that we have
no information regarding which stabilizer coset the error operator belongs to.
The syndrome locates the centralizer coset that contains the error sequence
that has taken place, but because all the elements of this coset are
associated to the same syndrome, there is no way of knowing which specific
stabilizer coset
$(\mathbf{T}_{i}\star\mathbf{L}_{j})\star\mathcal{\overline{S}}$ contains the
error sequence, where $j=1,\ldots,2^{2k}$. As mentioned previously, knowing
which particular stabilizer coset contains the error that has taken place is
important, since operators that belong to different stabilizer cosets act non-
trivially on the encoded quantum information.

###  II.4 Estimation and end-to-end errors

The effective Pauli operators induced by quantum channels and estimated by
decoders can be classified into three different groups (summarized in Table
LABEL:errors). Consider a channel error
$\mathbf{E}\in\mathbf{T}_{i}\star\mathbf{L}_{j}\star\mathcal{\overline{S}}$
and an estimated error sequence
$\mathbf{\hat{E}}\in\mathbf{\hat{T}}_{i}\star\mathbf{\hat{L}}_{j}\star\mathcal{\overline{S}}$,
then the following situations can be encountered:

Table 1: Characteristics of the different types of end-to-end errors that can arise when using stabilizer codes. The hat notation is used to represent estimations made by the decoder, i.e., $\hat{\mathrm{w}}$, $\hat{\mathbf{E}}$, $\mathbf{\hat{T}}_{i}$, and $\mathbf{\hat{L}}_{j}$ represent the estimated syndrome, estimated error sequence, centralizer coset representative of the estimated error sequence and stabilizer coset representative of the estimated error sequence, respectively.  Type of | Defining | Outcome | Outcome
---|---|---|---
error | Characteristics | (Phys. Error Rate) | (Logical Error Rate)
End-to-end error | $\hat{\mathrm{w}}\neq\mathrm{w}$ |  |
with | $\mathbf{\hat{T}}_{i}\neq\mathbf{T}_{i}$ | Failure | Failure
different syndrome | $\hat{\mathbf{E}}\neq\mathbf{E}$ |  |
End-to-end | $\hat{\mathrm{w}}=\mathrm{w}$ |  |
identical |  $\mathbf{\hat{T}}_{i}=\mathbf{T}_{i}$ and $\mathbf{\hat{L}}_{j}\neq\mathbf{L}_{j}$ | Failure | Failure
syndrome error | $\hat{\mathbf{E}}\neq\mathbf{E}$ |  |
End-to-end | $\hat{\mathrm{w}}=\mathrm{w}$ |  |
degenerate |  $\mathbf{\hat{T}}_{i}=\mathbf{T}_{i}$ and $\mathbf{\hat{L}}_{j}=\mathbf{L}_{j}$ | Failure | Success
error | $\hat{\mathbf{E}}\neq\mathbf{E}$ |  |

  * •

End-to-end errors with different syndromes: These events occur when the error
sequence estimated by the decoder and the real error sequence belong to
different centralizer cosets, i.e., $\mathbf{T}_{i}\neq\mathbf{\hat{T}}_{i}$.
Equipped with an ideal decoder, such scenarios would not exist, as the
syndrome of the estimated error pattern $\hat{\mathbf{E}}$ should always match
the measured syndrome associated to the channel error $\mathbf{E}$. However,
because sparse quantum codes are generally decoded based on the sub-optimal
classical SPA algorithm222The SPA algorithm solves the SWML (Symbol-Wise
Maximum Likelihood) problem and not the actual ML (Maximum Likelihood)
decoding problem. While the solutions to the SWML and ML problems usually
coincide, this is not always the case., these errors can take place with
varying probability [3, 14, 20, 34].

  * •

End-to-end identical syndrome errors: These events take place when the
estimated error sequence and the channel error both belong to the same
centralizer coset, $\mathbf{T}_{i}=\mathbf{\hat{T}}_{i}$, but each of them
belongs to a different stabilizer coset, i.e.,
$\mathbf{L}_{j}\neq\mathbf{\hat{L}}_{j}$ (the channel logical operator and
estimated logical operator do not match). Thus, although $\hat{\mathbf{E}}$
and $\mathbf{E}$ exhibit identical commutation properties with respect to the
stabilizer generators, they will each act on the transmitted codeword in a
distinct non-trivial manner and the decoder will fail. It should be noted that
in the literature this type of end-to-end error is generally referred to as a
logical error.

  * •

End-to-end degenerate errors: These events take place when the estimated error
pattern and the channel error both belong to the same stabilizer coset,
$\mathbf{T}_{i}=\mathbf{\hat{T}}_{i}$ and
$\mathbf{L}_{j}=\mathbf{\hat{L}}_{j}$, but they do not match, i.e.,
$\hat{\mathbf{E}}\neq\mathbf{E}$. Since the estimated error belongs to the
same stabilizer coset as the channel error, it will act identically on the
quantum codeword, which means that it will not actually result in a decoding
failure and should not be considered as such.

##  III Performance assessment metrics

The manifestation of the degeneracy phenomenon in the realm of quantum error
correction makes it impossible to accurately predict the performance of QEC
codes with methods that disregard its presence. Thus, in the paradigm of
sparse quantum codes, which are famous for their degenerate nature,
appropriate performance assessment is of paramount importance. This can be
achieved using the logical error rate, which accurately predicts the
performance of quantum codes and distinguishes between the different types of
end-to-end errors (see table LABEL:errors).

Prior to discussing how to compute the logical error rate, it should be
mentioned that the concept of undetected errors is not exclusive to the
quantum paradigm. In fact, even though degeneracy does not exist in the
classical coding framework, undetected or logical errors in classical LDPC
codes and classical turbo codes have previously been studied. This idea was
introduced by the early work of MacKay et al. [43], where a classical
undetected error is defined as a decoding estimate that is not equal to the
original error sequence and that is produced when the decoder exits before the
maximum number of decoding iterations (it produces a valid syndrome). In their
analysis of classical LDPC codes, MacKay et al. showed that all of the
decoding mistakes they encountered were detected errors (classical undetected
errors were only observed in turbo codes). This was also shown in [17] for a
slightly different decoding algorithm. Similar outcomes were observed in the
quantum paradigm for the failed recoveries of the modified decoding strategies
of [3, 24]. These techniques serve to improve standard SPA decoding of quantum
codes by post-processing the initial error estimates and producing new
estimates of the channel error. If these new estimates do not revert the
channel error, then they are referred to as failed recoveries or failed error
corrections. In [3], all of the failed error corrections were shown to be end-
to-end errors with different syndromes, whereas in [24] a small percentage of
failed estimates were shown to be end-to-end identical syndrome errors and
end-to-end degenerate errors333The authors of this work do not distinguish
between end-to-end identical syndrome errors and end-to-end degenerate
errors..

Aside from these failed recovery analyses, the literature is limited when it
comes to assessing the percentage of decoding failures that is caused by each
type of end-to-end error. It is reasonable to believe that QLDPC codes, given
their large number of degenerate operators [3, 4, 12, 14, 27, 28], will
experience a large percentage of end-to-end degenerate errors. We confirm this
intuition in the final section of our work, where we show how up to $30\%$ of
the end-to-end errors that take place when using the QLDPC codes of [21, 22,
26] are degenerate.

###  III.1 Discriminating between different types of end-to-end errors

It is clear from the defining characteristics of each specific type of end-to-
end error (see table LABEL:errors), that end-to-end errors with different
syndromes are the easiest type of error to identify. In fact, doing so is
trivial, as all that is required is a comparison of the syndrome estimate,
$\mathrm{\hat{w}}\in\mathbb{F}_{2}^{N-k}$, and the measured syndrome,
$\mathrm{w}\in\mathbb{F}_{2}^{N-k}$, where $k$ and $N$ represent the number of
logical qubits and physical qubits (blocklength) of the quantum code,
respectively. Similarly, knowing that either an end-to-end identical syndrome
error or an end-to-end degenerate error has occurred is simple. This can be
done by comparing the estimate of the error sequence $\mathbf{\hat{E}}$ to the
channel error $\mathbf{E}$ whenever $\mathrm{\hat{w}}=\mathrm{w}$, i.e., if
$\mathbf{\hat{E}}\neq\mathbf{E}$ either an end-to-end degenerate error or an
identical syndrome error has occurred, and if $\mathbf{\hat{E}}=\mathbf{E}$,
no error has taken place. The issue arises when trying to distinguish between
these two families of end-to-end errors. Notice that the comparison
$\mathbf{\hat{E}}\neq\mathbf{E}$ does not reveal if the error estimate belongs
to the same stabilizer coset as the channel error. Hence, we have no way of
discriminating between end-to-end degenerate errors and end-to-end identical
syndrome errors.

Conceptually, the simplest and most straightforward strategy that comes to
mind to resolve this problem is to compute the stabilizer of the code in
question, compute the $\star$ product of the stabilizer with the channel error
$\mathbf{E}$ to extract the specific stabilizer coset of the channel error,
and then check if $\mathbf{\hat{E}}$ belongs to this coset. As mentioned in
[14], this works because the coset representative choice for the coset
$(\mathbf{T}_{i}\star\mathbf{L}_{j})\star\mathcal{\overline{S}}$ is irrelevant
(any operator belonging to the coset serves as a valid representative), where
$\\{\mathbf{T}_{i},\mathbf{L}_{j}\\}\in\mathcal{\overline{G}}_{N}$, and
$\mathcal{\overline{S}}\subset\mathcal{\overline{G}}_{N}$, represent the
effective centralizer coset representative, the stabilizer coset
representative, and the stabilizer itself. Thus, computing
$\mathbf{E}\star\mathcal{\overline{S}}$ will yield the stabilizer coset of the
channel error, i.e.,
$\mathbf{E}\star\mathcal{\overline{S}}=(\mathbf{T}_{i}\star\mathbf{L}_{j})\star\mathcal{\overline{S}}$.
Therefore, whenever $\mathrm{\hat{w}}=\mathrm{w}$ and
$\mathbf{\hat{E}}\neq\mathbf{E}$, we will know that an end-to-end degenerate
error has occurred if the estimated error sequence $\mathbf{\hat{E}}$ is in
the coset $\mathbf{E}\star\mathcal{\overline{S}}$. If this does not occur,
then an end-to-end identical syndrome error will have taken place.

Unfortunately, since extracting the stabilizer of a quantum code becomes
increasingly complex as its blocklength increases, this strategy will only be
applicable to short quantum codes. The number of elements in the stabilizer of
a quantum code with blocklength $N$ and rate $R_{Q}$ is given by
$2^{N-k}=2^{N(1-R_{Q})}$ [14], which grows exponentially with $N$ and can
rapidly become intractable on a classical machine as this parameter increases.
In light of this, it is apparent that more practical methods to differentiate
between end-to-end degenerate errors and end-to-end identical syndrome errors
are necessary. Both the strategy we propose herein and that employed in [3,
17, 15, 16, 18], which are explained in the next two sections, resolve this
issue.

###  III.2 An algebraic perspective on end-to-end degenerate errors

The problem of differentiating between end-to-end identical syndrome errors
and end-to-end degenerate errors can also be formulated as a set of linear
equations. The Parity Check Matrix (PCM) of a stabilizer code that encodes $k$
logical qubits into $N$ physical qubits (a rate $R_{Q}=\frac{k}{N}$ code with
blocklength $N$) can be written as

$\mathbf{H}_{\mathcal{\overline{S}}}=\begin{pmatrix}\mathbf{h}_{1}\\\
\mathbf{h}_{2}\\\ \vdots\\\ \mathbf{h}_{N-k}\end{pmatrix},$ (10)

where $\mathbf{h}_{v}=\mathbf{s}_{v}$ denotes the symplectic representation of
the generators $\\{\mathbf{S}_{v}\\}_{v=1}^{N-k}\in\mathcal{\overline{G}}_{N}$
that define the stabilizer group $\mathcal{\overline{S}}$. Each of the
elements of $\mathcal{\overline{S}}$ is a linear combination of the $N-k$
generators, hence, if $\mathbf{S}$ is an element of the stabilizer and
$\mathbf{s}$ is the symplectic representation of this stabilizer element, then

$\mathbf{s}=\left(\sum_{i=1}^{N-k}\mathrm{a}_{i}\mathbf{h}_{i}\right)\mod{2},$
(11)

where $\mathbf{a}=(\mathrm{a}_{1},\ldots,\mathrm{a}_{N-k})$ is a unique binary
vector.

Whenever a channel error $\mathbf{E}$ takes place, the decoder will compute an
estimate of this error and produce an estimate of the syndrome associated to
it. As discussed previously, this syndrome only determines which specific
effective centralizer coset the channel error belongs to. In other words, the
syndrome provides the effective centralizer coset representative
$\mathbf{T}_{i}$ (known as the pure error component in the literature) of the
channel error. Assuming that an end-to-end error with different syndrome does
not occur, the estimated syndrome will match the measured syndrome, hence the
centralizer coset representative of the estimated error sequence and the
centralizer coset representative of the channel error will also be the same,
i.e., $\mathbf{T}_{i}=\mathbf{\hat{T}}_{i}$. Thus, if we compute the $\star$
operation of the channel error $\mathbf{E}$ and the estimated error
$\mathbf{\hat{E}}$, which can also be understood as the mod2 sum of their
symplectic representations over $\mathbb{F}_{2}^{2N}$:
$\beta(\mathbf{E})\oplus\beta(\mathbf{\hat{E}})=\mathbf{e}\oplus\mathbf{\hat{e}}$,
where $\beta$ denotes the symplectic map, the sequence $\mathbf{E}$ will be
shifted to the effective centralizer
$\mathcal{\overline{Z}}(\mathcal{\overline{S}})$. Note that we can also write
this using the symplectic map as
$\mathbf{E}\star\mathbf{\hat{E}}\in\mathcal{\overline{Z}}(\mathcal{\overline{S}})\rightarrow\beta(\mathbf{E})\oplus\beta(\mathbf{\hat{E}})\in\beta(\mathcal{\overline{Z}}(\mathcal{\overline{S}}))=\mathbf{e}\oplus\mathbf{\hat{e}}\in\Gamma_{R}$,
where $\Gamma_{R}\subset\mathbb{F}_{2}^{2N}$ denotes the equivalent group of
the effective centralizer over $\mathbb{F}_{2}^{2N}$. Based on this, the issue
of determining whether an end-to-end error is degenerate can be understood as
finding out if $\mathbf{E}\star\mathbf{\hat{E}}$ belongs to the stabilizer.
This can be formulated based on the symplectic map into the following
question:

$\exists\
\mathbf{a}:\mathbf{e}\oplus\mathbf{\hat{e}}=\left(\sum_{i=1}^{N-k}\mathrm{a}_{i}\mathbf{h}_{i}\right)\mod{2}\
\text{ ?}$ (12)

Essentially, if a set of coefficients $\mathbf{a}$ exists such that the above
equation holds, i.e., if
$\mathbf{e}\oplus\mathbf{\hat{e}}\in\mathbb{F}_{2}^{2N}$ is a linear
combination of the symplectic representation of the stabilizer generators,
then $\mathbf{E}\star\mathbf{\hat{E}}$ belongs to the stabilizer and an end-
to-end degenerate error will have occurred. If such a set of coefficients does
not exist, then and end-to-end identical syndrome error has taken place.

The expression shown in (12) defines a linear system of equations over the
binary field. An answer to this question can be found by writing the augmented
matrix
$[\mathbf{H}_{\mathcal{\overline{S}}}^{\top}|(\mathbf{e}\oplus\mathbf{\hat{e}})^{\top}]$
in its row-echelon form. This means that, based on this procedure, it is
possible to determine the type of end-to-end errors that occur and
subsequently compute the logical error rate. This is done in [20]. However,
although the procedure is conceptually simple, rewriting the augmented matrix
in such a manner becomes increasingly computationally complex as matrices grow
in size. Unfortunately, for sparse quantum codes to be good, the blocklength
must be large, which implies that the PCMs of these codes will also be
large444The PCMs of QEC codes are of size $N-k\times 2N$. A common size in the
literature of QLDPC codes is $10000$ qubits, thus the PCM associated to such a
code would be of size $(10000-k)\times 20000$.. Furthermore, the row-echelon
form of the matrix
$[\mathbf{H}_{\mathcal{\overline{S}}}^{\top}|(\mathbf{e}\oplus\mathbf{\hat{e}})^{\top}]$
must be computed during every simulation iteration (whenever the estimated
syndrome and the measured syndrome match) to determine what type of end-to-end
error has taken place, which may significantly increase simulation time. For
these reasons, calculating the logical error rate based on this procedure can
become a cumbersome and lengthy endeavour. Therefore, the task at hand is to
find a more practical and less computationally demanding way to determine if
the congruence equation system given in (12) has a solution, as this suffices
to determine if the end-to-end error is degenerate (we do not actually need to
solve the system itself).

####  III.2.1 Classical coding-inspired strategy

It is possible to find an answer to (12) by casting the problem in the
framework of classical linear block codes. In classical coding theory, the
encoding matrix or generator matrix $\mathbf{G}_{c}$ of a binary linear block
code and its corresponding parity check matrix $\mathbf{H}_{c}$ fulfil
$(\mathbf{G}_{c}\mathbf{H}_{c}^{\top})\mod
2=(\mathbf{H}_{c}\mathbf{G}_{c}^{\top})\mod 2=0$. This means that the parity
check matrix defines a basis for the nullspace of the generator matrix and
viceversa. In the classical scenario, having a basis for the nullspace of a
code enables us to determine whether the decoding outcome $\mathbf{x}$ belongs
to the code by simply computing its product with the parity check matrix of
the code, i.e., if $(\mathbf{H}_{c}\mathbf{x}^{\top})\mod 2=0$ then
$\mathbf{x}$ is a codeword. Essentially, whenever
$(\mathbf{H}_{c}\mathbf{x}^{\top})\mod 2=0$, the decoding outcome is a linear
combination of the rows of the generator matrix $\mathbf{G}_{c}$ and it
belongs to the code, and whenever $(\mathbf{H}_{c}\mathbf{x}^{\top})\mod 2\neq
0$, $\mathbf{x}$ does not belong to the code.

Notice that, based on this formulation, the quandary posed in (12) is
reminiscent of the classical decoding scenario. The main difference is that
instead of determining if the decoding outcome belongs to the code, we must
discover if the sum of the symplectic representations of the channel error and
the estimated error belong to the stabilizer. This parallelism between the
classical and quantum problems allows us to apply the classical resolution
strategy to the quantum paradigm with only a slight caveat: answering (12)
requires an inverse approach to the classical method. Since the generators of
the stabilizer code are given by the rows of the parity check matrix
$\mathbf{H}_{\mathcal{\overline{S}}}$, the corresponding kernel generator
matrix555We refer to the matrix $\mathbf{G}_{\mathcal{\overline{S}}}$ as the
kernel generator matrix to avoid the term stabilizer generator matrix, as this
latter term implies that the the matrix can be used for encoding purposes
(which may not be true in the present case).
$\mathbf{G}_{\mathcal{\overline{S}}}$ (instead of the parity check matrix like
in the classical paradigm) must be used to discover if
$\mathbf{e}\oplus\mathbf{\hat{e}}$ can be written as a linear combination of
the stabilizer generators. The matrix $\mathbf{G}_{\mathcal{\overline{S}}}$
defines a basis for the nullspace of the stabilizer code, hence it will
suffice to compute
$[\mathbf{G}_{\mathcal{\overline{S}}}(\mathbf{e}\oplus\mathbf{\hat{e}})^{\top}]\mod
2$ to find the answer to (12). If
$[\mathbf{G}_{\mathcal{\overline{S}}}(\mathbf{e}\oplus\mathbf{\hat{e}})^{\top}]\mod
2=0$, $\mathbf{E}\star\mathbf{\hat{E}}\in\mathcal{\overline{S}}$ which means
that an end-to-end degenerate error has occurred, and if
$[\mathbf{G}_{\mathcal{\overline{S}}}(\mathbf{e}\oplus\mathbf{\hat{e}})^{\top}]\mod
2\neq 0$, $\mathbf{E}\star\mathbf{\hat{E}}\not\in\mathcal{\overline{S}}$, and
an end-to-end identical syndrome error will have taken place.

This strategy provides us with a simple and computationally efficient method
to determine the type of end-to-end error that has taken place. The only
requirement is obtaining the matrix $\mathbf{G}_{\mathcal{\overline{S}}}$,
which can be computed once (by finding a basis for the nullspace of its parity
check matrix $\mathbf{H}_{\mathcal{\overline{S}}}$) and can then be stored
offline for any stabilizer code. In this manner, we have designed a simple
method to solve (12) that does not require the computation of the stabilizer
and so avoids the complexity issues that this entails.

###  III.3  Detecting end-to-end degenerate errors using encoded Pauli
operators

There is another manner of distinguishing between end-to-end identical
syndrome errors and end-to-end degenerate errors. It involves obtaining the
encoded Pauli operators666In the literature, these operators are referred to
as logical operators. However, we use the term encoded Pauli operators to
distinguish them from the stabilizer coset representatives
$\\{\mathbf{L}_{j}\\}_{j=1}^{2^{2k}}$ which we originally defined as logical
operators. of a code following a method derived by Gottesman in his seminal
work [8], and then using these operators to determine whether the error
estimate produced by the decoder is in the stabilizer coset of the channel
error (end-to-end degenerate errors occur when this happens and end-to-end
identical syndrome errors occur when it does not). This strategy was first
applied to QLDPC codes in [3], and has since been used in [17, 15, 16, 18].

The encoded Pauli operators of an $N$-qubit stabilizer code are defined as
those operators in $\mathcal{G}_{N}$ that commute with the elements of the
stabilizer group and whose action on an encoded state can be understood as an
$X,Y,$ or $Z$ operation on each of the encoded logical qubits. Each stabilizer
code has $2k$ encoded Pauli operators777Given the difference in the number of
stabilizer coset representatives (logical operators)
$\\{\mathbf{L}_{j}\\}_{j=1}^{2^{2k}}$ and encoded Pauli operators, it is
useful to employ different terminology for these concepts (even though encoded
Pauli operators are related to logical operators and vice-versa). which are
generally represented using the notation $\overline{Z}_{q}$ and
$\overline{X}_{l}$, where $\\{q,l\\}\in\\{1,\ldots,k\\}$. In this manner,
$\overline{Z}_{q}$ represents an operator in $\mathcal{G}_{N}$ whose action is
analogous to performing a $Z$ operation (phase flip) on the $i$-th logical
qubit. Thus $\overline{Z}_{q}\in\mathcal{G}_{N}$ maps to
$Z_{q}\in\mathcal{G}_{k}$, where $Z_{q}$ denotes the action of a $Z$ operator
on the $i$-th qubit and the action of $I$ operators on the remaining qubits
(identity operators are omitted). Recall that, since the global phase can be
ignored, it will be equivalent for the purpose of error correction to consider
the equivalent encoded Pauli operators over the effective $N$-fold Pauli
group, $\overline{Z}_{q}\equiv\overline{\mathbf{Z}}_{q}$ and
$\overline{X}_{l}\equiv\overline{\mathbf{X}}_{l}$, where
$\overline{\mathbf{Z}}_{q},\overline{\mathbf{X}}_{l}\in\mathcal{\overline{G}}_{N}$
(we use capital boldface to preserve the notation of [14].)

Based on this definition of the encoded Pauli operators, we know that an
encoded Pauli operator $\overline{\mathbf{Z}}_{q}$ commutes with all the
elements of $\mathcal{\overline{S}}$ as well as with all other encoded Pauli
operators except for the operator $\overline{\mathbf{X}}_{l}$ when $q=l$. This
means that, if the encoded Pauli operators of a stabilizer code are known, we
can determine if an operator
$\mathbf{A}\in\mathcal{\overline{Z}(\overline{S})}\subset\mathcal{\overline{G}}_{N}$
belongs to $\mathcal{\overline{S}}$ by checking the commutation relations of
$\mathbf{A}$ with the encoded Pauli operators. If $\mathbf{A}$ commutes with
all the encoded Pauli operators it is within the stabilizer and if it does not
(it anti commutes with one encoded Pauli operator) it is not in the
stabilizer. Against this backdrop, it is easy to see how this strategy can be
applied to solve the issue of discriminating between end-to-end identical
syndrome errors and end-to-end degenerate errors. After successful decoding
(the decoder produces a matching estimate of the syndrome), we know that
$\mathbf{E}\star\mathbf{\hat{E}}\in\mathcal{\overline{Z}(\overline{S})}$. Now,
we determine if $\mathbf{E}\star\mathbf{\hat{E}}$ is in
$\mathcal{\overline{S}}$ by checking its commutation status with
$\\{\overline{\mathbf{Z}}_{q}\\}_{q=1}^{k}$ and
$\\{\overline{\mathbf{X}}_{l}\\}_{l=1}^{k}$. If
$\mathbf{E}\star\mathbf{\hat{E}}$ commutes with all the encoded Pauli
operators, $\mathbf{E}\star\mathbf{\hat{E}}\in\mathcal{\overline{S}}$ and an
end-to-end degenerate error has occurred. If not, an end-to-end identical
syndrome error has occurred. It is based on these comparisons that the logical
error rate was successfully computed in [15, 16, 17, 18].

Naturally, to be able to apply the method one must first have knowledge of the
encoded Pauli operators of the code. This is similar to the classical coding-
based strategy we propose in this paper, which requires the computation of the
kernel generator matrix $\mathbf{G}_{\mathcal{\overline{S}}}$. The encoded
Pauli operators of a stabilizer code can be found based on the concept of the
standard form (see Chapter 4 of [8]). In this work, Gottesman showed how, by
applying row operations (i.e. Gaussian elimination) together with the
necessary qubit permutations (i.e. column permutations) on the parity check
matrix of a stabilizer code, one can obtain a special row reduced echelon form
of the parity check matrix: the standard form. Once the standard form is
known, the encoded Pauli operators $\\{\overline{\mathbf{Z}}_{q}\\}_{q=1}^{k}$
and $\\{\overline{\mathbf{X}}_{l}\\}_{l=1}^{k}$ can be directly obtained from
it using matrix algebra [8, 41]. As with the kernel generator matrix
$\mathbf{G}_{\mathcal{\overline{S}}}$, the encoded Pauli operators of a
specific code need only be computed once and can then be stored offline.

###  III.4 Method Comparison

For general stabilizer codes, computing the logical error rate based on the
classical coding inspired strategy does not yield benefits over doing so via
the encoded Pauli operator method. This has to do with the fact that both of
them have the same computational complexity: performing Gaussian elimination
and column permutations is also what finding the basis for the nullspace of a
matrix requires. As is shown in [45], these operations scale as $O(N^{3})$.
However, when it comes to the widely-employed family of Calderbank-Shor-Steane
codes, the classical coding inspired strategy we propose herein will benefit
from a substantial complexity advantage.

CSS codes [7, 44] are a particular type of stabilizer code that provide an
efficient design strategy to build QEC codes from existing classical codes.
The quantum parity check matrix of a CSS code is written as

$\mathbf{H}_{Q}=(\mathrm{H}_{x}|\mathrm{H}_{z})=\begin{pmatrix}\mathrm{H}_{x}^{{}^{\prime}}&0\\\
0&\mathrm{H}_{z}^{{}^{\prime}}\end{pmatrix},$ (13)

where $\mathrm{H}_{x}=\begin{pmatrix}\mathrm{H}_{x}^{{}^{\prime}}\\\
0\end{pmatrix}$ and $\mathrm{H}_{z}=\begin{pmatrix}0\\\
\mathrm{H}_{z}^{{}^{\prime}}\end{pmatrix}$.

In this construction, $\mathrm{H}_{x}^{\prime}$ and $\mathrm{H}_{z}^{\prime}$
are the parity check matrices of two binary classical LDPC codes $C_{1}$ and
$C_{2}$, respectively, where each matrix is used to correct either bit-flips
or phase-flips. As discussed previously, any classical binary LDPC code or any
classical binary linear block code for that matter, will satisfy
$(\mathbf{G}_{c}\mathbf{H}_{c}^{\top})\text{mod}2=\mathbf{0}$, where
$\mathbf{G}_{c}$ and $\mathbf{H}_{c}$ represent the generator and parity check
matrices of a binary classical LDPC code, respectively. Because the generator
matrix is necessary to encode a classical LDPC code, the issue of deriving the
matrix $\mathbf{G}_{c}$ from $\mathbf{H}_{c}$ has been widely researched in
the realm of classical error correction [45, 46, 47, 48, 49]. In general,
finding the matrix $\mathbf{G}_{c}$ from $\mathbf{H}_{c}$, i.e, bringing the
PCM into the desired form, requires $O(N^{3})$ operations of processing [45].
However, through the clever application of optimization algorithms, the
complexity of this task has been reduced [45, 46, 47] and classical LDPC codes
with a linear encoding complexity888Richardson et al.[45] showed that the
encoding complexity is upper-bounded by $O(N)+O(g^{2})$, where $g$ is the gap
to measure the “distance” between a given parity-check matrix and a lower
triangular matrix. This means that in the extreme case where $g=0$, such as
for Irregular Repeat–Accumulate (IRA) codes [50], $\mathbf{G}_{c}$ can be
computed with complexity $O(N)$. have been found. Note that based on the
structure of the QPCM of CSS codes (13) we can derive the kernel generator
matrix of a CSS code as

$\mathbf{G}_{\mathcal{\overline{S}}}=(\mathrm{G}_{x}|\mathrm{G}_{z})=\begin{pmatrix}\mathrm{G}_{x}^{{}^{\prime}}&0\\\
0&\mathrm{G}_{z}^{{}^{\prime}}\end{pmatrix},$ (14)

where $\mathrm{G}_{x}^{\prime}$ and $\mathrm{G}_{z}^{\prime}$ are the
generator matrices of the binary classical LDPC codes $C_{1}$ and $C_{2}$,
respectively. We know that the matrix given in (14) will actually serve the
purpose of a kernel generator matrix because its rows are all linearly
independent. The difficulty in computing (14) lies in deriving the generator
matrices $\mathrm{G}_{x}^{\prime}$ and $\mathrm{G}_{z}^{\prime}$ from the PCMs
$\mathrm{H}_{x}^{\prime}$ and $\mathrm{H}_{z}^{\prime}$. However, when
constructing CSS QLDPC codes from classical LDPC codes, it is a prerequisite
that the classical code be known. Thus, it is reasonable to assume that the
generator matrices of the classical codes that make up a CSS QLDPC code are
available999If the LDPC codes have previously been used in the classical
paradigm then these generator matrices are known (they must have been employed
in the classical encoding procedure).. Against this backdrop, because this
does not require finding the standard form of the QPCM and deriving its
encoded Pauli operators, the method we propose herein will have a complexity
advantage over the encoded Pauli operator method when computing the logical
error rate of sparse CSS quantum codes. More specifically, when using
classical LDPC codes to build QLDPC CSS codes, because the generator matrices
associated to the corresponding parity check matrices of these codes are
known, the complexity of our method is negligible, as no calculations will be
necessary to obtain the kernel generator matrix (it can be derived by simply
introducing the appropriate generator matrices in (14), i.e, the complexity is
$O(1)$). In the case that the generator matrix of a particular classical LDPC
code is not known, it can be derived as shown in [45] with complexity
$O(N)+O(g^{2})$, where $g$ is the gap to measure the “distance” between the
parity-check matrix and a lower triangular matrix. This means that the
computational complexity of calculating the kernel generator matrix of a CSS
code will be at most $O(N)+O(g^{2})$, which implies that, in the context of
CSS codes, our strategy is less computationally complex than the one based on
using encoded Pauli operators, which has complexity $O(N^{3})$.

##  IV Simulation Results

We close this section by using our method to show how end-to-end errors with
identical syndromes and end-to-end degenerate errors can account for a
significant percentage of the end-to-end errors that occur when using QLDPC
codes. For this purpose, we simulate the CSS QLDGM codes of [21, 22, 26] with
different rates and blocklengths over the depolarizing channel. The
characteristics of these codes are detailed in table 2. The underlying
classical LDGM matrices and the structure of the $M$ matrix, critical to the
performance of the QLDGM codes, have been chosen according to the optimization
guidelines detailed in [21, 22, 26, 51, 52]. The results of these simulations
are shown in Figure LABEL:fig:results-codes, where each subfigure groups the
results by blocklength, i.e, each of the subfigures portrays the results for
all the codes with the same value of $N$. The graphs plot the ratio of a
specific type of end-to-end error against the depolarizing probability. The
aforementioned ratio is computed as $\frac{\mathrm{E}_{i}}{\mathrm{E}_{T}}$,
where $\mathrm{E}_{i}$ denotes the total number of end-to-end errors of a
specific type ($i=1,2,3$.):

  * •

$\mathrm{E}_{1}\rightarrow$ end-to-end errors with different syndromes,

  * •

$\mathrm{E}_{2}\rightarrow$ end-to-end errors with identical syndromes,

  * •

$\mathrm{E}_{3}\rightarrow$ end-to-end degenerate errors,

and $\mathrm{E}_{T}$ represents the total number of end-to-end errors. To
ensure that the simulation results are precise, the ratios have been computed
after a total of $1000$ decoding mistakes have been made (following the Monte
Carlo simulation rule of thumb provided in [53]), i.e., $\mathrm{E}_{T}=1000$.

Table 2: Parameter values and configurations of simulated codes.  $N$ | $R_{Q}$ | Classical LDGM | $[m,p,x,y]$
---|---|---|---
$100$ | $0.1$ | P($3,3$) | [$45,24,6,3$]
$100$ | $0.2$ | P($3,3$) | [$40,18,6,3$]
$100$ | $0.25$ | P($3,3$) | [$38,15,6,3$]
$100$ | $0.5$ | P($3,3$) | [$25,6,7.57,3$]
$500$ | $0.1$ | P($5,5$) | [$225,170,11,3$]
$500$ | $0.2$ | P($5,5$) | [$200,144,11,3$]
$500$ | $0.25$ | P($5,5$) | [$188,130,11,3$]
$500$ | $0.33$ | P($5,5$) | [$163,102,11,3$]
$500$ | $0.5$ | P($5,5$) | [$125,60,11,3$]
$2000$ | $0.1$ | P($9,9$) | [$900,691,11,3$]
$2000$ | $0.2$ | P($9,9$) | [$800,581,11,3$]
$2000$ | $0.25$ | P($9,9$) | [$750,526,11,3$]
$2000$ | $0.33$ | P($9,9$) | [$670,438,11,3$]
$2000$ | $0.5$ | P($9,9$) | [$500,251,11,3$]

The outcomes portrayed in Figure LABEL:fig:results-codes confirm our initial
intuition that sparse quantum codes are degenerate. It is easy to see that for
all of the simulated blocklengths and rates (except for $R_{Q}=0.5$), the
percentage of end-to-end errors that are not of the $\mathrm{E}_{1}$ type is
not negligible, i.e.,
$\frac{\mathrm{E}_{2}}{\mathrm{E}_{T}}+\frac{\mathrm{E}_{3}}{\mathrm{E}_{T}}\neq
0$. Furthermore, these results speak towards the higher precision of the
logical error rate compared to the physical error rate when assessing the
performance of these codes. For instance, at a noise level of $p=0.005$,
$\frac{\mathrm{E}_{3}}{\mathrm{E}_{T}}=0.198$ for the $N=500$ $R_{Q}=0.1$
code. This means that $19.8\%$ of the end-to-end errors are degenerate and
should not be counted as decoding failures. Thus, in this scenario, the
physical error rate overestimates the number of decoding failures and does not
provide an accurate representation of the performance of the code. In fact,
regardless of the noise level of the channel, the rate of the code (except for
$R_{Q}=0.5$), and the blocklength of the code, end-to-end degenerate errors
take place, and so the physical error rate will always provide an inaccurate
representation of the performance of these sparse quantum codes. Therefore, as
is stated in [18], it is clear that performance results assessed based on the
physical error rate ($\mathbf{\hat{E}}=\mathbf{E}$ as the decoding success
criterion) [21, 22, 23, 24, 25, 26] are inaccurate (they report an upper
bound).

(a)

(b)

(c)

Figure 1: Ratios of end-to-end different syndrome, identical syndrome and
degenerate errors for codes of various rates and blocklengths: (a) $N=100$ (b)
$N=500$ (c) $N=2000$.

Furthermore, the results shown in Figure LABEL:fig:results-codes also reveal
how the frequency with which each type of end-to-end error takes place varies
as a function of different parameters:

  * •

End-to-end errors with different syndromes represent a large percentage of the
total number of end-to-end errors when the rate of the code is high. This
percentage decreases as the rate of the codes goes from $R_{Q}=0.5$ to
$R_{Q}=0.1$ (see ratio $\frac{\mathrm{E}_{1}}{\mathrm{E}_{T}}$ in Figure
LABEL:fig:results-codes). This trend becomes further exacerbated as the
blocklength of the simulated codes increases, i.e., for low rate large
blocklength codes the ratio $\frac{\mathrm{E}_{1}}{\mathrm{E}_{T}}$ will be
significantly smaller than for low rate short codes.

  * •

End-to-end identical syndrome errors represent the smallest percentage of the
total number of end-to-end errors in most of the simulated cases. This is
reflected by the fact that
$\frac{\mathrm{E}_{2}}{\mathrm{E}_{T}}<\frac{\mathrm{E}_{1}}{\mathrm{E}_{T}},\frac{\mathrm{E}_{3}}{\mathrm{E}_{T}}$
in all of our simulation outcomes.

  * •

As the noise level of the channel grows, the ratio
$\frac{\mathrm{E}_{1}}{\mathrm{E}_{T}}$ becomes larger and the ratio
$\frac{\mathrm{E}_{2}}{\mathrm{E}_{T}}$ diminishes. The ratio of end-to-end
degenerate errors $\frac{\mathrm{E}_{3}}{\mathrm{E}_{T}}$ stays relatively
constant.

The relationships between these parameters and different types of end-to-end
errors serve to draw conclusions, some of which should be explored in future
work. For instance, the large values of
$\frac{\mathrm{E}_{1}}{\mathrm{E}_{T}}$ in many of the simulated instances can
be understood as a sign that performance gains may be attained by improving
the decoding algorithm. This means that applying modified decoding strategies,
such as those of [20, 24, 15, 16, 17], will aid in reducing the presence of
end-to-end errors with different syndromes (they estimate the syndrome
correctly when the original decoder does not) and improve performance. A
matter that should be considered is how often these strategies produce failed
error corrections in the form of end-to-end identical syndrome errors. For the
methodology of [24], such events were shown to be rare, hence we expect these
strategies to be a good approach to improve the performance of QLDPC codes. On
the other hand, the large values of $\frac{\mathrm{E}_{3}}{\mathrm{E}_{T}}$
when compared to $\frac{\mathrm{E}_{2}}{\mathrm{E}_{T}}$, especially at higher
blocklengths, show that end-to-end identical syndrome errors are the least
frequent of all the end-to-end error types. Despite the relatively small
percentage that end-to-end identical syndrome errors represent, it is possible
that their relevance will grow when the amount of end-to-end errors with
different syndromes is reduced (using modified decoding strategies) or when
the degenerate content of the code is increased (through design). At this
point, it may be that further improvements in performance will only be
possible by designing an optimal degenerate decoder with the capability to
correct end-to-end identical syndrome errors. Finally, given that the method
proposed in this work is valid to detect end-to-end degenerate errors, it may
be interesting in future work to employ this methodology to specifically
design codes to be degenerate. This could result in code constructions in
which the likelihood of end-to-end degenerate errors is maximized, which would
allow the positive effects of degeneracy (improved error correction
capabilities without a decoding complexity increase) to be completely
exploited for quantum error correction purposes.

##  V Conclusion

We have presented a method to detect degenerate errors in sparse quantum codes
in a computationally efficient manner. We have also shown how this method is
less complex than other existing strategies to compute the logical error rate
of sparse CSS quantum codes. Making use of our scheme, we have shown how
sparse quantum codes have a significant percentage of degenerate errors. This
means that the discrepancy between the logical error rate and the physical
error rate is exacerbated for sparse quantum codes. Our results show that, for
specific families of QLDPC codes, performance may be up to $20\%$ better than
would be expected from previous results in the literature that are based on
the physical error rate. In addition, these simulation outcomes serve to show
how performance may be improved by constructing degenerate quantum codes, and
they also speak toward the positive impact that modified decoding strategies
can have on the performance of sparse quantum codes.

##  VI Acknowledgements

This work was financially supported by the Spanish Ministry of Economy and
Competitiveness through the ADELE project (Grant No. PID2019-104958RB-C44), by
the Spanish Ministry of Science and Innovation through the proyect “Few-qubit
quantum hardware, algorithms and codes, on photonic and solid- state systems”
(PLEC2021-008251), by the Ministry of Economic Affairs and Digital
Transformation of the Spanish Government through the QUANTUM ENIA project call
- QUANTUM SPAIN project, by the European Union through the Recovery,
Transformation and Resilience Plan - NextGenerationEU within the framework of
the Digital Spain 2025 Agenda, and by the Diputación Foral de Gipuzkoa through
the DECALOQC Project No. E 190 / 2021 (ES). This work was also funded in part
by NSF Award No. CCF-2007689. The authors would like to thank Dr. Pavel
Panteleev, Dr. Kao-Yueh Kuo, and Mr. Alex Rigby for their valuable input and
useful discussions.

## References

  * [1] D. P. DiVincenzo, P. W. Shor, and J. A. Smolin, “Quantum-channel capacity of very noisy channels”, _Phys. Rev. A_ , vol.57, pp. 830-839, 1998. doi: 10.1103/PhysRevA.57.830.
  * [2] G. Smith and J. A. Smolin, “Degenerate Quantum Codes for Pauli Channels”, _Phys. Rev. Lett._ , vol.98, pp. 030501, 2007. doi: 10.1103/PhysRevLett.98.030501.
  * [3] D. Poulin and Y. Chung, “On the iterative decoding of sparse quantum codes”, _QIC_ , vol.8, no.10 pp. 987, 2008. doi: 10.5555/2016985.2016993.
  * [4] M. H. Hsieh and F. Le Gall, “NP-hardness of decoding quantum error-correction codes”, _Phys. Rev. A_ , vol. 83, pp. 052331, 2010. doi: 10.1103/PhysRevA.83.052331.
  * [5] A. R. Calderbank and P. W. Shor, “Good quantum error correcting codes exist,” _Phys. Rev. A_ , vol. 54, pp. 1098-1105, 1996. doi: 10.1103/PhysRevA.54.1098.
  * [6] A. R. Calderbank, E. M. Rains, P. W. Shor, and N. J. A. Sloane, “Quantum error correction via codes over GF(4),” _IEEE Trans. Inf. Theory_ , vol. 44, pp.1369–1387, 1998. doi: 10.1109/18.681315.
  * [7] A. Steane, Proceedings of The Royal Society A Mathematical, “Multiple-particle interference and quantum error correction”, _Physical and Engineering Sciences_ , vol. 452, no. 1954, 1996. doi: 10.1098/rspa.1996.0136.
  * [8] D. Gottesman, “Stabilizer codes and quantum error correction,” Ph.D. dissertation, California Inst. Tech., Pasadena, CA, USA, 1997. online: arXiv:quant-ph/9705052.
  * [9] B. Yoshida and I. L. Chuang, “Framework for classifying logical operators in stabilizer codes”, _Phys. Rev. A_ , vol. 81, pp. 052302, 2010. doi: 10.1103/PhysRevA.81.052302.
  * [10] E. Pelchat and D. Poulin, “Degenerate Viterbi Decoding”, _IEEE Trans. on Information Theory_ , vol. 59, no. 6, pp. 3915 - 3921, 2013. doi: 10.1109/TIT.2013.2246815.
  * [11] S. Varsamopoulos, B. Criger, and K. Bertels, “Decoding small surface codes with feedforward neural networks”, _Quantum Science and Technology_ , vol. 3, no. 1, pp. 015004, 2017. doi: 10.1088/2058-9565/aa955a.
  * [12] P. Iyer and D. Poulin, “Hardness of decoding quantum stabilizer codes”, _IEEE Trans. on Information Theory_ , vol. 61, no. 9, pp. 5209-5223, 2015. doi: 10.1109/TIT.2015.2422294.
  * [13] D. Poulin, “Optimal and Efficient Decoding of Concatenated Quantum Block Codes”, _Phys. Rev. A_ , vol. 74, pp. 052333, 2006. doi: 10.1103/PhysRevA.74.052333.
  * [14] P. Fuentes, J. Etxezarreta Martinez, P. M. Crespo, and J. Garcia-Frias, “Degeneracy and its impact on the decoding of sparse quantum codes”, _IEEE Access_ vol. 9, pp. 89093-89119, 2021. doi: 10.1109/ACCESS.2021.3089829.
  * [15] P. Panteleev and G. Kalachev, “Degenerate quantum LDPC codes with good ﬁnite length performance,” online: arXiv:1904.02703, 2019.
  * [16] J. Roffe, D. R. White, S. Burton, and E. T. Campbell, “Decoding Across the Quantum LDPC Code Landscape,” Phys. Rev. Research, vol. 2, no. 4, pp. 043423, 2020. doi: 10.1103/PhysRevResearch.2.043423.
  * [17] K. -Y. Kuo and C. -Y. Lai, “Refined Belief Propagation Decoding of Sparse-Graph Quantum Codes,” IEEE Journal on Selected Areas in Information Theory, vol. 1, no. 2, pp. 487-498, 2020. doi: 10.1109/JSAIT.2020.3011758.
  * [18] K.-Y. Kuo and C.-Y. Lai, “Exploiting degeneracy in belief propagation decoding of quantum codes”, online: arXiv:2104.13659.
  * [19] T. Camara, H. Ollivier and J. Tillich, “A class of quantum LDPC codes: construction and performances under iterative decoding,” 2007 IEEE International Symposium on Information Theory, 2007, pp. 811-815, doi: 10.1109/ISIT.2007.4557324.
  * [20] A. Rigby, J. C. Olivier, and P. Jarvis, “Modified belief propagation decoders for quantum low-density parity-check codes,” Physical Review A, vol. 100, no. 1, pp. 012330, 2019. doi: 10.1103/PhysRevA.100.012330.
  * [21] H. Lou, and J. Garcia-Frias “Quantum error-correction using codes with low-density generator matrix,” _IEEE 6th Workshop on Signal Processing Advances in Wireless Communications_ , 2005. doi: 10.1109/SPAWC.2005.1506298.
  * [22] H. Lou and J. Garcia-Frias, “On the Application of Error-Correcting Codes with Low Density Generator Matrix over Different Quantum Channels”, 4th International Symposium on Turbo Codes & Related Topics, 2006. online: https://ieeexplore.ieee.org/document/5755950.
  * [23] Z. Babar, P. Botsinis, D. Alanis, S. X. Ng, and L. Hanzo, “Fifteen Years of Quantum LDPC Coding and Improved Decoding Strategies,” IEEE Access, vol. 3, pp. 2492-2519, 2015. doi. 10.1109/ACCESS.2015.2503267.
  * [24] Y. Wang, B. C. Sanders, B. Bai and X. Wang, “Enhanced Feedback Iterative Decoding of Sparse Quantum Codes,” IEEE Trans. Inform. Theory, vol. 58, no. 2, pp. 1231-1241, 2012. doi: 10.1109/TIT.2011.2169534.
  * [25] Z. Babar, P. Botsinis, D. Alanis, S. Xin Ng and L. Hanzo, “Construction of Quantum LDPC Codes From Classical Row-Circulant QC-LDPCs,” IEEE Communications Letters, vol. 20, no. 1, pp. 9-12, 2016, doi: 10.1109/LCOMM.2015.2494020.
  * [26] P. Fuentes, J. Etxezarreta Martinez, P. M. Crespo, and J. Garcia-Frias, “Approach for the construction of non-Calderbank-Steane-Shor low-density-generator-matrix based quantum codes,” Phys. Rev. A, vol. 102, pp. 012423, 2020. doi:10.1103/PhysRevA.102.012423.
  * [27] D. Lidar, and T. Brun, “Quantum Error Correction,” Cambridge: Cambridge University Press, 2013. doi: 10.1017/CBO9781139034807.
  * [28] N. Raveendran and B. Vasić, “Trapping Sets of Quantum LDPC Codes,” Quantum, vol. 5, no. 562, 2021. doi: 10.22331/q-2021-10-14-562.
  * [29] M. A. Nielsen, and I. Chuang, “Quantum Computation and Quantum Information: 10th Anniversary Edition,” _Cambridge: Cambridge University Press_ , 2011. doi:10.1017/CBO9780511976667.
  * [30] T. Brun, I. Devetak, and M. Hsieh, “Correcting Quantum Errors with Entanglement”, Science, vol. 314, no. 5798, pp. 436-439, 2006. doi: 10.1126/science.1131563.
  * [31] J. Etxezarreta Martinez, P. Fuentes, P. M. Crespo, and J. Garcia-Frias, “Approximating Decoherence Processes for the Design and Simulation of Quantum Error Correction Codes in Classical Computers,” _IEEE Access_ , vol. 8, pp. 172623-172643, 2020. doi: 10.1109/ACCESS.2020.3025619.
  * [32] T. A. Brun, I. Devetak, and M. Hsieh, “Catalytic Quantum Error Correction,” _IEEE Trans. Inf. Theory_ , vol. 60, no. 6, pp. 3073-3089, 2014. doi: 10.1109/TIT.2014.2313559.
  * [33] Z. Babar, D. Chandra, H. V. Nguyen, P. Botsinis, D. Alanis, S. X. Ng, and L. Hanzo, “Duality of Quantum and Classical Error Correction Codes: Design Principles and Examples,” _IEEE Communications Surveys Tutorials_ , vol. 29, no. 1, pp. 970–1010, 2019. doi:10.1109/COMST.2018.2861361.
  * [34] P. Fuentes, “Error Correction for Reliable Quantum Computing,” Ph.D. dissertation, Tecnun-School of Engineering, Donostia - San Sebastian, Spain, 2022. online: arXiv:2202.08599.
  * [35] M. M. Wilde, M. Hsieh, and Z. Babar, “Entanglement-Assisted Quantum Turbo Codes,” _IEEE Trans. Inf. Theory_ , vol. 60, no. 2, pp. 1203–1222, 2014. doi: 10.1109/TIT.2013.2292052.
  * [36] D. K. Tuckett, A. S. Darmawan, T. C. Chubb, S. Bravyi, S. D. Bartlett, and S. T. Flammia, ”Tailoring Surface Codes for Highly Biased Noise,” Phys. Rev. X, vol. 9, no. 4, pp. 041031, 2019. doi: 10.1103/PhysRevX.9.041031.
  * [37] D. K. Tuckett, “Tailoring surface codes: Improvements in quantum error correction with biased noise”, PhD. thesis, University of Sydney, 2020.
  * [38] E. Sabo, A. B. Aloshious, and K. R. Brown, “Trellis Decoding For Qudit Stabilizer Codes And Its Application To Qubit Topological Codes,” online: arXiv:2106.08251, 2021.
  * [39] J. Pearl, Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference, Morgan Kauffman, 1988. online: https://www.sciencedirect.com/book/.
  * [40] F.R. Kschischang, B.J. Frey, and H.A. Loeliger, “Factor graphs and the sum-product algorithm”, _IEEE Transactions on Information Theory_ , vol.47, no. 2, pp. 498–519, 2001. doi: 10.1109/18.910572.
  * [41] K. Kuo and C. Lu, ”A further study on the encoding complexity of quantum stabilizer codes,” 2010 International Symposium On Information Theory & Its Applications, 2010, pp. 1041-1044, doi: 10.1109/ISITA.2010.5649496.
  * [42] M. Wilde, ”Logical operators of quantum codes,” Phys. Rev. A, vol. 79, pp. 062322, 2009. doi: 10.1103/PhysRevA.79.062322.
  * [43] D. J. C. MacKay, “Good error-correcting codes based on very sparse matrices,” IEEE Trans. Inf. Theory, vol. 45, pp. 399–431, 1999. doi: 10.1109/18.748992.
  * [44] A. R. Calderbank and P. W. Shor, “Good quantum error correcting codes exist,” Physical Review A, vol. 54, pp. 1098-1105, 1996. doi: 10.1103/PhysRevA.54.1098.
  * [45] T. J. Richardson and R. L. Urbanke, “Efficient encoding of low-density parity-check codes,” IEEE Transactions on Information Theory, vol. 47, no. 2, pp. 638-656, 2001. doi: 10.1109/18.910579.
  * [46] S. Myung, K. Yang and J. Kim, “Quasi-cyclic LDPC codes for fast encoding,” IEEE Transactions on Information Theory, vol. 51, no. 8, pp. 2894-2901, 2005, doi: 10.1109/TIT.2005.851753.
  * [47] M. Battaglioni, P. Santini, M. Baldi and G. Cancellieri, ”Obtaining structured generator matrices for QC-LDPC codes,” 2019 AEIT International Annual Conference (AEIT), pp. 1-6, 2019. doi:10.23919/AEIT.2019.8893395.
  * [48] M. Baldi, M. Bianchi, G. Cancellieri, F. Chiaraluce and T. Klove, “On the generator matrix of array LDPC codes,” SoftCOM 2012 20th International Conference on Software, Telecommunications and Computer Networks, pp. 1-5, 2012.
  * [49] Su-Chang Chae and Yun-Ok Park, “Low complexity encoding of improved regular LDPC codes,” IEEE 60th Vehicular Technology Conference, vol. 4, pp. 2535-2539, 2004. doi: 10.1109/VETECF.2004.1400513.
  * [50] H. Jin, A. D. Kh, R. J. McEliece, “Irregular repeat-accumulate codes”, Proc. of 2nd International Symposium on Turbo Codes and Related Topics, Brest, France, 2000.
  * [51] P. Fuentes, J. Etxezarreta Martinez, P. M. Crespo, and J. Garcia-Frias, “Design of LDGM-based quantum codes for asymmetric quantum channels,” Phys. Rev. A, vol. 103, pp. 022617, 2021. doi: 10.1103/PhysRevA.103.022617.
  * [52] P. Fuentes, J. Etxezarreta Martinez, P. M. Crespo, and J. Garcia-Frías, “Performance of non-CSS LDGM-based quantum codes over the Misidentified Depolarizing Channel,” IEEE International Conference on Quantum Computing and Engineering (QCE20), 2020. doi:10.1109/QCE49297.2020.00022.
  * [53] M. Jeruchim, “Techniques for Estimating the Bit Error Rate in the Simulation of Digital Communication Systems,” _IEEE J. Selected Areas Commun,_ 1984, 2, 153–170.


* [77] J. T. Oden, S. Prudhomme, and L. Demkowicz, A posteriori error estimation for acoustic wave propagation problems, Archives of Computational Methods in Engineering, 12 (2005), pp. 343–389.
  * [78] J. T. Oden and J. N. Reddy, An introduction to the mathematical theory of finite elements, Courier Corporation, 2012.
  * [79] J. T. Oden and K. S. Vemaganti, Estimation of Local Modeling Error and Goal-Oriented Adaptive Modeling of Heterogeneous Materials: I. Error Estimates and Adaptive Algorithms, Journal of Computational Physics, 164 (2000), pp. 22–47.
  * [80] C. Piazzola and L. Tamellini, The Sparse Grids Matlab kit - a Matlab implementation of sparse grids for high-dimensional function approximation and uncertainty quantification, ArXiv, (2022).  10.48550/ARXIV.2203.09314.
  * [81] S. Prudhomme and J. T. Oden, On goal-oriented error estimation for elliptic problems: application to the control of pointwise errors, Computer Methods in Applied Mechanics and Engineering, 176 (1999), pp. 313–331.
  * [82] , Computable Error Estimators and Adaptive Techniques for Fluid Flow Problems, in Error Estimation and Adaptive Discretization Methods in Computational Fluid Dynamics, T. J. Barth and H. Deconinck, eds., Springer Berlin Heidelberg, 2003, pp. 207–268.
  * [83] W. Rachowicz, J. T. Oden, and L. Demkowicz, Toward a universal h-p adaptive finite element strategy part 3. design of h-p meshes, Computer Methods in Applied Mechanics and Engineering, 77 (1989), pp. 181–212.
  * [84] C.-H. Rhee and P. W. Glynn, Unbiased estimation with square root convergence for SDE models, Operations Research, 63 (2015), pp. 1026–1043.
  * [85] L. Scarabosio, B. Wohlmuth, J. T. Oden, and D. Faghihi, Goal-oriented adaptive modeling of random heterogeneous media and model-based multilevel Monte Carlo methods, Computers & Mathematics with Applications, 78 (2019), pp. 2700–2718.
  * [86] M. Scheuerer, Regularity of the sample paths of a general second order random field, Stochastic Processes and their Applications, 120 (2010), pp. 1879–1897.
  * [87] C. Schwab and R. A. Todor, Karhunen–Loève approximation of random fields by generalized fast multipole methods, Journal of Computational Physics, 217 (2006), pp. 100–122.
  * [88] E. Stephan and J. R. Whiteman, Singularities of the Laplacian at corners and edges of three-dimensional domains and their treatment with finite element methods, Mathematical Methods in the Applied Sciences, 10 (1988), pp. 339–350.
  * [89] A. Teckentrup, R. Scheichl, M. Giles, and E. Ullmann, Further analysis of multilevel Monte Carlo methods for elliptic PDEs with random coefficients, Numerische Mathematik, 125 (2013), pp. 569–600.
  * [90] D. Terpstra, H. Jagode, H. You, and J. Dongarra, Collecting performance data with PAPI-C, in Tools for High Performance Computing 2009, 3rd Parallel Tools Workshop, Dresden, Germany, Springer, Berlin Heidelberg, 2010, pp. 157–173.
  * [91] K. S. Vemaganti and J. T. Oden, Estimation of local modeling error and goal-oriented adaptive modeling of heterogeneous materials: Part II: a computational environment for adaptive modeling of heterogeneous elastic solids, Computer Methods in Applied Mechanics and Engineering, 190 (2001), pp. 6089–6124.
  * [92] L. B. Wahlbin, On the Sharpness of Certain Local Estimates for $\overset{\circ}{H^{1}}$ Projections into Finite Element Spaces: Influence of a Reentrant Corner, Mathematics of Computation, 42 (1984), pp. 1–8.
  * [93] E. Youett, Adaptive Multilevel Monte Carlo Methods for Random Elliptic Problems, PhD thesis, Freie Universität Berlin, 2018.