# Macroscopically distinct quantum superposition states as a bosonic code for amplitude damping

## I Introduction

In quantum information theory logical states are encoded as two orthogonal pure states. The simplest example is provided by a single two level system. The ground state $`|g`$ and excited state $`|e`$ can then encode logical $`0`$ and logical $`1`$ respectively. The ability to form a coherent superposition of logical states is why we refer to logical states as qubits rather than simply as bits.

Quantum computation gains its power through the potential ability to unitarily manipulate a coherent superposition of large collections of physical systems each encoding a single qubit. There is no fundamental reason to restrict oneself to physical systems with two dimensional Hilbert spaces for the encoding. It may be more natural in some contexts to encode logical states as a superposition over a large number of basis states. When the system supporting the qubit encoding is coupled to a perturbing environment an extra unwanted, and possibly uncontrollable, unitary interaction is introduced which can appear as an error in the encoded information. The coupling to the logical basis determines the type of logical error. While the coupling to the environment is fixed, we are free to choose how we encode the qubits, hence the choice of basis for the logical encoding may change the kind of error introduced. For example, with a single qubit, a bit flip in one logical encoding basis can appear as a phase flip in another. This is relevant, as some kinds of errors are easier to fix than others. Chuang and Yamamoto recently introduced a qubit coding for two bosonic modes.

These modes could be two optical modes or two vibrational modes of a single trapped ion. A particularly difficult source of error for bosonic modes arises from exponential decay of the energy. In a single mode, for example, one could use the ground state and first excited state as the logical basis. While the ground state is invariant under decay, the first excited state will ‘reset’ to the ground state in a single decay event. Such an error can in general be corrected by a five qubit code. However the code of Chuang and Yamamoto enables a more efficient error correction.

In this paper we give an example of how a careful choice of the coding scheme can make a difficult error correction task simpler. Our example is based on a quantum code for a single bosonic mode that enables amplitude damping or amplification to be corrected as a bit flip error. The code is based on quantum superpositions of bosonic coherent states, the so called ‘cat states’. Our coding scheme is not exact for very small amplitude coherent states, but improves exponentially when amplitudes are greater than unity. We demonstrate a completely unitary, adiabatic method to generate the cat states of our coding scheme.

## II Cat state encoding for amplitude damping

Let $`|\alpha `$ be a coherent state for a single bosonic degree of freedom. We then define two orthogonal states as symmetric and anti-symmetric superposition of coherent states by

$`|S`$ $`=`$ $`𝒩_+\left(|\alpha +|\alpha \right)`$ (2)   
$`|A`$ $`=`$ $`𝒩_{}\left(|\alpha |\alpha \right)`$ (3)   
where $`\alpha `$ is an arbitrary complex number. The normalisation constants are given by

$$𝒩_\pm =\left(2\pm 2e^{2|\alpha |^2}\right)^{1/2}$$
(4)   
It is easy to verify that the symmetric cat state, $`|S`$ contains only the even energy eigenstates, while the anti-symmetric cat state $`|A`$ contains only the odd energy eigenstates. This feature is independent of $`\alpha `$. The two states are orthogonal and we are led to the following logical encoding for a single qubit,

$`|0_L`$ $`=`$ $`|S`$ (6)   
$`|1_L`$ $`=`$ $`|A`$ (7)   
Under free dynamics, the coherent state evolves as $`|\alpha (0)e^{i\omega t}`$, however the two cat states remain orthogonal and thus the logical encoding of the qubit is invariant under free dynamics. Therefore we can transform to the interaction picture rotating at frequency $`\omega `$.

The amplitude damping model is the standard one for a bosonic mode, of frequency $`\omega `$, weakly coupled to a zero temperature heat bath in the Born and Markov approximation. The system obeys the following master equation in the interaction picture

$$\frac{d\rho }{dt}=\frac{\gamma }{2}(2a\rho a^{}a^{}a\rho \rho a^{}a)$$
(8)   
The solution to this equation may be written as

$$\rho (t)=\underset{k=0}{\overset{\mathrm{}}{}}\mathrm{{\rm Y}}_k(t)\rho (0)\mathrm{{\rm Y}}_k^{}(t)$$
(9)   
with

$$\mathrm{{\rm Y}}_k(t)=\underset{n=k}{\overset{\mathrm{}}{}}\sqrt{\left(\genfrac{}{}{0pt}{}{n}{k}\right)}(\eta (t))^{(nk)/2}(1\eta (t))^{k/2}|nkn|$$
(10)   
and $`\eta (t)=e^{\gamma t}`$ is the probability that the state is undecayed up to time $`t`$.

Our objective is to correct for at most one decay event over some characteristic time. In which case we only need to consider the two terms corresponding to $`\mathrm{{\rm Y}}_0`$ and $`\mathrm{{\rm Y}}_1`$. Coherent states remain coherent under amplitude damping, and in particular we have that,

$`\mathrm{{\rm Y}}_0|\alpha `$ $`=`$ $`e^{(1\eta )|\alpha |^2/2}|\sqrt{\eta }\alpha `$ (12)   
$`\mathrm{{\rm Y}}_1|\alpha `$ $`=`$ $`\alpha \sqrt{\eta }e^{(1\eta )|\alpha |^2/2}|\sqrt{\eta }\alpha .`$ (13)   
It is then easy to see that a single decay event will cause an even cat state to flip to an odd cat state and vice versa. It is this feature that we are attempting to exploit through our code states, so that a single decay event will correspond to a bit flip. A no decay event essentially leaves the state unchanged. These statements are strictly only true for cats with an infinitely large coherent amplitude, however we now show that only small amplitudes are sufficient for practical purposes.

An error correction code must satisfy the following conditions

$`_Lp|\mathrm{{\rm Y}}_k^{}\mathrm{{\rm Y}}_l|q_L`$ $`=`$ $`0\text{for }pq\text{ or }kl`$ (15)   
$`_Lp|\mathrm{{\rm Y}}_k^{}\mathrm{{\rm Y}}_k|p_L`$ $`=`$ $`P_k\text{for }p=0,1`$ (16)   
where $`p,q`$ are $`0`$ or $`1`$, and $`P_k`$ is a constant that depends only on $`k`$. The first equation requires that all erroneous states are orthogonal and the second requires the probability for each event (no decay or one decay) to occur to be independent of the logical state. It is easy to see that the cat state encoding satisfies the first condition. The second condition however requires more careful consideration. Using the conditional states given above we find that

$`{\displaystyle \frac{_L0|\mathrm{{\rm Y}}_0^{}\mathrm{{\rm Y}}_0|0_L}{_L1|\mathrm{{\rm Y}}_0^{}\mathrm{{\rm Y}}_0|1_L}}`$ $`=`$ $`{\displaystyle \frac{1+e^{2\eta \alpha ^2}}{1e^{2\eta \alpha ^2}}}`$ (18)   
$`{\displaystyle \frac{_L0|\mathrm{{\rm Y}}_1^{}\mathrm{{\rm Y}}_1|0_L}{_L1|\mathrm{{\rm Y}}_1^{}\mathrm{{\rm Y}}_1|1_L}}`$ $`=`$ $`{\displaystyle \frac{1e^{2\eta \alpha ^2}}{1+e^{2\eta \alpha ^2}}}.`$ (19)   
Each of these ratios should ideally be unity, but the departure from ideality is insignificant even for such a small value as $`\alpha =3`$. For example, with $`\eta =0.9`$ we find (18) gives 1.00149 for $`\alpha =2`$ but for $`\alpha =3`$ it gives 1.000000184. While (19) gives 0.9985079 for $`\alpha =2`$ and 0.999999815 for $`\alpha =3`$. If we increase the amplitude to $`\alpha =5`$ the departure from ideality is undetectable. Therefore the logical qubits are encoded in a manner that enables amplitude decay to be corrected to any desired degree of precision.

We can see that after many spontaneous emission events the amplitude will eventually decay away to zero. If the coherent amplitude is too small then the ratios (18) and (19) will deviate significantly from unity. It is therefore necessary to have a sufficient initial amplitude to allow computation for a reasonable amount of time and to know when it is prudent to reset the states.

It is possible to determine the time scale over which the states will be useful by considering the ratio (18). This ratio should not be significantly different from 1 for the encoding to work, so we allow the difference to be no greater than a small tolerance. The term responsible for any deviation of the ratio is $`\mathrm{exp}(2\eta \alpha ^2)`$ which we desire to be small enough such that the ratio is within tolerance. This implies that $`\eta \alpha ^2`$ has to be greater than some limiting value determined by the tolerance, below which the state must be reset. Therefore, given a certain error rate, initial coherent amplitude and desired tolerance we have sufficient information to calculate the time available for computation before reset.

## III Logical operations on cat states

A logical encoding is useless if we cannot implement one and two qubit operations on the encoded states. We now show how this can be done for the cat state encoding defined above. The particular form of qubit operations depends upon the particular physical realisation of the bosonic mode. For the purposes of illustration we simply postulate particular bosonic interactions to achieve the required gate operations. We will show that the Hadamard transform may be implemented by simple displacement of a single bosonic mode, while the two qubit operation may be realised by a mutual phase shift interaction term which commutes with the number operator of each bosonic mode.

If the bosonic mode is subject to a classical driving force the Hamiltonian describing this process in the interaction picture is

$$H_D=\mathrm{}(\beta a^{}+\beta ^{}a)$$
(20)   
where $`\beta `$ is the complex amplitude of the driving force. Let us now choose $`\beta `$ as real (in general we choose $`\beta `$ to be $`\pi /2`$ out of phase with $`\alpha `$).

For a given cat state amplitude we can choose the driving amplitude such that

$$\theta =\alpha \beta t$$
(21)   
where $`t`$ is the length of time the driving force is applied.

If the even cat state (encoding $`|0_L`$) is driven we find that

$$e^{iH_Dt/\mathrm{}}|0_L=\mathrm{cos}\theta |0_Li\mathrm{sin}\theta |1_L$$
(22)   
A displacement of this kind shifts the “cat” very slightly by an amount $`\beta `$ in a direction orthogonal to the orientation of the cat state in phase space. The transformation is approximately equivalent to a Hadamard transform of the single logical qubit when $`\theta =\pi /4`$ (in the limit of large $`\alpha `$ and small $`\beta `$) and will suffice as a universal one-qubit gate. We will refer to this as a H-gate.

The simplest way to realise a two qubit universal gate is via the two mode interaction Hamiltonian

$$H_P=\mathrm{}\chi a^{}ab^{}b$$
(23)   
where $`a,b`$ represent the mode amplitude operators for the two bosonic modes of interest. We choose the interaction time $`t`$ such that $`\chi t=\pi `$. As the $`|0_L`$ only has even bosonic number while $`|1_L`$ only has odd bosonic number, we find that the interaction leaves the states, $`|0_{La}|0_{Lb},|0_{La}|1_{Lb},|1_{La}|0_{Lb}`$ unchanged, but the state in which both modes encode a $`|1_L`$ transforms as

$$e^{i\pi a^{}ab^{}b}|1_{La}|1_{Lb}=|1_{La}|1_{Lb}$$
(24)   
This kind of conditional phase shift operation suffices for a universal two qubit gate. We will refer to this as a P-gate.

Using the one and two qubit gates described above, we can construct a controlled-not (CN) gate. Let mode $`a`$ code the control bit and mode $`b`$ code the target bit. A CN gate is then made by applying a H-gate to the target, then coupling the target and the control by a P-gate and finally applying another H-gate to the target.

We have shown that simple one mode and two mode transformations may be used to construct universal computational gates for a cat state logical encoding of bosonic systems. Amplitude damping appears as a simple bit-flip error in this encoding and thus a three qubit code can be used to correct it. This leads to relatively simple fault tolerant implementations of the gate operations described above using three coupled bosonic modes.

## IV Unitary construction of cat state encoding

The cat state encoding described in this paper will be of little use if we cannot encode our logical bits by unitary transformations. Unfortunately all previous schemes to generate cat states are based on an entanglement between a bosonic mode and a two level atom and require a measurement readout. The cat state produced is conditional on the two, mutually exclusive, results of this measurement, and we are equally likely to get an even cat as an odd cat. This method of encoding would randomly assign logical bits and is of little practical use. We now describe a unitary, although adiabatic, method to generate the two kinds of cat state used to encode the qubits.

Consider the Hamiltonian,

$$H_{NL}=\mathrm{}\chi (a^{})^2a^2$$
(25)   
which could describe a Kerr nonlinearity for an optical bosonic mode or the self-interaction of a single trapped ion driven at the carrier frequency, in which case $`\chi `$ is proportional to the fourth power of the Lamb-Dicke parameter. The Hamiltonian in (25) has two degenerate ground states which are the ground state, $`|0`$ and first excited state, $`|1`$ of a single bosonic mode. In both cases the eigenvalue is zero, however each of these ground states is distinguished by the parity operator, where $`|0`$ is even and $`|1`$ is odd. If we now consider the Hamiltonian

$$H_C=H_{NL}\mathrm{}\kappa (a^2+(a^{})^2)$$
(26)   
with $`\kappa 0`$. Noting that the cat states $`|0_L,|1_L`$ are eigenstates of $`a^2`$, it is easy to see that these same states are degenerate eigenstates of $`H_C`$ when $`\alpha =\sqrt{\kappa /\chi }`$ and the eigenvalue is $`\mathrm{}\kappa ^2/\chi `$. While the cat states are degenerate eigenstates of $`H_C`$ they are distinguished by their parity. The adiabatic theorem now enables us to predict that the even or odd initial eigenstates of $`H_{NL}`$, $`|0,|1`$, will evolve respectively into the even or odd eigenstates, $`|0_L,|1_L`$ of $`H_C`$ as we slowly turn on $`\kappa `$ from zero to a final target value. Thus we have a unitary method to code either a logical zero or logical one as a cat state by choosing to start from a bosonic ground state or a bosonic first excited state.

The adiabatic theorem is exact only in the case of infinite slowness, which is of little use for logical encoding in quantum computation, so what matters is how well we can do in practise. To test this we consider two different ways to vary $`\kappa `$ in time; linear and nonlinear.

The linear variation considered here consists of simply increasing $`\kappa `$ according to $`\kappa =t`$. The function $`\kappa =k_0\mathrm{tanh}^2(\lambda t)`$ was used in the nonlinear case due to the advantageous shape of the $`\mathrm{tanh}^2`$ function.

Figure 1 illustrates the fidelity versus time variation of the state $`|\psi `$ starting from the $`|1`$ Fock state with respect to the equivalent cat state of mean photon number $`\alpha =\sqrt{\kappa /\chi }`$. The fidelity is measured as the modulus squared of the dot product of the evolving state with the cat state. The notable features of Figure 1 are the fidelity oscillations, the “steady-state” fidelity and the relative characteristics of the linear and nonlinear methods of varying $`\kappa `$.

The fidelity oscillations result from carrying out the adiabatic evolution faster than as required for exactness by the adiabatic theorem. As the system evolves from $`t=0`$ the fidelity will tend away from unity as the state $`|\psi `$ evolves away from the relevant cat state. Continued evolution eventually causes $`|\psi `$ to more closely resemble the equivalent cat state with the fidelity increasing accordingly. The retreat and approach of the evolving state with respect to the cat state causes the oscillations seen in Figure 1.

The oscillations are damped by $`\kappa `$ until a “steady state” is reached with constant fidelity. The “steady state” fidelity is determined by how quickly $`\kappa `$ is increased from $`t=0`$; a slower initial increase implies a greater final fidelity. Hence there are two effects occurring with $`\kappa `$: as $`\kappa `$ increases, oscillations in fidelity are suppressed, and the faster $`\kappa `$ is increased initially, the lower the steady state fidelity of $`|\psi `$.

For this adiabatic process to be useful we have two aims; a steady state in a reasonable amount of time, and a state $`|\psi `$ as close as possible to the desired final state. For linear $`\kappa `$ these are complementary, although for nonlinear $`\kappa `$ we can choose a function which can achieve both aims, hence the use of the $`\mathrm{tanh}^2`$ function (s-curve). The s-curve has the properties that it starts slowly, thus giving a high final fidelity, and later damps the system very quickly to give a useful final state in a reasonable amount of time. If the variables $`k_0`$ and $`\lambda `$ are chosen carefully then it is possible to obtain a fidelity of almost unity in a usefully short time.

We thus conclude that the unitary logical encoding in terms of cat states may be performed with almost arbitrary accuracy using this adiabatic method.

## V Discussion and Conclusion

We have shown that the even and odd cats states may be used as a robust qubit encoding for a single bosonic mode subject to amplitude damping. A single decay event will then appear as a simple bit flip error. We have also shown how the states may be prepared unitarily and how one qubit and two qubit universal quantum gates may be realised. We now turn to an assessment of how practical the scheme is for present technology. To be specific we will consider the case in which the bosonic mode is the centre-of-mass vibrational state of a single trapped ion. Cat states have been produced in these systems using a conditional measurement scheme.

Given a cat state it is straightforward to protect it against decay using two additional qubits. These could be the electronic states of two ions in the trap. The error correction circuit for a bit flip is well known and is given in Figure 2. To implement the gate we need to implement a CN gate between the vibrational state and the electronic states of the two ions. Following de Matos Filho and Vogel we consider an ion trapped at an antinode of an optical standing wave tuned to the atomic frequency; the carrier frequency. In an interaction picture at frequency $`\nu `$ the interaction Hamiltonian is,

$$H_I=\mathrm{}\mathrm{\Omega }\eta ^2a^{}a\sigma _x+\mathrm{}\frac{\mathrm{\Omega }\eta ^4}{4}(a^{})^2a^2\sigma _x$$
(27)   
where $`\mathrm{\Omega }`$ is the Rabi frequency and $`\eta `$ is the Lamb-Dicke parameter. The first term in this expression suffices to build a CN gate between the cat state and the electronic state. If we choose the interaction time appropriately we can apply the transformation

$$U=\mathrm{exp}(i\pi a^{}a\sigma _x)$$
(28)   
When this acts on an even cat state it corresponds to the identity on the electronic system. When it acts on an odd cat state it corresponds to a $`\pi `$ pulse in the electronic system. If we code our electronic qubits as $`|g_1|0_i`$ and $`|e_1|1_i`$. The unitary interaction in (28) will effect a CN gate with the bosonic mode acting as the control and the electronic mode acting as the target. Thus joint excitation on the carrier frequency of the two ion system will produce the double CN gate in the first part of Figure 2. The final double CN gate in which the vibrational mode becomes the target can easily be produced with the same Hamiltonian with H-gates either side. This procedure would enable a cat state, once produced, to be protected from single decay events.

###### Acknowledgements.

GJM would like to thank the Benasque Centre for Physics for support of the visit at which this paper was written. PTC acknowledges the financial support of the Centre for Laser Science and the University of Queensland Postgraduate Research Scholarship.