wafer_a_b-2023-3304_vert

// Latest articles

Concept Cats: Designing Better Qubits

  • By Sebastien Jezouin, Chief of Experiments at Alice & Bob

Reading far-reaching theoretical proposals often puts experimentalists in an uncomfortable situation and arouses mixed feelings.

The construction is smart and elegant, and the end result appealing. On the other hand, when we start looking at the experimentally relevant numbers used in the calculations, we are, well, skeptical to say the least.
This is especially the case in quantum error correction.

Still, science is a bit like a minimization algorithm which, after a bunch of small steps, a few big steps, and a lot of time spent stuck exploring around local minima, usually ends up finding a way through.

A wafer being examined for resistance
A wafer being examined for resistance

Our recent theoretical paper, Gouzien et al. 2023 [1], is no exception here.
We demonstrate that, owing to the fact that bit-flip errors are suppressed exponentially at the physical level, the use of Cat Qubits can reduce by a factor of up to sixty the number of physical qubits required to run Shor’s algorithm — famously one of the most difficult tasks for a quantum computer.

On the other hand, to achieve this, we make two strong assumptions on the hardware performance:

  1. There should be at most a single physical bit-flip during the whole duration of the algorithm (8 hours).
  2. The ratio \kappa_2/\kappa_1 should be equal to 10^5, where \kappa_1 is the single-photon dissipation rate and \kappa_2 is the two-photon dissipation rate. The rate \kappa_1 sets the physical phase-flip error rate of the Cat Qubit and the rate \kappa_2 sets the duration of the Cat-Qubit gates used in the repetition code. Hence, \kappa_2/\kappa_1 can be understood as the ratio of the rate at which phase-flip errors can be corrected to the rate at which they occur.

We have just taken two big steps towards satisfying those metrics: in Réglade, Bocquet et al. [2], we increase the bit-flip time of a Cat Qubit by no less than four orders of magnitude compared to state-of-the-art, and in Marquet et al. [3], we increase \kappa_2 by a factor of 10.

Science is a bit like a minimization algorithm which, after a bunch of small steps, a few big steps, and a lot of time spent stuck exploring around local minima, usually ends up finding a way through.

A matter of design

Such big steps are possible because Cat Qubits are still relatively young and far from hitting their ceiling. If you are creative and have a good process for trying out new ideas, explained in detail in this blogpost, there’s still plenty of room for improvement — another reason why it’s exciting to work with Cat Qubits.

TomCat: a new, transmon-free measurement protocol

In Réglade, Bocquet et al. [2], we succeed in increasing the bit-flip time of our Cat Qubits by four orders of magnitude just by rethinking the way they are controlled and measured.

This was previously carried out by adding complex extra circuitry in the form of ancillary transmons, which roughly doubled the necessary hardware resources (footprint, number of instruments and calibrations) and, in fact, even limited the maximum attainable bit-flip times.
In contrast, we have devised here a new measurement scheme that relies solely on the very same circuitry that stabilizes the Cat Qubit.

Thanks to this invention, we demonstrate quantum control of superpositions of states having a bit-flip time of more than 10 seconds – that is a four order of magnitude improvement of the state-of-the-art, and what’s more, it uses only half of the resources traditionally required.

This Is a Great ReadOut!

Figure 1

Figure 1: Circuit design in Réglade, Bocquet et al. It only consists of a superconducting lambda/4 resonator hosting the Cat Qubit mode (blue) coupled to a lossy buffer mode (red). Pairs of photons of the memory are converted to buffer photons by pumping the ATS (white) through two flux lines (yellow). The ATS is also used to control and measure the state of the Cat Qubit. Hence, no transmon is necessary.

AutoCat: resonant stabilization of our Cat

In Marquet et al. [3], we redesign the quantum circuit component stabilizing our Cat Qubits using an autoparametric process (hence its name, AutoCat). This increases \kappa_2 ten-fold and halves the number of DC and AC signals required to control and stabilize the Cat Qubit. It also reduces the power needed to drive the circuit by orders of magnitude, a blessing when it comes to heat budget.
As an important milestone, the measured performances of this new Cat Qubit circuit are on par with the threshold of the phase-flip error correction code.

Figure 2

Figure 2: Circuit design of Marquet et al. Instead of (a) the traditional four-wave mixing element pumped to convert pairs of photons of the memory (green) to buffer photons (blue), a resonant coupling (b) with a three-wave mixing element is realized. Schematics of the circuit and the three-wave mixing element are shown in (c) and a photograph of the chip in (d).

Let me now describe these experiments in more depth…

Cats, bit-flip protection by design

The promise of Cat Qubits is to shorten the path towards fault-tolerant quantum computing (FTQC). This is because bit-flip errors are exponentially suppressed at the physical level, so the error correction code need only tackle the remaining phase flips.

More precisely, the bit-flip time scales exponentially with the number of photons in the Cat Qubit. This scaling allows us to gain orders of magnitude in the bit-flip time by linearly increasing the number of photons. However, previous experimental realizations have seen the scaling saturate at the millisecond timescale.

There were strong hints that this saturation was due to the measurement apparatus (an ancillary transmon qubit). Last year, we did an experiment (Berdou et al. [4]) in which we removed the transmon from the circuit and ran it in a regime where it was expected to be dynamically very stable. And behold! We observed a bit-flip time saturating at more than 100 seconds!

However, this move had a cost: it was no longer possible to measure phase flips and perform quantum gates on the circuit. So it was in effect a classical bit. Still, this work was very important. It demonstrated that the non-linear Josephson element, called the ATS, which we use to engineer the two-photon dissipation that stabilizes the Cat Qubit, is not what causes the bit-flip time to saturate so early.

The real problem is the transmon.

TomCat – Macroscopic bit-flip times

In the work by Réglade, Bocquet et al. [2], we overcome the shortcomings of Berdou et al. [4] by inventing a novel measurement and control protocol without an ancilla transmon:

  1. A Z(pi/2) gate is performed using the dynamical Zeno effect (Touzard et al. [5])

  2. An X(pi/2) gate is performed using the holonomic gate (Albert et al. [6])

  3. The Pauli operator Z is measured using a longitudinal readout (Touzard et al. [7])

The first two steps are based solely on the two-photon dissipation mechanism, so they do not require the use of an ancillary transmon qubit. The first step maps the Pauli operator X to the Pauli operator Y and the second step maps the Pauli operator Y to the Pauli operator Z.

To achieve the third step, we pump a new term of the ATS Hamiltonian to engineer the required longitudinal coupling. This third step is tricky as it involves pumping the ATS at the frequency of the buffer mode without displacing it, so a fine-tuned compensation circuit has to be set up (see the preprint for details). Interestingly, a similar longitudinal coupling Hamiltonian has to be implemented to realize the CNOT gate required for quantum error correction.

Thanks to this great readout, we were able to image quantum superpositions of a Cat Qubit with a bit-flip time exceeding 10 seconds and a phase-flip time longer than 490 ns. This is on par with the results of Berdou et al. [4] in the classical regime and four orders of magnitude better than the state-of-the-art for a Cat Qubit.

Most importantly, we show that the bit-flip time remains above 10 seconds when we apply the microwave drive that realizes the Z-gate. The gate is thus “bias-preserving”, a crucial property behind the fault-tolerant Cat Qubit architecture [10].

Figure 3

Figure 3: (Left) Wigner tomography of quantum superpositions of the Cat Qubit. From top to bottom, the Cat have size 2.5, 5.6 and 11.3 photons. (Center) Z(theta) gates performed on the three Cats of (a). (Right) Bit-flip and phase-flip times as a function of Cat size. Blue (orange) points are acquire in absence (presence) of the Zeno drive.

AutoCat – Less is more

Marquet et al. [3] takes a different approach by redesigning the way the two-photon dissipation is engineered.

In the usual A&B approach, we realize the two-photon dissipation by coupling the Cat Qubit to a buffer mode and pumping a four-wave mixing element, called the ATS, with photons having an energy equal to the difference between the energy of two Cat Qubit photons and the energy of one buffer photon.

For several reasons, this pump is by far the largest microwave signal sent to the chip. There are three main disadvantages:

  1. This large signal generates various harmonics which may reduce the dynamical stability of the quantum system.

  2. All the photons bouncing off the chip are dissipated in a resistive load; this contributes significantly to the heat budget and may increase the temperature seen by the quantum circuit.

  3. A dedicated microwave source has to be used to generate the pump, and it costs money and time to calibrate it.

In Marquet et al. [3], we introduce a three-wave mixing element which allows us to precisely match the energy of two Cat Qubit photons to the energy of one buffer photon. As a consequence, pairs of photons of the memory are converted into one photon of the buffer without the need for any pump.

This is known as an autoparametric process. This circuit thus has a “cleaner” dynamics, is less sensitive to heating, and drastically reduces the number of microwave sources. Furthermore, the three-wave mixing is only a third-order process, hence larger in magnitude than the usual four-wave mixing. In the end, we measure a two-photon dissipation rate \kappa_2/2pi = 2 MHz, which is 2 orders of magnitude greater than the one reported in Lescanne et al. [8] (40 kHz) and one greater than the one reported in Touzard et al. [5].

This result is crucial because the two-photon dissipation rate \kappa_2 stabilizes the Cat Qubit. A large \kappa_2 therefore means that stronger bit-flip noise sources can be countered, which may result in a later saturation of the bit-flip time and better scaling.
It also means that quantum gates can be performed faster without leaking out of the code space.

Both effects were visible in the experiment. The bit-flip time increases up to 0.3 seconds, despite the presence of an ancilla transmon qubit used for the tomography. A Z(pi) gate on a Cat Qubit with 10 photons was performed in only 28 ns with a record fidelity of 96.5%.

It is important to note that the requirements in terms of fidelity to run a repetition code below threshold are much less stringent than those for a surface code. As we will see in the next section, these numbers are very close to reaching the phase-flip threshold.

What does this mean for quantum error correction?

From one to many

As bit flips are suppressed at the physical level, only the remaining phase flips need to be corrected, and this can be done with a simple repetition code.

A quantum error correction cycle of the repetition code consists in preparing the ancilla Cat Qubits in their |+rangle state, applying two CNOT gates in-between each ancilla and its neighboring data Cat Qubits, and measuring X on the ancilla.
Even though a repetition code is in essence a multi-qubit system sensitive to imperfections like cross-talk and leakage which cannot be captured in a single-Cat experiment, it is still possible to estimate upper bounds for its performances, and this is a good way to gain some insight into the limitations of the design.

This is what I shall do below.

Logical bit flip

We have demonstrated that the Z-gate is bias-preserving. Assuming this holds true for the CNOT gate, the logical bit-flip error probability per cycle would simply be

\[p_{bf,L} = d \times (T_{cycle}+T_{CX}) / T_{bf} \approx d \times T_{cycle}/ T_{bf}]

Assuming the shortest possible cycle time T^*_{cycle}=1/\kappa_2 (I will come back later to this assumption) and a typical code distance d^*=20, we get p^*_{bf,L} approx 4times10^{-7} with a Cat size of 11 photons for Réglade, Bocquet et al. [2] and p^*_{bf,L} approx 5times10^{-6} with a Cat size of 20 photons for Marquet et al. [3].

To avoid any confusion, I add an asterisk to the quantities that are just extrapolations of how a repetition code would perform based on the results of our single-Cat experiments. Even though the extrapolated p^*_{bf,L} are very small, they are still orders of magnitude too high for any useful quantum computer. Improving them will be mainly a matter of improving the bit-flip scaling with the number of photons and unlocking the conditions for being able to use more photons.

Phase-flip threshold: the high-level picture

Regarding phase flips, it is usually estimated that a ratio \kappa_2/\kappa_1 of a few hundreds corresponds to a repetition code below threshold [11,12]. We obtain \kappa_2/\kappa_1 = 150 in Marquet et al. [3], and \kappa_2/\kappa_1 \le g_2/\kappa_1 = 80 in Réglade, Bocquet et al. [2] where g_2is the two-photon conversion rate and is used in the formula instead of the two-photon dissipation rate \kappa_2 for technical reasons explained in the preprint. Our results are thus close to the phase-flip threshold.

However, reaching the kind of performance required for useful quantum computation (e.g., \kappa_2/\kappa_1=10^5 in Gouzien et al. [1]) will require an increase of one-to-two orders of magnitude in both 1/\kappa_1 and \kappa_2. This amounts to having a state-of-the-art \kappa_1 and keeping on increasing \kappa_2 as we have been doing over the past few years.

Phase-flip threshold: a closer look

The ratio \kappa_2/\kappa_1 has the advantage of being a simple metric, but there are several assumptions and optimizations under the hood with regard to which our dear theoretician colleagues may have overlooked the experimental complexity. In order to be more accurate, let’s dig a bit deeper into the functioning of the repetition code. It is characterized by two numbers: the probability p_{pf,data} (resp. p_{pf,ancilla}) that a phase-flip error has occurred or propagated on a data (resp. ancilla) qubit during one error correction cycle.

In short, a phase-flip error on the data is what must be corrected, while a phase-flip error on the ancilla is what prevents us from correcting it. Interestingly, it is shown in Le Régent et al. [9] that for a given value of p_{pf,data} (resp. p_{pf,ancilla}), there always exist a threshold value p_{th,ancilla} (resp. p_{th,data}) such that data phase flips can be corrected to arbitrary precision by increasing the code distance d, provided p_{pf,ancilla} \leq p_{th,ancilla} (resp. p_{pf,data} \leq p_{th,data}). This is illustrated in Fig. 4.

Figure 4

Figure 4 Repetition code threshold as a function of data and ancilla phase-flip error probabilities. Courtesy of Le Régent et al. [9]

Assuming there are no process increasing single-photon losses during the various steps of the repetition code, we would have p_{pf,data} \approx \bar{n} \kappa_1 T_{cycle}. Again assuming T^<em>{cycle}=1/\kappa_2, we get p^</em>{pf,data}/\bar{n}=1.5% per photon and 0.7% per photon for, respectively, Réglade, Bocquet et al. [2] and Marquet et al. [3]. With a Cat size of 10 photons (corresponding to macroscopic bit-flip times for Réglade, Bocquet et al. [2]), we deduce from Fig. 4 that p^*_{th,ancilla}\approx3% and 10%, respectively. Importantly, if the threshold is too low to be reached, it is possible to increase its value by reducing the size of the Cat.

This comes at the cost of a higher logical bit-flip probability p_{bf,L}. For instance, with 4 photons, the thresholds reported above would increase to \approx 10 and 25%, respectively. Note that the value of the threshold for the repetition code is quite high compared with that for the surface code. This is due to the fact that the stabilizers of the repetition code are of weight 2, compared to weight 4 in the case of the surface code. This is important, since it makes it possible to reach the threshold with the kind of fidelities of the CNOT gate, state preparation and measurement, that Cat Qubits can attain in the short term (p>1%, for sure).

So, where do things stand at the moment? We can decompose the ancilla phase-flip probability as

[p_{cycle} = p_{P_+} + 2p_{CX} + p_{M_X}]

It is the sum of the phase-flip errors probabilities occurring during ancilla preparation p_{P_+}, CNOT gates p_{CX}, and ancilla measurement p_{M_X}. Let’s start with the CNOT.

From Z-gate to CNOT

The single-Cat Z-gate is very closely related to the CNOT, so its fidelity gives us a first hint of the fidelity of the CNOT. In Marquet et al. [3], we realize a Z(\pi) rotation in 28 ns with an infidelity of p_{Z(\pi)}=3.5% (9.3 photons). In Réglade, Bocquet et al. [2], the Z(\pi) gate is realized in 225 ns with an infidelity of p_{Z(\pi)}=13% (11.3 photons). From a basic theoretical analysis, we can extrapolate the following CNOT phase-flip infidelity based on that of the Z-gate: p^{CX}=(1-(1-2p{Z(\pi)})^{\bar{n}})/2. We get p^{CX}=48% for Réglade, Bocquet et al. [2] and p^*{CX}=25% for Marquet et al. [3].

These numbers exceed by far the total phase-flip error budget previously estimated for Cats with a size of 10 photons: p^*_{th,ancilla}\approx3% and 10%, respectively. However, reducing the size of the Cats to a few photons allows us to get much closer to the error budget at threshold. Unfortunately, the price to pay when reducing the number of photons of the Cat Qubit is to loose macroscopic bit-flip times. To reach threshold and, at the same time have macroscopic bit-flip times will either require to increase further \kappa_2/\kappa_1 and/or improve the bit-flip scaling [13].

State preparation and measurement

State preparation P_{|+\rangle} is based solely on the two-photon dissipation mechanism in both experiments. Therefore, we expect conclusions similar to those drawn by looking just at \kappa_2/\kappa_1. Things are different for state measurement M_X, which depends on the performances of the longitudinal readout (Réglade, Bocquet et al. [3]) or the ancilla transmon (Marquet et al. [2]).

To get straight to the point, the fidelity of the readout is bad in both experiments. Furthermore, the readout is slow, taking several microseconds, so if a repetition code was to be realized with either circuit as-is, T_{cycle} would be much longer than the value of 1/\kappa_2 quoted above. This would have disastrous consequences for the logical bit-flip time, and also for the phase-flip threshold, which would be much lower.

Still, we believe there is room for improvement in both cases and are actively working on it.

Two big steps of a long journey

We have demonstrated these new designs push two key metrics for building a Cat-Qubit-based quantum computer far beyond the state-of-the-art.
TomCat’s design improved the readout of the Cat qubit, while AutoCat design improved the non-linear Josephson element stabilizing it.

This is not the end of our journey, though. We have seen that it will be necessary to further increase \kappa_2/\kappa_1, the bit-flip scaling and the readout fidelity and duration.

Still, these new designs demonstrate that Cat Qubit improvements are not only driven by the quality of the nanofabrication and the microwave pulses, but also by better engineering of the Hamiltonian governing the quantum circuit, where there is still plenty of room for improvement.

We are pretty confident that the drawbacks of the current designs will soon be overcome. Stay tuned!


References

[1] Gouzien E., Ruiz D., Le Régent F.-M., Guillaud J. and Sangouard N., arXiv :2302.06639 (2023) Computing 256-bit Elliptic Curve Logarithm in 9 Hours with 126133 Cat Qubits

[2] Réglade U., Bocquet A., Gautier R., Marquet A., Albertinale E., Pankratova N., Hallén M., Rautschke F., Sellem L.-A., Rouchon P., Sarlette A., Mirrahimi M., Campagne-Ibarcq P., Lescanne R., Jezouin S. and Leghtas Z., arXiv :2307.06617 (2023) Quantum control of a cat-qubit with bit-flip times exceeding ten seconds

[3] Marquet A., Essig A., Cohen J., Cottet N., Murani A., Albertinale E., Dupouy S., Bienfait A., Peronnin T., Jezouin S., Lescanne R. and Huard B., arXiv :2307.06761 (2023) Autoparametric resonance extending the bit-flip time of a cat qubit up to 0.3 s

[4] Berdou C., Murani A., Réglade U., Smith W. C., Villiers M., Palomo J., Rosticher M., Denis A., Morinf P., Delbecq M., Kontos T., Pankratova N., Rautschke F., Peronnin T., Sellem L.-A., Rouchon P., Sarlette A., Mirrahimi M., Campagne-Ibarcq P., Jezouin S., Lescanne R. and Leghtas Z., PRX Quantum 4, 020350 (2022) One hundred second bit-flip time in a two-photon dissipative oscillator

[5] Touzard S., Grimm A., Leghtas Z., Mundhada S.O., Reinhold P., Heeres R., Axline C., Reagor M., Chou K., Blumoff J., Sliwa K.M., Shankar S., Frunzio L., Schoelkopf R.J., Mirrahimi M. and Devoret M.H., Phys. Rev. X 8, 021005 (2018) Coherent oscillations inside a quantum manifold stabilized by dissipation

[6] Albert V.V., Shu C., Krastanov S., Shen C., Liu R.-B., Yang Z.-B., Schoelkopf R.J., Mirrahimi M., Devoret M.H. and Jiang L., Phys. Rev. Lett. 116, 140502 (2016) Holonomic quantum control with continuous variable systems

[7] Touzard S., Kou A., Frattini N.E., Sivak V.V., Puri S., Grimm A., Frunzio L., Shankar S. and Devoret M.H., Phys. Rev. Lett. 122, 080502 (2019) Gated conditional displacement readout of superconducting qubits

[8] Lescanne R., Villiers M., Peronnin T., Sarlette A., Delbecq M., Huard B., Kontos T., Mirrahimi M. and Leghtas Z., Nature Physics 16, 509 (2020) Exponential suppression of bit-flips in a qubit encoded in an oscillator

[9] Le Régent F.-M., Berdou C., Leghtas Z., Guillaud J. and Mirrahimi, M., arXiv :2212.11927 (2022) High-performance repetition cat code using fast noisy operations

[10] Guillaud J. and Mirrahimi M., Phys. Rev. X 9, 041053 (2019) Repetition Cat Qubits for Fault-Tolerant Quantum Computation

[11] Chamberland C., Noh K., Arrangoiz-Arriola P., Campbell E.T., Hann C.T., Iverson J., Putterman H., Bohdanowicz T.C., Flammia S.T., Keller A., Refael G., Preskill J., Jiang L., Safavi-Naeini A.H., Painter O. and Brandao F., PRX Quantum 3, 010329 (2022) Building a fault-tolerant quantum computer using concatenated cat codes

[12] Guilland J. and Mirrahimi M., Phys. Rev. A 103, 042413 (2021) Error Rates and Resource Overheads of Repetition Cat Qubits

[13] Xu Q., Theng G., Wang Y.-X., Zoller P., Clerk A.A. and Jiang L., arXiv:2210.13406 (2022) Autonomous quantum error correction and fault-tolerant quantum computation with squeezed cat qubits

Create the future with us

Cat magnifying glass Alice & Bob