text:
# Quantum error correction for continuously detected errors

## I Introduction

Many of the applications of quantum information science, such as quantum computation ph219\_notes ; nc  and quantum cryptography secure\_QKD , rely on preserving the coherence of quantum states. However, these states are typically short-lived because of unavoidable interactions with the environment. Combatting this decoherence has been the subject of much study.

Two important tools that have been developed for this task are quantum error correction shor-ec ; steane-ec ; knill-laflamme ; gott-stab  and quantum feedback wiseman\_pra94 ; doherty-jacobs ; WisManWang02 . In the usual protocol for quantum error correction, projective measurements are performed to acquire an error syndrome. A unitary operation chosen based on the results of the projective measurements is then applied to correct for the error. Quantum feedback control, on the other hand, uses the tools of continuous measurements and Hamiltonian feedback. The parameter to be controlled is typically the strength of the feedback Hamiltonian, which is conditioned on the result of the continuous measurements.

Quantum error correction and quantum feedback both rely on performing operations that are conditioned on the result of some measurement on the system, which suggests that exploring the links between these two techniques adds to our understanding of both processes, and may lead to insights into future protocols and experimental implementations. In particular, this work provides an alternate avenue for examining the situation considered in mabuchi-zoller ; qec-spont ; detected-jump1 ; detected-jump2  of correcting for a specific error process, such as spontaneous emission, at the expense of correcting fewer general errors. Practically, as these authors point out, it makes sense to pursue the tradeoff between general correction ability and redudancy of coding, as smaller codes are more likely to be in the range of what can be experimentally realized in the near future. We shall see that combining the pictures of quantum feedback and error correction provides a convenient framework in which to investigate this situation.

An additional motivation for considering the union of these techniques, as in ADL , is to examine what is possible with different physical tools: in particular, continuous measurements and Hamiltonians instead of the projective measurements and fast unitary gates generally assumed by discrete quantum error correction. Continuous error correction might well be useful even in a scenario in which near-projective measurements are possible (e.g., ion traps Wineland  and superconducting qubits Vion2002 ); it could be modified to provide bounds on how strong interactions in such systems would have to be to perform operations such as error correction and stay within a certain error threshold.

Ref. ADL  presupposed that classical processing of currents could be done arbitrarily quickly, so the feedback was allowed to be an extremely complicated function of the entire measurement record. This can be modeled only by numerical simulations. In this paper, by contrast, we will restrict our feedback to be directly proportional to measured currents, thus removing any need for classical post-processing. In the Markovian limit, this allows an analytical treatment. This simplification is possible because in this paper we assume that the errors are detected. That is, the experimenter knows precisely what sort of error has occurred because the environment that caused the errors is being continuously measured. Since the environment is thus acting as part of the measurement apparatus, the errors it produces could be considered measurement-induced errors.

There are a number of implementations in which measurement-induced errors of this sort may be significant. In the efficient linear optics scheme of Knill et al. KLM , gates are implemented by nondeterministic teleportation. Failure of the teleportation corresponds to a gate error in which one of the qubits is measured in the computational basis with known result. In a number of solid state schemes, the readout device is always present and might make an accidental measurement of a qubit, even if the readout apparatus is in a quiescent state. An example is the use of RF single electron transistors to readout a charge transfer event in the Kane proposal. Such a measurement is modelled as a weak continuous measurement Wiseman2001 . While one supposes that the SET is biased in its low conductance state during qubit processing, it is useful to know that even if the device does accidentally make a measurement, the resulting error can be corrected.

In this paper, we show that for certain error models and codes, Markovian feedback plus an additional constant Hamiltonian (a “driving Hamiltonian”) can protect an unknown quantum state encoded in a particular codespace. Using the stabilizer formalism, we show that if there is one sort of error per physical qubit, and the error is detected perfectly, then it is always possible to store $`n1`$ logical qubits in $`n`$ physical qubits. This works whether the detector record consists of discrete spikes (Poisson noise) or a continuous current (white noise). This suggest that if the dominant decoherence process can be monitored, then using that information to control the system Hamiltonian may be the key to preventing such decoherence (see also the example in doherty\_thesis ).

As a salient application of this formalism, we consider the special case of spontaneous emission. Stabilizing states against spontaneous emission by using error-correcting codes has been studied by several groups mabuchi-zoller ; qec-spont ; detected-jump1 ; detected-jump2 . Here we demonstrate that a simple $`n`$-qubit error-correcting code, Markovian quantum feedback, and a driving Hamiltonian, is sufficient to correct spontaneous emissions on $`n1`$ qubits. The result of encoding $`n1`$ logical qubits in $`n`$ physical qubits has been recently independently derived by K-Lidar  for the special case of spontaneous emission; however, our scheme differs in a number of respects. We also show that spontaneous emission error correction by feedback can be incorporated within the framework of canonical quantum error correction, which can correct arbitrary errors.

The paper is organized as follows. We review some useful results in quantum error correction and quantum feedback theory in Sec. II. In Sec. III we present the example of detected spontaneous-emission errors, first for 2 qubits and then for $`n`$ qubits. In Sec. IV we generalize this for protecting an unknown state subject to any single-qubit measurements. We show how to perform universal quantum computation using our protocol in Sec. V. Sec. VI concludes.

## II Background

### II.1 Quantum error correction: stabilizer formalism

Quantum error correction has specifically been designed for protecting unknown quantum states gott-stab ; knill-laflamme ; ftqc . An important class of quantum error-correcting codes are the stabilizer codes. An elegant and simple formalism gott-stab  exists for understanding these codes; in this paper we will restrict ourselves to this class of codes in order to take advantage of this formalism.

In the remainder of this paper we will use the notation of nc  in which $`X`$, $`Y`$, and $`Z`$ denote the Pauli matrices $`\sigma _x`$, $`\sigma _y`$ and $`\sigma _z`$ respectively, and juxtaposition denotes a tensor product; hence any element of the Pauli group

$$P_n=\{\pm 1,\pm i\}\{I,X,Y,Z\}^n$$
(1)
may be denoted as a concatenation of letters (e.g., $`ZZI=\sigma _z\sigma _zI`$).

A stabilizer code may be defined simply as follows: Consider a $`2^n`$-dimensional ($`n`$-qubit) Hilbert space and a subgroup of $`2^{nk}`$ commuting Pauli operators $`𝒮P_n`$. This group of operators is the *stabilizer* of the code; the codespace $`𝒞(𝒮)`$ is the simultaneous $`+1`$ eigenspace of all the operators in $`𝒮`$. It can be shown that if $`I`$ is not an element of $`𝒮`$, the subspace stabilized is non-trivial, and the dimension of $`𝒞(𝒮)`$ is $`2^k`$; hence, we regard this system as encoding $`k`$ qubits in $`n`$. The generators of such a group are a subset of this group such that any element of the stabilizer can be described as a product of generators. It is not hard to show that $`nk`$ generators suffice to describe the stabilizer group $`𝒮`$.

When considering universal quantum computation it is also useful to define the normalizer of a code. Given a stabilizer group $`𝒮`$, the normalizer $`N(𝒮)`$ is the group of elements in $`P_n`$ that commute with all the the elements of $`𝒮`$, and it can be shown that the number of elements in $`N(𝒮)`$ is $`2^{n+k}`$.

Now, $`n+k`$ generators suffice to describe $`N(𝒮)`$. Of these, $`nk`$ can be chosen to be the generators of $`𝒮`$. It can be shown that the remaining $`2k`$ generators can be chosen to be the encoded operators $`\overline{Z}_\mu ,\overline{X}_\mu ,\mu =1,2,\mathrm{},k`$, where $`\overline{Z}_\mu ,\overline{X}_\mu `$ denote the Pauli operators $`X`$ and $`Z`$ acting on encoded qubit $`\mu `$, tensored with the identity acting on all other encoded qubits. These encoded operators act, as their name implies, to take states in $`𝒞(𝒮)`$ to other states in $`𝒞(𝒮)`$.

The usual protocol for stabilizer codes, which will be modified in what follows, starts with measuring the stabilizer generators. This projection discretizes whatever error has occurred into one of $`2^{nk}`$ error syndromes labeled by the $`2^{nk}`$ possible outcomes of the stabilizer generator measurements. The information given by the stabilizer measurements about what error syndrome has occurred is then used to apply a unitary recovery operator that returns the state to the codespace.

In this paper we will use a modified version of this protocol. In particular, we will not measure stabilizer elements. Instead, we will assume that a limited class of errors occurs on the system and that these errors are detectable: we know when an error has happened and what the error is. The correction back to the codespace can still be performed by a unitary recovery operator based on the information from the error measurement. Fig. 1 shows the difference between the conventional protocol and our modified protocol.

In this paper, we will also consider operators of the form

$$T=T_1\mathrm{}T_n,$$
(2)
where $`T_i`$ is an arbitrary traceless one-qubit operator normalized such that its eigenvalues are $`\{1,1\}`$. Operators of this form are not generally Pauli-group stabilizers as presented in gott-stab , as $`T`$ is not in general a member of $`P_n`$. However, because of the special form of $`T`$, $`T`$ is equivalent to a Pauli operator up to conjugation by a unitary that is a product of one-qubit unitaries, i.e., there exists some $`U=_{i=1}^nU_i`$ such that $`UTU^{}`$ is a member of $`P_n`$. Therefore, choosing $`T`$ as the sole stabilizer generator for a code is equivalent, up to conjugation by a unitary, to choosing a member of the Pauli group as the stabilizer generator. (Note that additional constraints are necessary if $`T`$ is not the only stabilizer generator.)

### II.2 Quantum feedback

Continuous quantum feedback can be defined, for the present purposes, as the process of monitoring a quantum system and using the continuous (in time) measurement record to control its dynamics. It can be analysed by considering the dynamics of the measured system conditioned on the continuous measurement record; this process is referred to as unraveling. The reduced dynamics of a system subject to weak continuous measurement is described by a Markov master equation, which determines the dynamics of the system averaged over all possible measurement records. However, if the time-continuous measurement record (a classical stochastic process) is known, then it is possible to describe the conditional state of the measured system by a stochastic conditional evolution equation. A given master equation does not uniquely determine the conditional evolution equation, as there are many ways in which information about the system may be collected from the environment to which it is coupled as a result of the measurement. That is to say, a given master equation admits many unravelings.

In this section we will introduce some of the results of this formalism; for more details see wiseman-semiclass . We will assume that the change in the state of the system over a time interval $`dt`$ due to its interaction with the environment can be described by a single jump operator $`c`$. By this we mean that jumps are represented by a Kraus operator $`\mathrm{\Omega }_1=c\sqrt{dt}`$, so that they occur with probability $`c^{}cdt`$. Normalization requires another Kraus operator, $`\mathrm{\Omega }_0=1c^{}cdt/2iHdt`$, where $`H`$ is Hermitian. Then the unconditional master equation without feedback is just the familiar Lindblad form carmichael

$`d\rho `$ $`=`$ $`\mathrm{\Omega }_0\rho \mathrm{\Omega }_0+\mathrm{\Omega }_1\rho \mathrm{\Omega }_1\rho `$ (3)
$`=`$ $`i[H,\rho ]dt+c\rho c^{}dt{\displaystyle \frac{1}{2}}(c^{}c\rho +\rho c^{}c)dt`$
$``$ $`i[H,\rho ]dt+𝒟[c]\rho dt.`$
A bosonic example is given in WallsMilb , while a fermionic example is given in Milburn1998 .

#### II.2.1 Jump unravelings

One way to unravel this master equation is to assume that the environment is measured so that the time of each jump event is determined. If the measured number of jumps up to time $`t`$ is denoted $`N(t)`$, then the increment $`dN(t)`$ is defined by

$`dN_c(t)^2`$ $`=`$ $`dN_c(t)`$ (4)
$`E[dN_c(t)]`$ $`=`$ $`c^{}c_cdt.`$ (5)
Here $`E[]`$ defines a classical ensemble average, and the subscript $`c`$ on the quantum average reminds us that the rate of the process at time $`t`$ depends on the conditional state of the quantum system up to that time. That is to say, it depends on the state of the quantum system conditioned on the entire previous history of the current $`dN/dt`$. This conditional state is determined by a stochastic Schrödinger equation

$`d|\psi _c(t)`$ $`=`$ $`[dN_c(t)({\displaystyle \frac{c}{\sqrt{c^{}c_c(t)}}}1)+dt`$ (6)
$`\times ({\displaystyle \frac{c^{}c_c(t)}{2}}{\displaystyle \frac{c^{}c}{2}}iH)]|\psi _c(t).`$
We will refer to this as a jump unraveling. If we average over the measurement record to form $`\rho (t)=E[|\psi _c(t)\psi _c(t)|]`$, it is easy to show using Eqs. (4) and (5) that $`\rho (t)`$ obeys the unconditional master equation given in Eq.(3).

Now consider Markovian Hamiltonian feedback, linear in the current:

$$H_{fb}(t)=\frac{dN(t)}{dt}V,$$
(7)
with $`V`$ an Hermitian operator. Taking into account that the feedback must act after the measurement, it can be shown wiseman\_pra94  that the feedback modifies the conditional evolution by changing the $`c`$ in the numerator of the first term into $`e^{iV}c`$. Since likewise changing all of the other occurrences of $`c`$ has no effect, the ensemble average behaviour is the same as before, with $`c`$ changed to $`e^{iV}c`$. That is to say, the feedback-modified master equation is

$$\dot{\rho }=i[H,\rho ]+𝒟[e^{iV}c]\rho .$$
(8)
#### II.2.2 Diffusive unravelings

A very different unraveling may be defined by first noting that given some complex number $`\gamma =|\gamma |e^{i\varphi }`$, we may make the transformation

$`c`$ $``$ $`c+\gamma `$
$`H`$ $``$ $`H{\displaystyle \frac{i|\gamma |}{2}}(e^{i\varphi }ce^{i\varphi }c^{})`$ (9)
and obtain the same master equation. In the limit as $`|\gamma |`$ becomes very large, the rate of the Poisson process is dominated by the term $`|\gamma |^2`$. In this case it may become impossible to monitor every jump process, and a better strategy is to approximate the Poisson stochastic process by a Gaussian white-noise process.

For large $`\gamma `$, we can consider the system for a time $`\delta t`$ in which the system changes negligibly but the number of detections $`\delta N(t)|\gamma |^2\delta t`$ is very large; then we can approximate $`\delta N(t)`$ as fieldquad

$$\delta N(t)|\gamma |^2\delta t+|\gamma |e^{i\varphi }c+c^{}e^{i\varphi }_c^{}\delta t+|\gamma |\delta W(t),$$
(10)
where $`\delta W(t)`$ is normally distributed with mean zero and variance $`\delta t`$.

We now define the stochastic measurement record as the current

$`{\displaystyle \frac{dQ(t)}{dt}}`$ $`=`$ $`\underset{\gamma \mathrm{}}{lim}{\displaystyle \frac{\delta N(t)|\gamma |^2\delta t}{|\gamma |\delta t}}`$ (11)
$`=`$ $`e^{i\varphi }c+e^{i\varphi }c^{}_c^{}+dW(t)/dt.`$ (12)
Given this stochastic measurement record, we can determine the conditional state of the quantum system by a stochastic Schrödinger equation analogous to Eq. (6). The equivalence (in the ensemble average) to the master equation (3) is, in this case, easier to see by considering $`\rho _c=|\psi _c\psi _c|`$, which obeys the stochastic master equation

$`d\rho _c(t)`$ $`=`$ $`i[H,\rho _c(t)]dt+𝒟[e^{i\varphi }c]\rho _c(t)dt`$ (13)
$`+[e^{i\varphi }c]\rho _c(t)dW(t).`$
In the above equations, the expectation $`a_c^{}`$ denotes $`\mathrm{tr}(\rho _ca)`$, $`dW`$ is a normally distributed infinitesimal random variable with mean zero and variance $`dt`$ (a *Wiener increment* gardiner ), and $``$ is a superoperator that takes a jump operator as an argument and acts on density matrices as

$`[c]\rho `$ $`=`$ $`c\rho +\rho c^{}\rho \mathrm{tr}[c\rho +\rho c^{}].`$ (14)
We thus have a different unraveling of the original master equation Eq.(3). Because of the white noise in the stochastic master equation (13) we call this a diffusive unraveling. It applies, for example, when one performs a continuous weak homodyne measurement of a field $`c`$ by first mixing it with a classical local oscillator in a beamsplitter and then measuring the output beams with photodetectors fieldquad . In that case the measurement process $`dQ(t)`$ determines the observed photocurent. Another measurement model in which it may be appropriate to approximate a Poisson measurement process by a white-noise measurement process is the electronic point contact model for monitoring a single quantum dotGoan2001b ; Goan2001 . In that case the form of the master equation itself determines a large background jump rate, rather than an imposed classical field prior to detection.

We now consider Markovian feedback of the white-noise measurement record via a Hamiltonian, where the strength of the feedback is a linear function of the measurement current:

$$H_{fb}(t)=\frac{dQ(t)}{dt}F,$$
(15)
where $`F`$ is a Hermitian operator. It can be shown that the addition of such feedback leads to the conditioned master equation wiseman\_pra94 ; WisMilprl93

$`\dot{\rho }`$ $`=`$ $`i[(e^{i\varphi }c^{}F+e^{i\varphi }Fc)/2+H,\rho ]`$ (16)
$`+𝒟[e^{i\varphi }ciF]\rho `$
$`+dW(t)[e^{i\varphi }ciF]\rho .`$
In order to derive analytic results given such feedback, it is convenient to consider the average over many such evolution trajectories. Since the expectation value of $`dW`$ is zero, averaging yields an unconditioned master equation

$`\dot{\rho }`$ $`=`$ $`i[(e^{i\varphi }c^{}F+e^{i\varphi }Fc)/2+H,\rho ]`$ (17)
$`+𝒟[e^{i\varphi }ciF]\rho `$
Note that these equations are only valid for perfect (unit-efficiency) detection; the correspondences between error correction and feedback are more readily seen in this case, and we discuss the case of imperfect detection in Sec. IV.4.

These feedback equations are easily generalized in the following way: Given $`n`$ qubits, denote a set of measurement operators by $`\{c_1,c_2,\mathrm{},c_n\}`$, where $`c_j`$ acts on the $`j`$th qubit, and a set of feedback operators by $`\{F_1,\mathrm{},F_n\}`$, where the action of $`F_j`$ is conditioned on the measurement of the $`j`$th qubit. Then the unconditional master equation (17), for example, generalizes to

$`\dot{\rho }={\displaystyle \underset{j=1}{\overset{n}{}}}`$ $`\{i[(e^{i\varphi _j}c_j^{}F_j+e^{i\varphi _j}F_jc_j)/2+H,\rho ]`$ (18)
$`+𝒟[e^{i\varphi _j}c_jiF_j]\rho \}.`$
## III Example: Spontaneous-emission correction

A particular example of a Poisson process error is spontaneous emission, in which the jump operator is proportional to $`|01|`$, so that the state simply decays from $`|1`$ to $`|0`$ at random times. Indeed, if the decay is observed (say by emitting a photon which is then detected), this may be regarded as a destructive measurement of the operator $`|11|`$.

Stabilizing states against the important decay process of spontaneous emission through application of error-correcting codes has been studied by several groups mabuchi-zoller ; qec-spont ; detected-jump1 ; detected-jump2 . In qec-spont  Plenio, Vedral and Knight considered the structure of quantum error correction codes and addressed the problem that spontaneous emission implies continuous evolution of the state even when no emission has occurred. They developed an eight-qubit code that both corrects one general error and corrects the no-emission evolution to arbitrary order.

More recently, in several papers Alber *et al.* detected-jump1 ; detected-jump2  have addressed a somewhat more specific problem relating to spontaneous emission from statistically independent resevoirs. In this formulation, the only errors possible are spontaneous emission errors, and the time and position of a particular spontaneous emission is known. They showed that given these constraints, a reduction of the redundancy in qec-spont  was possible, and constructed a four-qubit code which corrects for one spontaneous emission error.

Here we show that for the case considered in detected-jump1 ; detected-jump2 , a very simple error correcting code consisting of just two qubits with feedback is sufficient to correct spontaneous emissions for a single logical qubit. A crucial difference from Refs. detected-jump1 ; detected-jump2  is that we call for a constant driving Hamiltonian in addition to the feedback Hamiltonian. Moreover, a simple code of $`n`$ qubits, with the appropriate feedback and driving Hamiltonians, can encode $`n1`$ qubits and correct for spontaneous emissions when the position (i.e. which qubit) and time of the jump are known. We also show that an equally effective protocol can be found for a diffusive unraveling of the spontaneous emission (as in homodyne detection).

### III.1 Two-qubit code: Jump unraveling

The simplest system for which we can protect against detected spontaneous emissions is a system of two qubits. We consider the model in which the only decoherence process is due to spontaneous emission from statistically independent reservoirs. We will show that a simple code, used in conjunction with a driving Hamiltonian, protects the codespace when the time and location of a spontaneous emission is known and a correcting unitary is applied instantaneously; the codespace suffers no decoherence.

The codewords of the code are given by the following:

$`|\overline{0}`$ $``$ $`(|00+|11)/\sqrt{2}`$
$`|\overline{1}`$ $``$ $`(|01+|10)/\sqrt{2}.`$ (19)
In the stabilizer notation, this is a stabilizer code with stabilizer generator $`XX`$. Both codewords are $`+1`$ eigenstates of $`XX`$.

Following the presentation in Sec. II.2, the jump operators for spontaneous emission of the $`j`$th qubit are

$$\mathrm{\Omega }_j=\sqrt{\kappa _jdt}(X_jiY_j)\sqrt{\kappa _jdt}a_j,$$
(20)
where $`4\kappa _j`$ is the decay rate for that qubit. In the absence of any feedback, the master equation is

$$\dot{\rho }=\underset{j=1,2}{}\kappa _j𝒟[X_jiY_j]\rho i[H,\rho ].$$
(21)
If the emission is detected, such that the qubit $`j`$ from which it originated is known, it is possible to correct back to the codespace without knowing the state. This is because the code and error fulfill the necessary and sufficient conditions for appropriate recovery operations knill-laflamme :

$$\psi _\mu |E^{}E|\psi _\nu =\mathrm{\Lambda }_E\delta _{\mu \nu }.$$
(22)
Here $`E`$ is the operator for the measurement (error) that has occurred and $`\mathrm{\Lambda }_E`$ is a constant. The states $`|\psi _\mu ,|\psi _\nu `$ are the encoded states in Eq. (III.1) with $`\psi _\mu |\psi _\nu =\delta _{\mu \nu }`$. These conditions differ from the usual condition only by taking into account that we *know* a particular error $`E=\mathrm{\Omega }_j`$ has occurred.

More explicitly, if a spontaneous emission on the first qubit occurs, $`|\overline{0}|01`$ and $`|\overline{1}|00`$, and similarly for spontaneous emission on the second qubit. Since these are orthogonal states, this fulfills the condition given in (22), so a unitary exists that will correct this spontaneous emission error. One choice for the correcting unitary is

$`U_1`$ $`=`$ $`(XIZX)/\sqrt{2}`$
$`U_2`$ $`=`$ $`(IXXZ)/\sqrt{2}.`$ (23)
As pointed out in qec-spont , a further complication is the nontrivial evolution of the state in the time between spontaneous emissions. From Sec. II.2, this is described by the measurement operator

$`\mathrm{\Omega }_0`$ $`=`$ $`II\left(1(\kappa _1+\kappa _2)dt\right)\kappa _1dtZI`$ (24)
$`\kappa _2dtIZiHdt.`$
The non-unitary part of this evolution can be corrected by assuming a driving Hamiltonian of the form

$$H=(\kappa _1YX+\kappa _2XY).$$
(25)
This result can easily be seen by plugging (25) into (24) with a suitable rearrangement of terms:

$`\mathrm{\Omega }_0`$ $`=`$ $`II\left(1(\kappa _1+\kappa _2)dt\right)\kappa _1dtZI(IIXX)`$ (26)
$`\kappa _2dtIZ(IIXX),`$
and since $`IIXX`$ acts to annihilate the codespace, $`\mathrm{\Omega }_0`$ acts trivially on the codespace.

We then have the following master equation for the evolution of the system:

$$d\rho =\mathrm{\Omega }_0\rho \mathrm{\Omega }_0^{}\rho +dt\underset{j=\{1,2\}}{}\kappa _jU_ja_j\rho a_j^{}U_j^{},$$
(27)
where $`U_j`$ is the recovery operator for a spontaneous emission from qubit $`j`$. From Sec. II.2, these unitaries can be achieved by the feedback Hamiltonian

$$H_{fb}=\underset{j=1,2}{}\frac{dN_j(t)}{dt}V_j,$$
(28)
where $`N_j(t)`$ is the spontaneous emission count for qubit $`j`$, and $`U_j=\mathrm{exp}(iV_j)`$. Here, we can see from the simple form of (III.1) that $`V_j`$ can be chosen as proportional to $`U_j`$. Since $`U_ja_j\rho a_j^{}U_j^{}`$ acts as the identity on the codespace by definition, and since we have shown that $`\mathrm{\Omega }_0\rho \mathrm{\Omega }_0^{}`$ preserves the codespace, (27) must preserve the codespace.

Such a code is optimal in the sense that it uses the smallest possible number of qubits required to perform the task of correcting a spontaneous emission error, as we know that the information stored in one unencoded qubit is destroyed by spontaneous emission.

### III.2 Two-qubit code: Diffusive unraveling

A similar situation applies for feedback of a continuous measurement record with white noise, as from homodyne detection of the emission. We use the same codewords, and choose $`\varphi _j=\pi /2`$ for the measurement. Then (III.1) suggests using the following feedback operators:

$`F_1`$ $`=`$ $`\sqrt{\kappa _1}(XIZX)`$
$`F_2`$ $`=`$ $`\sqrt{\kappa _2}(IXXZ).`$ (29)
If we use these feedback Hamiltonians with the same driving Hamiltonian (25) as in the jump case, the resulting master equation is, using (18),

$`\dot{\rho }`$ $`=`$ $`\kappa _1𝒟[YIiZX]\rho +\kappa _2𝒟[IYiXZ]\rho `$ (30)
We can see that this master equation preserves the codespace, by again noting that $`YIiZX=YI(IIXX)`$, and similarly for $`IYiXZ`$. The operator $`IIXX`$ of course acts to annihilate the codespace. This insight will be used in the next section to derive a feedback procedure for a more general measurement operator.

### III.3 Generalizations to $`n`$ qubits

We will now demonstrate a simple $`n`$-qubit code that corrects for spontaneous emission errors only, while encoding $`n1`$ qubits. Both of the above calculations (jump and diffusion) generalize. The master equation is the same as (21), but now the sum runs from 1 to $`n`$. Again we need only a single stabilizer generator, namely $`X^n`$. The number of codewords is thus $`2^{n1}`$, enabling $`n1`$ logical qubits to be encoded. Since it uses only one physical qubit in excess of the number of logical qubits, this is again obviously an optimal code.

First, we consider the jump case. As in Sec. III.1, a spontaneous emission jump fulfills the error-correction condition (22) (see Sec. IV.1 below). Therefore, there exists a unitary that will correct for the spontaneous-emission jump. Additionally, it is easy to see by analogy with (26) that

$$H=\kappa _j\underset{j}{}X^{j1}YX^{nj}$$
(31)
protects against the nontrivial no-emission evolution. Therefore the codespace is protected.

Next, for a diffusive unraveling, we again choose $`\varphi _j=\pi /2`$, as in Sec. III.2. The same driving Hamiltonian (31) is again required, and the feedback operators generalize to

$$F_j=\sqrt{\kappa _j}\left(I^{j1}XI^{nj}+X^{j1}ZX^{nj}\right).$$
(32)
The master equation becomes

$$\dot{\rho }=\underset{j}{}\kappa _j𝒟[I^{j1}YI^{nj}(I^nX^n)].$$
(33)
These schemes with a driving Hamiltonian do not have the admittedly desirable property of the codes given in qec-spont ; detected-jump1 ; detected-jump2  that if there is a time delay between the occurrence of the error and the application of the correction, the effective no-emission evolution does not lead to additional errors. Nevertheless, as pointed out in detected-jump2 , the time delay for those codes must still be short so as to prevent two successive spontaneous emissions between correction; they numerically show that the fidelity decays roughly exponentially as a function of delay time. Therefore, we believe that this drawback of our protocol is not significant.

## IV One-qubit general measurement operators

The form of the above example strongly indicates that there is a nice generalization to be obtained by considering stabilizer generators in more detail. In this section, we consider an arbitrary measurement operator operating on each qubit. We find the condition that the stabilizers of the codespace must satisfy. We show that it is always possible to find an optimal codespace (that is, one with a single stabilizer group generator). We work out the case of diffusive feedback in detail and derive it as the limit of a jump process.

### IV.1 General unraveling

Different unravelings of the master equation (3) may be usefully parameterized by $`\gamma `$. In Sec. II.2, we have seen that a simple jump unraveling has $`\gamma =0`$, while the diffusive unraveling is characterized by $`|\gamma |\mathrm{}`$. We will now address the question of when a unitary correction operator exists for arbitrary $`\gamma `$, i.e., when a measurement scheme with a given $`\gamma `$ works to correct the error.

Consider a Hilbert space of $`n`$ qubits with a stabilizer group $`\{S_l\}`$. Let us consider a single jump operator $`c`$ acting on a single qubit. We may then write $`c`$ in terms of Hermitian operators $`A`$ and $`B`$ as

$`e^{i\varphi }c`$ $`=`$ $`\chi I+A+iB`$ (34)
$``$ $`\chi I+\stackrel{}{a}\stackrel{}{\sigma }+i\stackrel{}{b}\stackrel{}{\sigma }`$ (35)
where $`\chi `$ is a complex number, $`\stackrel{}{a}`$ and $`\stackrel{}{b}`$ are real vectors, and $`\stackrel{}{\sigma }=(X,Y,Z)^T`$.

We now use the standard condition (22), where here we take $`E=c+\gamma `$. Henceforth, $`\gamma `$ is to be understood as real and positive, since the relevant phase $`\varphi `$ has been taken into account in the definition (34). The relevant term is

$`E^{}E`$ $`=`$ $`(|\chi +\gamma |^2+\stackrel{}{a}^2+\stackrel{}{b}^2)I`$ (36)
$`+\mathrm{Re}(\chi +\gamma )A+\mathrm{Im}(\chi +\gamma )^{}iB+(\stackrel{}{a}\times \stackrel{}{b})\stackrel{}{\sigma })`$
$``$ $`(|\chi +\gamma |^2+\stackrel{}{a}^2+\stackrel{}{b}^2)I+D,`$
where $`D`$ is Hermitian.

Now we can use the familiar sufficient condition for a stabilizer code gott-stab : the stabilizer should anticommute with the traceless part of $`E^{}E`$. This condition becomes explicitly

$$0=\{S,D\}.$$
(37)
As long as this is satisfied, there is some feedback unitary $`e^{iV}`$ which will correct the error.

Normalization implies that when $`E`$ does not occur, there may still be nontrivial evolution. In the continuous time paradigm, where one Kraus operator is given by $`E\sqrt{dt}`$, the transform (II.2.2) tells us that the no-jump normalization Kraus operator is given by

$$\mathrm{\Omega }_0=1\frac{1}{2}E^{}Edt\frac{\gamma }{2}(e^{i\varphi }ce^{i\varphi }c^{})dtiHdt.$$
(38)
Now we choose the driving Hamiltonian

$$H=\frac{i}{2}DS+\frac{i\gamma }{2}(e^{i\varphi }ce^{i\varphi }c^{}).$$
(39)
This is a Hermitian operator because of (37). Then the total evolution due to $`\mathrm{\Omega }_0`$ is just the identity, apart from a term proportional to $`D(1S)`$, which annihilates the codespace. Thus for a state initially in the codespace, the condition (37) suffices for correction of both the jump and no-jump evolution.

A nice generalization may now be found for a set $`\{c_j\}`$ of errors such that $`c_j`$ \[with associated operator $`D_j`$ as defined in (36)\] acts on the $`j`$th qubit alone. Since $`D_j`$ is traceless, it is always possible to find some other Hermitian traceless one-qubit operator $`s_j`$ such that $`\{s_j,D_j\}=0`$. Then we may pick the stabilizer group by choosing the single stabilizer generator

$$S=s_1\mathrm{}s_n$$
(40)
so that the stabilizer group is $`\{1,S\}`$. As noted in Sec. II.1, this is not strictly a stabilizer group, as $`S`$ may not be in the Pauli group, but this does not change the analysis. Choosing $`H`$ according to this $`S`$ such that

$$H=\underset{j}{}\frac{i}{2}D_jS+\frac{i\gamma _j}{2}(e^{i\varphi _j}c_je^{i\varphi _j}c_j^{})$$
(41)
will, by our analysis above, provide a total evolution that protects the codespace, and the errors will be correctable; furthermore, this codespace encodes $`n1`$ qubits in $`n`$.

Note that we can now easily understand the $`n`$-qubit jump process error of spontaneous emission considered in Sec. III. Here, $`\gamma =0`$, $`S=X^n`$, and $`D_j=2\kappa _jZ_j`$. Thus (37) is satisfied, and the Hamiltonian (31) is derived directly from (41).

Moreover, one is not restricted to the case of one stabilizer; it is possible to choose a different $`S_j`$ for each individual error $`c_j`$. For example, for the spontaneous emission errors $`c_j=X_jiY_j`$ we could choose $`S_j`$ as different stabilizers of the five-qubit code. This choice is easily made, as the usual generators of the five-qubit code are $`\{XZZXI,IXZZX,XIXZZ,ZXIXZ\}`$ nc . For each qubit $`j`$, we may pick a stabilizer $`S_j`$ from this set which acts as $`X`$ on that qubit, and $`X`$ anticommutes with $`D_j=Z_j`$. This procedure would be useful in a system where spontaneous emission is the dominant error process; it would have the virtue of both correcting spontaneous emission errors by means of feedback as well as correcting other (rarer) errors by using canonical error correction in addition.

We note that the work in this section can very easily be modified to generalize the results of K-Lidar . That work has the same error model as ours: known jumps occuring on separate qubits so that the time and location of each jump is known; but K-Lidar  postulates fast unitary pulses instead of a driving Hamiltonian. Their scheme for spontaneous emission depends on applying the unitary $`X^n`$ at intervals $`T_c/2`$ that are small compared to the rate of spontaneous emission jumps. They show that after a full $`T_c`$ period, the no-jump evolution becomes

$$U=e^{iT_cH_c/2}X^ne^{iT_cH_c/2}X^n=e^{T_c/2_{i=1}^N\kappa _i}1.$$
(42)
Thus the application of these pulses acts, as does our driving Hamiltonian, to correct the no-jump evolution. The generalization from spontaneous emission to general jump operator $`c_j`$ for their case is simple: the code is the same as in the above one-stabilizer protocol, with single stabilizer equal to (40). The fast unitary pulses are in this case also simply equal to (40).

### IV.2 Diffusive unraveling

The case of white-noise feedback, where $`\gamma \mathrm{}`$, is easily treated by recalling the master equation (17) for white-noise measurement and feedback. It is clear that the first term in (17) can be eliminated by choosing the constant driving Hamiltonian

$$H=(e^{i\varphi }c^{}F+e^{i\varphi }Fc)/2$$
(43)
which is automatically Hermitian. The problem then becomes choosing a feedback Hamiltonian $`F`$ such that $`ciF`$ annihilates the codespace. The choice for $`F`$ can be made simply by noting that if the codespace is stabilized by some stabilizer $`S`$, we can choose

$$F=BiAS.$$
(44)
Now, note that the decoherence superoperator $`𝒟`$ acts such that

$$𝒟[\chi I+L]\rho =𝒟[L].$$
(45)
Then we know that $`𝒟[ciF]=𝒟[\chi I+A(IS)]`$ annihilates the codespace.

The only caveat is that $`F`$ is a Hamiltonian and therefore must be Hermitian. Then the choice (44) for $`F`$ is only possible if the anticommutator of $`S`$ and $`A`$ is zero:

$$\{S,A\}=0.$$
(46)
Therefore, if we are given the measurement operator $`e^{i\varphi }c=\chi +A+iB`$, we must choose a code with some stabilizer such that condition (46) applies; then it is possible to find a feedback and a driving Hamiltonian such that the total evolution protects the codespace.

At first glance, it may seem odd that the condition for feedback does not depend at all upon $`B`$. This independence has to do with the measurement unraveling: the diffusive measurement record (12) depends only upon $`e^{i\varphi }c+e^{i\varphi }c^{}=2(A+\chi )`$.

### IV.3 Diffusion as the limit of jumps

It is instructive to show that the diffusive feedback process can be derived by taking the limit of a jump feedback process using the transformation (II.2.2). This takes several steps, and we use the treatment in wiseman-backaction  as a guide. But to begin, note that the condition (46) follows by considering Eq. (37) in the limit $`\gamma \mathrm{}`$, as the leading order term in $`D`$ is proportional to $`A`$.

Consider the jump unraveling picture with jump operator $`c+\gamma `$ for $`\gamma `$ large (but not infinite). Recall that in the error-correction picture given in Sec. III, we postulated a feedback Hamiltonian $`(dN/dt)V`$ that produces a unitary correction $`e^{iV}`$ that acts instantaneously after the jump. In addition we will postulate a driving Hamiltonian $`K`$ that acts when no jump happens. In this picture, we will show that given the condition (46), it is possible to find asymptotic expressions for $`V`$ and $`K`$ so that the deterministic equation for the system preserves the stabilizer codespace. Finally, we will show that taking the limit $`\gamma \mathrm{}`$ leads to the expression for the feedback and driving Hamiltonians (43) and (44).

Let us consider the measurement operators for the unraveling with large $`\gamma `$ and $`H=0`$. Following (II.2.2) these are

$`\mathrm{\Omega }_1`$ $`=`$ $`\sqrt{dt}(c+\gamma )`$
$`\mathrm{\Omega }_0`$ $`=`$ $`1{\displaystyle \frac{dt}{2}}[c\gamma c^{}\gamma +(c+\gamma )^{}(c+\gamma )],`$ (47)
where we have assumed for simplicity that $`\gamma `$ is real. Now, including the feedback and driving Hamiltonians modifies these to

$`\mathrm{\Omega }_1^{}(dt)`$ $`=`$ $`\sqrt{dt}e^{iV}(c+\gamma )`$
$`\mathrm{\Omega }_0^{}(dt)`$ $`=`$ $`e^{iKdt}\mathrm{\Omega }_0(dt)`$ (48)
$`=`$ $`1iKdt{\displaystyle \frac{dt}{2}}(c^{}c+2\gamma c+\gamma ^2).`$
Following Ref. wiseman-backaction , expand $`V`$ in terms of $`1/\gamma `$ to second order: $`V=V_1/\gamma +V_2/\gamma ^2`$ where the $`V_i`$ are Hermitian. Then expanding the exponential in (IV.3) we get to second order

$`\mathrm{\Omega }_1^{}(dt)`$ $`=`$ $`\sqrt{dt}\left[1i\left({\displaystyle \frac{V_1}{\gamma }}+{\displaystyle \frac{V_2}{\gamma ^2}}\right){\displaystyle \frac{1}{2}}{\displaystyle \frac{V_1^2}{\gamma ^2}}\right](A+iB+\gamma )`$ (49)
$`=`$ $`\sqrt{dt}\gamma [1+{\displaystyle \frac{\chi }{\gamma }}+{\displaystyle \frac{1}{\gamma }}(A+iBiV_1)`$
$`+{\displaystyle \frac{1}{\gamma ^2}}(V_1^2/2iV_2i(A+iB)V_1)].`$
A reasonable choice for $`V_1`$, by analogy to (44), is $`BiAS`$. Following wiseman-backaction , we also use (43) and (44) to choose $`V_2`$ and $`K`$; note that (44) is exactly the expression we would expect for $`K`$ from (39) in the limit as $`\gamma `$ is taken to infinity. We will proceed to show that the choice fir $`V`$ and $`K`$,

$`V_1`$ $`=`$ $`BiAS`$ (50)
$`V_2`$ $`=`$ $`(c^{}F+Fc)/2`$ (51)
$`K`$ $`=`$ $`\gamma (BiAS),`$ (52)
leads to the correct evolution to second order in $`\gamma `$.

Now, the deterministic evolution is given by

$$d\rho =\mathrm{\Omega }_0^{}\rho \mathrm{\Omega }_0^{}+\mathrm{\Omega }_1^{}\rho \mathrm{\Omega }_1^{}\rho .$$
(53)
Substituting (IV.3)–(52) into (53) to second order in $`\gamma `$, after some algebra, gives the deterministic jump equation

$`d\rho `$ $`=`$ $`𝒟[A(1S)]\rho `$ (54)
which of course acts as zero on the codespace.

Now we will show that taking the limit as $`\gamma \mathrm{}`$ leads to the feedback operators given in (43) and (44). We saw in (50) and (51) that the feedback Hamiltonian needed to undo the effect of the jump operator $`c+\gamma `$ was just

$$H_{fb}=\frac{dN(t)}{dt}\left(\frac{BiAS}{\gamma }\frac{c^{}F+Fc}{2}\right).$$
(55)
Keeping terms of two orders in $`\gamma `$ gives

$`H_{fb}`$ $`=`$ $`\gamma (BiAS){\displaystyle \frac{c^{}F+Fc}{2}}`$ (56)
$`+{\displaystyle \frac{dN(t)\gamma ^2dt}{\gamma dt}}(BiAS).`$
The last term just becomes the current $`\dot{Q}(t)`$ as $`\gamma `$ approaches infinity, as in equation (11). Furthermore, we have not yet added in the driving Hamiltonian to the expression for the feedback. Doing so yields

$`H_{\mathrm{total}}(t)`$ $`=`$ $`H_{fb}+K`$ (57)
$`=`$ $`\dot{Q}(t)(BiAS){\displaystyle \frac{c^{}F+Fc}{2}}`$
which is just what we obtained in the previous section. Thus we can see that this continuous current feedback can be thought of as an appropriate limit of a jump plus unitary correction process.

### IV.4 Imperfect detection

These results for feedback were obtained by assuming unit efficiency, i.e., perfect detection. Realistically, of course, the efficiency $`\eta `$ will be less than unity. This results in extra terms in the feedback master equations we have derived wiseman\_pra94 . In the jump case, the extra term is

$$\dot{\rho }=(1\eta )\underset{j}{}(c_j\rho c_j^{}U_jc_j\rho c_j^{}U_j^{}).$$
(58)
In the diffusion case it is

$$\dot{\rho }=\frac{1\eta }{\eta }\underset{j}{}𝒟[F_j].$$
(59)
In both cases this results in exponential decay of coherence in the codespace. This is because the error correction protocol here relies absolutely upon detecting the error when it occurs. If the error is missed (jump case), or imperfectly known (diffusion case), then it cannot be corrected. This behavior is, of course, a property of any continuous-time error correction protocol that depends on correcting each error instantaneously (e.g., detected-jump1 ; detected-jump2 ; K-Lidar ).

On the other hand, such behavior for Markovian feedback is in contrast to the state-estimation procedure used in ADL . The latter is much more robust under non-unit efficiency; indeed, given non-unit efficiency it still works to protect an unknown quantum state without exponential loss ADL-qcmc . This difference in performance occurs because state-estimation is a function of the entire measurement record, not just instantaneous measurement results, and thence does not propagate errors to the same extent that a Markovian feedback system does. Thus we can see that there is a certain tradeoff. Our Markovian feedback scheme relies upon calculational simplicity, but at the expense of robustness. The state-estimation procedure, conversely, is designed to be robust, but at the cost of computational complexity.

## V Universal quantum gates

Given a protected code subspace, one interesting question, as in K-Lidar , is to investigate what kinds of unitary gates are possible on such a subspace. For universal quantum computation on the subspace— the ability to build up arbitrary unitary gates on $`k`$ qubits— it suffices to be able to perform arbitrary one-qubit gates for all $`k`$ encoded qubits and a two-qubit entangling gate such as controlled-NOT for all encoded qubits $`\mu ,\nu `$. Indeed, as is noted in K-Lidar , it is enough to be able to perform the Hamiltonians $`\overline{X}_\mu ,\overline{Z}_\mu `$, and $`\overline{X}_\mu \overline{X}_\nu `$ for all $`\mu ,\nu `$ Dodd02 . We will demonstrate that performing these Hamiltonians with our protocol is possible for the spontaneous emission scheme given in Sec. III, and then we will show how that construction generalizes for an arbitrary jump operator.

Recall that the example in Sec. III has single stabilizer $`X^n`$ and encodes $`n1`$ logical qubits in $`n`$ physical qubits. To find the $`2(n1)`$ encoded operations, we must find operators that together with the stabilizer generate the normalizer of $`X^n`$ nc . In addition, if these operators are to act as encoded $`X`$ and $`Z`$ operations, they must satisfy the usual commutation relations for these operators:

$`\{X_\mu ,Z_\mu \}`$ $`=`$ $`0`$
$`[X_\mu ,Z_\nu ]`$ $`=`$ $`0,\mu \nu `$
$`[X_\mu ,X_\nu ]`$ $`=`$ $`[Z_\mu ,Z_\nu ]=0.`$ (60)
Operators satisfying these constraints are easily found for this code:

$`\overline{X}_\mu `$ $`=`$ $`I^{\mu 1}XI^{n\mu }`$
$`\overline{Z}_\mu `$ $`=`$ $`I^{\mu 1}ZI^{n\mu 1}Z`$
$`\overline{X}_\mu \overline{X}_\nu `$ $`=`$ $`I^{\mu 1}XI^{\nu \mu 1}XI^{n\nu },`$ (61)
where we assume $`1\mu <\nu n1`$. If we apply a Hamiltonian $`H_{enc}`$ given by any linear combination of the operators in (V), the resulting evolution is encapsulated in the expression for $`\mathrm{\Omega }_0`$, from (24):

$`\mathrm{\Omega }_0`$ $`=`$ $`(1{\displaystyle \underset{j}{}}\kappa _jdt)1`$ (62)
$`{\displaystyle \underset{j}{}}\kappa _jZ_j(1X^n)dtiH_{enc}dt.`$
As the first term is proportional to the identity and the second term acts as zero on the codespace, the effective evolution is given solely by $`H_{enc}`$ as long as the state remains in the codespace under that evolution. But because the encoded operations are elements of the normalizer, as we saw in Sec. II.1, applying $`H_{enc}`$ does not take the state out of the codespace. Furthermore, our protocol assumes that spontaneous emission jumps are corrected immediately and perfectly, so jumps during the gate operation will also not take the state out of the codespace. Thus we can perform universal quantum computation without having to worry about competing effects from the driving Hamiltonian.

The generalization to the scheme given in Sec. IV.1 to encode $`n1`$ logical qubits in $`n`$ physical qubits is easily done. First we note that for the stabilizer $`S`$ given in the general scheme, we know that

$$S=UX^nU^{}$$
(63)
for some unitary $`U=_{i=1}^nU_i`$, so the encoded operations for that code are similarly given by

$`\overline{X}_\mu `$ $`=`$ $`I^{\mu 1}U_\mu XU_\mu ^{}I^{n\mu }`$
$`\overline{Z}_\mu `$ $`=`$ $`I^{\mu 1}U_\mu ZU_\mu ^{}I^{n\mu 1}U_nZU_n^{}`$
$`\overline{X}_\mu \overline{X}_\nu `$ $`=`$ $`I^{\mu 1}U_\mu XU_\mu ^{}I^{\nu \mu 1}U_\nu XU_\nu ^{}I^{n\nu }.`$ (64)
Now, from (39) we can see that the generalization of (62) is

$$\mathrm{\Omega }_0=(1fdt)1\underset{j}{}g_jD_j(1S)dtiH_{enc}dt,$$
(65)
for real numbers $`f,g_i`$ given by expanding the expression (38). Again, since $`D(1S)`$ annihilates the codespace, the effective evolution is given solely by $`H_{enc}`$ as long as the state remains in the codespace under that evolution. Again, $`H_{enc}`$ is made up of normalizer elements, which do not take the state out of the codespace; and again jumps that occur while the gate is being applied are immediately corrected and thus do not affect the gate operation. Therefore, universal quantum computation is possible under our general scheme.

## VI Conclusion

We have shown that it is possible to understand a particular variant of quantum control as quantum error correction. This method is very general in that it can correct any single qubit detected errors, while requiring only $`n`$ physical qubits to encode $`n1`$ logical qubits. As a particular example, we have shown how to correct for spontaneous emission evolution using feedback and a driving Hamiltonian, which allows less redundancy than has previously been obtained. We have additionally shown that universal quantum computation is possible under our method.

We expect that this work will provide a starting point for practically implementable feedback schemes to protect unknown states. The fact that only two qubits are required for a demonstration should be particularly appealing. We also expect a more complete theoretical development. Fruitful avenues for further research include applying notions of fault-tolerance to this sort of quantum control.

###### Acknowledgements.

C. A. is grateful for the hospitality of the Centre for Quantum Computer Technology at the University of Queensland, and thanks J. Preskill for helpful discussions. C. A. acknowledges support from an NSF fellowship and an Institute for Quantum Information fellowship. This work was supported by the Australian Research Council.