Bosonic Qubits

A bosonic qubit stores a finite-dimensional logical system in the Hilbert space of one or more harmonic-oscillator modes. The mode may be a microwave cavity field, an optical field, trapped-ion motion, an acoustic resonance, or another approximately bosonic degree of freedom. Its many levels supply redundancy inside each mode: photon loss, gain, dephasing, or small phase-space displacements can move a state into a distinguishable error sector without immediately revealing the logical information.

That compact statement can be misleading in two opposite directions. One oscillator can replace many two-level data carriers at the encoding layer, but a working bosonic module is not one passive resonator. It commonly needs a nonlinear ancilla, pumps, couplers, a readout channel, reset or engineered dissipation, and real-time control. Conversely, the ancillary system need not be more coherent than the storage mode if the control protocol detects, confines, or prevents propagation of its faults.

The right comparison is therefore not “one cavity versus one qubit.” It is a logical task performed by a complete module, with all modes, ancillas, control cycles, energy, latency, calibration, and accepted failures counted.

Purpose and Canonical Scope

This page owns the hardware and architecture layer for oscillator-encoded qubits. It develops:

• the physical contents of a bosonic module;
• the hardware consequences of cat, binomial, grid, and multimode encodings;
• preparation, universal control, readout, and syndrome extraction;
• active feedback, autonomous stabilization, and hybrid schemes;
• oscillator, ancilla, pump, leakage, and correlated-noise mechanisms;
• fair memory and logical-operation benchmarks;
• the evidence boundary between protected memories and fault-tolerant processors.

Bits, Qubits, Qudits, and Modes owns the carrier taxonomy. Number States and Coherent States in Phase Space own the oscillator mathematics. Bosonic Codes owns the common channel–code–recovery formalism and exact Knill–Laflamme tests. Cat Codes owns coherent-component conventions, loss-sector algebra, stabilization, recovery, and bias-preserving logical operations. Binomial Codes owns the finite-superposition construction, moment proof, modular syndromes, and code-specific recovery. GKP Codes owns grid-state conventions, finite-energy codewords, modular decoding, logical operations, and threshold analyses. This article uses representative formulas only to expose hardware requirements.

Bosonic and Encoded Computation Models owns the abstract induced-operation model that maps a declared oscillator encoding and complete physical program to a logical channel with leakage, rejection, recovery, frames, verification, and resources. This article retains hardware modules, controls, readout, noise, calibration, scaling, and dated evidence.

Bosonic qubits are also distinct from continuous-variable computation. A bosonic qubit selects a finite logical subspace or subsystem of an infinite-dimensional carrier. A continuous-variable processor may instead treat quadratures as the computational variables throughout. The same optical or microwave mode can support either use, but the state preparation, error model, gates, and benchmarks are not interchangeable. Continuous-Variable Platforms owns that hardware boundary, including Gaussian mode graphs, non-Gaussian injection, sampling workloads, and adaptive quadrature processing.

The Architecture Contract

Write a bosonic module as

$$\mathcal A_{\rm bos} = \left( \mathcal M_{\rm data}, \mathcal M_{\rm aux}, \mathcal Q_{\rm nl}, \mathcal C, \mathcal R, \mathcal D \right).$$

Here $\mathcal M_{\rm data}$ is the set of storage modes, $\mathcal M_{\rm aux}$ contains buffer and readout modes, $\mathcal Q_{\rm nl}$ contains nonlinear ancillas, $\mathcal C$ is the available control algebra, $\mathcal R$ specifies reset and engineered reservoirs, and $\mathcal D$ is the decoder or feedback policy. A credible architecture statement should also identify:

1. the logical encoding and finite-energy envelope;
2. the dominant physical error set and correction interval;
3. the preparation and destructive or nondestructive readout maps;
4. the native one- and two-logical-qubit operations;
5. how ancilla faults are detected or prevented from spreading;
6. the external code, if bosonic modes are concatenated;
7. all components, ports, pumps, and cryogenic or optical resources;
8. the reference used for break-even and the workload used for comparison.

Two experiments using “GKP qubits” may implement different finite-energy states, syndrome circuits, ancillas, feedback policies, and references. They are not the same architecture merely because the ideal code has the same name.

A bosonic logical qubit occupies an oscillator code space, but the operational module includes nonlinear control, entropy removal, measurement, feedback, and often inter-mode couplers. A resource count that reports only the storage mode omits the components most likely to set the logical error and scaling cost.

From an Oscillator to a Protected Carrier

The ideal mode and its useful imperfections

An ideal mode has Hamiltonian

$$H_0 = \hbar\omega \left( a^\dagger a+\frac{1}{2} \right), \qquad [a,a^\dagger]=1.$$

Its equally spaced spectrum is excellent for long-lived storage and poor for selective control: a resonant linear drive addresses every neighboring Fock transition at the same frequency. Bosonic hardware therefore combines two seemingly incompatible ingredients:

• a storage mode made as harmonic and isolated as possible;
• a controllable nonlinearity that distinguishes states or conditions operations on the oscillator.

In circuit QED, a dispersively coupled transmon can provide an effective Hamiltonian of the form

$$\begin{aligned} \frac{H}{\hbar} ={}& \omega_c a^\dagger a +\frac{\omega_q}{2}\sigma_z \\ &-\chi a^\dagger a\,|e\rangle\langle e| \\ &-\frac{K}{2}a^{\dagger 2}a^2+\cdots . \end{aligned}$$

The dispersive shift $\chi$ makes the ancilla transition number selective. The inherited self-Kerr $K$ can be useful for control, but it also shears phase-space states during idle periods. Higher-order terms, drive-induced shifts, and ancilla-state dependence matter once a state spans many number levels.

The architectural problem is to turn the nonlinearity on where useful without letting the nonlinear element spoil the storage mode continuously.

The dominant Markovian ledger

A common reduced model is

$$\begin{aligned} \dot\rho={}&-\frac{i}{\hbar}[H,\rho] +\kappa_\downarrow\mathcal D[a]\rho +\kappa_\uparrow\mathcal D[a^\dagger]\rho \\ &+\kappa_\phi\mathcal D[a^\dagger a]\rho +\sum_j\gamma_j\mathcal D[L_j^{\rm anc}]\rho , \end{aligned}$$

with

$$\mathcal D[L]\rho = L\rho L^\dagger -\frac{1}{2} \left\{ L^\dagger L,\rho \right\}.$$

The rates describe oscillator loss, thermal gain, oscillator dephasing, and ancilla faults. This model is a starting point, not a complete device description. Pump-induced heating, quasiparticle bursts, telegraph switching, mode collisions, correlated ancilla–cavity dephasing, reset transients, and slow parameter drift can violate its stationary and Markovian assumptions.

For a Fock state $|n\rangle$, the initial probability per unit time of a single loss is $n\kappa_\downarrow$. Increasing the mean occupation can make logical states more distinguishable while exposing them to more loss. Every finite-energy bosonic code negotiates that tradeoff.

The code condition is an operational target

Let $P$ project onto the logical code space and let $\{E_\mu\}$ be the errors to be corrected during one cycle. Exact correction requires the Knill–Laflamme conditions

$$P E_\mu^\dagger E_\nu P = c_{\mu\nu}P.$$

For oscillator loss over a short interval, the leading error set is often

$$E_0 \simeq I-\frac{\kappa_\downarrow\Delta t}{2}a^\dagger a, \qquad E_1 \simeq \sqrt{\kappa_\downarrow\Delta t}\,a.$$

The no-jump term matters: codewords with different mean photon number acquire logical information even when no photon is detected. A code that maps $a|\psi_L\rangle$ into an orthogonal error sector but ignores unequal $\langle a^\dagger a\rangle$ is not exactly correcting amplitude damping.

Real hardware satisfies the conditions only approximately and only for a declared error set. The residual logical channel includes uncorrectable multiple events, imperfect syndrome extraction, recovery error, and deformation of the finite-energy code manifold.

Encoding Families and Their Hardware Consequences

Fock and dual-rail encodings

The simplest single-mode encoding selects two number states, such as $|0_L\rangle=|0\rangle$ and $|1_L\rangle=|1\rangle$. It is a qubit in an oscillator but not, by itself, an error-correcting code. Loss maps the excited logical state to the ground logical state and is not distinguishable without learning logical information.

A two-mode dual-rail encoding,

$$|0_L\rangle=|1,0\rangle, \qquad |1_L\rangle=|0,1\rangle,$$

turns a single photon loss into the orthogonal vacuum state $|0,0\rangle$. It is therefore naturally error detecting. Passive beam-splitter interactions implement logical rotations, and total number can be a syndrome. The cost is a second mode, mode matching, and a mechanism to replace a lost excitation without revealing which rail held it.

Cat and rotation-symmetric encodings

A coherent state satisfies $a|\alpha\rangle=\alpha|\alpha\rangle$. Even and odd cat states are

$$|C_\alpha^\pm\rangle = \mathcal N_\pm \left( |\alpha\rangle\pm|-\alpha\rangle \right),$$

where

$$\mathcal N_\pm = \left[ 2\left(1\pm e^{-2|\alpha|^2}\right) \right]^{-1/2}.$$

They occupy opposite photon-number parity sectors, and one loss flips parity:

$$a|C_\alpha^\pm\rangle \propto |C_\alpha^\mp\rangle.$$

Larger rotation-symmetric codes use several coherent components around a circle in phase space. Their discrete rotational symmetry turns loss modulo a chosen integer into a syndrome. The same symmetry can make selected logical operations simple.

There are two related but different hardware idioms:

1. A cat code uses superpositions of coherent components and actively tracks or corrects loss events.
2. A stabilized cat qubit engineers two-photon drive and dissipation, or a Kerr potential, so two separated coherent states form a protected dynamical manifold.

In the stabilized-qubit convention, increasing $|\alpha|^2$ can suppress transitions between the two coherent basins approximately exponentially while phase-flip exposure grows roughly with photon number. This creates a strong noise bias rather than protection from every error. Gates, measurement, pump noise, and leakage must preserve that bias if an outer repetition code is to exploit it.

Binomial encodings

Binomial codes use finite superpositions of Fock states. A lowest-order single-loss code is

$$|0_L\rangle = \frac{|0\rangle+|4\rangle}{\sqrt 2}, \qquad |1_L\rangle=|2\rangle.$$

Both codewords have mean photon number two. One loss moves the code from even to odd parity without resolving the logical amplitudes. Binomial Codes derives that correction condition, its finite-time limitations, and the higher-order loss, gain, and dephasing family.

The hardware price is number-selective control over a deliberately broad Fock manifold. State preparation and recovery require calibrated nonlinear operations, while ancilla faults during a long number-selective pulse can imprint uncontrolled phases on the storage mode.

Gottesman–Kitaev–Preskill grid encodings

For dimensionless quadratures

$$\begin{gathered} q=\frac{a+a^\dagger}{\sqrt 2}, \qquad p=\frac{a-a^\dagger}{i\sqrt 2}, \\ [q,p]=i, \end{gathered}$$

the ideal square-lattice GKP qubit is stabilized by

$$S_q=e^{i2\sqrt{\pi}q}, \qquad S_p=e^{-i2\sqrt{\pi}p}.$$

The ideal states are infinite combs and are not normalizable. Laboratory states replace each peak by a finite-width packet and impose a finite-energy envelope. Small displacements in $q$ and $p$ shift the syndrome continuously; a decoder rounds the inferred displacement to a lattice cell while retaining the analog measurement value when useful.

Grid encodings are attractive because Gaussian displacements, rotations, squeezing, and beam-splitter interactions can implement important logical operations, and because common loss noise can be represented as a Gaussian attenuation channel plus displacement noise after amplification. Their hardware burden lies in producing high-quality non-Gaussian grid states, measuring both stabilizers repeatedly, controlling finite-energy deformation, and preventing ancilla faults from becoming large unheralded displacements.

“GKP squeezing” must specify a convention. Peak width, envelope width, mean energy, and an effective noise variance are related only after a state model is chosen. A single decibel number does not define the logical channel.

Multimode and concatenated encodings

One mode is not a sacred boundary. Logical information can be spread across two or more oscillators to make loss erasures easier to identify, add confidence information, simplify syndrome structure, or reduce sensitivity to one ancilla fault. A bosonic inner code can also be concatenated with an outer qubit code:

$$\begin{gathered} \text{oscillator physics} \\ \downarrow \\ \text{bosonic logical qubit} \\ \downarrow \\ \text{outer-code logical qubit} \end{gathered}$$

Stabilized cat qubits concatenated with a repetition code are one example. GKP qubits concatenated with a surface code are a prominent theoretical architecture. The outer decoder should use the inner decoder’s analog or erasure information when available; hard-decision syndromes can discard a substantial part of the bosonic advantage.

Multimode proposals can reduce the number of nonlinear ancillas per logical qubit through frequency multiplexing. They can also create mode crowding, correlated control errors, larger calibration graphs, and common-mode loss. “One logical qubit per cavity” is not a complete resource statement when one cavity contains many modes and shares nonlinear control hardware.

No family wins without a noise model

Encoding idiom	Main structure	Natural syndrome	Hardware opportunity	Characteristic cost
Dual rail	one excitation in two modes	total-number loss erasure	passive linear control	two matched modes and reloading
Cat or rotation symmetric	separated coherent components	number modulo a rotation order	biased noise and autonomous confinement	pumps, phase stability, and bias-preserving gates
Binomial	finite Fock superpositions	parity or generalized number residue	tailored correction with finite support	number-selective nonlinear control
GKP grid	lattice in quadrature phase space	modular quadratures	analog syndromes and Gaussian logical operations	finite-energy grid preparation and precise displacements
Multimode or concatenated	code across modes or code layers	joint checks plus inner confidence	lower outer-code overhead in favorable regimes	couplers, correlated faults, and a larger decoder

The table is a design map, not a ranking. The relevant question is which code, module, and recovery minimize task-level logical error under the measured noise and complete resource budget.

Physical Implementations

Superconducting microwave resonators

The most complete bosonic-QEC experiments use high-quality microwave storage modes coupled to Josephson nonlinearities. Storage can reside in a three-dimensional cavity, a coaxial resonator, or a planar resonator. Transmons, fluxonia, superconducting nonlinear asymmetric inductive elements, and pumped couplers can provide number selectivity, conditional displacements, conversion, and engineered multiphoton processes.

This division of labor is powerful:

• the cavity can have a much longer energy lifetime than the ancilla;
• the ancilla supplies preparation, gates, parity or modular measurement;
• a readout resonator converts the ancilla state into a classical record;
• a reset channel removes entropy between rounds;
• buffer modes and pumps stabilize a desired cat or grid manifold;
• tunable couplers connect storage modes while suppressing idle interaction.

It also creates the central circuit-QED failure mode: the long-lived cavity inherits noise from the short-lived nonlinear controller. Ancilla thermal occupation shifts the cavity frequency; ancilla relaxation during a dispersive interaction can leave an unknown cavity phase; strong drives can activate higher levels and spurious modes. Better bare cavity lifetime alone does not guarantee better logical lifetime.

Trapped-ion motion

A trapped ion’s quantized motion is a mechanical oscillator, while internal electronic states provide an ancilla. State-dependent optical forces generate conditional displacements, and optical pumping resets the spin. Grid states and dissipative error-correction maps have been demonstrated in this setting.

The platform offers precise spin–motion control and a clean oscillator model, but motional heating, frequency drift, anharmonicity, spectator modes, laser noise, and the need to couple several logical modes constrain scaling. The motion often serves as a shared gate bus in ion processors; using it as persistent logical storage changes scheduling and cooling requirements.

Optical modes

Optical bosonic encodings can propagate through room-temperature channels and support deterministic Gaussian transformations with beam splitters, phase shifters, squeezers, homodyne detection, and feed-forward. Their main error is loss. Cat and grid resources can convert optical continuous-variable hardware into finite logical carriers, and temporal or frequency multiplexing can create many modes in one spatial path.

The severe bottleneck is deterministic, scalable preparation of high-quality non-Gaussian resource states. Finite squeezing, source impurity, detector inefficiency, mode mismatch, and switching loss all enter the effective logical displacement channel. A state reconstructed only after heralding is not a deterministic logical source; its success probability and multiplexing cost belong in the clock-rate ledger.

Photonic Qubits owns discrete flying-qubit architectures, while Quantum Optics Frontiers tracks dated optical grid-state and cluster-state evidence.

Acoustic, mechanical, and hybrid modes

Bulk-acoustic, surface-acoustic, nanomechanical, and magnonic modes offer long lifetimes, compact wavelengths, or coupling to otherwise incompatible systems. A superconducting ancilla can prepare and measure nonclassical mechanical states; a spin can use motion for control or transduction.

These are promising oscillator carriers, but a nonclassical state or coherent swap is not yet a bosonic logical module. A QEC architecture additionally needs repeated nondemolition syndrome extraction, reset, logical readout, fault handling, and a benchmark against the best physical storage option. Thermal occupation is especially consequential because a mode at frequency $\omega$ and temperature $T$ has

$$\bar n_{\rm th} = \frac{1}{e^{\hbar\omega/(k_{\rm B}T)}-1}.$$

Low-frequency mechanical modes can require deep refrigeration, sideband cooling, or both before gain errors are rare enough for the intended code.

Preparation, Control, and Readout

Gaussian controls are necessary but not always sufficient

A resonant linear drive implements a displacement

$$D(\alpha) = e^{\alpha a^\dagger-\alpha^*a}.$$

Frequency conversion implements beam-splitter interactions, while parametric driving can generate squeezing and two-mode squeezing. These Gaussian operations are fast and structurally simple. They cannot by themselves prepare arbitrary non-Gaussian cat, Fock-superposition, or grid resources from vacuum.

The missing ingredient is nonlinearity or measurement. Circuit-QED modules use number-selective ancilla rotations, selective number-dependent arbitrary phase operations, echoed conditional displacements, optimal control, and measurement-based feedback. Optical platforms use photon counting, non-Gaussian ancilla states, conditional preparation, or nonlinear light–matter interfaces.

Preparation fidelity should be separated from logical survival. A protocol can prepare a state with high conditional fidelity but low success probability, or it can reach a stable manifold reliably while the logical phase remains poorly controlled.

Ancilla-mediated control is a fault path

Suppose the dispersive interaction is

$$H_{\rm disp} = -\hbar\chi a^\dagger a\,|e\rangle\langle e|.$$

If an ancilla relaxes at an unknown time $t_j$ during a gate, the cavity acquires a random number-dependent phase

$$U_j = e^{i\chi t_j a^\dagger a}.$$

For codewords spanning many Fock states, this can be more damaging than the ancilla’s own bit flip. Four design strategies recur:

1. detect the ancilla fault and reject or decode it as an erasure;
2. shape the interaction so the propagated error is correctable;
3. use error-transparent Hamiltonians whose action agrees in code and error sectors;
4. reduce ancilla participation through autonomous or direct bosonic interactions.

Fault-tolerant control is a property of the complete noisy operation, not of the ideal logical unitary.

Syndrome extraction is a quantum instrument

Parity, modular quadrature, or a joint multimode stabilizer must be measured without resolving the logical state. One round is a quantum instrument

$$\mathcal I_s(\rho) = M_s\rho M_s^\dagger, \qquad p(s)=\operatorname{Tr}\mathcal I_s(\rho),$$

where $s$ is the analog or digitized outcome. A useful report characterizes:

• the assignment matrix for the syndrome;
• measurement-induced dephasing within the logical subspace;
• leakage and ancilla-reset errors;
• correlations between successive rounds;
• latency from measurement to recovery;
• whether the decoder retains analog confidence.

Repeated high-fidelity ancilla readout does not imply a quantum-nondemolition logical measurement. The backaction channel must be measured on logical states.

Readout can be destructive or logical

Oscillator tomography often measures displaced parity,

$$\begin{aligned} W(\alpha) &= \frac{2}{\pi} \operatorname{Tr} \left[ \rho\,\Pi(\alpha) \right], \\ \Pi(\alpha) &= D(\alpha)\Pi D(-\alpha), \\ \Pi &= e^{i\pi a^\dagger a}. \end{aligned}$$

This reconstructs the Wigner function but is too expensive for routine processor readout. Operational schemes instead map a logical Pauli or modular observable to an ancilla, release the field into a detector, or decode the oscillator into a two-level system. Reported readout fidelity should state whether it includes decoding, heralding, leakage classification, and state preparation.

Active, Autonomous, and Hybrid Protection

An active correction cycle

An active round has four stages:

$$\begin{gathered} \text{interact} \longrightarrow \text{measure syndrome} \\ \downarrow \\ \text{decode} \longrightarrow \text{recover or update frame} \end{gathered}$$

The cycle time $t_{\rm cyc}$ must be short compared with accumulation of uncorrectable errors, yet making it too short can increase ancilla-induced error, readout load, and reset overhead. If a simplified per-cycle model has uncorrectable storage probability $A t_{\rm cyc}^2$ and correction overhead $B$, the logical error rate per unit time is

$$\Gamma_L(t_{\rm cyc}) \simeq A t_{\rm cyc} +\frac{B}{t_{\rm cyc}}.$$

Its optimum is

$$t_{\rm cyc}^{\star} = \sqrt{\frac{B}{A}}, \qquad \Gamma_L^\star=2\sqrt{AB}.$$

The formula is schematic, but the engineering lesson is real: maximum syndrome frequency is not automatically optimal.

Autonomous correction and confinement

Autonomous schemes engineer a reservoir whose steady manifold is the desired code or whose jumps repair a selected error. A target master equation might contain

$$\dot\rho \supset \kappa_2 \mathcal D[a^2-\alpha^2]\rho ,$$

which confines the oscillator near coherent amplitudes $\pm\alpha$. Additional engineered processes can restore parity or pump finite-energy grid states.

Autonomous protection removes measurement and digital-feedback latency, but it does not remove control hardware. Pumps, lossy buffer modes, filters, and reservoir calibration become part of the correction apparatus. The engineered dissipation must remove entropy faster than harmful errors while avoiding logical dephasing, heating, and undesired steady states.

Hybrid protection is often the practical architecture

Real modules can stabilize a manifold continuously, measure occasional syndromes, track likely errors in software, and concatenate modes with an outer code. For example:

• two-photon dissipation suppresses cat bit flips;
• an outer repetition code corrects remaining phase flips;
• ancilla outcomes flag dangerous control faults;
• a decoder combines flags with parity history.

The distinction between active and autonomous is therefore not binary. Architectures should state which entropy is removed by engineered physics, which information reaches a classical controller, and which residual channel the outer code sees.

Noise and Leakage Ledger

Photon or phonon loss

For a zero-temperature amplitude-damping channel with transmissivity $\eta=e^{-\kappa t}$, a number state evolves through

$$\begin{aligned} \mathcal E_\eta \left( |n\rangle\langle n| \right) &= \sum_{\ell=0}^{n} p_\ell |n-\ell\rangle\langle n-\ell|, \\ p_\ell &= \binom{n}{\ell} \eta^{n-\ell} (1-\eta)^\ell . \end{aligned}$$

Codes can identify low-order loss number $\ell$, but the probability of two or more losses grows with occupation and correction interval. Loss also shrinks coherent amplitudes and blurs finite-energy grids.

Thermal gain

Residual thermal population adds $a^\dagger$ jumps. A code optimized only for loss may not correct gain with the same distance. Thermal photons in an ancilla or readout mode can be equally damaging because dispersive coupling converts their occupation into storage-mode dephasing.

Dephasing and frequency noise

Oscillator frequency fluctuations couple through $a^\dagger a$. They rotate phase-space states and apply number-dependent phases to Fock superpositions. The same noise can act very differently on different codes: cat states separate primarily in phase, binomial states span selected number levels, and GKP peaks shear under rotation.

A Ramsey-derived $T_2$ is not enough when noise is nonstationary or when control pumps change the spectrum. Logical characterization should include idle, driven, and correction-cycle conditions.

Kerr and deterministic deformation

Self-Kerr evolution

$$U_K(t) = e^{iKt\,a^{\dagger 2}a^2/2}$$

is coherent rather than stochastic. It can be tracked or echoed if stable. Uncertainty in $K$, ancilla-state-dependent Kerr, and drive-induced nonlinear terms turn it into logical error. Calling all deformation “decoherence” hides a potentially calibratable mechanism.

Ancilla relaxation, dephasing, and leakage

Ancilla faults can propagate through dispersive or conditional operations. Leakage into higher ancilla levels changes dispersive shifts and can survive reset designed for a two-level model. A useful module reports ancilla temperature, $T_1$, $T_2$, leakage, reset error, and the storage channel conditioned on each detected ancilla event.

Pump and mode errors

Parametric pumps can heat chips, create quasiparticles, mix unwanted modes, or amplify phase noise. Multimode cavities introduce spectral crowding and cross-Kerr couplings. Filters and lossy buffers create extra fabrication and packaging constraints. Correction performance measured with one module does not establish that many pumped modules can operate simultaneously.

Metrics That Survive Comparison

A logical channel, not one lifetime

A logical memory maps an input state through encoding, storage and correction, then decoding. Its effective channel $\mathcal E_L(t)$ can be summarized by entanglement fidelity, average fidelity, Pauli error rates, or worst-axis survival. One exponential lifetime is meaningful only if the state ensemble, fit model, SPAM treatment, and logical observable are declared.

For a qubit channel, the average fidelity and entanglement fidelity obey

$$F_{\rm avg} = \frac{2F_e+1}{3},$$

provided both refer to the same trace-preserving logical channel. Postselected survival data define a conditional channel and must include the acceptance probability separately.

Break-even requires a named denominator

A common memory gain is

$$G = \frac{\tau_L}{\tau_{\rm ref}}.$$

Possible references include the storage mode’s best two-level subspace, the bare ancilla, the best physical qubit in the module, or the best unencoded memory available in the architecture. These denominators answer different questions. The comparison should match:

• input-state ensemble and error metric;
• total elapsed time and duty cycle;
• encoding and decoding;
• active control and accepted runs;
• hardware available to the reference;
• uncertainty and drift interval.

Crossing memory break-even establishes a useful logical memory under that contract. It does not establish fault-tolerant state preparation, gates, measurement, or scaling.

Per-round error needs a time and a circuit

An error probability per correction round can fall while the round duration grows. Reports should provide both $p_L$ per round and $\Gamma_L$ per unit time, the number and type of ancilla interactions, and the decoder. In concatenated experiments, logical improvement with distance is the key scaling evidence; one low-error distance is not a threshold demonstration.

Count every physical resource

At minimum, report

$$\mathcal R_{\rm module} = \left( N_d,N_a,N_q,N_c,N_p,N_r \right)$$

per simultaneously active logical qubit or per outer-code block. Here the entries count data modes, auxiliary modes, nonlinear ancillas, couplers, pump tones, and readout chains, respectively. Also report control bandwidth, decoder latency, cooling load, module yield, calibration time, and concurrency. Bosonic hardware may still win this complete comparison, but the result cannot be inferred from data-mode count alone.

Evidence Through August 2026

The following claims are deliberately ordered from component evidence to architecture evidence.

Encoding and universal single-mode control are established

Nonclassical cavity states, coherent-state superpositions, Fock-state superpositions, displaced-parity tomography, number-selective phase gates, and universal oscillator control have been demonstrated in circuit QED. Trapped-ion motion has supported modular quadrature measurements, grid-state encoding, and spin-mediated control. These results establish that an oscillator’s large Hilbert space is controllable; they do not by themselves establish that control lowers a logical error rate.

Repeated correction has worked for several code families

In 2016, a cat-code memory used repeated parity tracking and real-time feedback to reach a $320\ \mu{\rm s}$ process lifetime. That was about $1.1$ times the lifetime of the best physical reference in the device and about $2.2$ times the uncorrected encoding. It was a genuine unconditional memory break-even result, not a scalable threshold demonstration.

In 2019, a binomial-code experiment combined repeated correction with encoding, decoding, and a universal single-logical-qubit gate set. Correction extended the lifetime by a factor of $2.8$ relative to the uncorrected encoding and approached, but did not exceed, the best physical-component reference used in that work.

In 2020, a superconducting-cavity GKP experiment prepared square and hexagonal grid states and repeatedly corrected both quadratures without postselection. In 2022, a trapped-ion motional experiment implemented a dissipative map for finite-energy square and hexagonal GKP states and extended logical coherence by more than a factor of three relative to the uncorrected logical states.

These experiments established repeated, state-preserving syndrome extraction across distinct physical platforms. “Correction helps” and “correction beats the best physical memory” remain different claims.

Beyond-break-even GKP memories are established

In 2023, a superconducting GKP memory combined an oscillator, transmon, echoed conditional displacements, reset, and a reinforcement-learned control policy. Its reported average coherence gain over the best physical qubit in the device was

$$G=2.27\pm0.07.$$

The logical Pauli lifetimes were anisotropic, so the comparison used an average fidelity-decay rate rather than selecting the longest axis. A separate 2023 photon-number-encoded experiment exceeded its declared break-even reference by about $16\%$. These are strong logical-memory results under their stated ensembles and hardware; neither supplies a fault-tolerant two-logical-qubit gate.

In 2024, autonomous GKP correction was demonstrated with unconditional ancilla reset and engineered dissipation. This showed that digital measurement-based feedback is not the only route to a stabilized grid manifold. The relevant comparison still includes the reset channel, pumps, and finite-energy steady-state deformation.

Biased cat qubits now preserve selected errors exceptionally well

Driven-dissipative cat experiments have measured an exponential reduction of bit flips with increasing coherent-state separation while phase-flip exposure grows. In 2024, protected cat control reached bit-flip times exceeding $10\ {\rm s}$ while the measured phase-flip time was greater than $490\ {\rm ns}$. The striking ratio is a noise bias, not a ten-second arbitrary-state coherence time.

In 2025, a planar superconducting device concatenated five stabilized cat data qubits with a repetition code. The outer code corrected phase flips below its measured threshold, and the inner cats retained physical bit-flip suppression during a noise-biased controlled operation. The best average logical error per cycle was

$$p_L(d=5)=1.65\%\pm0.03\%,$$

compared with an average $1.75\%\pm0.02\%$ for two distance-three subsections. The experiment established expected phase-error scaling and a hardware-realized concatenation strategy. Because the total optimum error did not unambiguously fall from distance three to distance five, it should not be summarized as arbitrary-error suppression with increasing distance.

Higher-dimensional GKP memories have crossed break-even

In 2025, one superconducting oscillator hosted error-corrected GKP logical systems of dimensions three and four. Their reported gains over the best physical qutrit and ququart references were

$$G_3=1.82\pm0.03, \qquad G_4=1.87\pm0.03.$$

This establishes that bosonic redundancy can protect more than one logical qubit dimension. It does not mean that one oscillator supplied two independently addressable error-corrected qubits, and Hilbert-space dimension alone is not a processor throughput metric.

Logical operations are advancing but not yet a protected processor

Error-transparent phase gates and ancilla-fault-corrected cavity gates have shown that logical control can outperform a naive implementation under selected faults. A 2024 two-cavity experiment integrated erasure detection with dual-rail logical measurement. These are essential ingredients for fault-tolerant modules, but error detection, postselection, and active correction have different throughput and reliability contracts.

In 2025, a trapped-ion experiment implemented deterministic single-logical- qubit gates, a non-Clifford logical gate, a two-GKP-qubit controlled-$Z$ operation, and direct logical Bell-state preparation in two motional modes. The measured average controlled-$Z$ gate fidelity was $0.73(1)$, with motional dephasing dominant. This established a universal logical gate set for finite-energy GKP states; the operations were not simultaneously protected by repeated QEC and were not a fault-tolerant universal processor.

Integrated optical generation of GKP states was also reported in 2025. It is an important source result, while an optical fault-tolerant architecture still needs end-to-end loss accounting, multiplexing, correction, and logical operations.

The remaining systems claim is still open

As of 10 August 2026, the peer-reviewed experimental record does not yet combine all of the following in one bosonic architecture:

1. beyond-break-even storage against a matched physical reference;
2. fault-tolerant preparation and repeated syndrome extraction;
3. an error-corrected universal logical gate set;
4. improving total logical error as code resources increase;
5. many simultaneously operated modules with measured yield and crosstalk;
6. a complete resource advantage at fixed algorithmic accuracy.

Multimode grid and rotation-symmetric codes, bias-preserving gates, optical resources, and concatenated bosonic–qubit codes are active research programs. Non-peer-reviewed technical reports can guide what to test next, but they should not be assigned the same evidence status as an independently described, peer-reviewed logical benchmark.

Advantages and Bottlenecks

Architectural advantages

• Large local Hilbert space: redundancy can live inside one mode instead of requiring a separate data carrier for every inner-code degree of freedom.
• Favorable storage hierarchy: a high-quality oscillator can outlive the nonlinear ancilla that controls it.
• Noise tailoring: rotation symmetry, grid translation symmetry, and dual-rail number checks can convert dominant faults into detectable syndromes or strongly biased channels.
• Analog information: GKP and multimode measurements can return confidence values rather than only hard syndrome bits.
• Engineered protection: pumps and dissipation can remove selected entropy continuously, reducing digital-feedback latency.
• Native multimode operations: displacements, beam splitters, conversion, and squeezing can be fast and structurally simple in suitable hardware.

Central bottlenecks

• Nonlinearity without contamination: every useful ancilla or pump can shorten storage coherence, induce Kerr, or propagate faults.
• Preparation overhead: finite-energy non-Gaussian states are costly to create deterministically and repeatedly.
• Fault-tolerant gates: memory protection must survive logical operations, measurement, reset, and inter-module coupling.
• Mode and pump scaling: spectral crowding, common-mode noise, heating, and calibration grow with concurrent modules.
• Fair resource accounting: compact data encoding can hide buffers, couplers, readout chains, classical control, and outer-code overhead.
• Manufacturing and packaging: three-dimensional cavities provide excellent lifetimes but are not automatically dense; planar devices are denser but can expose storage modes to additional interfaces and loss.
• Verification: finite-energy envelopes, analog decoders, postselection, and anisotropic logical channels make one-number comparisons fragile.

Worked Claim Audit: “One Cavity Is One Error-Corrected Qubit”

Suppose a device announcement states:

Each multimode cavity contains one logical qubit, so the architecture needs no QEC overhead.

The claim mixes an encoding ratio with a system-resource claim. Audit it in five steps.

1. Identify the logical object

Ask whether the qubit is a code subspace, a stabilized subsystem, a postselected state, or a decoded logical channel. State preparation alone is not ongoing error correction.

2. Expand the module boundary

Count storage modes, nonlinear ancillas, buffers, readout resonators, couplers, pumps, detector chains, and classical decoder resources. A multimode cavity can contain several independently addressable modes while still requiring many control components.

3. Name the corrected error set

Determine whether the experiment corrects loss, gain, dephasing, small displacements, ancilla faults, or only a subset. Check the finite-energy envelope and the probability of leakage beyond the decoder’s model.

4. Inspect the benchmark

Require an unconditional logical channel, accepted-run probability, uncertainty, and a matched physical reference. If errors are converted to erasures, both the conditional error and erasure rate belong in the result.

5. Ask for scaling

Look for lower total logical error with increased code resources under the same task, plus concurrent operation of several modules. A one-to-one ratio of cavities to encoded qubits can be a useful hardware objective; it is not evidence of zero physical, control, or fault-tolerance overhead.

A defensible replacement is:

The experiment encodes one logical qubit in the stated cavity modes and demonstrates the reported correction or detection protocol. Whether this reduces total fault-tolerant resource cost remains an architecture-level question requiring gates, scaling, concurrency, and complete component accounting.

A Practical Comparison Checklist

Before comparing two bosonic modules, record:

1. carrier type, mode frequency, geometry, and operating temperature;
2. logical dimension, code family, mean occupation, and finite-energy parameter;
3. data, buffer, readout, and communication modes;
4. nonlinear ancillas, couplers, pumps, and reset channels;
5. measured loss, gain, dephasing, Kerr, and thermal occupation;
6. ancilla $T_1$, $T_2$, leakage, temperature, and propagated-error channel;
7. preparation fidelity, duration, and heralding probability;
8. syndrome assignment, backaction, cadence, latency, and analog information;
9. recovery, decoder, training data, and held-out validation;
10. logical idle and gate channels, including worst-axis behavior;
11. break-even reference, SPAM treatment, uncertainty, and rejected runs;
12. scaling with code size, module count, simultaneous operation, and yield.

If several fields are absent, the comparison is probably between selected components rather than complete logical architectures.

Common Mistakes

“An oscillator is already a logical qubit”

No. An oscillator is an infinite-dimensional carrier. A logical qubit also requires an encoding map, logical observables, preparation, readout, and a declared error or protection model.

“One mode means one physical component”

No. Storage, nonlinearity, readout, reset, pumps, filters, couplers, and classical feedback can be distinct physical resources even when one data mode hosts the code.

“A long cat bit-flip time is the qubit coherence time”

No. A biased cat can have an extremely long bit-flip time and a much shorter phase-flip time. Arbitrary-state memory depends on both channels and their correlations.

“Autonomous correction has no controller”

No. It removes selected real-time measurement and feedback steps. Pumps, reservoir modes, stabilization loops, calibration, and monitoring remain.

“A parity measurement corrects photon loss”

Parity can reveal that an odd number of losses occurred. Recovery additionally requires preserving the logical amplitudes, tracking when needed, restoring energy or updating a frame, and controlling measurement backaction.

“Beyond break-even means fault tolerant”

No. Break-even is a memory comparison under a named metric. Fault tolerance also constrains preparation, gates, syndrome propagation, measurement, reset, and scaling with code resources.

“Postselection simply improves fidelity”

Postselection defines a conditional channel. Its acceptance probability, latency, and treatment of rejected runs must accompany the conditional fidelity.

“More photons always give more protection”

No. Separation or effective distance may improve, while loss exposure, control complexity, nonlinear deformation, and finite-energy cost increase. The optimum is noise- and task-dependent.

“Finite-energy GKP states are ideal GKP states with small preparation error”

No. The envelope changes stabilizers, measurement statistics, gate action, energy, and logical noise. Finite energy is part of the code definition used by the device.

“A universal logical gate set is automatically fault tolerant”

No. Universality classifies ideal generated operations. Fault tolerance asks how faults propagate, whether correction runs during or around the gates, and whether logical error improves under the declared scaling.

Exercises

1. Bosonic enhancement of loss

A storage mode has energy-decay rate $\kappa$. Compare the no-loss probabilities of $|1\rangle$ and $|4\rangle$ after time $t$. Expand both to first order in $\kappa t$.

Solution

For a number state, every one of the $n$ excitations can be lost, so

$$P_0(n,t)=e^{-n\kappa t}.$$

Therefore,

$$P_0(1,t)=e^{-\kappa t}, \qquad P_0(4,t)=e^{-4\kappa t}.$$

At short times,

$$\begin{aligned} P_0(1,t)&\simeq1-\kappa t, \\ P_0(4,t)&\simeq1-4\kappa t. \end{aligned}$$

Higher occupation can increase code separation or redundancy, but it also increases the raw loss-event rate. Code performance depends on whether those more frequent events remain correctable.

2. Count a binomial recovery module

Binomial Codes verifies the leading single-loss conditions for the lowest member of the family. Suppose a physical implementation uses one storage cavity, one nonlinear ancilla, and one readout resonator. Parity extraction takes $1.2\,\mu\mathrm{s}$, conditional code-space restoration takes $0.5\,\mu\mathrm{s}$, and ancilla reset takes $0.8\,\mu\mathrm{s}$. The accepted-readout probability per cycle is $0.97$.

1. Count the quantum modes in the module.
2. Find the sequential cycle time.
3. Find the accepted-cycle throughput if cycles do not overlap.
4. Explain why these numbers do not by themselves establish break-even.

Solution

The module contains at least three quantum modes: storage, nonlinear ancilla, and readout. Control lines, pumps, amplifiers, and the classical controller also belong to a complete system ledger even though they are not counted as oscillator modes.

The sequential duration is

$$T_{\mathrm{cycle}} = 1.2+0.5+0.8 = 2.5\,\mu\mathrm{s}.$$

The raw cycle rate is $1/T_{\mathrm{cycle}}=4.0\times10^5\,\mathrm{s}^{-1}$. After acceptance,

$$R_{\mathrm{acc}} = \frac{0.97}{2.5\,\mu\mathrm{s}} = 3.88\times10^5\,\mathrm{s}^{-1}.$$

Break-even additionally requires the complete logical channel, including storage loss, no-jump deformation, ancilla and readout faults, leakage, misclassification, and rejected trials, to beat a named reference over a matched time and task. Component count and throughput alone do not provide that comparison.

3. Audit a biased-cat lifetime claim

A stabilized-cat experiment reports characteristic stochastic bit- and phase-flip times

$$T_X=10\ {\rm s}, \qquad T_Z=500\ {\rm ns}.$$

For this exercise, define $\Gamma_X=1/T_X$ and $\Gamma_Z=1/T_Z$.

1. Calculate the two rates and the bias $\eta=\Gamma_Z/\Gamma_X$.
2. State what the large bias supports.
3. Name at least four additional measurements needed before calling this a ten-second logical memory or a fault-tolerant qubit.

Solution

The rates are

$$\Gamma_X=0.1\ {\rm s}^{-1}, \qquad \Gamma_Z=2.0\times10^6\ {\rm s}^{-1},$$

so

$$\eta = \frac{\Gamma_Z}{\Gamma_X} = 2.0\times10^7.$$

The result supports an exceptionally asymmetric effective noise channel in the stated idle experiment. It does not make $T_X$ an arbitrary-state memory time: a superposition sensitive to $Z$ faults samples the much faster channel.

A complete claim should also report, for example, leakage and non-Pauli faults, correlations and drift, state-averaged process decay, preparation and readout errors, bias during gates and syndrome extraction, stabilization-pump and buffer resources, and performance against a matched physical reference. Fault tolerance additionally requires scalable correction and fault-contained logical operations. Cat Codes develops the convention-dependent logical noise map; the point here is how to audit the hardware claim.

4. Thermal occupation of a microwave mode

Estimate $\bar n_{\rm th}$ for a $5\ {\rm GHz}$ mode at:

1. $T=20\ {\rm mK}$;
2. $T=100\ {\rm mK}$.

Use $h f/k_{\rm B}\simeq0.240\ {\rm K}$.

Solution

The thermal occupation is

$$\bar n_{\rm th} = \frac{1}{e^{hf/(k_{\rm B}T)}-1}.$$

At $20\ {\rm mK}$, the exponent is $0.240/0.020=12$, so

$$\bar n_{\rm th} \simeq \frac{1}{e^{12}-1} \simeq 6.1\times10^{-6}.$$

At $100\ {\rm mK}$, the exponent is $2.4$, giving

$$\bar n_{\rm th} \simeq \frac{1}{e^{2.4}-1} \simeq 0.10.$$

The equilibrium estimate is extremely temperature sensitive. A measured mode can still be hotter than the refrigerator because of imperfect filtering, pump heating, readout backaction, or a hot ancillary system.

5. Ideal square-grid correction radius

In the ideal square GKP code with $[q,p]=i$, nearest-lattice decoding corrects an isolated $q$ displacement when

$$|\delta q|<\frac{\sqrt\pi}{2}.$$

Classify displacements $\delta q=0.60$ and $\delta q=1.00$. What is omitted by this binary classification?

Solution

Numerically,

$$\frac{\sqrt\pi}{2}\simeq0.886.$$

Thus $\delta q=0.60$ lies inside the nearest cell and is ideally correctable. The displacement $\delta q=1.00$ lies beyond the boundary and is rounded to a neighboring lattice point, producing a logical error under this decoder.

The statement omits finite peak width, the finite-energy envelope, imperfect syndrome measurement, simultaneous $p$ displacement, analog likelihood, loss-induced attenuation, and correlations between rounds. Near the boundary, a confidence-aware decoder can be more informative than a hard correct/error label.

6. Optimize a correction interval

For the schematic rate

$$\Gamma_L(t) = A t+\frac{B}{t}, \qquad A,B>0,$$

find the optimal cycle time and minimum rate. Explain the two terms.

Solution

Differentiate:

$$\frac{d\Gamma_L}{dt} = A-\frac{B}{t^2}.$$

The positive optimum is

$$t^\star=\sqrt{\frac{B}{A}}.$$

Substitution gives

$$\Gamma_L(t^\star) = 2\sqrt{AB}.$$

The $At$ term represents uncorrectable multiple storage errors becoming more likely as the interval grows. The $B/t$ term represents a roughly fixed syndrome, reset, or recovery error paid every cycle. Faster correction reduces the first contribution while applying the faulty correction apparatus more often.

7. Propagate a break-even uncertainty

A logical memory has

$$\begin{aligned} \tau_L &= (1.82\pm0.03)\ {\rm ms}, \\ \tau_{\rm ref} &= (0.800\pm0.010)\ {\rm ms}. \end{aligned}$$

Assuming independent Gaussian uncertainties, estimate $G=\tau_L/\tau_{\rm ref}$ and its uncertainty.

Solution

The central value is

$$G = \frac{1.82}{0.800} = 2.275.$$

For independent uncertainties,

$$\left( \frac{\sigma_G}{G} \right)^2 = \left( \frac{0.03}{1.82} \right)^2 + \left( \frac{0.010}{0.800} \right)^2.$$

This gives

$$\sigma_G\simeq0.047,$$

so a suitable rounded result is

$$G=2.28\pm0.05.$$

The calculation quantifies statistical separation from unity. It does not check whether the state ensemble, SPAM treatment, hardware access, and drift conditions were matched; those are part of the benchmark definition.

8. Conditional fidelity and accepted throughput

A heralded bosonic preparation reports conditional fidelity $F_{\rm cond}=0.98$ and acceptance probability $p_{\rm acc}=0.60$.

1. What is the probability per attempt of producing an accepted correct output under the simplified success model?
2. Why is $0.98$ alone insufficient for comparison with a deterministic source?

Solution

Under the simplified model,

$$\begin{aligned} p_{\rm useful} &= p_{\rm acc}F_{\rm cond} \\ &= 0.60\times0.98 \\ &= 0.588. \end{aligned}$$

The conditional fidelity describes only accepted runs. A complete comparison also needs repetition rate, detector and reset dead time, multiplexing, latency, false acceptance, and what the algorithm does when preparation fails. A deterministic source with lower state fidelity can have higher useful-state throughput or lower system cost.

9. Count a concatenated cat-memory module

Consider an outer distance-five repetition memory built from:

• five cat data modes;
• one lossy stabilization buffer per data mode;
• four syndrome transmons;
• one readout resonator per syndrome transmon.

Count the listed quantum modes or nonlinear ancillas. Name at least four additional resources omitted by that count.

Solution

The listed system contains

$$5+5+4+4=18$$

quantum modes or nonlinear ancillas: five data modes, five buffers, four transmons, and four readout resonators.

The count still omits, for example, tunable couplers, pump and microwave lines, filters and dump ports, parametric amplifiers, room-temperature electronics, digitizers, decoder compute, cryogenic wiring and attenuation, cooling power, package area, calibration time, and fabrication yield. Whether some of these are shared must be reported together with concurrency limits.

10. Classify a processor claim

An experiment demonstrates:

• one GKP qubit with memory gain $G=1.6$;
• a separate two-mode controlled-$Z$ gate with fidelity $0.90$;
• no correction during the gate;
• no scaling beyond two modes.

Which claims are supported, and which remain unsupported?

Solution

Supported claims include:

• beyond-break-even storage for the named GKP memory, assuming the reference and metric are valid;
• coherent two-logical-mode control;
• implementation of a controlled-$Z$ operation with the reported benchmark.

Unsupported claims include:

• an error-corrected controlled-$Z$ gate;
• a fault-tolerant universal gate set;
• improving logical error with increasing code resources;
• many-module concurrent operation;
• a complete resource advantage over another architecture;
• a fault-tolerant processor.

The memory and gate experiments test different channels. Their best metrics cannot be multiplied or combined unless they are integrated in one operational sequence with correction, preparation, readout, and failure accounting.

References

1. I. L. Chuang, D. W. Leung, and Y. Yamamoto, “Bosonic quantum codes for amplitude damping,” Physical Review A 56, 1114–1125 (1997), doi:10.1103/PhysRevA.56.1114.
2. D. Gottesman, A. Kitaev, and J. Preskill, “Encoding a qubit in an oscillator,” Physical Review A 64, 012310 (2001), doi:10.1103/PhysRevA.64.012310.
3. M. Mirrahimi et al., “Dynamically protected cat-qubits: a new paradigm for universal quantum computation,” New Journal of Physics 16, 045014 (2014), doi:10.1088/1367-2630/16/4/045014.
4. M. H. Michael et al., “New class of quantum error-correcting codes for a bosonic mode,” Physical Review X 6, 031006 (2016), doi:10.1103/PhysRevX.6.031006.
5. V. V. Albert et al., “Performance and structure of single-mode bosonic codes,” Physical Review A 97, 032346 (2018), doi:10.1103/PhysRevA.97.032346.
6. J. Guillaud and M. Mirrahimi, “Repetition cat qubits for fault-tolerant quantum computation,” Physical Review X 9, 041053 (2019), doi:10.1103/PhysRevX.9.041053.
7. A. L. Grimsmo, J. Combes, and B. Q. Baragiola, “Quantum computing with rotation-symmetric bosonic codes,” Physical Review X 10, 011058 (2020), doi:10.1103/PhysRevX.10.011058.
8. K. Noh and C. Chamberland, “Fault-tolerant bosonic quantum error correction with the surface–Gottesman–Kitaev–Preskill code,” Physical Review A 101, 012316 (2020), doi:10.1103/PhysRevA.101.012316.
9. S. Krastanov et al., “Universal control of an oscillator with dispersive coupling to a qubit,” Physical Review A 92, 040303(R) (2015), doi:10.1103/PhysRevA.92.040303.
10. R. W. Heeres et al., “Cavity State Manipulation Using Photon-Number Selective Phase Gates,” Physical Review Letters 115, 137002 (2015), doi:10.1103/PhysRevLett.115.137002.
11. B. Vlastakis et al., “Deterministically encoding quantum information using 100-photon Schrödinger cat states,” Science 342, 607–610 (2013), doi:10.1126/science.1243289.
12. Z. Leghtas et al., “Confining the state of light to a quantum manifold by engineered two-photon loss,” Science 347, 853–857 (2015), doi:10.1126/science.aaa2085.
13. N. Ofek et al., “Extending the lifetime of a quantum bit with error correction in superconducting circuits,” Nature 536, 441–445 (2016), doi:10.1038/nature18949.
14. L. Hu et al., “Quantum error correction and universal gate set operation on a binomial bosonic logical qubit,” Nature Physics 15, 503–508 (2019), doi:10.1038/s41567-018-0414-3.
15. P. Campagne-Ibarcq et al., “Quantum error correction of a qubit encoded in grid states of an oscillator,” Nature 584, 368–372 (2020), doi:10.1038/s41586-020-2603-3.
16. P. Reinhold et al., “Error-corrected gates on an encoded qubit,” Nature Physics 16, 822–826 (2020), doi:10.1038/s41567-020-0931-8.
17. Y. Ma et al., “Error-transparent operations on a logical qubit protected by quantum error correction,” Nature Physics 16, 827–831 (2020), doi:10.1038/s41567-020-0893-x.
18. J. M. Gertler et al., “Protecting a bosonic qubit with autonomous quantum error correction,” Nature 590, 243–248 (2021), doi:10.1038/s41586-021-03257-0.
19. C. Flühmann et al., “Encoding a qubit in a trapped-ion mechanical oscillator,” Nature 566, 513–517 (2019), doi:10.1038/s41586-019-0960-6.
20. B. de Neeve et al., “Error correction of a logical grid state qubit by dissipative pumping,” Nature Physics 18, 296–300 (2022), doi:10.1038/s41567-021-01487-7.
21. A. Eickbusch et al., “Fast universal control of an oscillator with weak dispersive coupling to a qubit,” Nature Physics 18, 1464–1469 (2022), doi:10.1038/s41567-022-01776-9.
22. V. V. Sivak et al., “Real-time quantum error correction beyond break-even,” Nature 616, 50–55 (2023), doi:10.1038/s41586-023-05782-6.
23. Z. Ni et al., “Beating the break-even point with a discrete-variable-encoded logical qubit,” Nature 616, 56–60 (2023), doi:10.1038/s41586-023-05784-4.
24. D. Lachance-Quirion et al., “Autonomous quantum error correction of Gottesman–Kitaev–Preskill states,” Physical Review Letters 132, 150607 (2024), doi:10.1103/PhysRevLett.132.150607.
25. U. Réglade et al., “Quantum control of a cat qubit with bit-flip times exceeding ten seconds,” Nature 629, 778–783 (2024), doi:10.1038/s41586-024-07294-3.
26. J. D. Teoh et al., “A superconducting dual-rail cavity qubit with erasure-detected logical measurements,” Nature Physics 20, 1454–1460 (2024), doi:10.1038/s41567-024-02539-4.
27. H. Putterman et al., “Hardware-efficient quantum error correction via concatenated bosonic qubits,” Nature 638, 927–934 (2025), doi:10.1038/s41586-025-08642-7.
28. B. L. Brock et al., “Quantum error correction of qudits beyond break-even,” Nature 641, 612–618 (2025), doi:10.1038/s41586-025-08899-y.
29. V. G. Matsos et al., “Universal quantum gate set for Gottesman–Kitaev–Preskill logical qubits,” Nature Physics 21, 1664–1669 (2025), doi:10.1038/s41567-025-03002-8.
30. M. V. Larsen et al., “Integrated photonic source of Gottesman–Kitaev–Preskill qubits,” Nature 642, 587–591 (2025), doi:10.1038/s41586-025-09044-5.
31. A. Blais, A. L. Grimsmo, S. M. Girvin, and A. Wallraff, “Circuit quantum electrodynamics,” Reviews of Modern Physics 93, 025005 (2021), doi:10.1103/RevModPhys.93.025005.
32. W. Cai, Y. Ma, W. Wang, C.-L. Zou, and L. Sun, “Bosonic quantum error correction codes in superconducting quantum circuits,” Fundamental Research 1, 50–67 (2021), doi:10.1016/j.fmre.2020.12.006.

Further Connections

• Hardware Overview supplies the platform-neutral architecture and evidence contract.
• Metrics for Quantum Hardware defines coherence, logical channels, leakage, readout, and workload metrics.
• Error-Correction Case Studies compares matched break-even denominators and scaling claims across oscillator and multi-qubit logical memories.
• Control, Readout, and Calibration develops waveform delivery, quantum-instrument inference, feedback, drift, and calibration dependencies.
• Superconducting Qubits owns the two-level circuit architectures that often supply bosonic nonlinear ancillas.
• Photonic Qubits owns discrete optical encodings, source-to-detector loss, fusion, and network architectures.
• Quantum Memories compares passive oscillator storage, write–read interfaces, active protection, and network-facing memory metrics across carrier families.
• Bits, Qubits, Qudits, and Modes separates the abstract carrier, encoding, logical object, and physical realization.
• Fock Space supplies the occupation number and multimode language used by oscillator encodings.
• Coherent States in Phase Space develops displacements, coherent states, overlaps, and phase-space geometry.
• Quantum Channels and Noise owns channel representations, damping, dephasing, composition, and operational distinguishability.
• Cavity and Circuit QED Frontiers tracks dated bosonic-memory, multimode, nonlinear-control, and transduction evidence.