Bosonic Codes

A bosonic code embeds a finite-dimensional logical system into the Hilbert space of one or more oscillator modes and pairs that encoding with a recovery designed for a declared family of oscillator errors.

The large Hilbert space of a mode supplies redundancy inside one carrier, but it does not supply protection for free. A complete code statement must name

1. the code space and logical dimension;
2. the physical modes and any energy constraint;
3. the channel or error set to be corrected;
4. the syndrome information and recovery map; and
5. the metric and reference used to judge the recovered logical channel.

This page is the canonical home for that common mathematical framework. The Cat Codes, Binomial Codes, and GKP Codes articles specialize it to coherent-state, finite Fock-superposition, and phase-space grid constructions. Bosonic Qubits owns the physical module, controls, ancillas, benchmarks, and experimental evidence. Erasure and Loss Channels owns the full channel derivation for bosonic attenuation.

Quantum Error Correction and Fault Tolerance routes a mode-based protection claim into the bosonic family and its specialist leaves; this page retains the oscillator channel–code–recovery framework, natural error algebras, generalized stabilizers, syndrome instruments, code selection, and resource boundary.

Why an Oscillator Can Carry Redundancy

A two-level physical qubit and one oscillator mode are both single physical systems, but their state spaces are different:

$$\mathcal H_{\mathrm{qubit}}\cong\mathbb C^2, \qquad \mathcal H_{\mathrm{osc}} = \operatorname{span}\{|n\rangle:n=0,1,2,\ldots\}.$$

Selecting two oscillator states as logical zero and one uses only a two-dimensional subspace of an infinite-dimensional carrier. The remaining levels can separate likely error images, record a syndrome, or shape the effective logical noise. This is Hilbert-space redundancy rather than redundancy across many nominally two-level components.

Let

$$V:\mathcal H_L\longrightarrow\mathcal H_{\mathrm{osc}}^{\otimes m}$$

be an isometric encoding of a $d_L$-dimensional logical system into $m$ modes. Its code projector is

$$P=VV^\dagger, \qquad V^\dagger V=I_L.$$

For a logical qubit with orthonormal codewords $\{|0_L\rangle,|1_L\rangle\}$,

$$P=|0_L\rangle\langle0_L|+|1_L\rangle\langle1_L|.$$

An arbitrary choice of two orthogonal oscillator states is an encoding. It becomes an error-correcting code only relative to a channel and a recovery. For example, the single-rail encoding $|0_L\rangle=|0\rangle$, $|1_L\rangle=|1\rangle$ is economical, but one photon loss maps $|1_L\rangle$ onto $|0_L\rangle$ and irreversibly merges two logical alternatives. The unused oscillator levels alone do not prevent that collision.

The Channel–Code–Recovery Triple

Let the physical noise channel have a Kraus representation

$$\mathcal N(\rho) = \sum_r E_r\rho E_r^\dagger, \qquad \sum_r E_r^\dagger E_r=I.$$

The encoding, noise, and recovery $\mathcal R$ induce the logical channel

$$\Lambda_L = V^\dagger \mathcal R\!\left[ \mathcal N\!\left(V\rho_LV^\dagger\right) \right] V,$$

when the recovery returns the state to the code space. If the output may retain leakage, an explicit decoding channel should replace the final projection by $V^\dagger(\cdot)V$.

Exact correction means that some completely positive trace-preserving recovery satisfies

$$\Lambda_L(\rho_L)=\rho_L$$

for every logical state, including states entangled with an inaccessible reference. The reference clause is essential: preserving a few chosen codewords is weaker than preserving arbitrary quantum information.

Knill–Laflamme conditions

The error operators $\{E_r\}$ are exactly correctable on the code if and only if

$$P E_r^\dagger E_s P=c_{rs}P$$

for a positive semidefinite matrix $c$ independent of the logical state. Equivalently, in any logical basis,

$$\langle\mu_L|E_r^\dagger E_s|\nu_L\rangle = c_{rs}\delta_{\mu\nu}.$$

These equations contain two physical requirements:

• no logical information leaks into the syndrome: diagonal matrix elements are the same for every logical basis state;
• different logical amplitudes remain coherent: off-diagonal matrix elements vanish when the identity action demands it.

To see the first point, attach an environment label to the Kraus operators:

$$|\psi_L\rangle|0_E\rangle \longmapsto \sum_r E_r|\psi_L\rangle|r_E\rangle.$$

Environment-state overlaps are matrix elements of $E_r^\dagger E_s$. If those overlaps depend on the logical state, the environment has learned which logical state was present. No operation on the oscillator alone can erase that information. If the overlaps are proportional to the identity on the code, a recovery can coherently separate the error syndrome from the logical subsystem.

The condition also has a useful linear-span property. If a code corrects $\{E_r\}$, it corrects every channel whose Kraus operators lie in $\operatorname{span}\{E_r\}$. Choosing a physically meaningful error basis can therefore be more informative than optimizing against one numerical channel instance.

Exact and approximate correction

Finite-energy bosonic codes often satisfy the exact conditions only for a truncated error set or to a specified order in a short time. Their performance under the complete channel is then approximate. A useful worst-case measure is the optimized entanglement infidelity

$$\epsilon_{\mathrm{ent}} = 1- \max_{\mathcal R} \min_{\rho_L} F_e\!\left( \rho_L, \mathcal R\circ\mathcal N\circ\mathcal V \right),$$

where $\mathcal V(\rho_L)=V\rho_LV^\dagger$ and $F_e$ tests preservation of entanglement with a reference. Average state fidelity can be convenient, but it answers a different question and may hide a poorly protected logical direction.

In an infinite-dimensional Hilbert space, performance comparisons also need an energy or occupation constraint. Otherwise a sequence of codewords can push farther into Fock space without paying for mean photon number, maximum occupation, preparation complexity, or increased exposure to loss. Typical constraints include

$$\operatorname{Tr}(\rho N)\le \bar n_{\max}, \qquad N=a^\dagger a,$$

or a hard cutoff $P_{n\le n_{\max}}$. Neither constraint is a harmless technicality: different constraints can rank codes differently.

Natural Error Algebras for a Mode

For one bosonic mode,

$$[a,a^\dagger]=I, \qquad N=a^\dagger a.$$

The useful error basis depends on the physical channel. Three descriptions appear repeatedly.

Loss, gain, and number errors

The zero-temperature pure-loss channel of transmissivity $\eta$ has Kraus operators

$$A_\ell = \sqrt{\frac{(1-\eta)^\ell}{\ell!}}\, \eta^{N/2}a^\ell, \qquad \ell=0,1,2,\ldots.$$

For $\eta=e^{-\kappa t}$ and $\kappa t\ll1$,

$$\begin{aligned} A_0 &= I-\frac{\kappa t}{2}N+O(t^2), \\ A_1 &= \sqrt{\kappa t}\,a+O(t^{3/2}), \\ A_{\ell\ge2} &= O(t^{\ell/2}). \end{aligned}$$

Thus a code that corrects the leading error set $\{I,a\}$ must satisfy

$$P a P=c_{01}P, \qquad P a^\dagger a P=c_{11}P.$$

Parity-separated codes usually have $PaP=0$. The second condition says that the mean occupation exposed to a one-loss event must be identical for all logical states. To correct up to $L$ losses, the relevant products are

$$P(a^\dagger)^r a^sP=c_{rs}P, \qquad 0\le r,s\le L.$$

For $r=s$, these constrain factorial moments of the number distribution:

$$(a^\dagger)^r a^r = N(N-1)\cdots(N-r+1).$$

Matching only the mean photon number is enough for the leading single-loss condition, not for arbitrary finite-time attenuation.

At nonzero temperature or in an actively driven device, a useful perturbative error set may also include creation and dephasing operators:

$$\mathcal E_{L,G,D} = \left\{ (a^\dagger)^g N^d a^\ell: 0\le\ell\le L,\; 0\le g\le G,\; 0\le d\le D \right\}.$$

This notation is a design model, not a claim that the physical errors occur as isolated monomials. It organizes the low-order expansion of loss, thermal gain, frequency noise, and control imperfections.

Displacement errors

The phase-space displacement operator is

$$D(\xi)=\exp(\xi a^\dagger-\xi^*a).$$

Small displacements generate polynomials in $a$ and $a^\dagger$, but a phase-space description retains geometric information that a low-order polynomial expansion can obscure. Grid codes arrange codewords so that small shifts remain inside a correctable cell, while larger shifts cross a logical decision boundary.

For quadratures

$$q=\frac{a+a^\dagger}{\sqrt2}, \qquad p=\frac{a-a^\dagger}{i\sqrt2}, \qquad [q,p]=i,$$

a real translation in $q$ is generated by $p$, and a real translation in $p$ is generated by $q$. Analog syndrome values can reveal where inside a cell the noisy state landed. Discarding that analog information before an outer decoder is generally suboptimal.

Lindblad generators are not themselves a code

A common oscillator master equation is

$$\dot\rho = \kappa(\bar n_{\mathrm{th}}+1)\mathcal D[a]\rho +\kappa\bar n_{\mathrm{th}}\mathcal D[a^\dagger]\rho +\kappa_\phi\mathcal D[N]\rho,$$

with

$$\mathcal D[L]\rho = L\rho L^\dagger -\frac12\{L^\dagger L,\rho\}.$$

This equation names loss, thermal gain, and number dephasing, but it does not select a code or a correction cadence. The same generator can favor different encodings at different times, energy budgets, syndrome efficiencies, and control-error rates. The channel over the full correction interval, including the recovery circuit, is the object that must ultimately be compared.

Code Geometry Follows the Error Model

Bosonic codes are often grouped by the geometry of their codewords. The groups overlap. Cat and binomial codes can both be rotation symmetric; a grid code may occupy several modes; a multimode code may use fixed total excitation as well as coherent-state structure.

organizing geometry	error information made accessible	representative constructions	characteristic limitation
finite Fock superpositions	loss number, gain number, and selected moments of $N$	binomial and numerically optimized number-state codes	higher-order channel terms and growing occupation
phase-space rotation	number modulo a symmetry order; angular separation	cat and other rotation-symmetric codes	overlap, dephasing, and symmetry-breaking control faults
displacement lattice	continuous shift modulo a phase-space lattice	GKP and multimode grid codes	finite energy, finite squeezing, and lattice-cell ambiguity
fixed-excitation multimode structure	total-number changes and located leakage	dual-rail detection and multimode amplitude-damping codes	mode loss, mode mismatch, and additional physical channels

A bosonic code is one part of a channel-adapted loop. A physical noise model defines a useful error basis; the code geometry separates those errors; a syndrome instrument and recovery produce an effective logical channel; and resource-constrained logical performance determines whether the design is actually favorable.

Number-selective and finite-superposition codes

A finite-superposition code has codewords

$$|\mu_L\rangle = \sum_{n=0}^{n_{\max}}c_{\mu n}|n\rangle.$$

The coefficients can be chosen so that likely error spaces are orthogonal and the relevant number moments agree across logical states. Binomial Codes give an analytic family in which number spacing and binomial weights enforce a chosen set of loss, gain, and dephasing conditions. Numerical searches can relax the analytic structure and optimize directly for a channel, energy budget, and recovery metric.

Finite support gives exact orthogonality and a finite control target, but it does not make the finite-time pure-loss channel exactly correctable. The no-jump factor $\eta^{N/2}$ weights different Fock components differently. Code design therefore separates two claims:

• exact correction of a declared polynomial error set;
• approximate correction of a complete finite-time channel.

The Binomial Codes article owns the systematic construction and its order conditions.

Rotation-symmetric codes

Define a discrete rotation by

$$R_M = \exp\!\left(\frac{2\pi i}{M}N\right).$$

Because

$$R_M a R_M^\dagger = e^{-2\pi i/M}a,$$

one loss changes the rotation sector by one unit. Number states in one sector share a residue class modulo $M$, so a modular-number measurement can reveal some loss information without directly measuring the logical amplitudes.

Rotation symmetry organizes both coherent-state cat codes and finite number-state codes. It does not by itself specify the codewords, the corrected loss order, or the recovery. Large coherent-state separation can suppress one logical error channel while increasing occupation and the raw rate of loss events. A claim of “noise bias” must therefore report both logical error directions and the operations that preserve the bias.

The Cat Codes article owns coherent-component constructions, dissipative confinement, biased logical noise, and bias-preserving operations.

Grid codes

Grid codes use a lattice of translations in continuous phase space. For the ideal square GKP qubit in the convention $[q,p]=i$, representative commuting stabilizers are

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

Their joint ideal eigenstates are periodic combs and are not normalizable. Physical codewords replace infinitely sharp peaks and an infinite envelope with finite squeezing and finite energy. The resulting state is an approximate code even before external noise is applied.

A modular quadrature measurement returns a continuous syndrome. Nearest-cell decoding is a useful baseline, but the residual displacement within the cell contains reliability information. When grid states are concatenated with an outer qubit code, passing that analog information to the outer decoder can change the threshold and overhead.

The GKP Codes article owns the full lattice conventions, logical displacements, finite-energy states, shift decoding, and concatenated threshold analyses.

Multimode codes

With modes $a_1,\ldots,a_m$, the physical error basis can distinguish loss location:

$$\mathcal E_1=\{I,a_1,\ldots,a_m\}.$$

Fixed-total-number encodings make a loss event leave the original excitation sector. The dual-rail encoding

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

therefore detects one photon loss as the vacuum state $|0,0\rangle$. It does not recover the lost logical qubit by itself; the flagged branch is an erasure that an outer code or retransmission protocol must handle.

More redundant multimode constructions can satisfy the Knill–Laflamme conditions for one or more amplitude-damping events. Their accounting must include every mode, mode-dependent attenuation, interferometric mismatch, and any measurement needed to identify the excitation sector. “One encoded qubit” and “one oscillator” are not synonyms.

Stabilized manifolds are a protection mechanism

An engineered Hamiltonian or dissipator can confine dynamics toward a code manifold. For example, a jump operator may have the desired code states as dark states. This autonomous stabilization can suppress leakage or repair selected errors continuously, but it does not define the whole code:

• the logical subspace and logical operators must still be specified;
• all uncontrolled noise channels must still be propagated;
• engineered dissipation can introduce its own faults;
• logical gates may leave the protected manifold or break its noise bias.

The same abstract code can be protected by measurement-based feedback, autonomous dynamics, or a hybrid of both. These are different recovery implementations, not different proofs of correctability.

Logical Operators and Generalized Stabilizers

An encoded operator $\bar O$ represents a logical operator $O_L$ when

$$P\bar O P=VO_LV^\dagger.$$

Different physical operators can have the same restriction to the code space. Their behavior outside the code matters during faults, leakage, and recovery, so code-space equivalence does not imply equal fault tolerance.

The word stabilizer is used in several related ways:

1. a unitary $S$ may fix every code state, $SP=P$;
2. several commuting displacements may define an ideal grid code;
3. a rotation symmetry may label number sectors;
4. a Hamiltonian or Lindblad operator may energetically or dissipatively confine a manifold.

These structures should not be inserted unmodified into the binary Pauli tableau. Ideal displacement stabilizers act on an infinite-dimensional space, finite-energy grid states are only approximate eigenstates, and dissipative fixed points need not form the joint $+1$ eigenspace of a Pauli group. Stabilizer Formalism owns the qubit Pauli construction.

Logical gates add a second design condition. A gate should implement the desired action in the code while keeping likely physical faults correctable. Useful distinctions include

• code preserving: the ideal gate maps the code space to itself;
• error transparent: selected errors before and after the gate have the same correctable logical effect;
• bias preserving: a strongly asymmetric logical noise channel remains asymmetric through the gate;
• fault tolerant: any allowed component fault produces an error within the declared correctable set, up to the protocol’s fault order.

None of the first three properties alone proves the fourth.

Bosonic and Encoded Computation Models takes a declared oscillator code and complete physical control-and-instrument program, composes it before decoding, and audits the induced logical channel, leakage, rejection, recovery, frames, verification, and resources. This page retains general code, error, syndrome, recovery, and family-comparison theory.

Syndrome Instruments and Recovery

A syndrome extraction is a quantum instrument $\{\mathcal M_y\}_y$, not merely a classical parity label:

$$\sum_y\mathcal M_y$$

is trace preserving, while each $\mathcal M_y$ gives the conditional quantum state and probability for record $y$. A measurement can reveal the error sector without revealing the logical state only when its backaction respects the code conditions.

For a measurement-based recovery with conditional correction $\mathcal C_y$,

$$\mathcal R = \sum_y\mathcal C_y\circ\mathcal M_y.$$

The decoder maps the record to a hypothesis or posterior over errors. In a bosonic code, the record may contain

• an integer loss or parity-change syndrome;
• a continuous modular-quadrature value;
• an ancilla readout history over several rounds;
• a leakage or erasure flag;
• confidence information from calibration and filtering.

Hard-decision decoding compresses this record to one correction. Soft or analog decoding retains likelihood information. The latter is especially important for grid codes and for concatenation with an outer stabilizer code. The Decoders page owns the common posterior, calibration, and real-time framework.

Recovery need not physically invert every displacement or loss event. A known logical byproduct can be tracked in a frame, and energy can be restored by a code-space repumping map. What matters is the complete logical channel, including cases in which the syndrome is wrong, the ancilla faults, or the state leaves the modeled subspace.

Degeneracy is useful, not pathological

Two errors may act identically on the code:

$$E_rP=\lambda E_sP.$$

They then need not be distinguished. The recovery only needs enough syndrome information to identify the equivalence class of the error modulo its action on the logical subsystem. Trying to infer a unique microscopic history can waste measurement resources and amplify noise.

Cadence changes the channel

If recovery is applied every $\tau$, the relevant map is not bare storage for time $\tau$. It is

$$\mathcal C_\tau = \mathcal R_\tau \circ \mathcal N_\tau,$$

including syndrome extraction, ancilla reset, latency, and idle evolution. After $r$ rounds the memory channel is

$$\mathcal C_\tau^r.$$

Reducing $\tau$ lowers the probability of multiple oscillator errors between corrections but increases the number of imperfect recovery cycles. An optimal cadence balances both contributions.

Selecting a Code Under a Resource Constraint

A code comparison is meaningful only after fixing a task and a resource boundary. One useful optimization statement is

$$\begin{aligned} \text{minimize}\quad &\epsilon\!\left(\Lambda_L\right) \\ \text{over}\quad &V,\mathcal R,\tau \\ \text{subject to}\quad &\bar n\le\bar n_{\max}, \\ &m\le m_{\max}, \\ &T_{\mathrm{cycle}}\le T_{\max}, \\ &\text{declared control and measurement resources}. \end{aligned}$$

The objective might be worst-case entanglement infidelity, logical failure per round, lifetime for a named logical observable, or accepted task success. Changing the objective can change the preferred code.

At minimum, report

quantity	why it matters
number of storage and auxiliary modes	prevents “one mode” from hiding a multimode module
mean and tail of occupation	controls loss exposure and truncation error
physical channel and interval	defines the error set being corrected
recovery and decoder	determines the actual logical map
cycle time and duty factor	converts per-round error into service rate
acceptance probability	exposes postselection and heralding cost
logical metric and reference	makes break-even or overhead claims falsifiable

The Bosonic Qubits page develops this hardware ledger. Error-Correction Case Studies owns dated experimental comparisons and matched break-even claims.

Diagnostic Workflow: From Operator Set to Channel

The lowest binomial code gives a compact application of the general formalism. Its full calculation, including the one-loss error words, no-jump deformation, modular syndrome, and higher-order family, lives in Binomial Codes. For any oscillator encoding, the same audit has four stages:

stage	calculation	failure signal
code space	normalize the codewords and verify their mutual orthogonality	the proposed logical basis is not an isometry
declared operators	evaluate every code-space block of $E_r^\dagger E_s$	the environment can distinguish or deform logical states
syndrome and recovery	identify error sectors and construct one coherent inverse on each correctable sector	the syndrome resolves logical information or the error words have unequal norms
complete channel	apply the finite-time Kraus map and the implemented recovery	no-jump deformation, omitted events, or recovery faults dominate

The last stage prevents an algebraic statement such as “corrects one loss” from being mistaken for exact correction of a complete finite-time channel.

What Bosonic Error Correction Does Not Guarantee

A large Hilbert space does not imply a good code

Useful redundancy requires codewords, an error model, and a recovery whose logical channel improves under a fair constraint. Infinite dimension is an opportunity, not a theorem of protection.

Orthogonal codewords need not have orthogonal error images

The condition is imposed on every $E_r^\dagger E_s$, not only on $\langle0_L|1_L\rangle$. Single rail fails for loss even though its codewords are orthogonal.

Detecting a jump is not the same as correcting the channel

The no-jump branch can deform amplitudes and reveal logical information. Multiple jumps, thermal gain, and dephasing may also contribute during one cycle.

A parity measurement is not a recovery

Parity can identify a sector change. Correction also requires preserving coherence, restoring the code space, treating measurement errors, and handling repeated cycles.

Unflagged attenuation is not automatically erasure

A loss event becomes a located erasure only if the protocol produces a reliable orthogonal flag. Postselecting on detected survival changes the channel and must report the acceptance probability.

Ideal GKP formulas do not describe finite-energy states exactly

Ideal comb states are nonnormalizable. Finite peak width and finite envelope produce intrinsic shift uncertainty, nonorthogonality corrections, and energy-dependent performance.

Strong bias is not full-qubit protection

Suppressing logical bit flips while phase errors remain large can be valuable for a bias-adapted outer code. It is not the same as extending the lifetime of every logical state.

Autonomous does not mean fault free

Pumps, auxiliary modes, engineered dissipation, and symmetry-breaking perturbations belong to the physical channel. They cannot be omitted because the feedback loop is implemented continuously.

Break-even memory is not scalable fault tolerance

A memory may beat a matched unencoded reference while logical gates, multi-module coupling, leakage control, and outer-code operation remain unresolved. The Fault-Tolerant Quantum Computing Frontier owns that system-level evidence boundary.

Exercises

1. Why single rail cannot correct loss

For $|0_L\rangle=|0\rangle$ and $|1_L\rangle=|1\rangle$, test the Knill–Laflamme conditions for $\{I,a\}$. Identify both failed conditions and interpret them physically.

Solution

First,

$$PaP = |0_L\rangle\langle1_L|,$$

which is not proportional to $P$. A one-loss amplitude from logical one lands inside the code space as logical zero.

Second,

$$PNP = |1_L\rangle\langle1_L|,$$

which is also not proportional to $P$. The probability of a loss depends on the logical population. The environment can distinguish vacuum from one photon, and the lost branch merges $|1_L\rangle$ with $|0_L\rangle$. No recovery on the oscillator can reconstruct an arbitrary input qubit.

2. Factorial moments for two-loss correction

Suppose a code exactly corrects $\{I,a,a^2\}$. Show that its logical codewords must have equal expectation values of $N$ and $N(N-1)$. Explain why equal mean occupation alone is insufficient.

Solution

The diagonal Knill–Laflamme products include

$$a^\dagger a=N$$

and

$$(a^\dagger)^2a^2=N(N-1).$$

Their projections must be proportional to $P$:

$$PNP=c_{11}P, \qquad PN(N-1)P=c_{22}P.$$

Thus every logical state has the same first and second factorial moments, and the off-diagonal logical matrix elements vanish. Equal means constrain only the leading one-loss probability. Two number distributions can have the same mean but different weight at large $n$, giving different two-loss probabilities.

3. Order of the no-jump mismatch

For the worked code, set $\eta=1-\delta$ with $\delta\ll1$. Expand the difference between the two no-jump probabilities through second order.

Solution

From the worked example,

$$\Delta p_0 = \frac{(1-\eta^2)^2}{2}.$$

Since

$$1-\eta^2 = 1-(1-\delta)^2 = 2\delta-\delta^2,$$

we obtain

$$\Delta p_0 = \frac{(2\delta-\delta^2)^2}{2} = 2\delta^2+O(\delta^3).$$

The first-order term cancels because the codewords have equal mean occupation. Their higher number moments differ, so the complete channel deviates at second order.

4. Rotation sectors under repeated loss

Let $R_M=e^{2\pi iN/M}$. Show that

$$R_Ma^\ell R_M^\dagger = e^{-2\pi i\ell/M}a^\ell.$$

What information can a measurement of the rotation sector reveal, and when does it become ambiguous?

Solution

Using $[N,a]=-a$,

$$e^{i\theta N}ae^{-i\theta N} = e^{-i\theta}a.$$

Applying this relation $\ell$ times with $\theta=2\pi/M$ gives the stated formula. A loss of $\ell$ excitations shifts the rotation eigenvalue by $\ell$ units modulo $M$. The syndrome can therefore reveal loss number modulo $M$ without resolving the logical amplitudes, provided the codewords share the required symmetry. Loss counts that differ by a multiple of $M$ have the same sector and require additional information or must be treated as potential logical failures.

5. Commutation of square-grid stabilizers

Using $[q,p]=i$, verify that

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

commute. Why does this not prove that finite-energy approximations are exact code states?

Solution

For operators $A=i2\sqrt\pi q$ and $B=-i2\sqrt\pi p$, their commutator is the scalar

$$[A,B] = (i2\sqrt\pi)(-i2\sqrt\pi)[q,p] = i4\pi.$$

The Weyl relation gives

$$e^Ae^B=e^Be^Ae^{[A,B]}=e^Be^A,$$

because $e^{i4\pi}=1$. Ideal joint eigenstates are periodic delta-comb states and have infinite energy. A finite-energy wave packet can only approximate the stabilizer eigenvalue equations, so it carries intrinsic shift uncertainty even before external noise.

6. A toy optimal correction cadence

Assume a code corrects one loss. Model the uncorrectable two-loss contribution per cycle as

$$p_2(\tau)\simeq\frac12(\kappa\bar n\tau)^2$$

and let each recovery cycle add a logical fault probability $q$. Neglect higher orders and derive the cycle duration that minimizes logical failure per unit time.

Solution

The approximate failure rate is

$$\Gamma_L(\tau) \simeq \frac{q+p_2(\tau)}{\tau} = \frac{q}{\tau} +\frac12(\kappa\bar n)^2\tau.$$

Differentiating,

$$\frac{d\Gamma_L}{d\tau} = -\frac{q}{\tau^2} +\frac12(\kappa\bar n)^2.$$

The optimum is

$$\tau_* = \frac{\sqrt{2q}}{\kappa\bar n},$$

with

$$\Gamma_L(\tau_*) = \sqrt{2q}\,\kappa\bar n.$$

More frequent correction suppresses double loss but exposes the state to more recovery faults. Real optimization must also include finite recovery time, non-Poissonian noise, ancilla reset, and decoder latency.

7. Why analog syndrome information helps

A one-dimensional grid decoder observes a residual shift $r$ in a fundamental cell. Under Gaussian shift noise of variance $\sigma^2$, compare the likelihoods that $r$ came from displacement $r$ or from the neighboring logical displacement $r-\sqrt\pi$.

Solution

Up to a common normalization,

$$\mathcal L_0(r) \propto \exp\!\left(-\frac{r^2}{2\sigma^2}\right),$$

while

$$\mathcal L_1(r) \propto \exp\!\left[ -\frac{(r-\sqrt\pi)^2}{2\sigma^2} \right].$$

Their log-likelihood ratio is

$$\log\frac{\mathcal L_0}{\mathcal L_1} = \frac{(r-\sqrt\pi)^2-r^2}{2\sigma^2} = \frac{\pi-2\sqrt\pi\,r}{2\sigma^2}.$$

A hard decoder keeps only the sign of this expression. An analog decoder also keeps its magnitude, which tells an outer decoder how close the event was to the decision boundary.

8. Audit a “one-mode logical qubit” claim

An experiment stores a logical qubit in one cavity, uses one nonlinear ancilla, two readout resonators, four pumps, and postselects away 8% of runs. List the resources and output quantities required for a fair comparison with an unencoded memory.

Solution

The physical boundary contains at least the storage cavity, nonlinear ancilla, both readout modes, pump and control channels, measurement chain, reset process, controller, and any cryogenic or optical duty-cycle cost that limits repeated operation. The code report should include mean and tail occupation, storage and recovery duration, ancilla and readout faults, logical channel or state-dependent lifetimes, decoder policy, leakage, postselection rule, and acceptance probability $0.92$.

The reference must be run under a matched time, task, and hardware boundary. A comparison only with the bare cavity lifetime omits the ancilla, recovery errors, and rejected trials and therefore does not establish a system-level overhead advantage.

References

1. E. Knill and R. Laflamme, “Theory of quantum error-correcting codes,” Physical Review A 55, 900–911 (1997), doi:10.1103/PhysRevA.55.900.
2. 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.
3. D. W. Leung, M. A. Nielsen, I. L. Chuang, and Y. Yamamoto, “Approximate quantum error correction can lead to better codes,” Physical Review A 56, 2567–2573 (1997), doi:10.1103/PhysRevA.56.2567.
4. P. T. Cochrane, G. J. Milburn, and W. J. Munro, “Macroscopically distinct quantum-superposition states as a bosonic code for amplitude damping,” Physical Review A 59, 2631–2634 (1999), doi:10.1103/PhysRevA.59.2631.
5. 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.
6. S. Glancy and E. Knill, “Error analysis for encoding a qubit in an oscillator,” Physical Review A 73, 012325 (2006), doi:10.1103/PhysRevA.73.012325.
7. W. Wasilewski and K. Banaszek, “Protecting an optical qubit against photon loss,” Physical Review A 75, 042316 (2007), doi:10.1103/PhysRevA.75.042316.
8. A. S. Fletcher, P. W. Shor, and M. Z. Win, “Channel-adapted quantum error correction for the amplitude damping channel,” IEEE Transactions on Information Theory 54, 5705–5718 (2008), arXiv:0710.1052.
9. C. Bény and O. Oreshkov, “General conditions for approximate quantum error correction and near-optimal recovery channels,” Physical Review Letters 104, 120501 (2010), doi:10.1103/PhysRevLett.104.120501.
10. 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.
11. 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.
12. 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.
13. 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.
14. 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.
15. B. M. Terhal, J. Conrad, and C. Vuillot, “Towards scalable bosonic quantum error correction,” Quantum Science and Technology 5, 043001 (2020), doi:10.1088/2058-9565/ab98a5.
16. 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

• Why Quantum Error Correction Is Possible explains syndrome extraction, reversibility, and the no-cloning boundary without assuming an oscillator carrier.
• Number States develops the ladder algebra and Fock basis used by loss-adapted constructions.
• Coherent States in Phase Space develops coherent-state overlap, displacement operators, and phase-space geometry.
• Erasure and Loss Channels distinguishes flagged erasure from unflagged bosonic attenuation and derives the pure-loss Kraus representation.
• Dephasing Channel gives the finite-dimensional channel language that bosonic number dephasing generalizes.
• Continuous-Variable Platforms owns computation in continuous quadratures rather than a finite logical subsystem embedded in them.