# Noise-adapted qudit codes for amplitude-damping noise

Sourav Dutta<EMAIL_ADDRESS>Debjyoti Biswas
<EMAIL_ADDRESS>Prabha Mandayam<EMAIL_ADDRESS>Department
of Physics, Indian Institute of Technology Madras
Chennai, India - 600036  Center for Quantum Information, Communication, and
Computing, IIT Madras

###### Abstract

Quantum error correction (QEC) plays a critical role in preventing information
loss in quantum systems and provides a framework for reliable quantum
computation. Identifying quantum codes with nice code parameters for
physically motivated noise models remains an interesting challenge. Going
beyond qubit codes, here we propose a class of qudit error correcting codes
tailored to protect against amplitude-damping noise. Specifically, we
construct a class of four-qudit codes that satisfies the error correction
conditions for all single-qudit and a few two-qudit damping errors up to the
leading order in the damping parameter $\gamma$. We devise a protocol to
extract syndromes that identify this set of errors unambiguously, leading to a
noise-adapted recovery scheme that achieves a fidelity loss of
$\mathcal{O}(\gamma^{2})$. For the $d=2$ case, our QEC scheme is identical to
the known example of the $4$-qubit code and the associated syndrome-based
recovery. We also assess the performance of our class of codes using the Petz
recovery map and note some interesting deviations from the qubit case.

##  I Introduction

Quantum computers have the remarkable potential to speed up complex
computational tasks by harnessing the principles of quantum mechanics. While
most quantum devices in operation have thus far used qubits – two-dimensional
quantum systems – as their fundamental building blocks of information, there
is a growing number of quantum devices built upon higher dimensional quantum
systems [1, 2, 3, 4, 5, 6, 7]. These $d$ levels quantum systems – often called
qudits – typically have larger information capacity and admit more complex
computations, making them a promising avenue for scaling up quantum algorithms
and achieving enhanced computational power [5, 6, 7, 8].

However, while moving to higher dimensional systems helps increase the
efficiency of quantum algorithms, these systems are also more susceptible to
errors than qubits. Since qudit systems also have more accessible levels, they
are more difficult to control compared to qubits. For example, transmon-based
qudit systems predominantly undergo multilevel decay errors, whereas transmon
qubits are mostly fragile to single-level-decay error.

Quantum error correction [9] provides a framework by which one can
systematically deal with noise in quantum systems and improve the reliability
and accuracy of quantum computing devices. Conventional quantum error
correction (QEC) codes, such as the surface codes [10] or stabilizer codes
[11] in general, were primarily designed to correct for arbitrary,
independently occurring Pauli errors. These _general-purpose QEC codes_ are
governed by rigid constraints on the minimal resources required for achieving
error correction. For example, both in the case of qubits and qutrits the
smallest QEC codes have a block length of five, requiring at least five
qubits/qutrits to encode a single qubit/qutrit to correct for any arbitrary
error on a single system [12].

Physical realizations of qudits are often dominated by certain specific noise
processes with their own error characteristics. For instance, the decoherence
mechanism in superconducting qubits is dominated by amplitude-damping noise
over other noise processes [13]. In such cases, it is possible to devise
encoding schemes that aim to correct for specific errors and hence require
fewer resources compared to general-purpose QEC codes [14]. This then leads to
the idea of _noise-adapted_ quantum error correction schemes that are tailored
to deal with specific noise models [15, 16, 17]. Since noise-adapted codes
achieve a degree of protection comparable to general-purpose QEC codes while
being more resource-efficient, they are potentially good candidates for
implementing on today’s NISQ (Noisy Intermediate-Scale Quantum) devices [18].
Noise-adapted QEC protocols have been developed for biased noise models, where
some Pauli errors are more likely to occur than others [19, 20, 21, 22].

Going beyond Pauli noise channels, the amplitude-damping channel is an
important example of a noise model that has been well studied from the
perspective of noise-adapted QEC. Apart from the $4$-qubit codes that correct
for single-qubit damping errors [17, 23], other examples of amplitude-damping
codes constructed in the literature include qudit codes that correct for
single-qubit damping errors [24, 25] and permutation-invariant codes that use
$t^{2}$ qubits to approximately correct for $t$ damping errors [26]. Extending
the idea of encoding qubits into qudits, the class of bosonic codes, including
binomial codes [27, 28] and cat codes [29, 30, 31, 32, 33, 28, 34] are
primarily designed to correct for single-damping errors which arise due to
single photon loss processes. Qudit stabilizer codes that correct for
amplitude-damping noise on qudits have also been developed from classical
asymmetric codes [35].

In this article, we construct a new class of noise-adapted codes, encoding a
single qudit of information into four qudits, to protect against amplitude-
damping noise. Our code can correct all single qudit damping errors and a few
two-qudit damping errors. We obtain the well-known four-qubit Leung code [14]
as a special case of our code construction, when the local dimension is two.
We also propose a noise-adapted recovery procedure for this class of codes, by
employing a syndrome measurement-based approach, relying on measuring the
outcomes of stabilizer operators associated with the code. Similar to the
four-qubit amplitude damping code, one needs extra measurements [36] to
identify the errors uniquely when the local dimension $d$ is less than or
equal to four. Our findings demonstrate that two stabilizer measurements are
indeed adequate for correcting single-qudit damping errors up to
$\mathcal{O}(\gamma^{2})$ when $d\geq 5$. Finally, we also present a quantum
circuit implementation of our syndrome-based recovery and compare its
performance with the near-optimal recovery map known as the Petz recovery[15,
37, 16]. It is interesting to observe that, in contrast to the qubit scenario,
the syndrome-based recovery outperforms the Petz recovery in the qutrit case.

The rest of the paper is organised as follows. In Sec. II, we briefly review
the structure of amplitude-damping noise for qudits and discuss the
approximate quantum error correction conditions which form the basis for our
code construction. In Sec. III, we introduce a class of four-qudit approximate
QEC codes for the amplitude damping noise. We demonstrate a syndrome-based
recovery protocol for this class of codes in Sec. IV and quantify the
performance of the qutrit code for different recovery operations in Sec. V.
Finally, we conclude in Sec. VI with a summary and future directions.

##  II Preliminaries

###  II.1 Approximate quantum error correction

Quantum states are fragile and susceptible to noise arising due to unwanted
interactions with a bath or environment. The effect of noise can be modelled
as a completely positive trace preserving (CPTP) map $\mathcal{E}$ – commonly
referred to as a _quantum channel_ – whose action on any state $\rho$ is
described by a set of _Kraus operators_ $\\{E_{k}\\}$, such that
$\mathcal{E}(\rho)=\sum_{k}E_{k}\rho E_{k}^{\dagger}$. The map $\mathcal{E}$
is guaranteed to be trace-preserving so long as the operators $E_{k}$ satisfy
$\sum_{k}E_{k}^{\dagger}E_{k}=I$.

The central idea in quantum error correction (QEC) is to encode the
information contained in the physical Hilbert space into a subspace of a
larger Hilbert space, known as the codespace. In order to be able to correct
for a noise channel $\mathcal{E}$ represented by a set of $N$ Kraus operators
$\\{E_{k}\\}_{a=1}^{N}$, the codespace must satisfy specific algebraic
conditions known as the Knill-Laflamme conditions [38], stated as follows. A
codespace $\mathcal{C}$ defined as the span of the quantum states
$\\{|i_{L}\rangle\\}_{i=1}^{dim(\mathcal{C})}$ corrects the errors associated
with operators ${E_{k}}$ if and only if,

$\langle
i_{L}|E_{k}^{\dagger}E_{l}|j_{L}\rangle=c_{kl}\delta_{ij}\qquad\forall~{}~{}k,l,$
(1)

for every pair of codewords $|i_{L}\rangle,|j_{L}\rangle$. Here, $c_{kl}$ are
elements of a Hermitian matrix, and are independent of $i,j$. The independence
of $c_{kl}$ from $i$ and $j$ ensures that the errors are simply unitary
deformations of the codespace, whereas the Kronecker delta in Eq. (1) implies
that orthogonality of the error subspaces associated with distinct errors
[39].

More generally, one may consider relaxing the perfect QEC conditions, leading
to approximate quantum error correction (AQEC) codes [14, 40, 16]. There are a
few variants of AQEC conditions proposed in the literature, depending on how
the exact QEC conditions are relaxed and the figure of merit used to benchmark
the performace of the codes. The specific form of the AQEC conditions that we
use here is due to [40], where the Knill-Laflamme conditions in Eq. (1) are
modified as follows. A quantum code $\mathcal{C}$ satisfying

$\langle i_{L}|E_{k}^{\dagger}E_{l}|j_{L}\rangle=c_{kl}\delta_{ij}+\langle
i_{L}|B_{kl}|j_{L}\rangle\qquad\forall~{}~{}k,l,$ (2)

for every pair of codewords $|i_{L}\rangle,|j_{L}\rangle$, can correct the
errors $\\{E_{k}\\}$ up to $\mathcal{O}(\epsilon^{t})$ if and only if the
perturbative term in Eq. (2) is bounded as

$\langle i_{L}|B_{kl}|j_{L}\rangle\leq\mathcal{O}(\epsilon^{t+1}).$ (3)

Clearly, the code $\mathcal{C}$ becomes a _perfect_ QEC code for the noise
channel $\mathcal{E}$ when $\langle i_{L}|B_{kl}|j_{L}\rangle$ in (2) goes to
zero. Indeed, if $\bra{i_{L}}B_{kl}\ket{j_{L}}$ vanishes for all $i\neq j$,
then the orthogonality condition in Eq. (1) is satisfied. In that case, there
exists a trace non-increasing completely positive map, that can approximately
correct the effect of the noise channel $\mathcal{E}$ on the code space
$\mathcal{C}$ [14, 41].

###  II.2 Amplitude-damping noise

The amplitude-damping (AD) noise channel models the phenomenon of energy
dissipation in open quantum systems [39]. It is known to be one of the most
commonly occurring and oftentimes dominant noise process for several physical
realizations of qubits [42]. AD errors arise due to the loss of energy from
the system to its surrounding environment, leading to loss of coherence as the
probability of finding the qubit in the excited state diminishes. The strength
of AD noise is characterized by $\gamma$, the probability of the qubit getting
_damped_ , that is, decaying from the ground state from the excited state.
Correspondingly, $1-\gamma$ is the probability that the qubit remains in the
excited state.

At zero temperature, this damping process for qubits is characterized by the
following pair of Kraus operators, which describe a single-qubit amplitude-
damping channel.

$\displaystyle A_{0}$ $\displaystyle=\begin{pmatrix}1&0\\\
0&\sqrt{1-\gamma}\end{pmatrix}\qquad A_{1}=\begin{pmatrix}0&\sqrt{\gamma}\\\
0&0\end{pmatrix}.$ (4)

Going beyond qubits, energy dissipation in qudit systems ($d$-level quantum
systems), can be described via a qudit amplitude-damping channel
$\mathcal{A}$, with $d$ Kraus operators $A_{k}$ ($1\leq k\leq d$)of the form
[35],

$\displaystyle A_{k}$ $\displaystyle=\sum\limits_{r=k}^{d-1}\,\sqrt{r\choose
k}\sqrt{(1-\gamma)^{r-k}\gamma^{k}}\ket{r-k}\bra{r},$ (5)

where $\gamma$ is now the probability for a single damping event to occur. The
quantum state $\ket{r}$ represents a system in the $r^{\rm th}$ excited state.
For a $d$-level quantum system, the index $k$ runs from $0$ to $d-1$. The
operator $A_{k}$ thus describes a $k$-level damping event that occurs with
probability $\mathcal{O}(\gamma^{k})$. In the rest of the article, we will
refer to $A_{k}$ as a $k$-damping error with a corresponding damping strength
of $\mathcal{O}(\gamma^{k})$.

A schematic representation of the qubit and qutrit amplitude-damping channels
is shown in Fig. 1. In the qutrit case, a single damping event causes the
system to decay from the state $\ket{2}$ to the state $\ket{1}$, without
decaying any further. Thus the probability for this process is
$\gamma(1-\gamma)$ up to a constant factor. We can thus obtain the Kraus
operators for a qutrit amplitude-damping channel by substituting $d=3$ in Eq.
(5), as,

$\displaystyle A_{0}$
$\displaystyle=\ket{0}\bra{0}+\sqrt{1-\gamma}\ket{1}\bra{1}+(1-\gamma)\ket{2}\bra{2}$
(6) $\displaystyle A_{1}$
$\displaystyle=\sqrt{\gamma}\ket{0}\bra{1}+\sqrt{2\gamma(1-\gamma)}\ket{1}\bra{2}$
(7) $\displaystyle A_{2}$ $\displaystyle=\gamma\ket{0}\bra{2},$ (8)

where $A_{0}$ is the no-damping error, $A_{1}$ corresponds to the single-
damping error and $A_{2}$ is the two-damping error operator.

Figure 1: (a) Amplitude-damping process for a qubit system, where only one
possible damping from $\ket{1}$ to $\ket{0}$ takes place with probability
$\gamma$. (b) Amplitude-damping process for a qutrit system, where damping
from $\ket{2}$ to $\ket{0}$ takes place with probability $\gamma^{2}$. The
probability of damping from $\ket{2}$ to $\ket{1}$ and $\ket{1}$ to $\ket{0}$
takes place with probability $2\gamma(1-\gamma)$ and $\gamma$ respectively.

In this work, we aim to construct quantum codes that can protect qudits from
single and multi-level damping errors. It is evident that whenever
$\gamma<0.5$, which holds true for most of the realistic cases, the
probability of no-damping and single-level damping is higher than multi-level
damping. This implies that the single-level damping errors affect the fidelity
of a quantum code the most.

###  II.3 Noise-adapted recovery

Before proceeding to our code construction, we briefly review the known noise-
adapted recovery schemes tailored to specific codes and noise processes. In
standard QEC, the recovery operation is simply a unitary gate – typically, a
Pauli operator – depending on the syndrome bits extracted. On the other hand,
noise-adapted QEC requires a non-trivial recovery operation which could in
general be a quantum channel. Given a code $\mathcal{C}$ and a noise channel
$\mathcal{E}$, there are three known approaches to constructing a noise-
adapted recovery scheme.

  1. 1.

Petz recovery: This approach to noise-adapted recovery is based on a universal
and near-optimal recovery channel, often known as the Petz map [15, 16]. The
Petz recovery specific to a code $\mathcal{C}$ and adapted to a noise channel
$\mathcal{E}$ with Kraus operators $\\{E_{i}\\}^{N}_{k=1}$, is the CPTP map
$\mathcal{R}_{P}$ whose Kraus operators are given by,

$\displaystyle R^{(P)}_{k}=PE^{{\dagger}}_{k}\mathcal{E}(P)^{-1/2},$ (9)

where $P$ is the projector onto the code space $\mathcal{C}$. Recent works
[43, 44] have shown that it is possible to construct circuit implementations
of the Petz recovery channel for arbitrary codes and noise processes.

  2. 2.

Leung recovery: For a quantum code $\mathcal{C}$ and a noise channel
$\mathcal{E}$ with Kraus operators $\\{E_{i}\\}^{N}_{k=1}$, the recovery map
due to Leung _et al._ [14] is constructed using the following set of Kraus
operators.

$R^{(L)}_{k}=PU_{k}^{{\dagger}},$ (10)

where $U_{k}$ is the unitary operator obtained via polar decomposition of the
operator $E_{k}P$ and $P$ is the projector onto the codespace. The map
$\mathcal{R}_{L}$ is trace non-increasing provided the error operators map the
codespace to orthogonal subspaces. This means that an additional constraint
$\bra{i_{L}}B_{kl}\ket{j_{L}}\propto\delta_{kl}$ should be imposed on the
approximate QEC conditions in Eq. (2) for $\mathcal{R}_{L}$ to correspond to a
physically realisable recovery map. Putting in this additional orthogonality
constraint, it is easy to check that the set of operators $\\{R^{(L)}_{k}\\}$
along with the additional operator
$P_{E}=I-\sum\limits_{k}R^{(L){\dagger}}_{k}R^{(L)}_{k}$ define a CPTP map
corresponding to a valid recovery channel.

  3. 3.

Cafaro recovery: Given a code $\mathcal{C}$ and a noise channel $\mathcal{E}$
with Kraus operators $\\{E_{k}\\}$, the recovery map due to Cafaro _et al._
[41] is defined by the Kraus operators,

$\displaystyle R^{(C)}_{k}$
$\displaystyle=\sum\limits_{i}\frac{\ket{i_{L}}\bra{i_{L}}E_{k}^{{\dagger}}}{\sqrt{\bra{i_{l}}E_{k}^{{\dagger}}E_{k}\ket{i_{L}}}}.$
(11)

This map is trace non-increasing if and only if
$\bra{i_{L}}B_{kl}\ket{j_{L}}\propto\delta_{kl}\delta_{ij}$ in Eq. (2). Note
that this is a slightly stronger condition than the one required for the Leung
recovery, since it has the additional $\delta_{ij}$ term. Similar to the Leung
case, once the orthogonality condition is satisfied, the full CPTP recovery
map is defined as
$\\{R^{(C)}_{k},I-\sum\limits_{k}R^{(C){\dagger}}_{k}R^{(C)}_{k}\\}$.

We can thus establish a hierarchy of noise-adapted recovery maps based on the
constraints necessary to ensure that the maps are physical (completely
positive and trace-preserving). The Petz recovery map in Eq. (9) is a physical
map for any noise channel $\mathcal{E}$ and code $\mathcal{C}$. On the other
hand, the recovery maps defined using the operators in Eqs. (10) and (11) are
physical if and only if the corresponding code and noise channel satisfy
certain algebraic conditions. Furthermore, these two recovery maps turn out to
be identical for codes and noise channels satisfying a specific form of the
approximate QEC condition. This is formally stated in the following Lemma and
proved in Appendix A.

###### Lemma 1

Consider a noise channel $\mathcal{E}$ and codespace $\mathcal{C}$ with
codewords $\\{|i_{L}\rangle,i=1,2,\ldots,d\\}$ that satisfy the following form
of the AQEC conditions,

$\langle
i_{L}|E_{k}^{\dagger}E_{l}|j_{L}\rangle=\left(c_{kk}\delta_{ij}+\langle
i_{L}|B_{kk}|j_{L}\rangle\right)\delta_{kl},$ (12)

for every pair of Kraus operators $E_{k},E_{l}$. Then, the Leung recovery in
Eq. (10) and the Cafaro recovery in Eq. (11) corresponding to this code and
noise channel are identical, if and only if,

$\langle
i_{L}|E_{k}^{{\dagger}}E_{k}|j_{L}\rangle\propto\delta_{ij},\;\forall,i,j\in[1,d].$
(13)

###  II.4 Fidelity measures

The performance of a QEC protocol is typically quantified by one of the
fidelity measures that quantify how close the initial encoded state is to the
recovered state. Here, we work with the fidelity function $F$ based on the
Bures metric, which is defined between a pure state $|\psi\rangle$ and a mixed
state $\rho$ as [39],

$F(|\psi\rangle,\rho)=\langle\psi|\rho|\psi\rangle.$ (14)

Since the fidelity is a function of the initial state, one may quantify the
performance of a QEC scheme over the entire codespace is using the _worst-case
fidelity_ , which is obtained by minimising the fidelity over all possible
logical states. The worst-case fidelity for a noise channel $\mathcal{E}$ and
recovery channel $\mathcal{R}$ acting on a codespace $\mathcal{C}$ is defined
as[39]

$\mathcal{F}_{wc}=\min_{\ket{\psi}\in\mathcal{C}}\bra{\psi}\mathcal{R}\circ\mathcal{E}(\ket{\psi}\bra{\psi})\ket{\psi}$
(15)

Alternately, one could quantify the performance of a QEC code is by using the
entanglement fidelity, defined as [39],

$\mathcal{F}_{ent}=\bra{\Psi}(\mathcal{R}\circ\mathcal{E})\otimes
I(\ket{\Psi}\bra{\Psi})\ket{\Psi},$ (16)

where $\ket{\Psi}$ is a purification of the maximally mixed state on the
codespace $\rho_{L}=\frac{1}{d}\sum_{i=0}^{d-1}\ket{i_{L}}\bra{i_{L}}$. By
evaluating the right hand side of Eq. (16), we get the following useful
expression for the entanglement fidelity.

$\mathcal{F}_{ent}=\frac{1}{(\textrm{dim}(\mathcal{C}))^{2}}\sum_{jk}\left(|\Tr_{\mathcal{C}}R_{j}E_{k}|^{2}\right).$
(17)

Since the state $\ket{\Psi}$ is a purification of the maximally mixed state
$\rho_{L}$ on the codespace, one may view the entanglement fidelity as a
measure of the entanglement-preserving capability of a given QEC scheme.

##  III A class of approximate four-qudit codes

We now propose a class of approximate four-qu _d_ it quantum error correcting
codes for arbitrary values of $d$, that can correct all single-qudit and a few
multi-qudit errors. To correct the errors due to the noise models discussed in
Sec. II.2, our $4$-qudit codespace is constructed as the span of a set of $d$
codewords, defined as follows.

$\displaystyle\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum\limits_{i=0}^{d-1}\,\ket{i}_{1}\ket{i}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}}_{4}.\
$ (18)

Here, $m\in\\{0,d-1\\}$ and the subscript $d$ indicates addition modulo $d$.

Figure 2: Encoding circuit for the approximate four-qudit code. The
controlled-$X_{d}$ gate is defined in Eq. (21) and
$\ket{+_{d}}=\frac{1}{\sqrt{d}}[\ket{0}+\ket{1}+\cdots+\ket{d-1}]$

.

The encoding circuit for this class of qudit codes is shown in Fig. 2. The
gate $X_{d}$ in the encoding circuit is simply the Pauli $X$ operator on a
qudit system, given by,

$X_{d}=\sum_{k=0}^{d-1}\ket{(k+1)_{d}}\bra{k}.$ (19)

This is simply a shift operator on the discrete set of states
$\\{|0\rangle,|1\rangle,\ldots,|d-1\rangle\\}$. Correspondingly, the phase
operator on a qudit system is defined as,

$Z_{d}=\sum_{k=0}^{d-1}e^{\frac{2\pi ik}{d}}\ket{k}\bra{k}.$ (20)

The controlled-$X_{d}$ gate, which is the $d$-dimensional analogue of the cnot
gate is then defined as,

$\displaystyle CX_{d}=\begin{bmatrix}\mathbf{I}_{d}&0&\cdots&0\\\
0&\mathbf{X}_{d}&\cdots&0\\\ \vdots&\vdots&\ddots&\vdots\\\
0&0&\cdots&\mathbf{X}^{d-1}_{d}\end{bmatrix}$ (21)

Also, the state $\ket{+_{d}}$ is simply an equal superposition of the single-
qudit basis states in the standard or computational basis.

From Eq. (18), it is evident that for $d=2$, our code exactly matches the
four-qubit code [14], tailored for the amplitude damping noise.

$\displaystyle\ket{0_{L}}$
$\displaystyle=\frac{1}{\sqrt{2}}[\ket{0000}+\ket{1111}]$
$\displaystyle\ket{1_{L}}$
$\displaystyle=\frac{1}{\sqrt{2}}[\ket{0011}+\ket{1100}]$ (22)

However, for $d\geq 3$, our code construction yields code parameters that have
not been explicitly observed in previous constructions of stabilizer qudit
codes for the amplitude-damping channel [35].

We now show that similar to the $4$-qubit code, our class of $4$-qudit codes
satisfies the Knill-Laflamme condition in Eq. (1) for amplitude-damping noise,
up to the first order in the decay strength $\gamma$. Specifically, we show
that the codewords defined in Eq. (18) satisfy the approximate QEC conditions
in Eq. (2) for all single-qudit and some two-qudit errors, with the
perturbation terms in Eq. (3) being of $\mathcal{O}(\gamma^{2})$. We note that
the four-qudit amplitude-damping channel has Kraus operators of the form
$A_{ijkl}=A_{i}\otimes A_{j}\otimes A_{k}\otimes A_{l}$, with the single-qudit
error operators $A_{k}$ defined in Eq. (5). The error $A_{ijkl}$ occurs with
probability $\mathcal{O}(\gamma^{i+j+k+l})$.

###### Theorem 1

The four-qudit code defined as the span of the codewords in Eq. (18) satisfies
the Knill-Laflamme conditions in Eq. (1) up to $\mathcal{O}(\gamma)$, for the
errors in the set

$\displaystyle\mathcal{A}_{\rm corr}$ $\displaystyle=$
$\displaystyle\\{\\{A_{x000},A_{0x00},A_{00x0},A_{000x}\;x\in\\{1,\ldots,d-1\\}\\},$
$\displaystyle A_{0000},A_{1010},A_{0101},A_{0110},A_{1001}\\},$

comprising _all_ single-qudit errors and some two-qudit errors. Here,
$A_{x000}=A_{x}\otimes A_{0}\otimes A_{0}\otimes A_{0}$ denotes a single-qudit
$x$-damping error with a damping strength $\mathcal{O}(\gamma^{x})$, whereas,
$A_{1010}=A_{1}\otimes A_{0}\otimes A_{1}\otimes A_{0}$ denotes a two-qudit
single-damping error of damping strength $\mathcal{O}(\gamma^{2})$.

Proof: We merely outline the steps of our proof here and leave the details to
Appendix B.

To verify that our $4$-qudit code satisfies the Knill-Laflamme conditions up
to $\mathcal{O}(\gamma)$, we first explicitly evaluate the action of the
single-qudit damping errors on the codewords, as given is Eqs. (44)- (47). It
is then easy to see by inspection that different single-qudit errors map each
of the codewords to distinct, orthogonal states. Specifically, we show that
the codewords in Eq. (18) satisfy,

$\displaystyle\bra{m_{L}}A^{\dagger}_{x000}A_{000y}\ket{n_{L}}$
$\displaystyle\propto$ $\displaystyle\delta_{m,n}\delta_{x,0}\delta_{y,0}$
$\displaystyle\bra{m_{L}}A^{\dagger}_{x000}A_{y000}\ket{n_{L}}$
$\displaystyle=$ $\displaystyle
f_{x}(d)\mathcal{O}(\gamma^{x})\delta_{m,n}\delta_{x,y}$
$\displaystyle\bra{m_{L}}A_{0000}^{{\dagger}}A_{0000}\ket{n_{L}}$
$\displaystyle=$
$\displaystyle(1-2(d-1)\gamma+\mathcal{O}(\gamma^{2}))\delta_{m,n}.$

Furthermore, we show by explicit calculation that the similar orthogonality
conditions hold true for the two-qudit errors in the set $\mathcal{A}_{\rm
corr}$.

$\displaystyle\bra{m_{L}}A_{\alpha}^{{\dagger}}A_{\beta}\ket{n_{L}}$
$\displaystyle=\frac{1}{d}\sum_{i=0}^{d-1}(i(i+m)_{d}\gamma^{2}+\mathcal{O}(\gamma^{3}))\delta_{m,n}\delta_{\alpha,\beta}$
(24) $\displaystyle\quad\forall
A_{\alpha},A_{\beta}\in\\{A_{1010},A_{0101},A_{1001},A_{0110}\\}.$

From Eqs. (LABEL:eq:single_qudit) and (24), we see that for every pair of
errors $A_{\alpha},A_{\beta}\in\mathcal{A}_{\rm corr}$, the codewords of the
$4$-qudit code satisfy,

$\langle
m_{L}|A^{\dagger}_{\alpha}A_{\beta}|n_{L}\rangle=\left(c_{\alpha,\beta}+g_{\alpha,\beta}(m,d)\right)\delta_{m,n},$

where, $c_{\alpha,\beta}$ are scalars of order $\mathcal{O}(\gamma)$ that are
independent of the choice of codewords $m,n$, and, $g_{\alpha,\beta}(m,d)$ are
scalar functions of order $\mathcal{O}(\gamma^{2})$ or higher that depend on
the codeword index $m$ and the codespace dimension $d$.

We have thus shown that for the errors in the set $\mathcal{A}_{\rm corr}$,
our $4$-qudit codes satisfy a special form of the approximate QEC conditions
stated in Eq. (2), where the perturbative terms are orthogonal in the codeword
labels ($m,n$) and are of order $\gamma^{2}$ or higher. $\square$

Having verified that our class of $4$-qudit codes satisfy the approximate QEC
conditions, we may draw upon the results in [14, 41] to conclude that our
codes can correct all the errors in $\mathcal{A}_{\rm corr}$ with a fidelity
loss of $\mathcal{O}(\gamma^{2})$. The leading order $\mathcal{O}(\gamma^{2})$
term in the fidelity loss is in fact caused by two two-qudit error operators –
$A_{1100}$ and $A_{0011}$ – that lead to logical errors. In what follows, we
will explicitly construct a syndrome-based recovery scheme that retrieves the
encoded information from the corrupted state with a fidelity loss of
$\mathcal{O}(\gamma^{2})$.

##  IV Syndrome-Based Recovery for approximate qudit codes

In principle, our $4$-qudit code can correct for all single-qudit errors and a
subset of two-qudit errors that occur with a probability of order up to
$\mathcal{O}(\gamma^{2})$, as shown in Theorem 1. There exist certain two-
qudit errors that are beyond the correction capabilities of using our code,
resulting in a fidelity loss proportional to $\gamma^{2}$. Since our fidelity
is limited by this factor, we may choose to disregard single-qudit errors of
order $\gamma^{3}$ or higher, whose contribution to the fidelity loss is
anyway of $\mathcal{O}(\gamma^{3})$.

We therefore construct a recovery scheme that can correct errors corresponding
to the Kraus operators in the set

$\displaystyle\mathcal{A}^{(1)}$ $\displaystyle=$
$\displaystyle\\{A_{0000},A_{1000},A_{0100},A_{0010},A_{0001},$ (25)
$\displaystyle A_{2000},A_{0200},A_{0020},A_{0002}\\}.$

In addition to these single-qudit errors, we show that our recovery scheme can
also correct some two-qudit errors given by the Kraus operators

$\mathcal{A}^{(2)}=\\{A_{1010},A_{1001},A_{0110},A_{0101}\\}.$ (26)

We first identify a set of stabilizer generators for our $4$-qudit code, using
the $d$-dimensional Pauli operators $X_{d}$ and $Z_{d}$ defined in Eqs. (19)
and (20). The $4$-qudit codewords in Eq. (18) are stabilized by the group
generated by,

$\displaystyle\mathcal{S}=\langle
X_{d}X_{d}X_{d}X_{d},Z_{d}^{s}Z_{d}^{d-s}I_{d}I_{d},I_{d}I_{d}Z_{d}^{s}Z_{d}^{d-s}\rangle,$
(27)

where $s$ can take an any integer value in the interval $[1,d-1]$. Without
loss of generality, we choose $s=1$ for the rest of this discussion.

To detect the errors due to the single-qudit errors in the set
$\mathcal{A}^{(1)}$ and the two-qudit errors in the set $\mathcal{A}^{(2)}$,
we initially measure the stabilizer generators $Z_{d}Z_{d}^{d-1}I_{d}I_{d}$
and $I_{d}I_{d}Z_{d}Z_{d}^{d-1}$, and, denote the corresponding measurement
results as $p_{1}$ and $p_{2}$ respectively. Depending on the location and
type of error, measurement of the $Z_{d}$-type stabilizers can yield one of
the $d$ roots of unity as outcome. We label these outcomes as integers between
$0$ and $(d-1)$, so that the syndromes $p_{1},p_{2}\in[0,d-1]$. The syndrome
values associated with the errors in $\mathcal{A}^{(1)}\cup\mathcal{A}^{(2)}$
are displayed in Table 1.

Primary Syndromes ($p_{1},p_{2}$)
---
Error |  d=3 |  d=4 |  d=5 |  d
$A_{1000}$ |  2,0 |  3,0 |  4,0 |  $d-1,0$
$A_{0100}$ |  1,0 |  1,0 |  1,0 |  $1,0$
$A_{2000}$ |  1,0 |  2,0 |  3,0 |  $d-2,0$
$A_{0200}$ |  2,0 |  2,0 |  2,0 |  $2,0$
$A_{0010}$ |  0,2 |  0,3 |  0,4 |  $0,d-1$
$A_{0001}$ |  0,1 |  0,1 |  0,1 |  $0,1$
$A_{0020}$ |  0,1 |  0,2 |  0,3 |  $0,d-2$
$A_{0002}$ |  0,2 |  0,2 |  0,2 |  $0,2$
$A_{1010}$ |  2,2 |  3,3 |  4,4 |  $d-1,d-1$
$A_{1001}$ |  2,1 |  3,1 |  4,1 |  $d-1,1$
$A_{0101}$ |  1,1 |  1,1 |  1,1 |  $1,1$
$A_{0110}$ |  1,2 |  1,3 |  1,4 |  $1,d-1$

Table 1: Primary syndrome string for different errors occurring with
probability up to $\mathcal{O}(\gamma^{2})$

.

We observe that syndromes $p_{1},p_{2}$ associated with different errors in
$\mathcal{A}^{(1)}\cup\mathcal{A}^{(2)}$ are unique whenever $d\geq 5$.
However, for $d=3,4$, there are pairs of errors that have the same
$(p_{1},p_{2})$ values. Measuring the two stabilizer generators
$Z_{d}Z_{d}^{d-1}I_{d}I_{d}$, $I_{d}I_{d}Z_{d}Z_{d}^{d-1}$ is thus not
adequate to uniquely identify the location and type of error. We will
therefore refer to $(p_{1},p_{2})$ as _primary_ syndromes and perform
additional measurements in the case of the qutrit ($d=3$) code and ququad
($d=4$) code, to obtain _secondary_ syndromes values denoted as $s_{1}$ and
$s_{2}$.

We explicitly discuss the syndrome-based recovery procedure for the qutrit
case in the following section. The explicit recovery for the ququad code is
discussed in Appendix C.

Interestingly, like the qutrit and ququad case, the $4$-qubit code also
requires a two-step syndrome extraction procedure, with both primary and
secondary syndromes required for unambiguous detection of single-damping
errors. Indeed, the syndrome-based recovery for the qubit code is well-
established [17], and a fault-tolerant implementation of the same was given in
[36]. However, the two-step syndrome-based recovery for the $4$-qubit code
cannot correct the two-qubit damping errors in the set $\mathcal{A}^{(2)}$, as
these errors will always annihilate the $\ket{1_{L}}$ state, making them non-
recoverable. However, these errors can still be detected unambiguously by
measuring the stabilizers $\\{ZZII,IIZZ\\}$.

##  V The $4$-qutrit code

The codewords of the $4$-qutrit code are obtained by setting $d=3$ in Eq.(18).

$\displaystyle\ket{0_{L}}$
$\displaystyle=\frac{1}{\sqrt{3}}\,[\ket{0000}+\ket{1111}+\ket{2222}]$ (28)
$\displaystyle\ket{1_{L}}$
$\displaystyle=\frac{1}{\sqrt{3}}\,[\ket{0011}+\ket{1122}+\ket{2200}]$ (29)
$\displaystyle\ket{2_{L}}$
$\displaystyle=\frac{1}{\sqrt{3}}\,[\ket{1100}+\ket{2211}+\ket{0022}]$ (30)

As already shown in Theorem 1, the code resulting from the span of these
codewords satisfies the approximate QEC conditions up to
$\mathcal{O}(\gamma^{2})$. Specifically, the set of single-damping and two-
damping errors in the sets $\mathcal{A}^{(1)}$ and $\mathcal{A}^{(2)}$ defined
in Sec. IV, map the codewords into mutually orthogonal states. Furthermore,
for each of the errors $A_{\alpha}\in\mathcal{A}^{(1)}\cup\mathcal{A}^{(2)}$,
the matrix elements $\langle
i_{L}|A_{\alpha}^{\dagger}A_{\alpha}|i_{L}\rangle$ that feature in the QEC
conditions are independent of the codeword index $i$ up to
$\mathcal{O}(\gamma)$, making this an approximate quantum error correcting
code.

###  V.1 Syndrome-based Recovery for the $4$-qutrit Code

Looking at the primary syndrome values in Table 1, we observe that there are
four specific situations in which the primary syndromes are unable to
definitively distinguish the errors in the qutrit case, meaning that two
different errors have the same primary syndromes ($p_{1}$ and $p_{2}$). If we
consider the first two qutrits as one block and the last two qutrits as
another block, the degeneracy in the primary syndromes arises due to a single
damping error in one qutrit and a double-damping error in the other qutrit of
the same block.

Table of syndromes for Qutrits
---
Errors |  $p_{1},p_{2}$ |  $s_{1},s_{2}$
$A_{1000}$ |  2,0 |  1,0
$A_{0100}$ |  1,0 |  1,0
$A_{2000}$ |  1,0 |  0,0
$A_{0200}$ |  2,0 |  0,0
$A_{0010}$ |  0,2 |  0,1
$A_{0001}$ |  0,1 |  0,1
$A_{0020}$ |  0,1 |  0,0
$A_{0002}$ |  0,2 |  0,0
$A_{1010}$ |  2,2 |  $\times$
$A_{1001}$ |  2,1 |  $\times$
$A_{0101}$ |  1,1 |  $\times$
$A_{0110}$ |  1,2 |  $\times$
Table 2: Primary and secondary syndrome strings for errors with probability up
to $\mathcal{O}(\gamma^{2})$ for the qutrit code.

To distinguish between the errors with overlapping values of $(p_{1},p_{2})$,
we measure two additional operators, namely, $\bar{Z}\bar{Z}II$ and
$II\bar{Z}\bar{Z}$ to obtain the so-called _secondary_ syndromes. Here,
$\bar{Z}$ is a single-qutrit operator of the form,

$\displaystyle\bar{Z}=\begin{bmatrix}1&0&0\\\ 0&-1&0\\\ 0&0&1\end{bmatrix},$
(31)

which leaves the quantum states $\ket{0}$ and $\ket{2}$ unchanged, but adds a
global phase of $\pi$ to the state $\ket{1}$. Our choice of the operator
$\bar{Z}$ to determine the secondary syndromes is motivated by its commutation
properties shown below.

$\displaystyle A_{k}\bar{Z}=\begin{cases}-\bar{Z}A_{k},&\text{when }k=1\\\
\bar{Z}A_{k},&\text{when }k=0,2\end{cases}$ (32)

The secondary syndrome measurements of $\bar{Z}\bar{Z}II$ and
$II\bar{Z}\bar{Z}$ can be performed via a controlled operation on ancillary
_qubits_ , controlled on the data qutrits. It is possible to implement the
same using qutrit ancillas, but the implementation using qubit ancillas might
be more cost-effective and robust to noise. The controlled operation required
for the secondary syndrome measurements for $d=3$ is thus represented by,

Figure 3: Circuit diagram for the qutrit syndrome-based recovery.
$p_{1},p_{2}$ are the primary syndromes and $s_{1},s_{2}$ are the secondary
syndromes. Here $\ket{0_{3}}$ is the qutrit ground state, and $\ket{0_{2}}$ is
the qubit ground state. The controlled-$X_{3}$ gate is defined in Eq.(21). The
function $f$ takes the syndromes $(p_{1},p_{2};s_{1},s_{2})$ as input,
identifies the error and applies a suitable unitary operator $U_{\alpha}$ (as
defined in Eq. (34)) to recover the state.

$\displaystyle C_{3}=\begin{bmatrix}\mathbf{I}_{2}&0&0\\\
0&\mathbf{X}_{2}&0\\\ 0&0&\mathbf{I}_{2}\end{bmatrix}.$ (33)

The operator $C_{3}$ flips the target ancilla qubit when the control qutrit is
in the state $|1\rangle$.

From Table 2, we see that the secondary syndromes, in conjunction with the
primary syndromes, can accurately identify the errors. The complete quantum
circuit for extracting the primary and secondary syndromes for the $4$-qutrit
code is illustrated in Fig. 3.

After identifying the errors using the primary and secondary syndromes, we map
back the noisy state to the codespace by using a unitary recovery operator
that is obtained as follows. Let $P_{\mathcal{C}}$ denote the projector onto
the $4$-qutrit subspace and $P_{\alpha}$ denote the projector associated with
the syndrome measurement corresponding to the error
$A_{\alpha}\in\mathcal{A}^{(1)}\cup\mathcal{A}^{(2)}$. Suppose the error
$A_{\alpha}$ is detected, we construct the unitary operator $U_{\alpha}$ via
polar decomposition of the non-unitary operator $A_{\alpha}P_{\mathcal{C}}$,
as,

$\displaystyle
A_{\alpha}P_{\mathcal{C}}=U_{\alpha}\sqrt{P_{\mathcal{C}}A_{\alpha}^{\dagger}A_{\alpha}P_{\mathcal{C}}}.$
(34)

The noisy state can be recovered by applying the inverse of the unitary
operator $U_{\alpha}$ followed by the projector on the codespace
$P_{\mathcal{C}}$. The recovery operation associated with error $A_{\alpha}$
can thus be expressed as

$R_{\alpha}=P_{\mathcal{C}}U_{\alpha}^{\dagger}P_{\alpha}.$ (35)

Note that $\sum_{\alpha}R_{\alpha}^{\dagger}R_{\alpha}\leq I$, since the
projectors $\\{P_{\alpha}\\}$ are mutually orthogonal. Thus, the the set of
Kraus operators $\\{R_{\alpha}\\}$, with the additional operator
$\sqrt{I-\sum_{\alpha}R^{\dagger}_{\alpha}R_{\alpha}}$ constitutes a CPTP
noise-adapted recovery channel.

It is worth noting here that our syndrome-based recovery is the same as the
noise-adapted recovery maps due to Leung _e_ t al [14] and Cafaro _et al_ [41]
defined in Sec. II.3. Since the $4$-qutrit code satisfies the orthogonal form
of the AQEC conditions in Eq. (13), our code satisfies the conditions of Lemma
1, making these two noise-adapted recovery maps identical in our case.

###  V.2 Fidelity-loss and Comparison with the Petz Recovery

We now compare the performance of our syndrome-based noise-adapted recovery
with the universal near-optimal recovery map, namely, the Petz map defined via
the Kraus operators in Eq. (9). We use the worst-case fidelity defined in (15)
to benchmark the performance of our $4$-qutrit code in conjunction with each
of these two recovery schemes.

As shown in Fig. (4), the syndrome-based recovery performs better than the
Petz recovery for the $4$-qutrit code subject to amplitude-damping noise for a
broad range of damping strength $\gamma$. This observation is important as the
Petz recovery is known to be near-optimal for the worst-case fidelity for any
choice of code and noise [16]. This behaviour also contrasts with the
behaviour of the $4$-qubit code under amplitude-damping noise, where the Petz
recovery outperforms the syndrome-based recovery. This deviation from the
qubit case is probably due to the fact that the class of $4$-qudit codes can
correct for more errors when $d\geq 3$. Specifically, while for $d\geq 3$, the
code can correct for the two-qudit errors in the set $\mathcal{A}^{(2)}$ (see
Eq. (26)), for $d=2$, the $4$-qubit code can only detect but not correct for
these two-qubit errors.

To gain a more detailed understanding, we have plotted the fidelity obtained
using the syndrome-based recovery and the Petz recovery for different logical
states subject to amplitude-damping noise. For the qutrit system, we can write
any state in the codespace as,

$\displaystyle\ket{\psi_{L}}$
$\displaystyle=\cos{\theta_{1}}\cos{\theta_{2}}\ket{0_{L}}+e^{i\phi_{1}}\cos{\theta_{1}}\sin{\theta_{2}}\ket{1_{L}}$
$\displaystyle\qquad+e^{i\phi_{2}}\sin{\theta_{1}}\ket{2_{L}}.$ (36)

Figure 4: Worst-case fidelity vs the damping strength $\gamma$ for the
$4$-qutrit code with the Petz recovery vs syndrome-based recovery.

Fig. 6 shows the fidelity between the initial state and the recovered state
for different values of $\theta_{1}$ and $\theta_{2}$, while setting the
relative phases $\phi_{1}$ and $\phi_{2}$ to be zero. We first observe that
the fidelity for the syndrome-based recovery is less sensitive to the choice
of state in comparison to the Petz recovery. It is also clear from Fig. 6,
that for a certain range of states, the Petz map performs better than
syndrome-based recovery.

Finally, we also estimate the entanglement fidelity for both recovery schemes.
For the $4$-qutrit code, the Petz recovery yields an entanglement fidelity of

$\mathcal{F}_{Petz}=1-4.52\gamma^{2}-\mathcal{O}(\gamma^{3}),$ (37)

whereas for the syndrome-based recovery, the entanglement fidelity is,

$\mathcal{F}_{\rm sym}=1-3.62\gamma^{2}-\mathcal{O}(\gamma^{3}).$ (38)

Fig. 5 confirms that the syndrome-based recovery does achieve a higher
entanglement fidelity than the Petz recovery for the $4$-qutrit code.

###  V.3 Performance of noise-adapted qu$d$it codes beyond $d=3$

As noise-adapted QEC codes do not correct for arbitrary errors, it follows
that these codes can at times beat the quantum Hamming bound. Recall that the
quantum Hamming bound gives us an upper bound on the number of qudits needed
to protect a certain number of qudits from arbitrary errors. The formula that
determines the Hamming bound for an $[[n,k,D]]_{d}$ code, where $d$ represents
the local dimension of the quantum system and $D$ is the distance of the code
protecting $t=\lfloor\frac{D-1}{2}\rfloor$ qudits, is given by [12],

$\displaystyle d^{n-k}-\sum_{j=0}^{t}{n\choose j}(d^{2}-1)^{j}\geq 0.$ (39)

We set $t$ and $k$ to be $1$ to know the minimum number of qudits required to
protect a single logical qudit from any single-qudit physical error. It
follows from the bound that we need a minimum of five qutrits to protect one
qutrit. However, for $d\geq 4$, four qudits are enough to correct for any
single-qudit error. Hence, our class of codes beats the quantum Hamming bound
for the qutrit case, similar to the $4$-qubit code [14].

Figure 5: Entanglement fidelity vs the damping strength $\gamma$ for the
$4$-qutrit code with Petz recovery vs syndrome-based recovery.

Increasing the local dimension $d$ of a quantum system increases the quantum
information processing capacity exponentially. This naturally raises the
question of how the performance of our class of $4$-qudit codes scales with
increasing the system dimension $d$.

Figure 6: Fidelity of qutrit logical states parametrized by angles
$\theta_{1}$ and $\theta_{2}$, with relative phases $\phi_{1}=\phi_{2}=0$, for
$\gamma=0.1$, using the Petz and syndrome-based recoveries.

Based on our calculations in Appendix B, we can precisely calculate the extent
to which our class of codes deviates from the Knill-Laflamme conditions for
any $d$. As seen from Eqs. (50)- (52), the leading order deviation is of
$\mathcal{O}(\gamma^{2})$ and the dimensional-dependent coefficient of this
term grows as $d^{2}$ for all the correctable errors. The fidelity of the
recovered state with respect to the encoded state is thus the form
$\mathcal{F}\approx 1-\chi\gamma^{2}+\mathcal{O}(\gamma^{3})$, where $\chi$ –
which captures the _fidelity-loss_ – grows as $\mathcal{O}(d^{2})$. We also
verify this numerically and plot the fidelity-loss coefficient $\chi$ as a
function of $d$ in Fig. 7.

Thus, while our class of $4$-qudit codes has the advantage that the number of
stabilizer measurements remains fixed for $d\geq 5$, the performance of the
code drops with increasing $d$, with the fidelity-loss scaling quadratically
in $d$.

##  VI Summary and Future Directions

We have proposed a new class of four-qudit quantum error correcting codes
tailored to protect against amplitude-damping noise. We show that this class
of codes satisfies a special form of the approximate QEC conditions with the
deviation term being of $\mathcal{O}(\gamma^{2}$ where $\gamma$ is the
probability of a single jump or single-damping event. We further identify a
set of stabilizer generators for our class of codes in terms of the
generalised, $d$-dimensional Pauli operators. Based on this, we construct a
noise-adapted recovery scheme that uniquely identifies the syndromes and
corrects for all single-qudit and some two-qudit errors, thus achieving the
desired order ($\mathcal{O}(\gamma^{2})$) of fidelity.

Our class of codes includes the well known $4$-qubit amplitude-damping code
[14] as a special case. Similar to the $4$-qubit case [17, 36], we see that
the syndrome-based recovery for the $4$-qutrit and $4$-quqad codes also
requires a two-step syndrome extraction procedure with a two primary and two
secondary syndrome measurements. However, for $d\geq 5$, we do not need any
secondary syndromes to distinguish the single-qudit errors of damping strength
up to $\mathcal{O}(\gamma^{2})$, so the number of syndrome measurements does
not grow with the local dimension of the code.

To benchmark the performance of the syndrome-based recovery, we consider the
specific case of the $4$-qutrit code and calculate both the wort-case and
entanglement fidelities for this case. We then compare these fidelities with
those achieved by the Petz recovery map for the same code and noise channel.
Interestingly, in a departure from the qubit case, we find that the syndrome-
based recovery method yields higher fidelities than the Petz recovery. We
believe that this trend should hold true for higher dimensions as well, since
for all $d\geq 3$, this class of codes corrects some subset of two-qudit
errors in addition to the single-qudit errors.

Figure 7: Fidelity loss ($\chi$) vs local dimension $d$ under the Petz
recovery.

Going forward, the class of $4$-qudit codes and the associated syndrome-based
recovery presented here could provide a promising avenue for exploring fault-
tolerant quantum computation using qudits that are predominantly undergo
amplitude-damping noise. We know from the work of Akshaya _et al._ [36] that
the $4$-qubit code can be used to achieve fault tolerance against amplitude-
damping noise, with a finite pseudothreshold in the noise strength $\gamma$.
It would therefore be interesting to study how this threshold scales with the
local system dimension $d$, using the class of codes discussed here.

###### Acknowledgements.

We would like to acknowledge the grant from the Mphasis F1 Foundation to
CQuICC. We are thankful to Akshaya Jayashankar for many insightful discussions
and Shrikant Utagi and Vismay Joshi for helpful comments.

##  Appendix A Proof of Lemma 1

Given a code with codewords $\\{|i_{L}\rangle,i=1,\ldots,d\\}$, and a set of
Kraus operators $\\{E_{k}\\}$ that satisfy Eqs. (12) and (13), we first put
the two conditions together to get the following form of the AQEC conditions

$\langle i_{L}|E_{k}^{{\dagger}}E_{l}|j_{L}\rangle=\left(c_{kk}+\langle
i_{L}|B_{kk}|j_{L}\rangle\right)\delta_{kl}\delta_{ij}.$ (40)

Polar decomposition of the Kraus operators on the codespace leads to unitaries
$U_{k}$, given by

$\displaystyle E_{k}P$
$\displaystyle=U_{k}\sqrt{PE_{k}^{{\dagger}}E_{k}P}=U_{k}P\sqrt{PE_{k}^{{\dagger}}E_{k}P}$
(41)

It follows from the orthogonality in the $(k,l)$ indices in Eq. (40) that the
unitaries $\\{U_{k}\\}$ satisfy,

$\displaystyle PU_{k}^{{\dagger}}U_{l}P$ $\displaystyle\propto\delta_{kl}P$

The recovery due to Leung _et al_ is then defined via the operators
$R^{(L)}_{k}=PU_{k}^{\dagger}$. This can be rewritten as,

$\displaystyle R_{k}^{(L)}$
$\displaystyle=PU_{k}^{{\dagger}}=\left(\sqrt{PE_{k}^{{\dagger}}E_{k}P}\right)^{-1}PE_{k}^{{\dagger}}$
$\displaystyle=\left(\sum\limits_{i,j=0}^{d-1}\ket{i_{L}}\bra{j_{L}}\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{j_{L}}\right)^{-\frac{1}{2}}PE_{k}^{{\dagger}}.$
(42)

Now, if we also invoke the orhtogonality in the codeword indices $(i,j)$, we
see that the Leung _et al_ recovery operators can be written as,

$R_{k}^{(L)}=\sum\limits_{i=0}^{d-1}\frac{\ket{i_{L}}\bra{i_{L}}E_{k}^{{\dagger}}}{\sqrt{\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{i_{L}}}},$
(43)

where we have used
$\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{j_{L}}=\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{i_{L}}\delta_{ij}$.
Recalling the definition of the Cafaro _et al_ recovery operators
$R_{k}^{(C)}$ from Eq. (11), we see that the R.H.S. of Eq. (43) is indeed the
same as $R_{k}^{(C)}$, showing that the two recovery maps are indeed
identical.

Conversely, for a set of codewords $\\{|i_{L}\rangle\\}$ and Kraus operators
$\\{E_{k}\\}$ for which the two set of recovery operators $\\{R_{k}^{(L)}\\}$
and $\\{R_{k}^{(C)}\\}$ are identical, we must have,

$R_{k}^{(L)}=PU_{k}^{\dagger}=\sum\limits_{i=0}^{d-1}\frac{\ket{i_{L}}\bra{i_{L}}E_{k}^{{\dagger}}}{\sqrt{\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{i_{L}}}}.$

From the definition of the unitaries $\\{U_{k}\\}$ in Eq. (42), we see that
this is true only if
$\bra{i_{L}}E_{k}^{{\dagger}}E_{k}\ket{j_{L}}\propto\delta_{ij}$, thus proving
Lemma 1.

##  Appendix B Proof of Theorem 1

The errors on the four-qudit system have the form $A_{ijkl}=A_{i}\otimes
A_{j}\otimes A_{k}\otimes A_{l}$ where the error $A_{ijkl}$ occurs with
probability $\mathcal{O}(\gamma^{i+j+k+l})$. Consider the action of the
single-qudit errors in the set $\mathcal{A}_{\rm corr}$ on the codewords
defined in Eq. (18). For all $m,x\in[0,d-1]$, we note that,

$\displaystyle A_{x000}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=x}^{d-1}\sqrt{\binom{i}{x}}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x}{2}}\ket{i-x}_{1}\ket{i}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}}_{4}$
(44) $\displaystyle A_{0x00}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=x}^{d-1}\sqrt{\binom{i}{x}}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x}{2}}\ket{i}_{1}\ket{i-x}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}}_{4}$
(45) $\displaystyle A_{00x0}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{(i+m)_{d}=x}^{d-1}\sqrt{\binom{(i+m)_{d}}{x}}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x}{2}}\ket{i}_{1}\ket{i}_{2}\ket{(i+m)_{d}-x}_{3}\ket{(i+m)_{d}}_{4}$
(46) $\displaystyle A_{000x}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{(i+m)_{d}=x}^{d-1}\sqrt{\binom{(i+m)_{d}}{x}}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x}{2}}\ket{i}_{1}\ket{i}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}-x}_{4}.$
(47)

We can now prove that our class of $4$-qudit codes satisfy the Knill-Laflamme
condition for error correction up to $\mathcal{O}({\gamma})$ by taking the
inner products of the states in Eqs. (44) through (47).

We first consider a pair of single-qudit damping errors on different qudit
locations.

$\displaystyle\bra{m_{L}}A^{\dagger}_{x000}A_{000y}\ket{n_{L}}$
$\displaystyle=\frac{1}{d}\sum\limits_{i=x,(j+n)_{d}=y}^{d-1}\sqrt{{i\choose
x}{(j+n)_{d}\choose
y}}(1-\gamma)^{i+j+(i+m)_{d}+(j+n)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x+y}{2}}\delta_{i-x,j}\delta_{i,j}\delta_{(i+m)_{d},(j+n)_{d}}\delta_{(i+m)_{d},(j+n)_{d}-y}$
$\displaystyle=\frac{1}{d}\sum\limits_{i=x}^{d-1}\sqrt{{i\choose
x}{(i+n)_{d}\choose
y}}(1-\gamma)^{2i+2(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x+y}{2}}\delta_{i-x,i}\delta_{(i+m)_{d},(i+n)_{d}}\delta_{(i+m)_{d},(i+n)_{d}-y}$
(48)

As
$\delta_{i-x,i}\delta_{(i+m)_{d},(i+n)_{d}}\delta_{(i+m)_{d},(i+n)_{d}-y}=\delta_{m,n}\delta_{x,0}\delta_{y,0}$,
the R.H.S of the Eq.(48) is non-zero if and only if $m=n$ and $x=y=0$.
Therefore, single-qudit errors occurring in different locations map the
codewords in Eq.(18) to mutually orthogonal states.

Next, we consider pairs of single-qudit errors occurring in the same location.

$\displaystyle\bra{m_{L}}A_{x000}^{{\dagger}}A_{y000}\ket{n_{L}}$
$\displaystyle=\frac{1}{d}\sum_{i=x,j=y}^{d-1}\sqrt{\binom{i}{x}\binom{j}{y}}(1-\gamma)^{i+j+(i+m)_{d}+(j+n)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x+y}{2}}\delta_{i-x,j-y}\delta_{i,j}\delta_{(i+m)_{d},(j+n)_{d}}$
$\displaystyle=\frac{1}{d}\sum_{i=x}^{d-1}\sqrt{\binom{i}{x}\binom{i}{y}}(1-\gamma)^{2i+(i+m)_{d}+(i+n)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{\frac{x+y}{2}}\delta_{i-x,i-y}\delta_{(i+m)_{d},(i+n)_{d}}$
$\displaystyle=\frac{1}{d}\sum_{i=x}^{d-1}\binom{i}{x}(1-\gamma)^{2i+2(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)^{x}\delta_{x,y}\delta_{m,n}$
$\displaystyle=\frac{1}{d}\sum_{i=x}^{d-1}\gamma^{x}{i\choose
x}\left(1-(p-x)\gamma+(\frac{p(p-1)}{2}+\frac{x(x-1)}{2}-xp)\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{x,y}\delta_{m,n}.$
(49)

where, $p=2i+2(i+m)_{d}$. The presence of $\delta_{x,y}$ and $\delta_{m,n}$ in
Eq. (B) confirms again that different single-qudit errors occurring at the
same location also map the codewords in Eq. (18) to orthogonal states.

For the cases when $x=y$ in Eq. (B), we now calculate the coefficients of
different orders of $\gamma$, as follows.

  * •

The no-damping error operator $A_{0000}$ ($x=0$)

$\displaystyle\bra{m_{L}}A_{0000}^{{\dagger}}A_{0000}\ket{n_{L}}$
$\displaystyle=\frac{1}{d}\sum_{i=0}^{d-1}\left(1-p\gamma+\frac{p(p-1)}{2}\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$
(50)
$\displaystyle=\left(1-2(d-1)\gamma+\frac{1}{d}\sum_{i=0}^{d-1}(i+(i+m)_{d})(2i+2(i+m)_{d}-1)\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$

  * •

The single-qudit, single-damping error operator $A_{1000}$ ($x=1$)

$\displaystyle\bra{m_{L}}A_{1000}^{{\dagger}}A_{10000}\ket{n_{L}}$
$\displaystyle=\frac{1}{d}\sum_{i=1}^{d-1}\gamma
i\left(1-(p-1)\gamma+(p+\frac{p(p-1)}{2})\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$
$\displaystyle=\left(\frac{d-1}{2}\gamma+\frac{1}{d}\sum_{i=1}^{d-1}i(1-2i-2(i+m)_{d})\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$
(51)

  * •

The single-qudit two-damping error operator $A_{2000}$ ($x=2$)

$\displaystyle\bra{m_{L}}A_{2000}^{{\dagger}}A_{20000}\ket{n_{L}}$
$\displaystyle=\left(\frac{1}{2d}\sum_{i=2}^{d-1}i(i-1)\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$
$\displaystyle=\left(\frac{1}{6}(d-1)(d-2)\gamma^{2}+\mathcal{O}(\gamma^{3})\right)\delta_{m,n}$
(52)

  * •

For single-qudit errors with a higher degree of damping, that is, $A_{x000}$
with $x\geq 3$, we get,

$\bra{m_{L}}A_{x000}^{{\dagger}}A_{x0000}\ket{n_{L}}=\mathcal{O}(\gamma^{x})\delta_{m,n}.$

Therefore, we see that the coefficient of $\gamma$ is independent of $m$,
whereas the coefficient of $\gamma^{2}$ depends on the value of $m$ for $x\leq
2$. This shows that the codewords in Eq.(18) satisfy the Knill-Laflamme
conditions up to $\mathcal{O}(\gamma)$ for all the single-qudit damping
errors.

Finally, we consider the two-qudit errors
$\\{A_{1010},A_{1001},A_{0101},A_{0110}\\}$ in the set $\mathcal{A}_{\rm
corr}$. The action of these errors on the codewords is given by,

$\displaystyle A_{1010}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=1}^{d-1}\Theta[(i+m)_{d}-1]i(i+m)_{d}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)\ket{i-1}_{1}\ket{i}_{2}\ket{(i+m)_{d}-1}_{3}\ket{(i+m)_{d}}_{4}$
(53) $\displaystyle A_{1001}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=1}^{d-1}\Theta[(i+m)_{d}-1]i(i+m)_{d}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)\ket{i-1}_{1}\ket{i}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}-1}_{4}$
(54) $\displaystyle A_{0101}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=1}^{d-1}\Theta[(i+m)_{d}-1]i(i+m)_{d}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)\ket{i}_{1}\ket{i-1}_{2}\ket{(i+m)_{d}}_{3}\ket{(i+m)_{d}-1}_{4}$
(55) $\displaystyle A_{0110}\ket{m_{L}}$
$\displaystyle=\frac{1}{\sqrt{d}}\sum_{i=1}^{d-1}\Theta[(i+m)_{d}-1]i(i+m)_{d}(1-\gamma)^{i+(i+m)_{d}}\left(\frac{\gamma}{1-\gamma}\right)\ket{i}_{1}\ket{i-1}_{2}\ket{(i+m)_{d}-1}_{3}\ket{(i+m)_{d}}_{4}$
(56)

Here, $\Theta[x]$ is the Heaviside step function that takes value 1 when
$x\geq 0$ and 0 otherwise. It is evident that all the noisy states in Eqs.
(53)- (56) are orthogonal to each other. Furthermore, it is easy to check that
the noisy states in Eqs. (53)- (56) are also orthogonal to the noisy states in
Eqs. (44)- (47) obtained due to the single-qudit errors.

Now, we consider the following inner product, where $A_{1010}$ acts on
different logical states.

$\displaystyle\bra{m_{L}}A_{1010}^{{\dagger}}A_{1010}\ket{n_{L}}=\frac{1}{d}\sum_{i=1}^{d-1}\Theta[(i+m)_{d}-1]i^{2}\gamma^{2}(i+m)_{d}^{2}(1-\gamma)^{2i+2(i+m)_{d}-2}\delta_{m,n}$
(57)

We get identical expressions for the other two-qudit errors as well. The
$\delta_{m,n}$ term in Eq. (57) verifies that the codewords get mapped to
orthogonal states by different two-qudit error operators. The leading order
term in Eq. (57) is $\mathcal{O}(\gamma^{2})$ and its coefficient does depend
on the codewords.

##  Appendix C Ququad code for Amplitude-damping

When the local dimension of the codewords in Eq. (18) is four, the primary
syndromes $(p_{1},p_{2})$ obtained by measuring the stablilizer generators in
Eq. (27) alone cannot differentiate between the pair of errors
$(A_{2000},A_{0200})$ and the pair of errors $(A_{0020},A_{0002})$. However,
it is possible to distinguish between these errors by utilising secondary
syndrome measurements, as in the case of $d=3$.

We measure the secondary syndromes $(s_{1},s_{2})$ for the $4$-ququad code by
using the additional operators $\tilde{Z}III$ and $II\tilde{Z}I$. The operator
$\tilde{Z}$ has the matrix representation,

$\displaystyle\tilde{Z}=\begin{bmatrix}1&0&0&0\\\ 0&1&0&0\\\ 0&0&-1&0\\\
0&0&0&-1\end{bmatrix}$ (58)

To execute these measurements, we attach an ancilla qubit and perform the
following controlled operation.

$\displaystyle CX_{4}=\begin{bmatrix}\mathbf{I}_{2}&0&0&0\\\
0&\mathbf{I}_{2}&0&0\\\ 0&0&\mathbf{X}_{2}&0\\\
0&0&0&\mathbf{X}_{2}\end{bmatrix}.$ (59)

Here, $\mathbf{X}_{2}$ is the Pauli $X$ operator for qubits. The controlled
operation $CX_{4}$ flips the ancilla target qubit whenever the control state
is $\ket{2}$ or $\ket{3}$.

From Table 3, we note that the secondary syndromes $s_{1},s_{2}$ distinguish
the errors whose primary syndromes $p_{1},p_{2}$ are identical.

Table of syndromes for ququads
---
Errors |  $\qquad p_{1},p_{2}$ |  $\qquad s_{1},s_{2}$
$A_{1000}$ |  3,0 |  $\times$
$A_{0100}$ |  1,0 |  $\times$
$A_{2000}$ |  2,0 |  0,0
$A_{0200}$ |  2,0 |  1,0
$A_{0010}$ |  0,3 |  $\times$
$A_{0001}$ |  0,1 |  $\times$
$A_{0020}$ |  0,2 |  0,0
$A_{0002}$ |  0,2 |  0,1
$A_{1010}$ |  3,3 |  $\times$
$A_{1001}$ |  3,1 |  $\times$
$A_{0101}$ |  1,1 |  $\times$
$A_{0110}$ |  1,3 |  $\times$
Table 3: Primary and secondary syndrome string for different errors with
probability up to $\mathcal{O}(\gamma^{2})$ for the ququad code.

## References

  * [1] Yuchen Wang, Zixuan Hu, Barry C Sanders, and Sabre Kais.  Qudits and high-dimensional quantum computing.  Frontiers in Physics, 8:589504, 2020.
  * [2] Yulin Chi, Jieshan Huang, Zhanchuan Zhang, Jun Mao, Zinan Zhou, Xiaojiong Chen, Chonghao Zhai, Jueming Bao, Tianxiang Dai, Huihong Yuan, et al.  A programmable qudit-based quantum processor.  Nature communications, 13(1):1166, 2022.
  * [3] MingXing Luo and XiaoJun Wang.  Universal quantum computation with qudits.  Science China Physics, Mechanics & Astronomy, 57:1712–1717, 2014.
  * [4] Brian Mischuck and Klaus Mølmer.  Qudit quantum computation in the jaynes-cummings model.  Physical Review A, 87(2):022341, 2013.
  * [5] S. S. Ivanov, H. S. Tonchev, and N. V. Vitanov.  Time-efficient implementation of quantum search with qudits.  Phys. Rev. A, 85:062321, Jun 2012.
  * [6] Anna S Nikolaeva, Evgeniy O Kiktenko, and Aleksey K Fedorov.  Efficient realization of quantum algorithms with qudits.  arXiv preprint arXiv:2111.04384, 2021.
  * [7] Shuxiang Cao, Mustafa Bakr, Giulio Campanaro, Simone D Fasciati, James Wills, Deep Lall, Boris Shteynas, Vivek Chidambaram, Ivan Rungger, and Peter Leek.  Emulating two qubits with a four-level transmon qudit for variational quantum algorithms.  arXiv preprint arXiv:2303.04796, 2023.
  * [8] A. S. Nikolaeva, E. O. Kiktenko, and A. K. Fedorov.  Decomposing the generalized Toffoli gate with qutrits.  Phys. Rev. A, 105(3):032621, March 2022.
  * [9] Barbara M Terhal.  Quantum error correction for quantum memories.  Reviews of Modern Physics, 87(2):307, 2015.
  * [10] Austin G Fowler, Matteo Mariantoni, John M Martinis, and Andrew N Cleland.  Surface codes: Towards practical large-scale quantum computation.  Physical Review A, 86(3):032324, 2012.
  * [11] Daniel Gottesman.  Stabilizer codes and quantum error correction.  California Institute of Technology, 1997.
  * [12] Sixia Yu, C. H. Lai, and C. H. Oh.  Strengthened quantum hamming bound, 2010.
  * [13] Miha Papič, Adrian Auer, and Inés de Vega.  Fast estimation of physical error contributions of quantum gates, 2023.
  * [14] Debbie W. Leung, M. A. Nielsen, Isaac L. Chuang, and Yoshihisa Yamamoto.  Approximate quantum error correction can lead to better codes.  Phys. Rev. A, 56:2567–2573, Oct 1997.
  * [15] Howard Barnum and Emanuel Knill.  Reversing quantum dynamics with near-optimal quantum and classical fidelity.  Journal of Mathematical Physics, 43(5):2097–2106, 2002.
  * [16] Hui Khoon Ng and Prabha Mandayam.  Simple approach to approximate quantum error correction based on the transpose channel.  Phys. Rev. A, 81:062342, Jun 2010.
  * [17] Andrew S Fletcher, Peter W Shor, and Moe Z Win.  Channel-adapted quantum error correction for the amplitude damping channel.  IEEE Transactions on Information Theory, 54(12):5705–5718, 2008.
  * [18] John Preskill.  Quantum computing in the nisq era and beyond.  Quantum, 2:79, 2018.
  * [19] Panos Aliferis and John Preskill.  Fault-tolerant quantum computation against biased noise.  Physical Review A, 78(5):052331, 2008.
  * [20] Joschka Roffe, Lawrence Z. Cohen, Armanda O. Quintavalle, Daryus Chandra, and Earl T. Campbell.  Bias-tailored quantum LDPC codes.  Quantum, 7:1005, May 2023.
  * [21] Qian Xu, Nam Mannucci, Alireza Seif, Aleksander Kubica, Steven T. Flammia, and Liang Jiang.  Tailored xzzx codes for biased noise.  Phys. Rev. Res., 5:013035, Jan 2023.
  * [22] Shruti Puri, Lucas St-Jean, Jonathan A. Gross, Alexander Grimm, Nicholas E. Frattini, Pavithran S. Iyer, Anirudh Krishna, Steven Touzard, Liang Jiang, Alexandre Blais, Steven T. Flammia, and S. M. Girvin.  Bias-preserving gates with stabilized cat qubits.  Science Advances, 6(34):eaay5901, 2020.
  * [23] Akshaya Jayashankar, Anjala M Babu, Hui Khoon Ng, and Prabha Mandayam.  Finding good quantum codes using the cartan form.  Physical Review A, 101(4):042307, 2020.
  * [24] Isaac L. Chuang, Debbie W. Leung, and Yoshihisa Yamamoto.  Bosonic quantum codes for amplitude damping.  Phys. Rev. A, 56:1114–1125, Aug 1997.
  * [25] Wojciech Wasilewski and Konrad Banaszek.  Protecting an optical qubit against photon loss.  Physical Review A, 75(4):042316, 2007.
  * [26] Yingkai Ouyang and Rui Chao.  Permutation-invariant constant-excitation quantum codes for amplitude damping.  IEEE Transactions on Information Theory, 66(5):2921–2933, 2020.
  * [27] Marios H. Michael, Matti Silveri, R. T. Brierley, Victor V. Albert, Juha Salmilehto, Liang Jiang, and S. M. Girvin.  New class of quantum error-correcting codes for a bosonic mode.  Phys. Rev. X, 6:031006, Jul 2016.
  * [28] Victor V. Albert.  Bosonic coding: introduction and use cases, 2022.
  * [29] Zaki Leghtas, Gerhard Kirchmair, Brian Vlastakis, Robert J. Schoelkopf, Michel H. Devoret, and Mazyar Mirrahimi.  Hardware-efficient autonomous quantum memory protection.  Phys. Rev. Lett., 111:120501, Sep 2013.
  * [30] P. T. Cochrane, G. J. Milburn, and W. J. Munro.  Macroscopically distinct quantum-superposition states as a bosonic code for amplitude damping.  Phys. Rev. A, 59:2631–2634, Apr 1999.
  * [31] Mazyar Mirrahimi, Zaki Leghtas, Victor V Albert, Steven Touzard, Robert J Schoelkopf, Liang Jiang, and Michel H Devoret.  Dynamically protected cat-qubits: a new paradigm for universal quantum computation.  New Journal of Physics, 16(4):045014, apr 2014.
  * [32] Andrew S. Darmawan, Benjamin J. Brown, Arne L. Grimsmo, David K. Tuckett, and Shruti Puri.  Practical quantum error correction with the xzzx code and kerr-cat qubits.  PRX Quantum, 2:030345, Sep 2021.
  * [33] Alexander Grimm, Nicholas E Frattini, Shruti Puri, Shantanu O Mundhada, Steven Touzard, Mazyar Mirrahimi, Steven M Girvin, Shyam Shankar, and Michel H Devoret.  The kerr-cat qubit: stabilization, readout, and gates.  arXiv preprint arXiv:1907.12131, 2019.
  * [34] Weizhou Cai, Yuwei Ma, Weiting Wang, Chang-Ling Zou, and Luyan Sun.  Bosonic quantum error correction codes in superconducting quantum circuits.  Fundamental Research, 1(1):50–67, 2021.
  * [35] Markus Grassl, Linghang Kong, Zhaohui Wei, Zhang-Qi Yin, and Bei Zeng.  Quantum error-correcting codes for qudit amplitude damping.  IEEE Transactions on Information Theory, 64(6):4674–4685, 2018.
  * [36] Akshaya Jayashankar, My Duy Hoang Long, Hui Khoon Ng, and Prabha Mandayam.  Achieving fault tolerance against amplitude-damping noise.  Phys. Rev. Res., 4:023034, Apr 2022.
  * [37] Marius Junge, Renato Renner, David Sutter, Mark M Wilde, and Andreas Winter.  Universal recovery maps and approximate sufficiency of quantum relative entropy.  In Annales Henri Poincaré, volume 19, pages 2955–2978. Springer, 2018.
  * [38] Emanuel Knill, Raymond Laflamme, and Lorenza Viola.  Theory of quantum error correction for general noise.  Phys. Rev. Lett., 84:2525–2528, Mar 2000.
  * [39] Michael A. Nielsen and Isaac L. Chuang.  Quantum Computation and Quantum Information.  Cambridge University Press, 2000.
  * [40] Cédric Bény and Ognyan Oreshkov.  General conditions for approximate quantum error correction and near-optimal recovery channels.  Phys. Rev. Lett., 104:120501, Mar 2010.
  * [41] Carlo Cafaro and Peter van Loock.  Approximate quantum error correction for generalized amplitude-damping errors.  Phys. Rev. A, 89:022316, Feb 2014.
  * [42] Luca Chirolli and Guido Burkard.  Decoherence in solid-state qubits.  Advances in Physics, 57(3):225–285, 2008.
  * [43] András Gilyén, Seth Lloyd, Iman Marvian, Yihui Quek, and Mark M Wilde.  Quantum algorithm for petz recovery channels and pretty good measurements.  Physical Review Letters, 128(22):220502, 2022.
  * [44] Debjyoti Biswas, Gaurav M Vaidya, and Prabha Mandayam.  Noise-adapted recovery circuits for quantum error correction.  arXiv preprint arXiv:2305.11093, 2023.