text:
# Encoding a qubit in an oscillatorCALT-68-2273

## I Introduction

Classical information can be carried by either a discrete (digital) signal or a continuous (analog) signal. Although in principle an analog signal can be processed, digital computing is far more robust – a digital signal can be readily re-standardized and protected from damage caused by the gradual accumulation of small errors.

Quantum information can also be carried by either a discrete (finite-dimensional) system like a two-level atom or an electron spin, or by a continuous (infinite-dimensional) system like a harmonic oscillator or a rotor. Even in the finite-dimensional case, quantum information is in a certain sense continuous – a state is a vector in a Hilbert space that can point in any direction. Nevertheless, we have known for nearly five years that cleverly encoded quantum states can be re-standardized and protected from the gradual accumulation of small errors, or from the destructive effects of decoherence due to uncontrolled interactions with the environment .

One is tempted to wonder whether we can go still further and protect the quantum state of a system described by continuous quantum variables. Probably this is too much to hope for, since even the problem of protecting analog classical information seems to pose insuperable difficulties.

In this paper we achieve a more modest goal: we describe quantum error-correcting codes that protect a state of a finite-dimensional quantum system (or “qudit”) that is encoded in an infinite-dimensional system. These codes may be useful for implementing quantum computation and quantum communication protocols that use harmonic oscillators or rotors that are experimentally accessible.

We also explain how encoded quantum states can be processed fault tolerantly. Once encoded states have been prepared, a universal set of fault-tolerant quantum gates can be implemented using, in the language of quantum optics, linear optical operations, squeezing, homodyne detection, and photon counting. However, for preparation of the encoded states, nonlinear couplings must be invoked.

Our continuous-variable quantum error-correcting codes are effective in protecting against sufficiently weak diffusive phenomena that cause the position and momentum of an oscillator to drift, or against losses that cause the amplitude of an oscillator to decay. By concatenating with conventional finite-dimensional quantum codes, we can also provide protection against errors that heavily damage a (sufficiently small) subset of all the oscillators in a code block.

A different scheme for realizing robust and efficient quantum computation based on linear optics has been recently proposed by Knill, Laflamme, and Milburn .

We begin in §II by describing codes that embed an $`n`$-state quantum system in a larger $`d`$-state system, and that protect the encoded quantum information against shifts in the amplitude or phase of the $`d`$-state system. A realization of this coding scheme based on a charged particle in a magnetic field is discussed in §III. Our continuous-variable codes are obtained in §IV by considering a $`d\mathrm{}`$ limit. Formally, the code states of the continuous-variable codes are nonnormalizable states, infinitely squeezed in both position and momentum; in §V we describe the consequences of using more realistic approximate code states that are finitely squeezed. In §VI we outline the theory of more general continuous-variable codes based on lattice sphere packings in higher-dimensional phase space.

We discuss in §VII how continuous-variable codes protect against quantum diffusion, amplitude damping, and unitary errors. In §VIII, we establish a lower bound on the quantum capacity of the Gaussian quantum channel.

We then proceed to develop schemes for fault-tolerant manipulation of encoded quantum information, starting in §IX with a discussion of the symplectic operations that can be implemented with linear optics and squeezing. In §X we discuss the measurement of the error syndrome and error recovery, which can be achieved with symplectic operations and homodyne detection. Completion of the fault-tolerant universal gate set by means of photon counting is described in §XI, and the preparation of encoded states is explained in §XII.

Finally, §XIII contains some further remarks about the physical realization of our coding schemes, and §XIV contains concluding comments.

## II Shift-resistant quantum codes

The main novelty of our new codes is that they are designed to protect against a different type of error than has been considered in previous discussions of quantum coding. This distinction is more easily explained if we first consider not the case of a continuous quantum variable, but instead the (also interesting) case of a “qudit,” a $`d`$-dimensional quantum system. Quantum codes can be constructed that encode $`k`$ protected qudits in a block of $`N`$ qudits, so that the encoded qudits can be perfectly recovered if up to $`t`$ qudits are damaged, irrespective of the nature of the damage . Error recovery will be effective if errors that act on many qudits at once are rare. More precisely, a general error superoperator acting on $`N`$ qudits can be expanded in terms of a basis of operators, each of definite “weight” (the number of qudits on which the operator acts nontrivially). Encoded information is well protected if the error superoperator has nearly all its support on operators of weight $`t`$ or less.

But consider instead a different situation, in which the amplitude for an error to occur on each qudit is not small, but the errors are of a restricted type. The possible errors acting on a single qudit can be expanded in terms of a unitary operator basis with $`d^2`$ elements, the “Pauli operators”:

$$X^aZ^b,a,b=0,1,2,\mathrm{},d1.$$
(1)
Here $`X`$ and $`Z`$ are generalizations of the Pauli matrices $`\sigma _x`$ and $`\sigma _z`$, which act in a particular basis $`\{|j,j=0,1,2,\mathrm{},d1\}`$ according to

$`X`$ $`:`$ $`|j|j+1(\mathrm{mod}d),`$ (2)
$`Z`$ $`:`$ $`|j\omega ^j|j,`$ (3)
where $`\omega =\mathrm{exp}(2\pi i/d)`$. Note that it follows that

$$ZX=\omega XZ.$$
(4)
For $`N`$ qudits, there is a unitary operator basis with $`d^{2N}`$ elements consisting of all tensor products of single-qudit Pauli operators.

We will now imagine that errors with $`|a|,|b|`$ small compared to $`d`$ are common, but errors with large $`|a|`$ and $`|b|`$ are rare. This type of error model could be expected to apply in the case of a continuous quantum variable, which is formally the $`d\mathrm{}`$ limit of a qudit. For example, decoherence causes the position $`q`$ and momentum $`p`$ of a particle to diffuse with some nonzero diffusion constant. In any finite time interval $`q`$ and $`p`$ will drift by some amount that may be small, but is certainly not zero. How can we protect encoded quantum information under these conditions?

Fortunately, the general “stabilizer” framework  for constructing quantum codes can be adapted to this setting. In this framework, one divides the elements of a unitary operator basis into two disjoint and exhaustive classes: the set $``$ of “likely errors” that we want to protect against, and the rest, the “unlikely errors.” A code subspace is constructed as the simultaneous eigenspace of a set of commuting “stabilizer generators,” that generate an Abelian group, the “code stabilizer.” The code can reverse errors in the set $``$ if, for each pair of errors $`E_a`$ and $`E_b`$, either $`E_a^{}E_b`$ lies in the stabilizer group, or $`E_a^{}E_b`$ fails to commute with some element of the stabilizer. (In the latter case, the two errors alter the eigenvalues of the generators in distinguishable ways; in the former case they do not, but we can successfully recover from an error of type $`a`$ by applying either $`E_a^{}`$ or $`E_b^{}`$.) In typical discussions of quantum coding, $``$ is assumed to be the set of all tensor products of Pauli operators with weight up to $`t`$ (those that act trivially on all but at most $`t`$ qudits). But the same principles can be invoked to design codes that protect against errors in a set $``$ with other properties.

Quantum codes for continuous variables have been described previously by Braunstein  and by Lloyd and Slotine . For example, one code they constructed can be regarded as the continuous limit of a qudit code of the type originally introduced by Shor in the binary ($`d=2`$) case, an $`[[N=9,k=1,2t+1=3]]`$ code that protects a single qudit encoded in a block of 9 from arbitrary damage inflicted on any one of the 9. The 8 stabilizer generators of the code can be expressed as

$`Z_1Z_2^1,Z_2Z_3^1,Z_4Z_5^1,Z_5Z_6^1,Z_7Z_8^1,Z_8Z_9^1,`$ (5)
$`(X_1X_2X_3)(X_4X_5X_6)^1,(X_4X_5X_6)(X_7X_8X_9)^1,`$ (6)
and encoded operations that commute with the stabilizer and hence act on the encoded qudit can be chosen to be

$`\overline{Z}`$ $`=`$ $`Z_1Z_4Z_7,`$ (7)
$`\overline{X}`$ $`=`$ $`X_1X_2X_3.`$ (8)
In the $`d\mathrm{}`$ limit, we obtain a code that is the simultaneous eigenspace of eight commuting operators acting on nine particles, which are

$`q_1q_2,q_2q_3,q_4q_5,q_5q_6,q_7q_8,q_8q_9,`$ (9)
$`(p_1+p_2+p_3)(p_4+p_5+p_6),`$ (10)
$`(p_4+p_5+p_6)(p_7+p_8+p_9).`$ (11)
Logical operators that act in the code space are

$`\overline{q}`$ $`=`$ $`q_1+q_4+q_7,`$ (12)
$`\overline{p}`$ $`=`$ $`p_1+p_2+p_3.`$ (13)
This code is designed to protect against errors in which one of the particles makes a large jump in $`q`$ or $`p`$ (or both) while the others hold still. But it provides little protection against small diffusive motions of all the particles, which allow $`\overline{q}`$ and $`\overline{p}`$ to drift.

Entanglement purification protocols for continuous variable systems have also been proposed — good entangled states can be distilled from noisy entangled states via a protocol that requires two-way classical communication . These purification protocols work well against certain sorts of errors, but their reliance on two-way classical communication makes them inadequate for accurately preserving unknown states in an imperfect quantum memory, or for robust quantum computation.

Returning to qudits, let us consider an example of a quantum code that can protect against small shifts in both amplitude and phase, but not against large shifts. It is already interesting to discuss the case of a system consisting of a single qudit, but where the dimension $`n`$ of the encoded system is (of course) less than $`d`$. For example, a qubit ($`n=2`$) can be encoded in a system with dimension $`d=18`$, and protected against shifts by one unit in the amplitude or phase of the qudit; that is, against errors of the form $`X^aZ^b`$ where $`|a|,|b|1`$. The stabilizer of this code is generated by the two operators

$$X^6,Z^6,$$
(14)
and the commutation relations of the Pauli operators with these generators are

$`(X^aZ^b)X^6`$ $`=`$ $`\omega ^{6b}X^6(X^aZ^b),`$ (15)
$`(X^aZ^b)Z^6`$ $`=`$ $`\overline{\omega }^{6a}Z^6(X^aZ^b).`$ (16)
Therefore, a Pauli operator commutes with the stabilizer only if $`a`$ and $`b`$ are both multiples of $`3=18/6`$; this property ensures that the code can correct single shifts in both amplitude and phase. Logical operators acting on the encoded qudit are

$$\overline{X}=X^3,\overline{Z}=Z^3,$$
(17)
which evidently commute with the stabilizer and are not contained in it.

Since the codewords are eigenstates of $`Z^6`$ with eigenvalue one, the only allowed values of $`j`$ are multiples of three. And since there are also eigenstates of $`X^6`$ with eigenvalue one, the codewords are invariant under a shift in $`j`$ by six units. A basis for the two-dimensional code space is

$`|\overline{0}={\displaystyle \frac{1}{\sqrt{3}}}\left(|0+|6+|12\right),`$ (18)
$`|\overline{1}={\displaystyle \frac{1}{\sqrt{3}}}\left(|3+|9+|15\right).`$ (19)
If an amplitude error occurs that shifts $`j`$ by $`\pm 1`$, the error can be diagnosed by measuring the stabilizer generator $`Z^6`$, which reveals the value of $`j`$ modulo 3; the error is corrected by adjusting $`j`$ to the nearest multiple of 3. Phase errors are shifts in the Fourier transformed conjugate basis, and can be corrected similarly.

This code is actually perfect, meaning that each possible pair of eigenvalues of the generators $`X^6`$ and $`Z^6`$ is a valid syndrome for correcting a shift. There are nine possible errors $`\{X^aZ^b,|a|,|b|1\}`$, and the Hilbert space of the qudit contains nine copies of the two-dimensional code space, one corresponding to each possible error. These “error spaces” just barely fit in the qudit space for $`d=18=92`$.

Similar perfect codes can be constructed that protect against larger shifts. For $`d=r_1r_2n`$, consider the stabilizer generators

$$X^{r_1n},Z^{r_2n}.$$
(20)
There is an encoded qunit, acted on by logical operators

$`\overline{X}`$ $`=`$ $`X^{r_1},`$ (21)
$`\overline{Z}`$ $`=`$ $`Z^{r_2},`$ (22)
which evidently commute with the stabilizer and satisfy

$$\overline{Z}\overline{X}=\omega ^{r_1r_2}\overline{X}\overline{Z}=e^{2\pi i/n}\overline{X}\overline{Z}.$$
(23)
The commutation relations of the Pauli operators with the generators are

$`(X^aZ^b)X^{r_1n}`$ $`=`$ $`\omega ^{r_1nb}X^{r_1n}(X^aZ^b)`$ (24)
$`=`$ $`e^{2\pi ib/r_2}X^{r_1n}(X^aZ^b),`$ (25)
$`(X^aZ^b)Z^{r_2n}`$ $`=`$ $`\overline{\omega }^{r_2na}Z^{r_2n}(X^aZ^b)`$ (26)
$`=`$ $`e^{2\pi ia/r_1}Z^{r_2n}(X^aZ^b).`$ (27)
The phases are trivial only if $`a`$ is an integer multiple of $`r_1`$ and $`b`$ an integer multiple of $`r_2`$. Therefore, this code can correct all shifts with

$`|a|`$ $`<`$ $`{\displaystyle \frac{r_1}{2}},`$ (28)
$`|b|`$ $`<`$ $`{\displaystyle \frac{r_2}{2}}.`$ (29)
The number of possible error syndromes is $`r_1r_2=d/n`$, so the code is perfect.

Expressed in terms of $`Z`$ eigenstates, the codewords contain only values of $`j`$ that are multiples of $`r_1`$ (since $`Z^{r_2n}=1`$), and are invariant under a shift of $`j`$ by $`r_1n`$ (since $`X^{r_1n}=1`$). Hence a basis for the $`n`$-dimensional code subspace is

$`|\overline{0}`$ $`={\displaystyle \frac{1}{\sqrt{r_2}}}\left(|0+|nr_1+\mathrm{}+|(r_21)nr_1\right),`$ (30)
$`|\overline{1}`$ $`={\displaystyle \frac{1}{\sqrt{r_2}}}\left(|r_1+\mathrm{}+|((r_21)n+1)r_1\right),`$ (33)
$``$
$``$
$`|\overline{n}\overline{1}`$ $`={\displaystyle \frac{1}{\sqrt{r_2}}}\left(|(n1)r_1+\mathrm{}+|(r_2n1)r_1\right).`$ (34)
If the states undergo an amplitude shift, the value of $`j`$ modulo $`r_1`$ is determined by measuring the stabilizer generator $`Z^{r_2n}`$, and the shift can be corrected by adjusting $`j`$ to the nearest multiple of $`r_1`$. The codewords have a similar form in the Fourier transformed conjugate basis (the basis of $`X`$ eigenstates), but with $`r_1`$ and $`r_2`$ interchanged. Therefore, amplitude shifts by less than $`r_1/2`$ and phase shifts by less than $`r_2/2`$ can be corrected.

## III A qudit in a Landau level

A single electron in a uniform magnetic field in two dimensions provides an enlightening realization of our codes. General translations in a magnetic field are noncommuting, since an electron transported around a closed path acquires an Aharonov-Bohm phase $`e^{ie\mathrm{\Phi }}`$, where $`\mathrm{\Phi }`$ is the magnetic flux enclosed by the path. Two translations $`T`$ and $`S`$ commute only if the operator $`TST^1S^1`$ translates an electron around a path that encloses a flux $`\mathrm{\Phi }=k\mathrm{\Phi }_0`$, where $`\mathrm{\Phi }_0=2\pi /e`$ is the flux quantum and $`k`$ is an integer.

Translations commute with the Hamiltonian $`H`$, and two translations $`T_1`$ and $`T_2`$ form a maximally commuting set if they generate a lattice that has a unit cell enclosing one quantum of flux. Simultaneously diagonalizing $`H`$, $`T_1`$ and $`T_2`$, we obtain a Landau level of degenerate energy eigenstates, one state corresponding to each quantum of magnetic flux. Then $`T_1`$ and $`T_2^n`$ are the stabilizer generators of a code, where $`\overline{Z}=T_1^{1/n}`$ and $`\overline{X}=T_2`$ are the logical operators on a code space of dimension $`n`$.

Suppose the system is in a periodically identified box (a torus), so that $`T_1^{r_1}=(T_2^n)^{r_2}=1`$ are translations around the cycles of the torus. The number of flux quanta through the torus, and hence the degeneracy of the Landau level, is $`nr_1r_2`$. The code, then, embeds an $`n`$ dimensional system in a system of dimension $`d=r_1r_2n`$.

In this situation, the logical operations $`\overline{X}`$ and $`\overline{Z}`$ can be visualized as translations of the torus in two different directions; the stabilizer generator $`\overline{X}^n`$ is a translation by a fraction $`1/r_2`$ of the length of the torus in one direction, and the stabilizer generator $`\overline{Z}^n`$ is a translation by $`1/r_1`$ of the length in the other direction. Therefore, for any state in the code space, the wave function of the electron in a cell containing $`n`$ flux quanta is periodically repeated altogether $`r_1r_2`$ times to fill the entire torus. Our code can be regarded as a novel kind of “quantum repetition code” – identical “copies” of the wave function are stored in each of $`r_1r_2`$ cells. But of course there is only one electron, so if we detect the electron in one cell its state is destroyed in all the cells.

This picture of the state encoded in a Landau level cautions us about the restrictions on the type of error model that the code can fend off successfully. If the environment strongly probes one of the cells and detects nothing, the wave function is suppressed in that cell. This causes a $`\overline{X}`$ error in the encoded state with a probability of about $`1/2r_2`$, and a $`\overline{Z}`$ error with a probability of about $`1/2r_1`$. The code is more effective if the typical errors gently deform the state in each cell, rather than strongly deforming it in one cell.

## IV Continuous variable codes for a single oscillator

Formally, we can construct quantum codes for systems described by continuous quantum variables by considering the large-$`d`$ limit of the shift-resistant codes described in §II. We might have hoped to increase $`d`$ to infinity while holding $`r_1/d`$ and $`r_2/d`$ fixed, maintaining the ability to correct shifts in both amplitude and phase that are a fixed fraction of the ranges of the qudit. However, since the perfect codes satisfy

$$\frac{r_1}{d}=\frac{1}{nr_2},\frac{r_2}{d}=\frac{1}{nr_1},$$
(35)
this is not possible. Nonetheless, interesting codes can be obtained as the amplitude and phase of the qudit approach the position $`q`$ and momentum $`p`$ of a particle – we can hold fixed the size of the shifts $`\mathrm{\Delta }q`$ and $`\mathrm{\Delta }p`$ that can be corrected, as the ranges of $`q`$ and $`p`$ become unbounded.

Another option is to take $`d\mathrm{}`$ with $`r_1/d\frac{1}{m}`$ fixed and $`r_2=m/n`$ fixed, obtaining a rotor $`Z=e^{i\theta }`$ (or a particle in a periodically identified finite box) that can be protected against finite shifts in both the orientation $`\theta `$ of the rotor and its (quantized) angular momentum $`L`$. The stabilizer of this code is generated by

$`Z^{r_2n}`$ $``$ $`e^{i\theta m},`$ (36)
$`X^{r_1n}`$ $`=`$ $`X^{d/r_2}e^{2\pi iL(n/m)}`$ (37)
and the logical operations are

$`\overline{Z}`$ $`=`$ $`e^{i\theta m/n}`$ (38)
$`\overline{X}`$ $`=`$ $`e^{2\pi iL/m}`$ (39)
Since $`\overline{X}`$ shifts the value of $`\theta `$ by $`2\pi /m`$, and $`\overline{Z}`$ shifts the value of $`L`$ by $`m/n=r_2`$, this code can correct shifts in $`\theta `$ with $`\mathrm{\Delta }\theta <\pi /m`$ and shifts in $`L`$ with $`|\mathrm{\Delta }L|<m/2n`$.

Alternatively, we can consider a limit in which $`r_1`$ and $`r_2`$ both become large. We may write $`r_1=\alpha /\epsilon `$ and $`r_2=1/n\alpha \epsilon `$, where $`d=nr_1r_2=1/\epsilon ^2`$, obtaining a code with stabilizer generators

$`Z^{r_2n}`$ $``$ $`\left(e^{2\pi iq\epsilon }\right)^{(1/\alpha \epsilon )}=e^{2\pi iq/\alpha },`$ (40)
$`X^{r_1n}`$ $``$ $`\left(e^{ip\epsilon }\right)^{(n\alpha /\epsilon )}=e^{inp\alpha },`$ (41)
and logical operations

$$\overline{Z}=e^{2\pi iq/n\alpha },\overline{X}=e^{ip\alpha },$$
(42)
where $`\alpha `$ is an arbitrary real number. Using the identity $`e^Ae^B=e^{[A,B]}e^Be^A`$ (which holds if $`A`$ and $`B`$ commute with their commutator) and the canonical commutation relation $`[q,p]=i`$, we verify that

$$\overline{Z}\overline{X}=\omega \overline{X}\overline{Z},\omega =e^{2\pi i/n}.$$
(43)
Since $`\overline{X}`$ translates $`q`$ by $`\alpha `$ and $`\overline{Z}`$ translates $`p`$ by $`2\pi /n\alpha `$, the code protects against shifts with

$`|\mathrm{\Delta }q|`$ $`<`$ $`{\displaystyle \frac{\alpha }{2}},`$ (44)
$`|\mathrm{\Delta }p|`$ $`<`$ $`{\displaystyle \frac{\pi }{n\alpha }}.`$ (45)
Note that the shifts in momentum and position that the code can correct obey the condition

$$\mathrm{\Delta }p\mathrm{\Delta }q<\frac{\pi }{2n}\mathrm{}.$$
(46)
In typical situations, errors in $`q`$ and $`p`$ are of comparable magnitude, and it is best to choose $`\alpha =\sqrt{2\pi /n}`$ so that

$$\overline{Z}=\mathrm{exp}\left(iq\sqrt{\frac{2\pi }{n}}\right),\overline{X}=\mathrm{exp}\left(ip\sqrt{\frac{2\pi }{n}}\right).$$
(47)
Formally, the codewords are coherent superpositions of infinitely squeezed states, e.g. (up to normalization)

$`|\overline{Z}=\omega ^j`$ $`=`$ $`{\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}|q=\alpha (j+ns),`$ (48)
$`|\overline{X}=\overline{\omega }^j`$ $`=`$ $`{\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}|p={\displaystyle \frac{2\pi }{n\alpha }}(j+ns).`$ (49)
(See Fig. 1.) Of course, realistic codewords will be normalizable finitely squeezed states, rather than nonnormalizable infinitely squeezed states. But squeezing in at least one of $`p`$ and $`q`$ is required to comfortably fulfill the condition eq. (46).

The Wigner function associated with the codeword wave function $`\psi ^{(j)}(q)q|\overline{Z}=\omega ^j`$ is a sum of delta functions positioned at the sites of a lattice in phase space, where three quarters of the delta functions are positive and one quarter are negative. Explicitly, we have

$`W^{(j)}(q,p)`$ $``$ $`{\displaystyle \frac{1}{2\pi }}{\displaystyle _{\mathrm{}}^{\mathrm{}}}𝑑xe^{ipx}\psi ^{(j)}(q+x/2)^{}\psi ^{(j)}(qx/2)`$ (50)
$``$ $`{\displaystyle \underset{s,t=\mathrm{}}{\overset{\mathrm{}}{}}}(1)^{st}\delta \left(p{\displaystyle \frac{\pi }{n\alpha }}s\right)`$ (52)
$`\times \delta \left(q\alpha j{\displaystyle \frac{n\alpha }{2}}t\right);`$
the delta functions are negative on the sublattice with $`s,t`$ odd. If we integrate over $`p`$, the oscillating sign causes the terms with odd $`t`$ to cancel in the sum over $`s`$, and the surviving positive delta functions have support at $`q=(n\mathrm{integer}+j)\alpha `$. If we integrate over $`q`$, the terms with odd $`s`$ cancel in the sum over $`t`$, and the surviving positive delta functions have support at $`p=(2\pi /n\alpha )\mathrm{integer}`$. Wigner functions for the $`\overline{X}`$ eigenstates are similar, but with the roles of $`q`$ and $`p`$ interchanged.

It is also of interest to express the encoded states in terms of the basis of coherent states. Consider for example the encoded state with $`\overline{X}=1`$, which is the unique simultaneous eigenstate with eigenvalue one of the operators $`e^{2\pi iq/\alpha }`$ and $`e^{ip\alpha }`$. In fact starting with any state $`|\psi `$, we can construct the encoded state (up to normalization) as

$`\left({\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}e^{isp\alpha }\right)\left({\displaystyle \underset{t=\mathrm{}}{\overset{\mathrm{}}{}}}e^{2\pi itq/\alpha }\right)|\psi `$ (53)
$`={\displaystyle \underset{s,t}{}}\mathrm{exp}\left[i\left(sp\alpha +2\pi tq/\alpha +\pi st\right)\right]|\psi .`$ (54)
In particular, if we choose $`|\psi `$ to be the ground state $`|0`$ of the oscillator, then the operator $`_{s,t}\mathrm{exp}\left[i\left(sp\alpha +2\pi tq/\alpha +\pi st\right)\right]`$ displaces it to a coherent state centered at the point $`(q,p)=(s\alpha ,2\pi t/\alpha )`$ in the quadrature plane. Thus the encoded state is an equally weighted superposition of coherent states, with centers chosen from the sites of a lattice in the quadrature plane whose unit cell has area $`2\pi `$. Since the coherent states are overcomplete the expansion is not unique; indeed, if we choose $`|\psi `$ to be a coherent state rather than the vacuum, then the lattice is rigidly translated, but the encoded state remains invariant.

We can envision the stabilizer of the code as a lattice of translations in phase space that preserve the code words, the lattice generated by the translations $`e^{2\pi iq/\alpha }`$ and $`e^{inp\alpha }`$. In fact, this lattice need not be rectangular – we can encode an $`n`$-dimensional system in the Hilbert space of a single oscillator by choosing any two variables $`Q`$ and $`P`$ that satisfy the canonical commutation relation $`[Q,P]=i`$, and constructing the code space as the simultaneous eigenstate of $`e^{2\pi iQ}`$ and $`e^{inP}`$. The unit cell of the lattice has area $`2\pi \mathrm{}n`$, in keeping with the principle that each quantum state “occupies” an area $`2\pi \mathrm{}`$ in the phase space of a system with one continuous degree of freedom.

## V Finite squeezing

Strictly speaking, our codewords are nonnormalizable states, infinitely squeezed in both $`q`$ and $`p`$. In practice, we will have to work with approximate codewords that will be finitely squeezed normalizable states. We need to consider how using such approximate codewords will affect the probability of error.

We will replace a position eigenstate $`\delta (0)`$ by a normalized Gaussian of width $`\mathrm{\Delta }`$ centered at the origin,

$`|\psi _0`$ $`=`$ $`{\displaystyle _{\mathrm{}}^{\mathrm{}}}{\displaystyle \frac{dq}{(\pi \mathrm{\Delta }^2)^{1/4}}}e^{\frac{1}{2}q^2/\mathrm{\Delta }^2}|q`$ (55)
$`=`$ $`{\displaystyle _{\mathrm{}}^{\mathrm{}}}{\displaystyle \frac{dp}{(\pi /\mathrm{\Delta }^2)^{1/4}}}e^{\frac{1}{2}\mathrm{\Delta }^2p^2}|p.`$ (56)
A codeword, formally a coherent superposition of an infinite number of $`\delta `$-functions, becomes a sum of Gaussians weighted by a Gaussian envelope function of width $`\kappa ^1`$; in the special case of a two-dimensional code space, the approximate codewords become

$`|\stackrel{~}{0}`$ $`=`$ $`N_0{\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}e^{\frac{1}{2}\kappa ^2(2s\alpha )^2}T(2s\alpha )|\psi _0,`$ (57)
$`|\stackrel{~}{1}`$ $`=`$ $`N_1{\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}e^{\frac{1}{2}\kappa ^2[(2s+1)\alpha )]^2}T[(2s+1)\alpha ]|\psi _0,`$ (58)
where $`T(a)`$ translates $`q`$ by $`a`$, $`N_{0,1}`$ are normalization factors, and we use e.g. $`|\stackrel{~}{0}`$ rather than $`|\overline{0}`$ to denote the approximate codeword. We will assume that $`\kappa \alpha `$ and $`\mathrm{\Delta }/\alpha `$ are small compared to one, so that $`N_0N_1(4\kappa ^2\alpha ^2/\pi )^{1/4}`$; then in momentum space, the approximate codeword becomes e.g.,

$`(|\stackrel{~}{0}+|\stackrel{~}{1})/\sqrt{2}`$ $`\left({\displaystyle \frac{\kappa ^2\alpha ^2}{\pi }}\right)^{1/4}{\displaystyle _{\mathrm{}}^{\mathrm{}}}{\displaystyle \frac{dp}{(\pi /\mathrm{\Delta }^2)^{1/4}}}e^{\frac{1}{2}\mathrm{\Delta }^2p^2}`$ (60)
$`\times {\displaystyle \underset{s=\mathrm{}}{\overset{\mathrm{}}{}}}e^{\frac{1}{2}\kappa ^2(s\alpha )^2}e^{ip(\alpha s)}|p.`$
By applying the Poisson summation formula,

$$\underset{m=\mathrm{}}{\overset{\mathrm{}}{}}e^{\pi a(mb)^2}=(a)^{1/2}\underset{s=\mathrm{}}{\overset{\mathrm{}}{}}e^{\pi s^2/a}e^{2\pi isb},$$
(61)
this approximate codeword can be rewritten as

$`(|\stackrel{~}{0}+`$ $`|\stackrel{~}{1})/\sqrt{2}({\displaystyle \frac{\kappa ^2\alpha ^2}{\pi }})^{1/4}{\displaystyle }_{\mathrm{}}^{\mathrm{}}{\displaystyle \frac{dp}{(\pi /\mathrm{\Delta }^2)^{1/4}}}e^{\frac{1}{2}\mathrm{\Delta }^2p^2}`$ (65)
$`\times {\displaystyle \frac{\sqrt{2\pi }}{\kappa \alpha }}{\displaystyle \underset{m=\mathrm{}}{\overset{\mathrm{}}{}}}\mathrm{exp}\left[{\displaystyle \frac{1}{2}}\left(p{\displaystyle \frac{2\pi }{\alpha }}m\right)^2/\kappa ^2\right]|p`$
$`={\displaystyle _{\mathrm{}}^{\mathrm{}}}{\displaystyle \frac{dp}{(\pi \kappa ^2)^{1/4}}}\left({\displaystyle \frac{4\pi \mathrm{\Delta }^2}{\alpha ^2}}\right)^{1/4}{\displaystyle \underset{m=\mathrm{}}{\overset{\mathrm{}}{}}}e^{\frac{1}{2}\mathrm{\Delta }^2p^2}`$
$`\times \mathrm{exp}\left[{\displaystyle \frac{1}{2}}\left(p{\displaystyle \frac{2\pi }{\alpha }}m\right)^2/\kappa ^2\right]|p,`$
again a superposition of Gaussians weighted by a Gaussian envelope. (See Fig. 2.)

The approximate codewords $`|\stackrel{~}{0},|\stackrel{~}{1}`$ have a small overlap if $`\mathrm{\Delta }`$ is small compared to $`\alpha `$ and $`\kappa `$ is small compared to $`\pi /\alpha `$. For estimating the error probability caused by the overlap, let’s consider the special case where $`q`$ and $`p`$ are treated symmetrically, $`\alpha =\sqrt{\pi }`$ and $`\kappa =\mathrm{\Delta }`$; then

$$|q|\stackrel{~}{0}|^2\frac{2}{\sqrt{\pi }}\underset{s=\mathrm{}}{\overset{\mathrm{}}{}}e^{4\pi \mathrm{\Delta }^2s^2}\mathrm{exp}[(q2s\sqrt{\pi })^2/\mathrm{\Delta }^2]$$
(66)
and

$`{\displaystyle \frac{1}{2}}\left|p|\stackrel{~}{0}+p|\stackrel{~}{1}\right|^2`$ (67)
$`{\displaystyle \frac{2}{\sqrt{\pi }}}{\displaystyle \underset{m=\mathrm{}}{\overset{\mathrm{}}{}}}e^{\mathrm{\Delta }^2p^2}\mathrm{exp}[(p2m\sqrt{\pi })^2/\mathrm{\Delta }^2].`$ (68)
To perform error recovery, we measure the value of $`q`$ and $`p`$ modulo $`\sqrt{\pi }`$ and then correct for the observed shift. In the state $`|\stackrel{~}{0}`$, the probability of failure is the probability that $`q`$ is closer to an odd multiple of $`\sqrt{\pi }`$ than an even multiple, and in the state $`(|\stackrel{~}{0}+|\stackrel{~}{1})/\sqrt{2}`$, the error probability is the probability that $`p`$ is closer to an odd multiple of $`\sqrt{\pi }`$ than an even multiple. For both the amplitude and phase errors, the intrinsic error probability arising from the imperfections of the approximate codewords becomes exponentially small for small $`\mathrm{\Delta }`$. Using the asymptotic expansion of the error function,

$$_x^{\mathrm{}}𝑑te^{t^2}=\left(\frac{1}{2x}\right)e^{x^2}\left(1O(1/x^2)\right),$$
(69)
we may estimate the error probability by summing the contributions from the tails of all the Gaussians, obtaining

$`\mathrm{Error}\mathrm{Prob}`$ $`<`$ $`{\displaystyle \frac{2}{\sqrt{\pi }}}\left({\displaystyle \underset{n=\mathrm{}}{\overset{\mathrm{}}{}}}e^{4\pi \mathrm{\Delta }^2n^2}\right)2{\displaystyle _{\sqrt{\pi }/2}^{\mathrm{}}}𝑑qe^{q^2/\mathrm{\Delta }^2}`$ (70)
$``$ $`{\displaystyle \frac{2}{\sqrt{\pi }}}{\displaystyle \frac{1}{2\mathrm{\Delta }}}2\mathrm{\Delta }{\displaystyle \frac{\mathrm{\Delta }}{\sqrt{\pi }}}e^{\pi /4\mathrm{\Delta }^2}`$ (71)
$`=`$ $`{\displaystyle \frac{2\mathrm{\Delta }}{\pi }}e^{\pi /4\mathrm{\Delta }^2}.`$ (72)
This error probability is about $`1\%`$ for $`\mathrm{\Delta }.5`$, and is already less than $`10^6`$ for a still modest value $`\mathrm{\Delta }.25`$. Using finitely squeezed approximate codewords does not badly compromise the error-correcting power of the code, since a gentle spreading in $`p`$ and $`q`$ is just the kind of error the code is intended to cope with.

The mean photon number of a finitely squeezed approximate codeword is

$$a^{}a+1/2=\frac{1}{2}p^2+q^2\mathrm{\Delta }^2$$
(73)
for small $`\mathrm{\Delta }`$. Therefore, an error probability of order $`10^6`$ can be achieved with Gaussian approximate codewords that have mean photon number of about $`(.25)^216`$.

More generally, a finitely squeezed codeword $`|\psi `$ can be regarded as a perfect codeword $`|\xi `$ that has undergone an error; we may write

$$|\psi =𝑑u𝑑v\eta (u,v)e^{i(up+vq)}|\xi ,$$
(74)
where $`\eta (u,v)`$ is an error “wave function.” In the special case of a Gaussian finitely squeezed codeword, we have

$$\eta (u,v)=\frac{1}{\sqrt{\pi \kappa \mathrm{\Delta }}}\mathrm{exp}\left(\frac{1}{2}(u^2/\mathrm{\Delta }^2+v^2/\kappa ^2)\right),$$
(75)
where $`\mathrm{\Delta }`$ and $`\kappa `$ are the squeezing parameters defined above.

If $`\eta (u,v)`$ vanishes for $`|u|>\alpha /2`$ or $`|v|>\pi /(n\alpha )`$, then the error is correctable. In this case, the interpretation of $`\eta (u,v)`$ as a wave function has a precise meaning, since there is an unambiguous decomposition of a state into codeword and error. Indeed, if $`|\xi _1`$, $`|\xi _2`$ are perfect codewords and $`|\psi _1`$, $`|\psi _2`$ are the corresponding finitely squeezed codewords with error wave functions $`\eta _1`$, $`\eta _2`$, then

$$\psi _1|\psi _2=\xi _1|\xi _2\eta _1|\eta _2,$$
(76)
where

$$\eta _1|\eta _2=𝑑u𝑑v\eta _1(u,v)^{}\eta _2(u,v).$$
(77)
## VI Continuous variable codes for many oscillators

The continuous variable codes described in §IV are based on simple lattices in the two-dimensional phase space of a single particle. We can construct more sophisticated codes from lattices in the $`(2N)`$-dimensional phase space of $`N`$ particles. Then codes of higher quality can be constructed that take advantage of efficient packings of spheres in higher dimensions.

For a system of $`N`$ oscillators, a tensor product of Pauli operators can be expressed in terms of the canonical variables $`q_i`$ and $`p_i`$ as

$$U_{\alpha \beta }=\mathrm{exp}\left[i\sqrt{2\pi }\left(\underset{i=1}{\overset{N}{}}\alpha _ip_i+\beta _iq_i\right)\right],$$
(78)
where the $`\alpha _i`$’s and $`\beta _i`$’s are real numbers. (In this setting, the Pauli operators are sometimes called “Weyl operators.”) Two such operators commute up to a phase:

$`U_{\alpha \beta }U_{\alpha ^{}\beta ^{}}=e^{2\pi i[\omega (\alpha \beta ,\alpha ^{}\beta ^{})]}U_{\alpha ^{}\beta ^{}}U_{\alpha \beta },`$ (79)
where

$$\omega (\alpha \beta ,\alpha ^{}\beta ^{})\alpha \beta ^{}\alpha ^{}\beta $$
(80)
is the symplectic form. Thus two Pauli operators commute if and only if their symplectic form is an integer.

Now a general continuous variable stabilizer code is the simultaneous eigenspace of commuting Pauli operators, the code’s stabilizer generators. If the continuous variable phase space is $`2N`$-dimensional and the code space is a finite-dimensional Hilbert space, then there must be $`2N`$ independent generators. The elements of the stabilizer group are in one-to-one correspondence with the points of a lattice $``$ in phase space, via the relation

$$U(k_1,k_2,\mathrm{}k_{2N})=\mathrm{exp}\left[i\sqrt{2\pi }\left(\underset{a=1}{\overset{2N}{}}k_av_a\right)\right].$$
(81)
Here $`\{v_a,a=1,2,\mathrm{},2N\}`$ are the basis vectors of the lattice (each a linear combination of $`q`$’s and $`p`$’s), the $`k_a`$’s are arbitrary integers, and $`U(k_1,k_2,\mathrm{}k_{2N})`$ is the corresponding element of the stabilizer. For the stabilizer group to be Abelian, the symplectic inner product of any pair of basis vectors must be an integer; that is, the antisymmetric $`2N\times 2N`$ matrix

$$A_{ab}=\omega (v_a,v_b)$$
(82)
has integral entries. The lattice $``$ has a $`2N\times 2N`$ generator matrix $`M`$ whose rows are the basis vectors,

$$M=\left(\begin{array}{c}v_1\\ v_2\\ \\ \\ v_{2N}\end{array}\right).$$
(83)
In terms of $`M`$, the matrix $`A`$ can be expressed as

$$A=M\omega M^T,$$
(84)
where $`\omega `$ denotes the $`2N\times 2N`$ matrix

$$\omega =\left(\begin{array}{cc}0& I\\ I& 0\end{array}\right),$$
(85)
and $`I`$ is the $`N\times N`$ identity matrix.

The generator matrix of a lattice is not unique. The replacement

$$MM^{}=RM$$
(86)
leaves the lattice unmodified, where $`R`$ is an invertible integral matrix with determinant $`\pm 1`$ (whose inverse is also integral). Under this replacement, the matrix $`A`$ changes according to

$$AA^{}=RAR^T.$$
(87)
By Gaussian elimination, an $`R`$ can be constructed such that the antisymmetric matrix $`A`$ is transformed to

$$A^{}=\left(\begin{array}{cc}0& D\\ D& 0\end{array}\right),$$
(88)
where $`D`$ is a positive diagonal $`N\times N`$ matrix.

There are also Pauli operators that provide a basis for the operations acting on the code subspace – these are the Pauli operators that commute with the stabilizer but are not contained in the stabilizer. The operators that commute with the stabilizer themselves form a lattice $`^{}`$ that is dual (in the symplectic form) to the stabilizer lattice. The basis vectors of this lattice can be chosen to be $`\{u_b,b=1,2,3,\mathrm{},2N\}`$ such that

$$\omega (u_a,v_b)=\delta _{ab};$$
(89)
then the generator matrix

$$M^{}=\left(\begin{array}{c}u_1\\ u_2\\ \\ \\ u_{2N}\end{array}\right)$$
(90)
of $`^{}`$ has the property

$$M^{}\omega M^T=I.$$
(91)
It follows from eq. (82) and eq. (89) that the $``$ basis vectors can be expanded in terms of the $`^{}`$ basis vectors as

$$v_a=\underset{b}{}A_{ab}u_b,$$
(92)
or

$$M=AM^{},$$
(93)
and hence that

$$\omega (u_a,u_b)=\left(A\right)_{ba}^1,$$
(94)
or

$$M^{}\omega \left(M^{}\right)^T=\left(A^1\right)^T.$$
(95)
If the lattice basis vectors are chosen so that $`A`$ has the standard form eq. (88), then

$$\left(A^1\right)^T=\left(\begin{array}{cc}0& D^1\\ D^1& 0\end{array}\right).$$
(96)
In the special case of a self-dual lattice, corresponding to a code with a one-dimensional code space, both $`A`$ and $`A^1`$ must be integral; hence $`D=D^1`$ and the standard form of $`A`$ is

$$A=\left(\begin{array}{cc}0& I\\ I& 0\end{array}\right)=\omega .$$
(97)
Since the code subspace is invariant under the translations in $``$, we can think of the encoded information as residing on a torus, the unit cell of $``$. The encoded Pauli operators $`\{\overline{X}^a\overline{Z}^b\}`$ are a lattice of translations on this torus, corresponding to the coset space $`^{}/`$. The number of encoded Pauli operators is the ratio of the volume of the unit cell of $``$ to the volume of the unit cell of $`^{}`$, namely the determinant of $`A`$, which is therefore the square of the dimension of the Hilbert space of the code. Thus the dimension of the code space is

$$n=|\mathrm{Pf}A|=\mathrm{det}D,$$
(98)
where $`\mathrm{Pf}A`$ denotes the Pfaffian, the square root of the determinant of the antisymmetric matrix $`A`$.

The stabilizer lattice unit cell has volume $`|\mathrm{Pf}A|`$ in units with $`h=2\pi \mathrm{}=1`$, and the unit cell of the lattice of encoded operations has volume $`|\mathrm{Pf}A|^1`$ in these units. So the code fits an $`n`$-dimensional code space into $`n`$ units of phase space volume, as expected.

Codes of the CSS type (those analogous to the binary quantum codes first constructed by Calderbank and Shor  and by Steane ) are constructed by choosing one lattice $`_q`$ describing stabilizer generators that are linear combinations of the $`q`$’s, and another lattice $`_p_q^{}`$ describing stabilizer generators that are linear combinations of the $`p`$’s. (Here $`_q^{}`$ denotes the Euclidean dual of the lattice $`_q`$.) The generator matrix of a CSS code has the form

$$M=\left(\begin{array}{cc}M_q& 0\\ 0& M_p\end{array}\right),$$
(99)
where $`M_q`$ and $`M_p`$ are $`N\times N`$ matrices, and the integral matrix $`A`$ has the form

$$A=\left(\begin{array}{cc}0& M_qM_p^T\\ M_pM_q^T& 0\end{array}\right)$$
(100)
For single-oscillator codes described in §IV, $`A`$ is the $`2\times 2`$ matrix

$$A=\left(\begin{array}{cc}0& n\\ n& 0\end{array}\right),$$
(101)
where $`n`$ is the code’s dimension. For a single-oscillator CSS code, the lattice is rectangular, as shown in Fig. 3.

The closest packing of circles in two dimensions is achieved by the hexagonal lattice. The generator matrix for a hexagonally encoded qunit can be chosen to be

$$M=\left(\frac{2}{\sqrt{3}}n\right)^{1/2}\left(\begin{array}{cc}1& 0\\ 1/2& \sqrt{3}/2\end{array}\right),$$
(102)
and the dual lattice is generated by

$$M^{}=\frac{1}{n}M.$$
(103)
The shortest vector of the dual lattice has length $`\left(2/n\sqrt{3}\right)^{1/2}`$, compared to length $`1/\sqrt{n}`$ for the square lattice. Therefore the size of the smallest uncorrectable shift is larger for the hexagonal code than for the square lattice code, by the factor $`\left(2/\sqrt{3}\right)^{1/2}1.07457`$.

An important special class of quantum codes for many oscillators are the concatenated codes. In particular, we can encode a qubit in each of $`N`$ oscillators using the code of §IV. Then we can use a binary stabilizer code that encodes $`k`$ qubits in a block of $`N`$ oscillators, and protects against arbitrary errors on any $`t`$ oscillators, where $`2t+1`$ is the binary code’s distance. The concatenated codes have the important advantage that they can protect against a broader class of errors than small diffusive shifts applied to each oscillator – if most of the oscillators undergo only small shifts in $`p`$ and $`q`$, but a few oscillators sustain more extensive damage, then concatenated codes still work effectively.

For example, there is a binary $`[[7,1,3]]`$ quantum code, well suited to fault-tolerant processing, that encodes one logical qubit in a block of seven qubits and can protect against heavy damage on any one of the seven . Given seven oscillators, we can encode a qubit in each one that is resistant to quantum diffusion, and then use the $`[[7,1,3]]`$ block code to protect one logical qubit against severe damage to any one of the oscillators.

For $`n5`$, there is a \[\] polynomial code , also well suited to fault-tolerant processing, encoding one qunit in a block of 5. (Actually, $`[[5,1,3]]`$ quantum codes exist for $`n<5`$ as well , but these codes are less conducive to fault-tolerant computing.) The larger value of $`n`$ increases the vulnerability of each qunit to shift errors. Hence, whether the \[\] binary code or the \[\] should be preferred depends on the relationship of the size of the typical shift errors to the rate of large errors.

## VII Error models

What sort of errors can be corrected by these codes? The codes are designed to protect against errors that shift the values of the canonical variables $`p`$ and $`q`$. In fact the Pauli operators are a complete basis, so the action of a general superoperator $``$ acting on the input density matrix $`\rho `$ of a single oscillator can be expanded in terms of such shifts, as in

$`(\rho )`$ $`=`$ $`{\displaystyle 𝑑\alpha 𝑑\beta 𝑑\alpha ^{}𝑑\beta ^{}C(\alpha ,\beta ;\alpha ^{}\beta ^{})}`$ (104)
$`\times `$ $`e^{i(\alpha p+\beta q)}\rho e^{i(\alpha ^{}p+\beta ^{}q)}.`$ (105)
If the support of $`C(\alpha ,\beta ;\alpha ^{},\beta ^{})`$ is concentrated on sufficiently small values of its arguments, then the input $`\rho `$ can be recovered with high fidelity.

A useful model of decoherence is the special case of a “Pauli channel” in which $`C(\alpha ,\beta ;\alpha ^{},\beta ^{})`$ is diagonal and the superoperator can be expressed as

$$(\rho )=𝑑\alpha 𝑑\beta P(\alpha ,\beta )e^{i(\alpha p+\beta q)}\rho e^{i(\alpha p+\beta q)}.$$
(106)
Since $``$ is positive and trace preserving, we infer that $`P(\alpha ,\beta )0`$ and

$$𝑑\alpha 𝑑\beta P(\alpha ,\beta )=1.$$
(107)
Thus, we may interpret $`P(\alpha ,\beta )`$ as a probability distribution: the phase space translation

$$(q,p)(q\alpha ,p+\beta )$$
(108)
is applied with probability $`P(\alpha ,\beta )`$.

Weak interactions between an oscillator and its environment drive a diffusive process that can be well modeled by a Pauli channel. If the environment quickly “forgets” what it learns about the oscillator, the evolution of the oscillator can be described by a master equation. Over a short time interval $`dt`$, the shifts applied to the oscillator may be assumed to be small, so that the Pauli operator can be expanded in powers of $`\alpha `$ and $`\beta `$. Suppose that the shifts are symmetrically distributed in phase space such that

$`\alpha =\beta =0,`$ (109)
$`\alpha ^2=\beta ^2,`$ (110)
$`\alpha \beta =0,`$ (111)
where $``$ denotes the mean value determined by the probability distribution $`P(\alpha ,\beta )`$. Suppose further that the shifts are diffusive, so that the mean square displacement increases linearly with $`dt`$; we may write

$$\alpha ^2=\beta ^2=Ddt,$$
(112)
where $`D`$ is a diffusion constant. We then obtain

$`\rho (t+dt)`$ $`=`$ $`{\displaystyle 𝑑\alpha 𝑑\beta P(\alpha ,\beta )e^{i(\alpha p+\beta q)}\rho e^{i(\alpha p+\beta q)}}`$ (113)
$`=`$ $`\rho (t)+Ddt\left(p\rho p{\displaystyle \frac{1}{2}}p^2\rho {\displaystyle \frac{1}{2}}\rho p^2\right)`$ (114)
$`+`$ $`Ddt\left(q\rho q{\displaystyle \frac{1}{2}}q^2\rho {\displaystyle \frac{1}{2}}\rho q^2\right)+O(dt^{3/2}),`$ (115)
or

$$\dot{\rho }=\frac{D}{2}[p,[p,\rho ]]\frac{D}{2}[q,[q,\rho ]].$$
(116)
The interpretation of $`D`$ as a diffusion constant can be confirmed by computing

$$\frac{d}{dt}\mathrm{tr}\left(p^2\rho \right)=D=\frac{d}{dt}\mathrm{tr}\left(q^2\rho \right);$$
(117)
the mean square values of $`p`$ and $`q`$ increase with time as $`Dt`$.

More generally, the master equation contains a diffusive term determined by the covariance of the distribution $`P(\alpha ,\beta )`$, and perhaps also a nondissipative drift term determined by the mean of $`P(\alpha ,\beta )`$. Our quantum error-correcting codes can successfully suppress decoherence caused by quantum diffusion, if the recovery operation is applied often enough; roughly, the time interval $`\mathrm{\Delta }t`$ between error correction steps should be small compared to the characteristic diffusion time $`D^1`$.

Interactions with the environment might also damp the amplitude of the oscillator, as described by the master equation

$$\dot{\rho }=\mathrm{\Gamma }\left(a\rho a^{}\frac{1}{2}a^{}a\rho \frac{1}{2}\rho a^{}a\right);$$
(118)
here $`a=(q+ip)/\sqrt{2}`$ is the annihilation operator and $`\mathrm{\Gamma }`$ is a decay rate. This master equation cannot be obtained from a Pauli channel, but as for quantum diffusion, the effects of amplitude damping over short time intervals can be expressed in terms of small phase-space displacements.

The master equation for amplitude damping can be obtained as the $`dt0`$ limit of the superoperator

$`\rho (t+dt)`$ $`=`$ $`(\rho (t))=\left(\sqrt{\mathrm{\Gamma }dt}a\right)\rho (t)\left(\sqrt{\mathrm{\Gamma }dt}a^{}\right)`$ (120)
$`+\left(I{\displaystyle \frac{\mathrm{\Gamma }dt}{2}}a^{}a\right)\rho (t)\left(I{\displaystyle \frac{\mathrm{\Gamma }dt}{2}}a^{}a\right).`$
For $`dt`$ small, the annihilation operator can be expanded in terms of Pauli operators as

$`\sqrt{\mathrm{\Gamma }dt}a`$ $``$ $`{\displaystyle \frac{i}{2}}\left(e^{i\sqrt{\mathrm{\Gamma }dt/2}q}e^{i\sqrt{\mathrm{\Gamma }dt/2}q}\right)`$ (122)
$`+{\displaystyle \frac{1}{2}}\left(e^{i\sqrt{\mathrm{\Gamma }dt/2}p}e^{i\sqrt{\mathrm{\Gamma }dt/2}p}\right)`$
Thus, if the time interval $`\mathrm{\Delta }t`$ between error correction steps is small compared to the damping time $`\mathrm{\Gamma }^1`$, the displacements applied to codewords are small, and error correction will be effective.

Aside from decoherence, we also need to worry about “unitary errors.” For example, an inadvertent rotation of the phase of the oscillator induces the unitary transformation

$$U(\theta )\mathrm{exp}\left(i\theta a^{}a\right)$$
(123)
Like any unitary transformation, this phase rotation can be expanded in terms of Pauli operators. It is convenient to introduce the notation for the phase-space displacement operator

$`D(\gamma )`$ $``$ $`\mathrm{exp}\left(\gamma a\gamma ^{}a^{}\right)`$ (124)
$`=`$ $`\mathrm{exp}\left(i\sqrt{2}\left[(\mathrm{Im}\gamma )q(\mathrm{Re}\gamma )p\right]\right),`$ (125)
where $`\gamma `$ is a complex number. The displacements satisfy the identity

$$\mathrm{tr}\left(D(\gamma )D(\eta )^{}\right)=\pi \delta ^2(\gamma \eta ),$$
(126)
so the operator $`U(\theta )`$ can be expanded in terms of displacements as

$$U(\theta )=\frac{1}{\pi }d^2\gamma u_\theta (\gamma )D(\gamma ),$$
(127)
where

$$u_\theta (\gamma )=\mathrm{tr}\left(U(\theta )D(\gamma )^{}\right).$$
(128)
Evaluating the trace in the coherent state basis, we find that

$$u_\theta (\gamma )=\frac{ie^{i\theta /2}}{2\mathrm{sin}(\theta /2)}\mathrm{exp}\left(\frac{i}{2}|\gamma |^2\mathrm{cot}(\theta /2)\right).$$
(129)
For small $`\theta `$, the coefficient

$$u_\theta (\gamma )\frac{i}{\theta }\mathrm{exp}\left(\frac{i}{\theta }|\gamma |^2\right)$$
(130)
has a rapidly oscillating phase, and can be regarded as a distribution with support concentrated on values of $`\gamma `$ such that $`|\gamma |^2\theta `$; indeed, formally

$$\underset{\theta 0}{lim}u_\theta (\gamma )=\pi \delta ^2(\gamma ).$$
(131)
Thus a rotation by a small angle $`\theta `$ can be accurately expanded in terms of small displacements – error correction is effective if an oscillator is slightly overrotated or underrotated.

## VIII The Gaussian quantum channel

At what rate can error-free digital information be conveyed by a noisy continuous signal? In classical information theory, an answer is provided by Shannon’s noisy channel coding theorem for the Gaussian channel . This theorem establishes the capacity that can be attained by a signal with specified average power, for a channel with specified bandwidth and specified Gaussian noise power. The somewhat surprising conclusion is that a nonzero rate can be attained for any nonvanishing value of the average signal power.

A natural generalization of the Gaussian classical channel is the Gaussian quantum channel. The Gaussian quantum channel is a Pauli channel: $`N`$ oscillators are transmitted, and the $`q`$ and $`p`$ displacements acting on the oscillators are independent Gaussian random variables with mean 0 and variance $`\sigma ^2`$. A code is an $`M`$-dimensional subspace of the Hilbert space of the $`N`$ oscillators, and the rate $`R`$ of the code (in qubits) is defined as

$$R=\frac{1}{N}\mathrm{log}_2M.$$
(132)
The quantum-information capacity $`C_Q`$ of the channel is the maximal rate at which quantum information can be transmitted with fidelity arbitrarily close to one.

The need for a constraint on the signal power to define the capacity of the Gaussian classical channel can be understood on dimensional grounds. The classical capacity (in bits) is a dimensionless function of the variance $`\sigma ^2`$, but $`\sigma ^2`$ has dimensions. Another quantity with the same dimensions as $`\sigma ^2`$ is needed to construct a dimensionless variable, and the power fulfills this role. But no power constraint is needed to define the quantum capacity of the quantum channel. The capacity (in qubits) is a function of the dimensionless variable $`\mathrm{}/\sigma ^2`$, where $`\mathrm{}`$ is Planck’s constant.

An upper bound on the quantum capacity of the Gaussian quantum channel was derived by Holevo and Werner ; they obtained (reverting now to units with $`\mathrm{}=1`$)

$$C_Q\mathrm{log}_2(1/\sigma ^2),$$
(133)
for $`0<\sigma ^2<1`$, and $`C_Q=0`$ for $`\sigma ^21`$. They also computed the coherent information $`I_Q`$ of the Gaussian quantum channel, and maximized it over Gaussian signal states, finding

$$\left(I_Q\right)_{\mathrm{max}}=\mathrm{log}_2(1/e\sigma ^2),$$
(134)
for $`0<\sigma ^2<1/e`$ (where $`e=2.71828\mathrm{})`$. The coherent information is conjectured to be an attainable rate ; if this conjecture is true, then eq. (134) provides a lower bound on $`C_Q`$.

Using our continuous variable codes, rigorous lower bounds on $`C_Q`$ can be established. For $`\sigma ^2`$ sufficiently small, a nonzero attainable rate can be established asymptotically for large $`N`$ by either of two methods. In one method, the $`n=2`$ code described in §IV is invoked for each oscillator, and concatenated with a binary quantum code. In the other method, which more closely follows Shannon’s construction, a code for $`N`$ oscillators is constructed as in §VI, based on a close packing of spheres in $`2N`$-dimensional phase space. However (in contrast to the classical case), neither method works if $`\sigma ^2`$ is too large. For large $`\sigma ^2`$, encodings can be chosen that protect against $`q`$ shifts or against $`p`$ shifts, but not against both.

To establish an attainable rate using concatenated coding (the method that is easier to explain), we first recall a result concerning the quantum capacities of binary channels . If $`X`$ and $`Z`$ errors are independent and each occur with probability $`p_e`$, then binary CSS codes exist that achieve a rate

$`R`$ $`>`$ $`12H_2(p_e)`$ (135)
$``$ $`1+2p_e\mathrm{log}_2p_e+2(1p_e)\mathrm{log}_2(1p_e);`$ (136)
this rate is nonzero for $`p_e<.1100`$.

Now, for the Gaussian quantum channel, if we use the $`n=2`$ continuous variable code, errors afflicting the encoded qubit are described by a binary channel with independent $`X`$ and $`Z`$ errors. Since the code can correct shifts in $`q`$ or $`p`$ that satisfy $`\mathrm{\Delta }q,\mathrm{\Delta }p<\sqrt{\pi }/2`$, the error probability is

$$p_e<2\frac{1}{\sqrt{2\pi \sigma ^2}}_{\sqrt{\pi }/2}^{\mathrm{}}𝑑xe^{x^2/2\sigma ^2}.$$
(137)
Since the expression bounding $`p_e`$ in eq. (137) has the value .110 for $`\sigma .555`$, we conclude that the Gaussian quantum channel has nonvanishing quantum capacity $`C_Q`$ provided that

$$\sigma <.555.$$
(138)
One might expect to do better by concatenating the hexagonal $`n=2`$ single-oscillator code with a binary stabilizer code, since the hexagonal code can correct larger shifts than the code derived from a square lattice. For the Gaussian quantum channel, the symmetry of the hexagonal lattice ensures that $`X`$, $`Y`$, and $`Z`$ errors afflicting the encoded qubit are equally likely. A shift is correctable if it lies within the “Voronoi cell” of the dual lattice, the cell containing all the points that are closer to the origin than to any other lattice site. By integrating the Gaussian distribution over the hexagonal Voronoi cell, we find that the probability $`p_{e,\mathrm{total}}`$ of an uncorrectable error satisfies

$$p_{e,\mathrm{total}}<1\frac{12}{2\pi \sigma ^2}_0^r𝑑x_0^{x/\sqrt{3}}𝑑ye^{(x^2+y^2)/2\sigma ^2},$$
(139)
where $`r=(\pi /2\sqrt{3})^{1/2}`$ is the size of the smallest uncorrectable shift. For a binary quantum channel with equally likely $`X`$, $`Y`$, and $`Z`$ errors, it is known  that there are stabilizer codes achieving a nonvanishing rate for $`p_{e,\mathrm{total}}<.1905`$; our bound on $`p_{e,\mathrm{total}}`$ reaches this value for $`\sigma .547`$.

Somewhat surprisingly, for very noisy Gaussian quantum channels, square lattice codes concatenated with CSS codes seem to do better than hexagonal codes concatenated with stabilizer codes. The reason this happens is that a CSS code can correct independent $`X`$ and $`Z`$ errors that occur with total probability $`p_{e,\mathrm{total}}=p_X+p_Zp_Xp_Z`$, which approaches $`.2079>.1905`$ as $`p_X=p_Z.1100.`$ For a given value of $`\sigma `$, the qubit encoded in each oscillator will have a lower error probability if the hexagonal code is used. But if the square lattice is used, a higher qubit error rate is permissible, and this effect dominates when the channel is very noisy.

We remark that this analysis is readily extended to more general Gaussian quantum channels. We may consider Pauli channels acting on a single oscillator in which the probability distribution $`P(\alpha ,\beta )`$ is a more general Gaussian function, not necessarily symmetric in $`p`$ and $`q`$. In that case, a symplectic transformation (one preserving the commutator of $`p`$ and $`q`$) can be chosen that transforms the covariance matrix of the Gaussian to a multiple of the identity; therefore, this case reduces to that already discussed above. We may also consider channels acting on $`N`$ oscillators that apply shifts in the $`2N`$-dimensional phase space, chosen from a Gaussian ensemble. Again there is a symplectic transformation that diagonalizes the covariance matrix; therefore, this case reduces to $`N`$ independent single oscillator channels, each with its own value of $`\sigma ^2`$ .

## IX Symplectic operations

To use these codes for fault-tolerant quantum computation, we will need to be able to prepare encoded states, perform error recovery, and execute quantum gates that act on the encoded quantum information. The most difficult task is encoding; we will postpone the discussion of encoding until after we have discussed encoded operations and error recovery.

Suppose, for example, that we have $`N`$ oscillators, each encoding a qunit. We wish to apply $`U(n^N)`$ transformations that preserve the code subspace of the $`N`$ qunits. As is typical of quantum codes, we will find that there is a discrete subgroup of $`U(n^N)`$ that we can implement “easily;” but to complete a set of universal gates we must add further transformations that are “difficult.” In the case of our continuous variable codes, the easy gates will be accomplished using linear optical elements (phase shifters and beam splitters), along with elements that can “squeeze” an oscillator. For the “difficult” gates we will require the ability to count photons.

The easy gates are the gates in the Clifford group. In general, the Clifford group of a system of $`N`$ qunits is the group of unitary transformations that, acting by conjugation, take tensor products of Pauli operators to tensor products of Pauli operators (one says that they preserve the “Pauli group”). Since for $`N`$ oscillators the tensor products of Pauli operators have the form eq. (78), the Clifford group transformations, acting by conjugation, are linear transformations of the $`p`$’s and $`q`$’s that preserve the canonical commutation relations. Such transformations are called symplectic transformations. The symplectic group has a subgroup that preserves the photon number

$$\mathrm{total}\mathrm{photon}\mathrm{number}=\underset{i=1}{\overset{N}{}}a_i^{}a_i.$$
(140)
The transformations in this subgroup can be implemented with linear optics . The full symplectic group also contains “squeeze operators” that take an $`a`$ to a linear combination of $`a`$’s and $`a^{}`$’s; equivalently, the squeeze operators rescale canonical operators by a real number $`\lambda `$ along one axis in the quadrature plane, and by $`\lambda ^1`$ along the conjugate axis, as in (for example)

$$q_1\lambda q_1,p_1\lambda ^1p_1.$$
(141)
With squeezing and linear optics we can in principle implement any symplectic transformation.

Aside from the symplectic transformations, we will also assume that it is easy to do displacements that shift $`q`$ and $`p`$ by constants. A displacement of $`q_1`$ by $`c`$ is actually the limiting case of a symplectic transformation on two oscillators $`q_1`$ and $`q_2`$:

$`q_1q_1+\epsilon q_2,`$ $`p_1p_1+\epsilon p_2`$ (142)
$`q_2q_2\epsilon q_1,`$ $`p_2p_2\epsilon p_1`$ (143)
where $`\epsilon 0`$ with $`\epsilon q_2=c`$ held fixed.

Since for the code with stabilizer generators eq. (40) the Pauli operators acting on our encoded qunits are $`\overline{X}=e^{ip\alpha }`$ and $`\overline{Z}=e^{2\pi iq/n\alpha }`$, the Clifford group transformations acting on $`N`$ qunits constitute a subgroup of the symplectic transformations (including shifts) acting on $`N`$ oscillators, the subgroup that preserves a specified lattice in phase space. Thus we can do any encoded Clifford group gate we please by executing an appropriate symplectic transformation (possibly including a shift).

A similar comment applies to the case of a qunit encoded in a qudit. Since the logical Pauli operators are $`\overline{X}=X^{r_1}`$ and $`\overline{Z}=Z^{r_2}`$, each Clifford group transformation in the $`n`$-dimensional code space is also a Clifford group transformation on the underlying qudit.

But we must also be sure that our implementation of the Clifford group is fault tolerant. In previous discussions of quantum fault tolerance for $`[[N,k,2t+1]]`$ codes, the central theme has been that propagation of error from one qudit to another in the same code block must be very carefully controlled . For shift-resistant codes the main issue is rather different. Since each qudit typically has a (small) error anyway, propagation of error from one qudit to another is not necessarily so serious. But what must be controlled is amplification of errors – gates that turn small errors into large errors should be avoided.

The Clifford group can be generated by gates that are fault-tolerant in this sense. The Clifford group for qunits can be generated by three elements. The SUM gate is a two-qunit gate that acts by conjugation on the Pauli operators according to

$$\mathrm{SUM}:X_1^aX_2^bX_1^aX_2^{ba},Z_1^aZ_2^bZ_1^{a+b}Z_2^b.$$
(144)
Here qunit 1 is said to be the control of the SUM gate, and qunit 2 is said to be its target; in the binary ($`n=2`$) case, SUM is known as controlled-NOT, or CNOT. The Fourier gate $`F`$ acts by conjugation as

$$F:XZ,ZX^1;$$
(145)
for $`n=2`$ the Fourier Transform is called the Hadamard gate. The phase gate $`P`$ acts as

$$P:X(\eta )XZ,ZZ,$$
(146)
where the $`n`$-dependent phase $`\eta `$ is $`\omega ^{1/2}`$ if $`n`$ is even and 1 if $`n`$ is odd. Any element of the Clifford group can be expressed as a product of these three generators. (In Ref.  another gate $`S`$ was included among the generators of the Clifford group, but in fact the $`S`$ gate can be expressed as a product of SUM gates.)

For an $`n`$-dimensional system encoded in a continuous variable system, these Clifford group generators can all be realized as symplectic transformations. In the case where the stabilizer generators are symmetric in $`q`$ and $`p`$,

$$\overline{X}=\mathrm{exp}\left(ip\sqrt{\frac{2\pi }{n}}\right),\overline{Z}=\mathrm{exp}\left(iq\sqrt{\frac{2\pi }{n}}\right),$$
(147)
the required symplectic transformations are

$`\mathrm{SUM}:`$ $`q_1q_1,p_1p_1p_2,`$ (149)
$`q_2q_1+q_2,p_2p_2,`$
$`F:`$ $`qp,pq,`$ (150)
$`P:`$ $`qq,ppq+c,`$ (151)
where the $`n`$-dependent shift $`c`$ is $`0`$ for $`n`$ even and $`\sqrt{\pi /2n}`$ for $`n`$ odd. Under these symplectic transformations, small deviations of $`q`$ and $`p`$ from the stabilizer lattice remain small; in this sense the transformations are fault tolerant.

## X Error recovery

If we are willing to destroy the encoded state, then measuring the encoded $`\overline{X}`$ or $`\overline{Z}`$ is easy – we simply conduct a homodyne measurement of the $`q`$ or $`p`$ quadrature of the oscillator. For example, suppose that we measure $`q`$ for a state in the code subspace. If there are no errors and the measurement has perfect resolution, the only allowed values of $`q`$ will be integer multiples of $`\alpha `$. If there are errors or the measurement is imperfect, classical error correction can be applied to the outcome, by adjusting it to the nearest $`\alpha k`$, where $`k`$ is an integer. Then the outcome of the measurement of $`\overline{Z}`$ is $`\omega ^k`$.

To diagnose errors in a coded data state, we must measure the stabilizer generators. This measurement can be implemented by “feeding” the errors from the code block to a coded ancilla, and then measuring the ancilla destructively, following the general procedure proposed by Steane  (see Fig. 4). For example, to measure the generator $`e^{2\pi iq/\alpha }`$ (i.e., the value of $`q`$ modulo $`\alpha `$), we prepare the ancilla in the state $`(|\overline{0}+|\overline{1})/\sqrt{2}`$, the equally weighted superposition of all $`|q=s\alpha `$, $`s`$ an integer. Then a SUM gate is executed with the data as control and the ancilla as target – acting according to

$$q_2q_1+q_2,$$
(152)
where $`q_1,q_2`$ are the values of $`q`$ for the data and ancilla respectively, prior to the execution of the SUM gate. By measuring $`q`$ of the ancilla, the value of $`q_1+q_2`$ is obtained, and this value modulo $`\alpha `$ determines the shift that should be applied to the data to recover from the error.

Similarly, to measure the stabilizer generator $`e^{inp\alpha }`$, we prepare the ancilla in the state $`|\overline{0}`$, the equally weighted superposition of all $`|p=s2\pi /n\alpha `$, $`s`$ an integer. Then a SUM gate is executed with the ancilla as control and the data as target. Finally, the $`p`$ quadrature of the ancilla is measured. The outcome reveals the value of $`p_2p_1`$ prior to the SUM gate, where $`p_1`$ is the momentum of the data, and $`p_2`$ is the momentum of the ancilla. The measured value modulo $`2\pi /n\alpha `$ then determines the shift that should be applied to the data to recover from the error.

Of course, the ancilla used in the syndrome measurement can also be faulty, resulting in errors in the syndrome and imperfect recovery. Similarly, the measurement itself will not have perfect resolution, and the shift applied to recover will not be precisely correct. Furthermore, as is discussed in §V, the ideal codewords are unphysical nonnormalizable states, so that the encoded information will always be carried by approximate codewords. For all these reasons, deviations from the code subspace are unavoidable. But if a fresh supply of ancilla oscillators is continuously available, we can prevent these small errors from accumulating and eventually damaging the encoded quantum information.

## XI Universal quantum computation

Symplectic transformations together with homodyne measurements are adequate for Clifford group computation and for error recovery (assuming we have a supply of encoded states). But to achieve universal computation in the code space, we need to introduce additional operations. Fortunately, the quantum optics laboratory offers us another tool that can be used to go beyond the symplectic computational model – the ability to count photons.

There are a variety of ways in which photon counting can be exploited to complete a universal set of fault-tolerant gates. We will describe two possible ways, just to illustrate how universal fault-tolerant quantum computation might be realized with plausible experimental tools. For this discussion, we will consider the binary case $`n=2`$.

### A Preparing a Hadamard eigenstate

We can complete the universal gate set if we have the ability to prepare eigenstates of the Hadamard operator $`H`$ . For this purpose it suffices to be able to destructively measure $`H`$ of an encoded qubit. Assuming we are able to prepare a supply of the encoded $`\overline{Z}`$ eigenstate $`|\overline{0}`$, we can make an encoded EPR pair using symplectic gates. Then by destructively measuring $`H`$ for one encoded qubit in the pair, we prepare the other qubit in an encoded eigenstate of $`H`$ with known eigenvalue.

But how can we destructively measure $`H`$? The Hadamard gate acts by conjugation on the encoded Pauli operators according to

$$H:\overline{X}\overline{Z},\overline{Z}\overline{X}.$$
(153)
If we use the code that treats $`q`$ and $`p`$ symmetrically so that $`\overline{X}=\mathrm{exp}(ip\sqrt{\pi })`$ and $`\overline{Z}=\mathrm{exp}(iq\sqrt{\pi })`$, then the Hadamard gate can be implemented by the symplectic transformation.

$$qp,pq$$
(154)
(recalling that $`\overline{X}^2=\overline{Z}^2=I`$ on the code subspace). This transformation is just the Fourier transform

$$F:\mathrm{exp}\left(i\frac{\pi }{2}a^{}a\right)$$
(155)
(where $`a^{}a`$ is the photon number), which describes the natural evolution of the oscillator for one quarter cycle. Thus the phase of the Hadamard operator is simply the photon number modulo four; we can measure the eigenvalue of the encoded Hadamard transformation by counting photons.

In fact the photon number in the code space is even – all codewords are invariant under a $`180^{}`$ rotation in the quadrature plane. Because of this feature, the preparation of the Hadamard eigenstate has some fault tolerance built in; if the photon count is off by one, the number will be odd and an error will be detected. In that case we reject the state we have prepared and make a new attempt. If the photon number is large, then obtaining a reliable determination of the photon number modulo four will require highly efficient photodetection. But on the other hand, the photon number need not be very large – the mean value of $`a^{}a`$ is about $`\mathrm{\Delta }^2`$ where $`\mathrm{\Delta }`$ is the squeeze factor, and we have seen that the intrinsic error rate due to imperfect squeezing is quite small for $`\mathrm{\Delta }1/4`$, or $`a^{}a16`$.

An alternative to preparing an encoded EPR pair and destructively measuring one member of the pair is to prepare $`|\overline{0}`$ and then perform a quantum nondemolition measurement of the photon number modulo 4. This might be done by coupling the oscillator to a two-level atom as proposed in Ref. . Indeed, since only one bit of information needs to be collected (the photon number is either 0 or 2 modulo 4), the measurement could be made in principle by reading out a single atom. Suppose that the coupling of oscillator to atom is described by the perturbation

$$H^{}=\lambda a^{}a\sigma _z,$$
(156)
where $`\sigma _z=1`$ in the atomic ground state $`|g`$ and $`\sigma _z=1`$ in the atomic excited state $`|e`$. By turning on this coupling for a time $`t=\pi /4\lambda `$, we execute the unitary transformation

$$U=\mathrm{exp}(i(\pi /4)a^{}a\sigma _z).$$
(157)
Then the atomic state $`(|g+|e)/\sqrt{2}`$ evolves as

$`U:`$ $`{\displaystyle \frac{1}{\sqrt{2}}}(|g+|e)`$ (159)
$`{\displaystyle \frac{1}{\sqrt{2}}}e^{ia^{}a\pi /4}(|g+e^{ia^{}a\pi /2}|e).`$
By measuring the atomic state in the basis $`(|g\pm |e)/\sqrt{2}`$, we read out the value of the photon number modulo 4 (assumed to be either 2 or 4). Since this is a nondemolition measurement, it can be repeated to improve reliability. By measuring the photon number mod 4 many times (perhaps with rounds of error correction in between the measurements), we obtain a Hadamard eigenstate with excellent fidelity.

How does the ability to construct the Hadamard eigenstate enable us to achieve universal quantum computation? We can make contact with constructions that have been described previously in the literature by observing that the Hadamard eigenstate can be transformed by applying symplectic gates to the “$`\pi /8`$ phase state.” First note that the two Hadamard eigenstates can be converted to one another by applying the encoded gate $`\overline{X}\overline{Z}`$, which can be implemented by shifting both $`p`$ and $`q`$. Therefore it is sufficient to consider the eigenstate corresponding to the eigenvalue $`1`$,

$$|\psi _{H=1}=\mathrm{cos}(\pi /8)|0+\mathrm{sin}(\pi /8)|1.$$
(160)
By applying the symplectic single-qubit gate

$`HP^1`$ $``$ $`{\displaystyle \frac{1}{\sqrt{2}}}\left(\begin{array}{cc}1& 1\\ 1& 1\end{array}\right)\left(\begin{array}{cc}1& 0\\ 0& i\end{array}\right)`$ (161)
$`=`$ $`{\displaystyle \frac{1}{\sqrt{2}}}\left(\begin{array}{cc}1& i\\ 1& i\end{array}\right),`$ (162)
we obtain the $`\pi /8`$ state

$$|\psi _{\pi /8}=\frac{1}{\sqrt{2}}\left(e^{i\pi /8}|0+e^{i\pi /8}|1\right).$$
(163)
Now this $`\pi /8`$ state can be used to perform the nonsymplectic phase gate

$$S=\left(\begin{array}{cc}e^{i\pi /8}& 0\\ 0& e^{i\pi /8}\end{array}\right),$$
(164)
which completes the universal gate set . The gate is constructed by executing the circuit shown in Fig. 5. We perform a CNOT gate with the arbitrary single-qubit state $`|\psi =a|0+b|1`$ as the control, and the $`\pi /8`$ phase state as the target; then the target qubit is measured in the basis $`\{|0,|1\}`$. If the measurement outcome is $`|0`$ (which occurs with probability 1/2), then the control qubit has become $`ae^{i\pi /8}|0+be^{i\pi /8}|1=S|\psi `$ and we are done. If the measurement outcome is $`|1`$, then the control qubit has become $`ae^{i\pi /8}|0+be^{i\pi /8}|1`$, and we obtain $`S|\psi `$ by applying the symplectic single-qubit gate

$$e^{i\pi /4}P=\left(\begin{array}{cc}e^{i\pi /4}& 0\\ 0& e^{i\pi /4}\end{array}\right).$$
(165)
Completing the universal gate set by measuring the Hadamard transformation has some drawbacks. For one thing, while photon number modulo four corresponds to the Hadamard eigenvalue in the ideal code space, this correspondence will not apply to approximate codewords unless they are of a special type.

Recall that the imperfections of the codewords arising from finite squeezing can be described by an “embedded error” $`|\eta `$ as in eq. (74); a Gaussian approximate codeword has a Gaussian embedded error

$$\eta (u,v)=\frac{1}{\sqrt{\pi \mathrm{\Delta }\kappa }}\mathrm{exp}\left(\frac{1}{2}(u^2/\mathrm{\Delta }^2+v^2/\kappa ^2)\right),$$
(166)
where $`\mathrm{\Delta }`$ is the width in $`q`$ and $`\kappa `$ is the width in $`p`$. Symplectic gates act separately on the encoded qubit and the “embedded error” $`|\eta `$; for example, the Fourier transform gate and the $`\mathrm{SUM}`$ gate act on the error according to

$`F:`$ $`|u,v`$ $`|v,u,`$ (167)
$`\mathrm{SUM}:`$ $`|u_1,v_1;u_2,v_2`$ $`|u_1,v_1+v_2;u_2u_1,v_2.`$ (168)
By measuring the photon number modulo $`4`$, we actually measure the product of the eigenvalue of the Hadamard gate acting on the codeword and the eigenvalue of $`F`$ acting on the embedded error. The latter always equals $`1`$ if we use symmetrically squeezed codewords, with $`\mathrm{\Delta }=\kappa `$.

Symmetric squeezing is not in itself sufficient to ensure that the measurement of the photon number modulo 4 will prepare the desired encoded Hadamard eigenstate. We also need to consider how the embedded error is affected by the preparation of the EPR pair that precedes the measurement. To prepare the EPR pair, we use the SUM gate. Suppose that we start with two symmetrically squeezed states. Then the SUM gate yields the error wave function

$`\eta ^{}(u_1,v_1;u_2,v_2)`$ (169)
$`=\mathrm{exp}\left(\left(u_1^2+(v_1v_2)^2+(u_1+u_2)^2+v_2^2\right)/\mathrm{\Delta }^2\right).`$ (170)
Not only is it not symmetric, but the error is entangled between the two oscillators. The Fourier transform measurement will not give the desired result when applied to either oscillator.

To ameliorate this problem, we could perform error correction after the preparation of the EPR pair and before the measurement, where the error correction protocol has been designed to produce symmetrically squeezed states. Or we could avoid preparing the EPR state by using the nondemolition measurement of photon number modulo 4, as described above.

### B Preparing a cubic phase state

Now we will describe another way to use photon counting to implement non-symplectic gates, which is less sensitive to the codeword quality. Again, we will complete the universal gate set by constructing the $`\pi /8`$ phase gate $`S`$.

For our binary ($`n=2`$) code, the code subspace has the basis

$`|\overline{0}`$ $`=`$ $`{\displaystyle \underset{s=\mathrm{}}{\overset{+\mathrm{}}{}}}|q=2s\alpha ,`$ (171)
$`|\overline{1}`$ $`=`$ $`{\displaystyle \underset{s=\mathrm{}}{\overset{+\mathrm{}}{}}}|q=(2s+1)\alpha .`$ (172)
(For now we ignore the embedded error due to imperfect squeezing; it will be taken into account later.) An $`S`$ gate acting on the encoded qubit is implemented (up to an irrelevant overall phase) by the unitary operator

$$W=\mathrm{exp}\left(\frac{i\pi }{4}\left[2(q/\alpha )^3+(q/\alpha )^22(q/\alpha )\right]\right).$$
(173)
Indeed, we can check that

$$2x^3+x^22x(mod8)=\{\begin{array}{cc}0,\hfill & \text{if }x=2s\text{ ,}\hfill \\ 1,\hfill & \text{if }x=2s+1\text{ .}\hfill \end{array}$$
(174)
The operator $`W`$ is the product of a symplectic gate and the cubic phase gate

$$V_\gamma =\mathrm{exp}(i\gamma q^3),$$
(175)
where $`\gamma =\pi /(2\alpha ^3)`$. But how do we implement the cubic gate? In fact, if we are able to prepare a “cubic phase state”

$$|\gamma =𝑑xe^{i\gamma x^3}|x,$$
(176)
then we can perform the gate $`V_\gamma `$ by executing the circuit shown in Fig. 6.

To understand how the circuit works, consider the more general problem of implementing a phase gate that acts on the position eigenstates according to

$$V_\varphi :|qe^{i\varphi (q)}|q$$
(177)
(where $`\varphi (q)`$ is a real-valued function), using the prepared phase state

$$|\varphi =𝑑xe^{i\varphi (x)}|x.$$
(178)
If we perform the gate $`\mathrm{SUM}^1`$ with position eigenstate $`|q`$ as control and $`|\varphi `$ as target, and then measure the position of the target obtaining the outcome $`|a`$, the state of the control oscillator has become $`e^{i\varphi (q+a)}|q`$. We can therefore complete the construction of $`V_\varphi `$ by applying the transformation

$$U(a)=e^{i[\varphi (q)\varphi (q+a)]}.$$
(179)
If the function $`\varphi (q)`$ is cubic, then the argument of the exponential is quadratic and hence $`U(a)`$ is a symplectic transformation.

Now the problem of implementing universal quantum computation in the code subspace has been reduced to the problem of preparing the cubic phase state $`|\gamma `$. We can accomplish this task by preparing an EPR pair, and then performing a suitable photon counting measurement (a nonideal homodyne measurement) on one member of the pair.

Of course, the EPR pair will not be perfect. To be definite, let us suppose (although this assumption is not really necessary) that it is a Gaussian state

$`|\psi _{\sigma _p,\sigma _q}`$ $`=`$ $`\left({\displaystyle \frac{\sigma _p}{\pi \sigma _q}}\right)^{1/2}{\displaystyle 𝑑q_1𝑑q_2\mathrm{exp}\left[\frac{1}{2}\sigma _p^2\left(\frac{q_1+q_2}{2}\right)^2\right]}`$ (181)
$`\times \mathrm{exp}\left[{\displaystyle \frac{1}{2}}\left(q_1q_2\right)^2/\sigma _q^2\right]|q_1,q_2`$
with $`\sigma _p,\sigma _q1`$.

Now suppose that the second oscillator is mixed with a coherent light beam, resulting in a large shift in momentum,

$$|\psi e^{iwq}|\psi ,w\sigma _q^1,\sigma _p^1;$$
(182)
then the photon number is measured and $`n`$ photons are detected. Thus the state of the first oscillator becomes (up to normalization)

$`|\psi _1^{(n)}`$ $``$ $`\left({\displaystyle \frac{\sigma _p}{\pi \sigma _q}}\right)^{1/2}{\displaystyle 𝑑q_1|q_1e^{\frac{1}{2}\sigma _p^2q_1^2}}`$ (184)
$`\times {\displaystyle }dq_2\phi _n^{}(q_2)e^{iwq_2}e^{\frac{1}{2}\left(q_1q_2\right)^2/\sigma _q^2},`$
where $`|\phi _n`$ denotes the photon number eigenstate, the eigenstate with eigenvalue $`n+\frac{1}{2}`$ of the Hamiltonian $`H=\frac{1}{2}(p^2+q^2)`$.

We can evaluate the $`q_2`$ integral in eq. (184) by appealing to the semiclassical approximation. For $`q_2`$ in the classically allowed region and far from the classical turning points, we may write

$`\phi _n^{}(q_2)`$ $``$ $`{\displaystyle \frac{1}{\sqrt{2\pi p(q_2)}}}\mathrm{exp}\left(i{\displaystyle ^{q_2}}𝑑xp(x)\right)`$ (186)
$`+{\displaystyle \frac{1}{\sqrt{2\pi p(q_2)}}}\mathrm{exp}\left(+i{\displaystyle ^{q_2}}𝑑xp(x)\right),`$
where

$$p(x)=\sqrt{2n+1x^2}.$$
(187)
For $`w\sigma _q^1`$, the rapid phase oscillations strongly suppress the contribution to the integral arising from the left-moving part of $`\phi ^{(n)}(q_2)`$. A contribution from the right-moving part survives provided that

$$|p(q_1)w|<\sigma _q^1.$$
(188)
When this condition is satisfied, it is a reasonable approximation to replace the Gaussian factor $`e^{\frac{1}{2}\left(q_1q_2\right)^2/\sigma _q^2}`$ in the $`q_2`$ integral by $`\sqrt{2\pi \sigma _q^2}\delta (q_1q_2)`$, so that we obtain

$`|\psi _1^{(n)}`$ $``$ $`\left(2\sigma _p\sigma _q\right)^{1/2}{\displaystyle 𝑑q_1|q_1e^{\frac{1}{2}\sigma _p^2q_1^2}}`$ (189)
$`\times `$ $`{\displaystyle \frac{1}{\sqrt{2\pi p(q_1)}}}\mathrm{exp}\left(i{\displaystyle ^{q_1}}𝑑x\left(p(x)w\right)\right).`$ (190)
The probability that $`n`$ photons are detected is given by the norm of this $`|\psi _1^{(n)}`$. The values of $`n`$ that occur with appreciable probability satisfy eq. (188) for some $`q_1`$ with $`|q_1|<\sigma _p^1`$; thus typical measurement outcomes are in the range

$$n+\frac{1}{2}\frac{1}{2}\left(w\pm \sigma _q^1\right)^2+\frac{1}{2}\sigma _p^2,$$
(191)
with a flat probability distribution

$$\mathrm{Prob}(n)=\psi _1^{(n)}|\psi _1^{(n)}\frac{\sigma _q}{w}.$$
(192)
Heuristically, after the momentum shift is applied, the oscillator that is measured has momentum of order $`w\pm \sigma _q^1`$, and position of order $`\sigma _p^1`$, so that the value of the energy is $`n+\frac{1}{2}=\frac{1}{2}(p^2+q^2)\frac{1}{2}\left(w\pm \sigma _q^1\right)^2+\frac{1}{2}\sigma _p^2`$.

For a particular typical outcome of the photon-counting measurement, since $`|\psi _1^{(n)}`$ has its support on $`|q_1|<\sigma _p^1w`$, we can Taylor expand $`p(x)`$ about $`x=q_1`$ to express $`|\psi _1^{(n)}`$ as

$`\psi _1^{(n)}(q_1)\mathrm{exp}\left(i{\displaystyle ^{q_1}}\left(\sqrt{(2n+1)x^2}w\right)𝑑x\right)`$ (193)
$`\mathrm{exp}({\displaystyle \frac{i}{6\sqrt{2n+1}}}q_1^3i(\sqrt{2n+1}w)q_1`$ (194)
$`+O(q_1^5/w^3)).`$ (195)
This is a cubic phase state to good precision if $`w`$ is large enough.

The coefficient $`\gamma ^{}`$ of $`q_1^3`$ in the phase of $`\psi _1`$ is of order $`n^{1/2}`$, while the phase $`\gamma `$ of the operator $`V_\gamma `$ that we wish to execute is of order one. However, we can construct $`V_\gamma `$ from $`V_\gamma ^{}`$ as

$$V_\gamma =\left(S_{\gamma /\gamma ^{}}\right)^1V_\gamma ^{}\left(S_{\gamma /\gamma ^{}}\right),$$
(196)
where $`S_r`$ is a squeeze operation that acts according to

$`S_r:q`$ $``$ $`(r)^{1/3}q,`$ (197)
$`p`$ $``$ $`(r)^{1/3}p.`$ (198)
Alternatively, we could squeeze the phase state $`|\gamma ^{}`$ before we use it to implement the cubic phase gate.

Is this procedure fault tolerant? Before considering the errors introduced during the implementation of the cubic phase gate, we should check that the gate does not catastrophically amplify any preexisting errors. In general, a phase gate can transform a small position shift error into a potentially dangerous momentum shift error. Commuting $`V(\varphi )=e^{i\varphi (q)}`$ through the shift operator $`e^{iup}`$, we find

$$e^{i\varphi (q)}e^{iup}=e^{iup}e^{if_u(q)}e^{i\varphi (q)},$$
(199)
where $`f_u(q)=\varphi (q+u)\varphi (q)`$; the operator $`e^{if_u(q)}`$ can be expanded in terms of momentum shift operators of the form $`e^{ivq}`$ by evaluating the Fourier transform

$$\stackrel{~}{f}_u(v)=\frac{dq}{2\pi }e^{i(f_u(q)vq)}.$$
(200)
Assuming we use a code where the parameter $`\alpha `$ is of order one, uncorrectable errors will be likely if $`\stackrel{~}{f}_u(v)`$ has significant support on values of $`v`$ that are order one.

Suppose that $`V(\varphi )`$ acts on an approximate codeword whose wave function is concentrated on values of $`q`$ in the domain $`|q|<L`$. Phase cancellations will strongly suppress $`\stackrel{~}{f}_u(v)`$, unless the stationary phase condition $`f_u^{}(q)=v`$ is satisfied for some value of $`q`$ in the domain of the approximate codeword. Therefore, $`V(\varphi )`$ can propagate a preexisting position shift $`u`$ to a momentum shift error of magnitude

$$|v|\underset{|q|L}{\mathrm{max}}|f_u^{}(q)|.$$
(201)
The cubic phase gate needed to implement the encoded $`S`$ gate is $`W=e^{i\varphi (q)}`$ where $`\varphi (q)=\pi q^3/2\alpha ^3`$, so that $`f_u(q)=3\pi uq^2/2\alpha ^3+\mathrm{}`$ (ignoring small terms linear and constant in $`q`$), and $`f_u^{}(q)=3\pi uq/\alpha ^3`$; the gate transforms the position shift $`u`$ to a momentum shift

$$v3\pi Lu/\alpha ^3.$$
(202)
For $`\alpha `$ of order one, then, to ensure that $`v`$ is small we should use approximate codewords with the property that the typical embedded position shift $`u`$ satisfies

$$|u|L^1.$$
(203)
In particular, if the approximate codeword’s embedded errors are Gaussian, where $`\kappa `$ is the typical size of a momentum shift and $`\mathrm{\Delta }`$ is the typical size of a position shift, we require

$$\mathrm{\Delta }\kappa .$$
(204)
We assume that shift errors due to other causes are no larger than the embedded error.

In the circuit Fig. 6 that implements the cubic phase gate, position shift errors in either the encoded state $`|\psi `$ or the ancilla state $`|\gamma `$ might cause trouble. A shift by $`u`$ in $`|\psi `$ is transformed to a phase error $`e^{if_u(q)}`$, and a shift by $`u`$ in $`|\gamma `$ infects $`|\psi `$ with a phase error $`e^{if_u(q+a)}`$. Therefore, we should require that position shift errors in both $`|\psi `$ and $`|\gamma `$ satisfy the criterion eq. (203), where $`L`$ is the larger of the two wave packet widths.

When a cubic phase state is prepared by measuring half of an EPR pair, the packet width is of order $`\sigma _p^1`$ and typical position shift errors have $`u\sigma _q`$. However, we must also take into account that either the encoded state or the ancilla must be squeezed as in eq. (197). Suppose that the ancilla is squeezed, by a factor of order $`n^{1/6}w^{1/3}`$; the wave packet is rescaled so that, after squeezing, the width $`L^{}`$ and the typical shifts $`u^{}`$ are given by

$$L^{}\sigma _p^1w^{1/3},u^{}\sigma _qw^{1/3}.$$
(205)
Then the condition $`|u^{}|L^1`$ is satisfied provided that $`\sigma _q\sigma _pw^{2/3}`$. We also require that the rescaled packet has width large compared to 1, or $`\sigma _pw^{1/3}`$.

For the derivation of eq. (193), we used the approximations $`w\sigma _q1`$ and $`w\sigma _p1`$. We also need to check that the remainder terms in the Taylor expansion give rise to a phase error that is acceptably small. This error has the form $`e^{if(q_1)}`$, where $`f(q_1)=O(q_1^5/w^3)`$, corresponding to a momentum shift

$$vf^{}(q_1)\sigma _p^4w^3.$$
(206)
Squeezing amplifies this momentum shift error to $`v^{}vw^{1/3}\sigma _p^4w^{8/3}`$, which will be small compared to 1 provided that $`\sigma _pw^{2/3}`$. To summarize, our implementation of the cubic phase gate works well if the approximate codewords have embedded errors satisfying $`\mathrm{\Delta }\kappa `$, and if widths $`\sigma _q`$ and $`\sigma _p`$ of the approximate EPR state satisfy $`w\sigma _q^1`$ and

$$w^{1/3}\sigma _pw^{2/3}.$$
(207)
Finally, how accurately must we count the photons? An error $`\mathrm{\Delta }n`$ in the photon number results in a phase error $`e^{ivq_1}`$ with $`|v|n^{1/2}\mathrm{\Delta }n`$ in $`\psi _1^{(n)}(q_1)`$, which will be amplified by squeezing to $`|v^{}||v|w^{1/3}n^{1/3}\mathrm{\Delta }n`$. Therefore, the precision of the photon number measurement should satisfy

$$\mathrm{\Delta }nn^{1/3}$$
(208)
to ensure that this error is acceptably small.

### C Purification

Either of the above two methods could be used to implement a nonsymplectic phase transformation that completes the universal gate set. Of course, experimental limitations might make it challenging to execute the gate with very high fidelity. One wonders whether it is possible to refine the method to implement fault-tolerant universal gates of improved fidelity.

In fact, such refinements are possible. We have seen that we can reach beyond the symplectic transformations and achieve universal quantum computation if we have a supply of appropriate “nonsymplectic states” that can’t be created with the symplectic gates. If the nonsymplectic states have the right properties, then we can carry out a purification protocol to distill from our initial supply of noisy nonsymplectic states a smaller number of nonsymplectic states with much better fidelity .

An example of a nonsymplectic state that admits such a purification protocol is a variant of the state originally introduced by Shor , the three-qubit state

$$2^{3/2}\underset{a,b,c\{0,1\}}{}(1)^{abc}|a_1|b_2|c_3;$$
(209)
it can be characterized as the simultaneous eigenstate of three commuting symplectic operators: $`\mathrm{\Lambda }(Z)_{1,2}X_3`$ and its two cyclic permutations, where $`\mathrm{\Lambda }(Z)`$ is the two-qubit conditional phase gate

$$\mathrm{\Lambda }(Z):|a,b(1)^{ab}|a,b$$
(210)
As Shor explained, this nonsymplectic state can be employed to implement the Toffoli gate

$$T:|a,b,c|a,b,cab,$$
(211)
and so provides an alternative way to complete the universal gate set.

To purify our supply of nonsymplectic states, symplectic gates are applied to a pair of nonsymplectic states and then one of the states is measured. Based on the outcome of the measurement, the other state is either kept or discarded. If the initial ensemble of states approximates the nonsymplectic states with adequate fidelity, then as purification proceeds, the fidelity of the remaining ensemble converges rapidly toward one.

The details of the purification protocol will be described elsewhere; here we will only remark that these Shor states can be readily created using symplectic gates and $`\pi /8`$ phase gates. The Shor state is obtained if we apply the transformation

$$\mathrm{\Lambda }^2(Z):|a,b,c(1)^{abc}|a,b,c$$
(212)
to the state

$$H_1H_2H_3|0,0,0=2^{3/2}\underset{a,b,c\{0,1\}}{}|a,b,c.$$
(213)
As shown in Fig. 7, $`\mathrm{\Lambda }^2(Z)`$ can be applied by executing a circuit containing 5 $`S`$ gates, 4 $`S^1`$ gates, and 8 CNOT gates.

Therefore, if we can apply symplectic gates accurately, and are also able to create a supply of $`\pi /8`$ states of reasonable fidelity (or can otherwise implement $`S`$ gates of reasonable fidelity), then we can use the purification protocol to implement Toffoli gates with very good fidelity.

## XII Encoding

Now we have discussed how to execute universal quantum computation fault tolerantly, and how to perform error recovery. But the discussion has all been premised on the assumption that we can prepare encoded states. It is finally time to consider how this can be done. In fact, preparing simultaneous eigenstates of the stabilizer generators $`\mathrm{exp}(2\pi iq/\alpha )`$ and $`\mathrm{exp}(inp\alpha )`$ is a challenging task.

For the $`[[N,k]]`$ stabilizer codes that have been discussed previously, encoding is not intrinsically difficult in that it can be accomplished with Clifford group gates. Acting by conjugation, Clifford group transformations take tensor products of Pauli matrices to tensor products of Pauli operators. In particular, there is a Clifford group transformation that takes the state $`|0^N`$ (the simultaneous eigenstate with eigenvalue one of all $`N`$ single-qubit $`Z`$’s) to the encoded $`|\overline{0}^k`$ (the simultaneous eigenstate with eigenvalue one of $`(Nk)`$ stabilizer generators and $`k`$ encoded $`\overline{Z}`$’s).

Where our codes are different, in both their finite-dimensional and infinite-dimensional incarnations, is that a single qudit or oscillator is required to obey two independent stabilizer conditions – i.e., to be the simultaneous eigenstate of two independent Pauli operators. Hence there is no Clifford group encoder. In the continuous variable case, the problem can be stated in more familiar language: the symplectic transformations take Gaussian (coherent or squeezed) states to Gaussian states. Hence no symplectic transformation can take (say) the oscillator’s ground state to a state in the code subspace.

So encoding requires nonsymplectic operations, and as far as we know it cannot be accomplished by counting photons either – we must resort to a nonlinear coupling between oscillators, such as a $`\chi ^{(3)}`$ coupling. We will describe one possible encoding scheme: First, we prepare a squeezed state, an eigenstate of the momentum with $`p=0`$. This state is already an eigenstate with eigenvalue one of the stabilizer generator $`e^{inp\alpha }`$, but not an eigenstate of $`e^{2\pi iq/\alpha }`$; rather its value of $`q`$ is completely indefinite. To obtain an encoded state, we must project out the component with a definite value of $`q`$ modulo $`\alpha `$.

This can be achieved by coupling the oscillator to another oscillator that serves as a meter, via the perturbation of the Hamiltonian

$$H^{}=\lambda q\left(b^{}b\right),$$
(214)
where $`b`$ is the annihilation operator of the meter.<sup>*</sup><sup>*</sup>*There is an extensive literature on the experimental realization and applications of this kind of coupling; see . This perturbation modifies the frequency of the meter,

$$\mathrm{\Delta }\omega _{\mathrm{meter}}=\lambda q;$$
(215)
then if this coupling is turned on for a time $`t=2\pi /\lambda n\alpha `$, the phase of the meter advances by

$$\mathrm{\Delta }\theta _{\mathrm{meter}}=2\pi q/n\alpha .$$
(216)
By reading out the phase, we can determine the value of $`q`$ modulo $`n\alpha `$, and apply a shift if necessary to obtain the state with $`q0`$ (mod $`n\alpha `$), the known state $`|\overline{0}`$ in the code subspace. (See Fig. 8.)

Of course, in practice the state squeezed in $`p`$ prepared in the first step will be only finitely squeezed, and the measurement of $`q`$ modulo $`n\alpha `$ will have imperfect resolution. If the squeezed state is Gaussian and the measurement has a Gaussian acceptance, then this procedure will produce an approximate codeword of the sort described in §V.

If we are able to prepare “good enough” encoded states, we can distill better ones. The distillation protocol is similar to the error recovery procedure, but where the ancilla used for syndrome measurement may be fairly noisy. We might improve the convergence of the distillation procedure by discarding the data oscillator if the measurement of the ancilla oscillator yields a value of $`q`$ or $`p`$ that is too distant from the values allowed by the code stabilizer.

So far, we have described how to prepare encoded states for the “single-oscillator” codes described in §IV. To prepare an encoded state for one of the $`N`$-oscillator codes described in §VI, we proceed in two steps. First we prepare each of $`N`$ oscillators in a single-oscillator encoded state. Then we apply a symplectic transformation to obtain the encoded state of the $`N`$-oscillator code.

A particular known encoded state of a lattice stabilizer code can itself be regarded as a code with an $`(n=1)`$-dimensional code space. Hence it can be characterized by a self-dual symplectic lattice. For example, the $`\overline{X}=1`$ state of a qunit encoded in a single oscillator is the simultaneous eigenstate with eigenvalue one of the operators $`e^{ip\alpha }`$ and $`e^{2\pi iq/\alpha }`$ – the state associated with the self-dual lattice whose basis vectors are $`p\alpha /\sqrt{2\pi }`$ and $`q\sqrt{2\pi }/\alpha `$.

One encoded state can be transformed to another by symplectic gates if there is a symplectic linear transformation that takes the self-dual lattice associated with the first state to the self-dual lattice associated with the second. In fact, such a symplectic transformation exists for any pair of self-dual lattices.

A linear transformation acting on the $`p`$’s and $`q`$’s modifies the generator matrix $`M`$ of a lattice according to

$$MMS;$$
(217)
this transformation is symplectic if

$$S\omega S^T=\omega ,$$
(218)
where

$$\omega =\left(\begin{array}{cc}0& I\\ I& 0\end{array}\right).$$
(219)
We saw in §VI that we can always choose the generator matrix $`M`$ of a self-dual lattice so that the matrix $`A`$ has the form

$$AM\omega M^T=\omega ;$$
(220)
that is, so that $`M`$ is a symplectic matrix. Therefore, the generator matrices $`M_1`$ and $`M_2`$ of two self-dual lattices can each be chosen to be symplectic; then the linear transformation

$$S=M_1^1M_2$$
(221)
that takes one lattice to the other is also symplectic.

Thus, while the task of preparing the encoded states of the single-oscillator codes can be accomplished only by introducing a nonlinear coupling between oscillators, proceeding from single-oscillator encoded states to many-oscillator encoded states can be achieved with linear optical operations and squeezing.

## XIII Physical fault tolerance?

In a physical setting, making use of the continuous variable quantum error-correcting codes proposed here (or “digital” quantum codes that have been proposed previously) is a daunting challenge. We must continually measure the stabilizer operators (the “error syndrome”) to diagnose the errors; to recover we must apply frequent shifts of the canonical variables that are conditioned on the measurement outcomes. Cold ancilla oscillators must be provided that are steadily consumed by the syndrome measurements. The ancillas must be discarded (or refreshed) to rid the system of excess entropy that has been introduced by the accumulated errors.

An alternative to this complex scheme was suggested in Ref. . Perhaps we can engineer a quantum system whose (degenerate) ground state is the code subspace. Then the natural coupling of the system to its environment will allow the system to relax to the code space, removing errors introduced by quantum and thermal noise, or through the imperfect execution of quantum gates. Such a system, if it could be built, would be a highly stable quantum memory.

Continuous variable coding suggests new approaches to implementing this type of physical fault tolerance. For example, the Hamiltonian

$$H=2\left[\mathrm{cos}p+\mathrm{cos}(2\pi nq)\right]$$
(222)
has an $`n`$-fold degenerate (but nonnormalizable) ground state that is just the code space of a continuous variable code. (The operators $`\mathrm{cos}p`$ and $`\mathrm{cos}2\pi nq`$ commute and can be simultaneously diagonalized.) The low-lying states of a real system whose Hamiltonian is a reasonable approximation to $`H`$ would resemble the approximate codewords described in §V.

One possible way to realize physical fault tolerance is suggested by the codes for an electron in a Landau level, described in §III. The wave functions in the code space are doubly periodic with a unit cell that encloses $`n`$ flux quanta, where $`n`$ is the code’s dimension. If we turn on a tunable periodic potential whose unit cell matches that of the code, then the Landau level is split into $`n`$ energy bands, and the codewords are the states with vanishing Bloch momentum. Therefore, an encoded state could be prepared by turning on the potential, waiting for dissipative effects to cause the electrons to relax to the bottom of the lowest band, and then adiabatically turning off the potential. If dissipative effects cause electrons to relax to the bottom of a band on a time scale that is short compared to spontaneous decay from one band to another, then more general encoded states could be prepared by a similar method. Furthermore, turning on the potential from time to time would remove the accumulated Bloch momentum introduced by errors, allowing the electron to relax back to the code space.

## XIV Concluding comments

We have described codes that protect quantum states encoded in a finite-dimensional subspace of the Hilbert space of a system described by continuous quantum variables. With these codes, continuous variable systems can be used for robust storage and fault-tolerant processing of quantum information.

For example, the coded information could reside in the Hilbert space of a single-particle system described by canonical quantum variables $`q`$ and $`p`$. In practice, these variables might describe the states of a mode of the electromagnetic field in a high-finesse microcavity, or the state of the center of mass motion of an ion in a trap. Or the continuous Hilbert space could be the state space of a rotor described by an angular variable $`\theta `$ and its conjugate angular momentum $`L`$; in practice, these variables might be the phase and charge of a superconducting quantum dot. Our coding scheme can also be applied to a charged particle in a magnetic field.

Our codes are designed to protect against small errors that occur continually – diffusive drifts in the values of the canonical variables. The codes are less effective in protecting against large errors that occur rarely. In some settings, we may desire protection against both kinds of errors. One way to achieve that would be to concatenate our continuous-variable codes with conventional finite-dimensional quantum codes.

When we consider how to manipulate continuous-variable quantum information fault tolerantly, the issues that arise are rather different than in previous discussions of quantum fault tolerance. With continuous variable codes, propagation of error from one oscillator to another is not necessarily a serious problem. More damaging are processes that amplify a small shift of the canonical variables to a large shift. We have described how to implement a universal set of fault-tolerant quantum gates; with these, harmful error amplification can be avoided as the encoded state is processed.

Apart from encouraging the intriguing possibility that continuous quantum variables might prove useful for the construction of robust quantum memories and computers, these new quantum codes also have important theoretical applications. In this paper we have discussed an application to the theory of the quantum capacity of the Gaussian quantum channel. Furthermore, quantum codes can be invoked to investigate the efficacy of quantum cryptographic protocols, even in cases where the protocol makes no direct use of the encoded states . With continuous variable codes, we can demonstrate the security of key distribution protocols based on the transmission of continuous variable quantum information. This application is discussed in a separate paper .

## ACKNOWLEDGMENTS

We gratefully acknowledge helpful discussions with Isaac Chuang, Sumit Daftuar, David DiVincenzo, Andrew Doherty, Steven van Enk, Jim Harrington, Jeff Kimble, Andrew Landahl, Hideo Mabuchi, Harsh Mathur, Gerard Milburn, Michael Nielsen, and Peter Shor. This work has been supported in part by the Department of Energy under Grant No. DE-FG03-92-ER40701, and by the Caltech MURI Center for Quantum Networks under ARO Grant No. DAAD19-00-1-0374. Some of this work was done at the Aspen Center for Physics.