Cat Qubits 101

Introduction

Bosonic “cat qubits” are quantum bits encoded in the states of bosonic oscillators (e.g. modes of a microwave cavity) that resemble Schrödinger’s famous alive/dead cat superposition. Instead of relying on a single two-level quantum element, a cat qubit stores information in two coherent states of a harmonic oscillator and their quantum superposition. This approach is promising for quantum computing because it inherently protects the qubit from certain errors. In particular, cat qubits can suppress bit-flip errors by encoding 0/1 as two “classical-like” oscillator states that are very different (opposite phases) and thus unlikely to be confused by random noise. This means fewer physical qubits may be needed for error correction: increasing the energy (photon number) of the oscillator makes bit-flips exponentially rare, potentially reducing error-correction overhead by up to an order of magnitude.

By contrast, standard superconducting qubits like transmons encode a qubit in the two lowest energy levels of an anharmonic circuit and suffer from both bit-flip and phase-flip errors at similar rates, requiring heavy error correction. Cat qubits take a different route by using bosonic modes with large state spaces, trading hardware complexity for an improved error profile. This bosonic encoding is an increasingly important strategy on the road to scalable, fault-tolerant quantum computers.

How Cat Qubits Work

A cat qubit stores quantum information in a superposition of two coherent states of a resonator, often denoted  $|\alpha\rangle$  and  $|-\alpha\rangle$, which correspond to two opposite-phase oscillation states of the field. These are analogous to two “classical” states (like a pendulum swinging to the right vs. to the left) that a harmonic oscillator can have. The logical qubit states are realized as Schrödinger cat states, for example an “even cat” state proportional to  $|\alpha\rangle + |-\alpha\rangle$  and an “odd cat” state proportional to  $|\alpha\rangle – |-\alpha\rangle$. Intuitively, one can think of these as the “alive + dead” and “alive – dead” superpositions in Schrödinger’s analogy. Because  $|\alpha\rangle$  and  $|-\alpha\rangle$  become more distinguishable as the amplitude $\alpha$ (number of photons) increases, the overlap between the two gets exponentially small (scaling as $e^{-2|\alpha|^2}$). This makes it naturally unlikely for the quantum state to randomly hop from one coherent state to the other, giving cat qubits an inherent resilience to bit-flip errors. In other words, the two logical states reside in well-separated “islands” in the oscillator’s phase space, so a bit-flip (which would correspond to a large jump between those islands) occurs with very low probability.

Crucially, cat qubits convert the dominant physical noise of a cavity (photon loss) into a type of error that is easier to handle. Losing or gaining a single photon from the resonator mostly causes a phase-flip of the cat state (it changes the relative sign between  $|\alpha\rangle$  and  $|-\alpha\rangle$  in the superposition) rather than a bit-flip. Bit-flips correspond to a complete swap of the two coherent-state components – a process that would require a large perturbation or multiple photons lost at once. Thus, by design, cat qubit encodings make phase-flip (Z) errors more common and bit-flip (X) errors exceedingly rare. This bias in error rates can be exploited by error-correcting codes to greatly reduce the overhead of quantum error correction, since one type of error (bit-flips) almost never happens. In essence, the cat qubit behaves like a qubit that almost exclusively suffers phase noise, a more benign situation for building reliable quantum logic.

To implement cat qubits, experimentalists use high-quality microwave resonators or superconducting cavities coupled to nonlinear elements. One approach is to physically encode the cat state in a 3D superconducting microwave cavity, using a standard transmon qubit as an ancilla to actively create, stabilize, and measure the cat state. For example, Yale researchers in 2016 encoded a logical qubit as a superposition of coherent states in a cavity and used a transmon to perform error correction, extending the qubit’s lifetime. Another approach is the Kerr-cat qubit, which uses a single nonlinear oscillator (with a Kerr nonlinearity) and a two-photon drive to autonomously stabilize the system into a cat state. In this scheme, the oscillator itself has a built-in mechanism (via engineered dissipation or drives) that confines it to the two-coherent-state manifold. The cat states are continuously reinforced so that if, say, a photon is lost, the system naturally relaxes back into the nearest logical state rather than hopping to an arbitrary state. By using microwave resonators with quality factors in the millions (photon lifetimes on the order of milliseconds) and careful driving, experiments have created long-lived cat qubits in hardware. In summary, a cat qubit is typically a superconducting resonator mode (acting as a bosonic memory) that is either actively stabilized or periodically corrected to stay in the quantum superposition of two coherent states. This encoding dramatically suppresses bit-flips, at the cost of making phase-flip errors the primary concern.

Comparison with Transmon Qubits

Encoding and Degrees of Freedom: Transmon qubits (the workhorse of many quantum processors) use a single superconducting circuit element as a two-level system – essentially isolating the lowest two energy eigenstates of an anharmonic oscillator. In contrast, a cat qubit uses an entire oscillator’s state space: the logical basis is a pair of coherent states  |\pm \alpha\rangle  in a cavity, which are non-orthogonal but become nearly orthogonal for large photon numbers. This means cat qubits leverage a higher-dimensional Hilbert space (of a bosonic mode) to encode a two-level qubit in a more distributed way. While a transmon’s information is localized in one circuit, a cat qubit’s information is “smeared” between many photons in a mode, giving it distinct error properties.

Error Rates and Noise Channels: A conventional transmon has no built-in bias for error types – it can relax from |1> to |0> (a bit-flip in computational basis) or accumulate random phase between |0> and |1> (phase-flip), with typical coherence times on the order of 50–100 µs for both T1 (energy relaxation) and T2 (dephasing). A cat qubit, however, is engineered to prefer one type of error over the other. Bit-flip errors (which would correspond to the two coherent-state components swapping) are exponentially suppressed by increasing the average photon number in the cat state. Experiments have shown that a cat qubit’s bit-flip lifetime can be 1–2 orders of magnitude longer than a transmon’s: for instance, Amazon Web Services (AWS) reported cat qubits with bit-flip times approaching one second, over 1000× longer than a typical transmon’s lifetime. On the other hand, the cat qubit’s Achilles’ heel is phase-flip errors – slight phase shifts or photon loss events that disturb the relative phase of the superposed coherent states. A cat qubit without additional correction might have phase coherence times in the tens of microseconds (comparable to transmon coherence). In summary, transmons have a balanced error budget (both X and Z errors need active correction), whereas cat qubits offer an imbalanced (biased) error budget – bit-flips are strongly suppressed natively, leaving phase-flips as the dominant error.

Gate Operations: Because transmons are nonlinear two-level circuits, they are directly manipulated with microwave pulses to implement single-qubit rotations and two-qubit gates. The gating of cat qubits is a bit more involved – since the information is in a cavity mode, operations often require an intermediary (like a transmon ancilla) or tailored drives that respect the noise bias. For example, a controlled-NOT between two cat qubits can be implemented via a noise-biased CNOT gate that uses an ancilla transmon to couple the cavity modes. These gates are designed to preserve the cat’s delicate superposition (avoiding inadvertent bit-flips). Research has shown it’s possible to perform a universal set of gates on cat qubits while maintaining the bias – e.g. bias-preserving CNOT and Toffoli gates have been proposed and experimentally tested. However, gate speeds can be slower, and gate design is more complex than for transmons, since one must carefully avoid breaking the protective structure of the cat code. Reading out a transmon is straightforward via microwave dispersive readout; for a cat qubit, readout typically involves measuring a related observable like photon number parity (often using a coupled ancilla to extract that information).

Scalability and Hardware Complexity: Transmon qubits are lithographically fabricated on chips and can be tiled in 2D arrays (as companies like IBM and Google have done, scaling to 50+ qubits in a processor). Each transmon is a single circuit element that can be controlled and coupled to others with on-chip wiring. Bosonic cat qubits historically were realized in large 3D microwave cavities – much bulkier devices, where each qubit is a macroscopic cavity that might only house one logical qubit. This made scaling a challenge, as early demonstrations used one cavity per qubit along with a transmon per cavity. Recent progress is closing this gap: experiments have integrated high-Q resonators on-chip in a 2D architecture (using, for instance, superconducting air-bridge resonators or multi-layer circuits) to host cat qubits. The AWS Ocelot chip in 2025 showcased a prototype of a multi-qubit bosonic processor with five cat qubits fabricated on a silicon substrate. Still, the hardware overhead per cat qubit tends to be larger – each logical qubit can require one storage resonator, one or two buffer resonators, and ancillary transmons for control – whereas a transmon qubit is just one circuit. The trade-off is that cat qubits may require fewer total qubits for error correction in the long run (because of their error suppression), even if each one is more complex internally. In practice, a quantum computer might use a hybrid: transmons (or other nonlinear qubits) to control and connect the cat qubit memories. The best approach is still an open question, but bosonic cat qubits offer a fundamentally different paradigm compared to transmon-based qubits, with distinct advantages in error resilience.

Mathematical Background

Formally, a cat qubit is encoded in a two-dimensional subspace of an infinite-dimensional harmonic oscillator Hilbert space. The simplest code uses two coherent states of opposite phase. Let  $|\alpha\rangle$  represent a coherent state of a mode with complex amplitude $\alpha$ (which can be thought of as a state with an average of $|\alpha|^2$ photons oscillating with a certain phase). Then one can define normalized superposition states:

 $|\mathcal{C}_+\rangle = \frac{1}{\sqrt{2(1+e^{-2|\alpha|^2})}}\big(|\alpha\rangle + |-\alpha\rangle\big)$, 

 $|\mathcal{C}_-\rangle = \frac{1}{\sqrt{2(1-e^{-2|\alpha|^2})}}\big(|\alpha\rangle – |-\alpha\rangle\big)$, 

which serve as the logical basis states of the cat qubit. These are often referred to as “even” and “odd” cat states because they are eigenstates of the photon-number parity operator. In fact,  $|\mathcal{C}+\rangle$  contains only an even number of photons $(parity +1)$ and  $|\mathcal{C}-\rangle$  only an odd number (parity –1). The logical computational states |0⟩L and |1⟩L can be chosen as either the even/odd cats or combinations thereof; one convenient choice is  $|0_L\rangle = |\mathcal{C}+\rangle$  and  $|1_L\rangle = |\mathcal{C}-\rangle$. In the limit of large $|\alpha|$, these two states approach the pure coherent states  $|\alpha\rangle$  and  $|-\alpha\rangle$  (which are nearly orthogonal for big $\alpha$). At finite photon numbers, they are non-orthogonal but still distinguishable, and their overlap is  $\langle \mathcal{C}+ | \mathcal{C}- \rangle = 0$  by construction (the states are orthogonal). The overlap of the underlying coherent states is  $\langle \alpha | -\alpha \rangle = e^{-2|\alpha|^2}$, which quantifies how well-separated the classical states are in phase space. For a modest amplitude $\alpha=2$, this overlap is already extremely small $(~3.4×10^(-4))$, indicating the two components of the cat are almost orthogonal. This is the mathematical origin of the cat qubit’s exponential bit-flip protection: an error that swaps  $|\alpha\rangle$  with  $|-\alpha\rangle$  would require overcoming this tiny overlap or a series of unlikely dissipative events.

From the perspective of error channels: in a cat qubit, a single photon loss (the dominant noise in a bosonic mode) causes a transition  $|\mathcal{C}+\rangle \leftrightarrow |\mathcal{C}-\rangle$. This manifests as a phase-flip error on the logical qubit (since it flips the eigenvalue of the parity, effectively applying a Pauli Z in the logical basis). However, a single photon loss does not take the system out of the logical codespace – it maps an even cat to an odd cat or vice versa, which is still a valid logical state. This error can be detected and corrected by checking the photon parity (one can perform a parity measurement to see if an error occurred). A bit-flip in logical terms would mean the even cat state somehow morphed into a different even cat state that is orthogonal to it (or similarly for odd), which in this code requires a non-local error event (like two photon losses or a large phase-space displacement). The probability of such an event can be made arbitrarily small as |\alpha| grows. In essence, the cat code converts single-photon-loss errors into tractable phase flips, and pushes true bit flips to higher order noise processes.

Using the stabilizer formalism, one can describe the cat qubit with a stabilizer (parity operator)  $\mathcal{P} = e^{i\pi a^\dagger a}$  that has $\mathcal{P}|\mathcal{C}+\rangle = +|\mathcal{C}+\rangle$ and $\mathcal{P}|\mathcal{C}-\rangle = -|\mathcal{C}-\rangle$. This $\mathcal{P}$ acts like a logical Z operator (${Z_L}$) for the qubit, distinguishing the two code states by eigenvalue. A single-photon loss flips the photon number parity and anticommutes with $\mathcal{P}$, so it is a detectable error (parity flip). Meanwhile, the logical X operator (${X_L}$) can be realized by a unitary that swaps $|\alpha\rangle$ and $|-\alpha\rangle$ (for instance, a $-\alpha$ displacement followed by a $+\alpha$ displacement, or an effective tunneling between the two quasi-stable points). In practice, error correction on cat qubits often involves monitoring the parity. If an unexpected parity change is observed, one knows a photon loss (phase flip) occurred and can apply a corrective operation (or track the error in software). Multiple cat qubits can be concatenated with a simple code (like a repetition code) to correct these phase flips (see next section), since bit-flips are so rare that they can be neglected at first order. This is how cat qubits fit into a larger error-correction scheme: they supply a bias where $Z$ errors are frequent but $X$ errors are exponentially suppressed, and then an outer code corrects the $Z$ errors, leading to a fully protected logical qubit.

First Academic Paper on Cat Qubits

The concept of encoding quantum information in Schrödinger-cat states has its roots in quantum optics research dating back to the 1990s. For example, in 2002 Jeong and Kim proposed using coherent state superpositions for quantum computing in optical systems. However, the idea of a bosonic cat qubit as a practical element of a superconducting quantum computer was first clearly formulated in the early 2010s. The breakthrough paper is often credited to Zaki Leghtas and collaborators in 2013, titled “Hardware-efficient autonomous quantum error correction”. Published in Physical Review Letters in 2013, this paper proposed encoding a logical qubit in “a multi-component superposition of coherent states in a harmonic oscillator, more specifically a cavity mode.” The authors detailed how a single superconducting ancilla (a nonlinear qubit like a transmon) could be used to encode, protect, and correct a logical cat qubit in a cavity. This was the first concrete design for a cat qubit in a circuit QED architecture, addressing how to perform encoding, error detection, and correction all in hardware. The main contribution of Leghtas et al. was showing that one could stabilize a logical qubit against energy relaxation (photon loss) by using engineered coupling between a cavity and a transmon, effectively autonomously correcting errors as they occurred. This idea of a “hardware-efficient” quantum memory was revolutionary because it promised to extend qubit lifetimes without the huge overhead of a many-qubit error-correcting code.

The 2013 Leghtas paper set the stage for experimental demonstrations. It was soon followed by a 2014 paper by Mirrahimi et al. describing how to manipulate cat qubits for universal quantum computing (introducing the idea of bias-preserving gates). In 2016, the Yale team (Ofek et al.) reported the first experimental realization of a logical qubit encoded in cat states, achieving an extension of the qubit lifetime by actively correcting errors in a cavity. That experiment proved the validity of the cat qubit concept by showing, for the first time, quantum error correction that outlasted the natural decoherence – a milestone result. Since then, the cat qubit proposal from 2013 has influenced a large body of research in quantum error correction and bosonic codes, spawning further theoretical proposals and hardware implementations. It introduced the notion that qubits could be oscillators rather than just two-level atoms, and that intelligent encoding in those oscillators could yield huge gains in error robustness. This insight has had a profound impact on quantum computing research, inspiring both university groups and industry efforts (as we’ll see next) to pursue bosonic qubits as an alternative route to scaling up quantum processors.

Challenges and Future Prospects

Cat qubits represent a promising leap forward, but several challenges remain on the path to large-scale, fault-tolerant quantum computing with this approach. One major challenge is scaling up the correction of phase-flip errors. By design, cat qubits largely solve the bit-flip problem, but they still experience phase-flip errors (dephasing or photon loss) at rates similar to or somewhat better than regular qubits. To reach the very low logical error rates needed for useful algorithms, one must concatenate the cat qubits with an outer error-correcting code (like a repetition code or surface code) to handle those phase flips. However, going to large codes will require many cat qubits and many ancilla qubits for syndrome measurements. Ensuring that such a system remains error-biased (i.e. the operations to detect/correct errors don’t introduce new bit-flip errors) is an active area of research. Scientists are working on bias-preserving logic gates that allow complex operations on cat qubits without leaking out of the protected subspace. For example, a CNOT gate between two cat qubits should ideally not cause any of the cats to bit-flip; implementations using transmon mediators have to be carefully tuned to preserve the noise bias. Developing a whole library of bias-preserving gates (single- and multi-qubit) is a key step toward universal quantum computing with cat qubits.

Another challenge is hardware complexity and stability. Cat qubits demand high-Q resonators and nonlinear couplers (for stabilization or for operations). The hardware is more complex than a simple transmon circuit, and with many elements (resonators, couplers, ancillas) per logical qubit, the system could be more susceptible to crosstalk, leakage, or fabrication variability. The drive power needed to stabilize cat states (in the Kerr-cat approach) must be carefully managed – too strong a drive can heat the system or cause additional noise. Recent solutions like on-chip filters have shown it’s possible to stabilize cats without excess heating, but integrating many such systems while maintaining isolation is non-trivial. Moreover, while cat qubits can in theory use relatively small photon numbers (e.g. 2–4 photons) to get good protection, increasing the cat size further for even better protection eventually encounters diminishing returns due to other noise sources (e.g. two-photon loss, which can start to matter at higher photon number). Tuning the system to have just the right photon number for optimal bias is an ongoing engineering task.

From a software and architecture perspective, a question arises: how to best incorporate cat qubits into a quantum computer’s design? One vision is to use them as building blocks for highly efficient quantum error correction – for example, a surface code where each “physical qubit” is actually a cat qubit might reach error correction thresholds with far fewer components than a surface code on bare transmons. Simulations and theoretical studies suggest that concatenating a bias-preserving code (like a repetition code) with a two-dimensional code can yield ultra-low logical error rates without an astronomical number of qubits. The challenge is to actually implement those multi-layer codes in hardware and control them in real time. This will require advances in classical feedback systems and calibration techniques to keep dozens or hundreds of resonators and ancillas tuned up simultaneously. Ensuring that the error bias remains strong as the system size grows is crucial – if too much stray coupling occurs, the noise could become symmetric again, erasing the cat qubit’s advantage.

Looking forward, researchers are exploring variations of cat codes to overcome some challenges. Examples include squeezed cat qubits (which use squeezed coherent states to potentially reduce phase-flip rates) and two-mode cat codes (where entangled cat states in two cavities might provide additional error protection). Others are combining cat qubits with error-biased decoders and tailored error-correction protocols to maximize the benefit of the bias. There’s also interest in connecting cat qubits with other hardware modalities: for instance, cat qubits storing quantum information and transmons performing fast gates, or cat qubits used as memories in a network while spin qubits or transmons act as processors. In the broader landscape of quantum error correction, bosonic qubits like the cat code and its cousins (e.g. binomial codes and GKP codes) form an important category. They illustrate a general principle: by using more complex physical states to encode a qubit, one can shift the burden of error correction from needing hundreds of qubits to, in part, the physics of a single oscillator. This is a very appealing idea for quantum engineers and is likely to remain a hot research topic.

In summary, bosonic cat qubits offer a path to more efficient quantum computing hardware by suppressing one of the two fundamental error types at the physical level. They have moved from theory to proof-of-concept demonstrations in the last decade, and now to multi-qubit prototypes in industry labs. Challenges such as correcting the remaining errors, scaling up the hardware, and performing universal operations without losing the noise bias are active research problems. If these are solved, cat qubits could become a cornerstone of fault-tolerant quantum machines. As cat qubit research continues, we will see how this approach integrates with other quantum computing advances, potentially accelerating the timeline toward large-scale, reliable quantum computers.