Binomial Codes

A binomial code encodes a finite-dimensional logical system in a finite superposition of oscillator number states. The occupied number states are spaced far enough apart to separate declared loss and gain errors, while binomial weights make selected moments of the number distribution independent of the logical state. Those two ingredients implement two different parts of quantum error correction:

• spacing makes error sectors distinguishable;
• moment matching prevents the error probability from revealing or deforming the logical amplitudes.

The construction is analytic, finite-energy, and exactly orthogonal. It exactly corrects a chosen finite operator set. A physical loss, gain, or dephasing channel over nonzero time contains more operators than that finite set, so correction of the complete channel is approximate and depends on the cycle time, recovery, and hardware faults.

Bosonic Codes is the canonical home for oscillator encodings, exact and approximate Knill–Laflamme conditions, channel metrics, and energy constraints. This page owns the binomial family, its finite-difference proof, modular-number syndromes, logical operators, recovery options, and code-specific evidence. Bosonic Qubits owns the physical cavity–ancilla module, controls, calibration, and broader hardware comparison.

Throughout, one mode has annihilation operator $a$, creation operator $a^\dagger$, and number operator

$$n=a^\dagger a.$$

Quantum Error Correction and Fault Tolerance treats a binomial code as one finite-Fock construction inside a complete protection record; this page retains moment-matching and spacing arguments, checks, logical operators, recovery, gate options, approximate-channel effects, evidence, and resources.

Construction from a Declared Error Set

Suppose the code should correct any one operator in

$$\begin{aligned} \overline{\mathcal E}_{L,G,D} = \{& I,a,\ldots,a^L, \\ & a^\dagger,\ldots,(a^\dagger)^G, \\ & n,\ldots,n^D \}. \end{aligned}$$

Here:

• $L$ is the largest corrected number of losses;
• $G$ is the largest corrected number of gains;
• $D$ is the largest corrected power of the number operator.

The parameter $D$ labels polynomial dephasing errors. It should not be read as a universal count of phase-noise events; a complete stochastic channel must be expanded and checked separately.

Define the minimal spacing and moment orders

$$S=L+G, \qquad K=\max\{L,G,2D\}.$$

The original construction commonly calls the second parameter $N$. This page uses $K$ so that it cannot be confused with the number operator $n$.

The binomial qubit codewords are

$$\begin{aligned} |0_L\rangle &= \frac{1}{\sqrt{2^K}} \sum_{\substack{0\le p\le K+1\\p\ {\rm even}}} \sqrt{\binom{K+1}{p}}\, |p(S+1)\rangle, \\ |1_L\rangle &= \frac{1}{\sqrt{2^K}} \sum_{\substack{0\le p\le K+1\\p\ {\rm odd}}} \sqrt{\binom{K+1}{p}}\, |p(S+1)\rangle. \end{aligned}$$

Three structural facts are visible immediately:

1. the support is finite;
2. every occupied number is a multiple of $S+1$;
3. logical zero uses even $p$, while logical one uses odd $p$.

For $K\ge1$, the even and odd binomial sums both equal $2^K$:

$$\sum_{p\ {\rm even}}\binom{K+1}{p} = \sum_{p\ {\rm odd}}\binom{K+1}{p} = 2^K.$$

The codewords are therefore normalized. Their number-state supports are disjoint, so

$$\langle0_L|1_L\rangle=0$$

exactly, without a large-amplitude or large-energy limit.

Energy and cutoff

The largest occupied number is

$$n_{\max}=(K+1)(S+1).$$

For either logical codeword, the mean occupation is

$$\bar n = \langle n\rangle = \frac{(K+1)(S+1)}{2}.$$

Thus increasing the corrected error order raises both the control cutoff and the raw exposure to number-dependent loss. A finite support is useful for state synthesis and numerical modeling, but it is not free: every occupied Fock component must be prepared, phase aligned, measured, and recovered with adequate fidelity.

The choices above are minimal. One can increase the spacing beyond $L+G$ or match more moments than the declared set requires. Such over-designed codes may herald additional errors or perform better for a particular channel, at the cost of larger occupation and more complex control.

Why the Binomial Weights Work

The exact correction condition for the finite error set is

$$P E_i^\dagger E_j P = c_{ij}P,$$

where

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

projects onto the code space. The general meaning of this condition is developed in Bosonic Codes. Here the two ingredients can be verified directly.

Number spacing kills the off-diagonal overlaps

A product $(a^\dagger)^r a^s$ changes number by $r-s$. Any two occupied number states differ by an integer multiple of $S+1$. For the corrected loss and gain products,

$$|r-s| \le L+G = S.$$

No nonzero shift in that range can connect two occupied supports. Therefore matrix elements with unequal numbers of creation and annihilation operators vanish:

$$\langle\mu_L| (a^\dagger)^r a^s |\nu_L\rangle =0, \qquad r\ne s,$$

for the products generated by the declared error set.

This is syndrome separation. It is not yet enough. A loss could still occur with a different probability for logical zero and logical one, thereby measuring the logical state through the environment.

Moment matching removes logical-state information

For a nonnegative integer $q$, define the moment difference

$$\Delta_q = \langle0_L|n^q|0_L\rangle - \langle1_L|n^q|1_L\rangle.$$

Substituting the codewords gives

$$\Delta_q = \frac{(S+1)^q}{2^K} \sum_{p=0}^{K+1} (-1)^p \binom{K+1}{p} p^q.$$

The alternating sum is a finite difference. Equivalently,

$$\sum_{p=0}^{K+1} (-1)^p \binom{K+1}{p} p^q = \left. \left( x\frac{d}{dx} \right)^q (1-x)^{K+1} \right|_{x=1}.$$

For $q\le K$, at least one factor of $1-x$ remains after differentiation, so

$$\Delta_q=0, \qquad 0\le q\le K.$$

The logical codewords consequently have identical number moments through order $K$.

Diagonal products such as $(a^\dagger)^r a^r$ are falling factorials in $n$:

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

They are polynomials of degree $r$. Matching moments through $K\ge\max\{L,G\}$ makes their expectation values logical-state independent. The gain products $a^r(a^\dagger)^r=(n+1)\cdots(n+r)$ are rising factorials of the same degree and obey the same argument. Products of dephasing errors reach $n^{2D}$, which explains the condition $K\ge2D$.

Spacing and moment matching together establish the exact Knill–Laflamme conditions for the declared finite set. Neither ingredient can replace the other.

Checks, Logical Operators, and Distance

Let

$$M=S+1.$$

Every code component has number $n=pM$, so the discrete rotation

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

acts as the identity on the code space. Measuring number modulo $M$ is equivalent to resolving the eigenspaces of this rotation.

The half-angle rotation

$$Z_L = \exp\!\left( \frac{\pi i}{M}n \right)$$

acts as a logical Pauli:

$$Z_L|0_L\rangle=|0_L\rangle, \qquad Z_L|1_L\rangle=-|1_L\rangle.$$

A logical $X_L$ exists abstractly,

$$X_L = |0_L\rangle\langle1_L| +|1_L\rangle\langle0_L|,$$

with an arbitrary unitary extension outside the code. Unlike $Z_L$, it is not generally one elementary oscillator rotation. Implementations use number-selective phases, shaped drives, optimal control, teleportation, or engineered multiphoton couplings.

The rotation check does not uniquely define the binomial code. Its $+1$ eigenspace contains every superposition supported on multiples of $M$, an infinite-dimensional space. The finite binomial envelope and the logical even–odd split are additional structure. Calling $R_M$ the whole stabilizer description hides that distinction.

Several distance notions coexist

An oscillator code does not have one hardware-independent Pauli weight. Useful channel-adapted distances are:

notion	binomial interpretation
number-shift spacing	adjacent occupied Fock components differ by $M=S+1$ quanta
pure-loss distance	$d_{\rm loss}=L+1$ for the minimally spaced loss code
gain protection	gains through order $G$ are corrected
dephasing order	powers through $n^D$ are corrected when moments through $2D$ match
finite-time channel order	residual terms depend on cadence, energy, and recovery, not only on $L,G,D$

For a pure-loss code, $L+1$ annihilation operators are the first order capable of confusing logical sectors. This is the useful loss-distance statement. It does not imply distance $L+1$ against arbitrary oscillator operators.

Worked Example: The Lowest Single-Loss Code

Set

$$L=1, \qquad G=D=0.$$

Then $S=K=1$, and

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

Both codewords have even parity and mean occupation two:

$$\langle0_L|n|0_L\rangle = \langle1_L|n|1_L\rangle =2.$$

One loss gives

$$\begin{aligned} a|0_L\rangle &= \sqrt2\,|3\rangle, \\ a|1_L\rangle &= \sqrt2\,|1\rangle. \end{aligned}$$

The two error words are orthogonal, have equal norm, and lie in the odd-parity sector. Equivalently,

$$P a P=0, \qquad P a^\dagger a P=2P.$$

For an arbitrary encoded state

$$|\psi_L\rangle = u|0_L\rangle+v|1_L\rangle,$$

the normalized one-loss branch is

$$\frac{a|\psi_L\rangle}{\sqrt2} = u|3\rangle+v|1\rangle.$$

The logical amplitudes $u$ and $v$ survive unchanged. A parity measurement learns that a loss occurred without learning those amplitudes. A conditional unitary can then map

$$|3\rangle\mapsto|0_L\rangle, \qquad |1\rangle\mapsto|1_L\rangle.$$

The lowest binomial code occupies the even number states $0$, $2$, and $4$. One loss maps its two logical basis states to orthogonal odd-parity error words with equal norm. Parity supplies the syndrome; the conditional recovery $U_1$ restores the finite superpositions.

Why two losses are not correctable

Two losses return the state to even parity:

$$\begin{aligned} a^2|0_L\rangle &= \sqrt6\,|2\rangle, \\ a^2|1_L\rangle &= \sqrt2\,|0\rangle. \end{aligned}$$

The first branch overlaps logical one, and the second overlaps logical zero. Endpoint parity cannot distinguish this event from no loss. This is why the code has loss distance two: it corrects one loss, while two losses are a leading uncorrectable process.

No-jump evolution is also nontrivial

Under pure loss with rate $\kappa$, the no-jump branch over a short interval $\Delta t$ is

$$A_0 = e^{-\kappa\Delta t\,n/2} = I -\frac{\kappa\Delta t}{2}n +\frac{(\kappa\Delta t)^2}{8}n^2 +\cdots.$$

Because $P n P=2P$, the first projected correction is the same for both logical states. But

$$\langle0_L|n^2|0_L\rangle=8, \qquad \langle1_L|n^2|1_L\rangle=4.$$

The full exponential is therefore not exactly proportional to the identity on the code. Higher moment matching and a designed recovery suppress this deformation order by order; the finite-time channel is not exactly corrected merely because $\{I,a\}$ is.

Higher-Order Examples

One loss plus first-order number dephasing

To correct $\{I,a,n\}$, choose

$$L=1, \qquad G=0, \qquad D=1.$$

Then $S=1$ and $K=2$, giving

$$\begin{aligned} |0_L\rangle &= \frac{|0\rangle+\sqrt3|4\rangle}{2}, \\ |1_L\rangle &= \frac{\sqrt3|2\rangle+|6\rangle}{2}. \end{aligned}$$

The support remains even, but the longer binomial envelope matches number moments through second order. That is the extra condition required by the products generated by $I$ and $n$.

Two-loss code

For two corrected losses and first-order number dephasing,

$$L=2, \qquad G=0, \qquad D=1,$$

the minimal parameters are $S=K=2$. The codewords are

$$\begin{aligned} |0_L\rangle &= \frac{|0\rangle+\sqrt3|6\rangle}{2}, \\ |1_L\rangle &= \frac{\sqrt3|3\rangle+|9\rangle}{2}. \end{aligned}$$

The code occupies number $0$ modulo $3$. One and two losses land in residues $2$ and $1$, respectively. Measuring $n\bmod3$ distinguishes the two error orders during a correction interval, provided three or more losses are negligible or separately flagged.

One loss and one gain

For $L=G=1$ and $D=0$, one has $S=2$ and $K=1$:

$$|0_L\rangle = \frac{|0\rangle+|6\rangle}{\sqrt2}, \qquad |1_L\rangle = |3\rangle.$$

The no-error sector has residue zero modulo three. A gain gives residue one; a loss gives residue two. This example shows why the minimal spacing depends on $L+G$, not only on the larger of the two.

Complete Channels and Approximate Correction

The exact finite error set is a design target, not a complete description of dissipation over finite time.

For a pure-loss channel with transmissivity

$$\eta=e^{-\kappa\Delta t},$$

the Kraus operators can be written

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

There are infinitely many loss branches. The factor $\eta^{n/2}$ also reweights different Fock components in every branch. A code correcting $a^\ell$ for $\ell\le L$ therefore does not exactly correct every $A_\ell$ at finite $\Delta t$.

The binomial construction is nevertheless systematic. Expanding $\eta^{n/2}$ in powers of $\kappa\Delta t$ produces powers of $n$. By increasing $K$ and correcting more loss branches, one can make all retained terms satisfy approximate correction conditions to a chosen order. Under ideal syndrome extraction and recovery, the first omitted loss branches scale with higher powers of $\kappa\Delta t$.

Three qualifications matter:

1. the coefficients also depend on the occupation distribution, not only on the formal power of $\Delta t$;
2. recovery faults can dominate before the nominal code order does;
3. making $\Delta t$ shorter increases how often the ancilla, measurement, reset, and controller are used.

The useful correction cadence is therefore an optimum, not “as fast as possible.”

Thermal gain and number dephasing add further Kraus or trajectory branches. The declared $G$ and $D$ parameters are meaningful only after the physical rates, correlations, and control-induced channels have been measured. Erasure and Loss Channels derives the pure-loss channel and explains why an unobserved lost photon is not automatically a located erasure.

Syndrome Extraction, Decoding, and Recovery

Modular-number syndrome

For $M=S+1$, define residue projectors

$$\Pi_r = \sum_{q=0}^{\infty} |qM+r\rangle\langle qM+r|, \qquad r=0,\ldots,M-1.$$

Equivalently,

$$\Pi_r = \frac{1}{M} \sum_{j=0}^{M-1} e^{-2\pi i jr/M} \exp\!\left( \frac{2\pi i j}{M}n \right).$$

The code starts in residue zero. The syndrome map is

$$\begin{aligned} \ell\ {\rm losses} &: r=-\ell\pmod M, \\ g\ {\rm gains} &: r=+g\pmod M. \end{aligned}$$

With the minimal choice $S=L+G$, the declared loss and gain residues are disjoint. The measurement reveals the error class without resolving which logical superposition occupies that class.

In a physical implementation, modular number is mapped to an ancilla through a dispersive interaction, phase estimation, a tailored frequency comb, or another number-selective control. The measured ancilla record is only an estimate. Assignment errors, ancilla decay, leakage, and reset failure must enter the decoder model.

The decoder is a channel model, not a residue table

For an ideal one-error interval, decoding can be a lookup table from $r$ to a loss or gain order. Repeated operation needs more:

• a prior over multiple events within each interval;
• the full history of noisy syndrome outcomes;
• ancilla and readout error models;
• leakage and invalid-state flags;
• timing information when the logical phase depends on jump time;
• a rule for ambiguous or out-of-model records.

For the lowest code, an odd endpoint parity is compatible with one, three, five, and further odd losses. Calling it “one loss” is a short-time inference, not an algebraic identity.

Conditional recovery

Let $E_r$ denote the inferred error representative and let $U_r$ map its normalized logical error words back to the code. An idealized recovery has the form

$$\mathcal R(\rho) = \sum_{r\in\mathcal C} U_r\Pi_r\rho\Pi_r U_r^\dagger +\mathcal R_{\rm fail}(\rho).$$

Here $\mathcal C$ is the set of residues assigned to modeled correctable events. The final term acts on the complementary subspace, completes the map, and records declared failures. On each correctable sector,

$$U_r \frac{E_r|\mu_L\rangle} {\sqrt{\langle\mu_L|E_r^\dagger E_r|\mu_L\rangle}} = |\mu_L\rangle.$$

The equal norms guaranteed by the correction conditions allow the same linear isometry to recover every logical superposition. Measuring the syndrome without the conditional state transfer detects an error but does not repump energy or restore the binomial envelope.

Recovery can also be teleportation based: transfer the logical state into a fresh code block and track the byproduct in software. That exchanges a difficult in-place unitary for encoded-state preparation, entangling operations, measurements, and feedforward. Which route is cheaper is a hardware question.

Logical Gates and Fault-Tolerance Options

The discrete rotation $Z_L$ is structurally simple. Arbitrary logical rotations are not automatically simple. For example, $\exp(i\theta n/M)$ generally applies different phases to the several Fock components inside one codeword and can leave the code space unless $\theta$ has a code-compatible value.

Demonstrated and proposed control routes include:

• number-selective phase operations;
• optimal-control pulses on a cavity coupled to a nonlinear ancilla;
• self-Kerr and cross-Kerr interactions for selected rotation-code gates;
• teleportation-based gates and recovery;
• engineered multiphoton couplings;
• error-transparent or path-independent operations.

An error-transparent gate implements the same logical motion in the code and correctable error sectors. If $H_0$ is the desired code-space generator, $H_r$ is the generator in an error sector, and $E_r$ is a correctable error, the defining intertwining condition is

$$H_r E_r P = E_r H_0 P.$$

Then an error occurring at an unknown time during the gate does not change the final logical operation, up to the tracked error. Satisfying this condition for one jump does not automatically handle no-jump deformation, ancilla faults, or every higher-order loss.

A universal pulse set on the ideal code space is therefore weaker than a fault-tolerant gate set. A complete gate claim must state:

1. which oscillator and ancilla faults remain correctable during the gate;
2. whether the syndrome is extracted during or after the operation;
3. how faults propagate between modes;
4. whether the gate preserves the code’s loss and dephasing order;
5. the logical operation error under the complete noisy protocol.

Recent theory gives explicit error-transparent amplitude-mixing constructions for binomial codes, while experiments have demonstrated error-transparent phase operations and ancilla-fault-aware gates. These are important ingredients, not yet an end-to-end scalable binomial-code processor.

Physical Module and Resource Ledger

The data carrier is one oscillator mode, but a practical module typically contains more than one component.

resource	why it is needed	failure modes to count
storage mode	carries the finite Fock superpositions	loss, thermal gain, dephasing, Kerr distortion
nonlinear ancilla	state synthesis, modular-number mapping, conditional recovery	relaxation, dephasing, leakage, thermal population
readout mode and amplifier	converts ancilla state to a classical syndrome	assignment error, latency, backaction
shaped drives or frequency comb	resolves selected number sectors	off-resonant phases, amplitude drift, spectral crowding
reset channel	prepares the ancilla for the next round	residual excitation, correlated heating
controller and decoder	interprets records and triggers recovery	missed deadlines, stale calibration, model mismatch

Code-level resources should include

$$\left( M, K, \bar n, n_{\max}, \Delta t, N_{\rm tones}, N_{\rm anc}, T_{\rm latency} \right),$$

not only “one cavity.” The maximum occupied number sets a minimum control cutoff; the mean occupation contributes to raw loss exposure; the modular syndrome order controls ancilla resolution; and the correction interval sets the balance between uncorrectable data errors and control faults.

Relation to Other Bosonic Codes

Cat Codes and binomial codes can both have discrete rotation symmetry, but their envelopes are different. Cat constructions use coherent components and Poisson-like number weights; binomial constructions use a finite number-state support and exact finite moment identities. A stabilized two-component cat qubit often targets strong noise bias, whereas a binomial code is usually presented as an active correction code for a declared loss, gain, and dephasing set.

Grid codes organize small displacements modulo a phase-space lattice rather than finite shifts on a number lattice. Their ideal codewords have infinite energy and physical versions require finite squeezing; binomial codewords are normalizable finite sums from the outset.

These distinctions do not rank the families universally. The best code depends on the measured channel, available nonlinear operations, syndrome fidelity, recovery cost, energy budget, and target logical operations.

Experimental Evidence Through August 2026

The evidence should be separated by capability.

Established components

Finite number-state superpositions, parity and modular-number measurements, universal single-mode control, encode–decode maps, and conditional feedback have all been demonstrated in circuit-QED oscillator–ancilla systems.

In 2019, Hu and collaborators demonstrated repeated correction of a binomial logical qubit together with encoding, decoding, and a universal single-logical-qubit gate set. The corrected lifetime was reported as $2.8$ times the uncorrected binomial encoding, while the average process fidelity of the demonstrated logical gate set was about $97\%$. The memory approached but did not exceed the strongest physical reference used in that experiment.

In 2020, separate experiments demonstrated error-transparent phase operations and an ancilla-error-corrected gate on oscillator-encoded logical qubits. They showed that a logical operation can be designed around a correctable data error or a noisy nonlinear ancilla. Neither result by itself constituted a protected universal two-logical-qubit gate set.

Memory break-even

In 2023, Ni and collaborators used the lowest binomial code, a tailored frequency-comb syndrome pulse, and real-time feedback. The reported corrected memory lifetime exceeded the declared Fock-qubit physical reference by about $16\%$. The experiment also identified two-photon loss, syndrome error, recovery error, and ancilla thermal excitation in its cycle budget.

This is a genuine break-even result under the stated process-lifetime metric. It is not an increasing-distance threshold demonstration: one fixed lowest-order code was compared with named references.

Protected entanglement

In 2024, a two-mode bosonic module protected entanglement between spatially separated microwave-mode logical qubits using repeated correction. The reported entanglement coherence time improved by $45\%$ over the unprotected logical counterpart. This extended the discrete-Fock-space program beyond a single stored logical qubit, while leaving scalable gates, increasing code order, and full processor accounting open.

Not yet established

As of the review date, the literature does not establish all of the following in one binomial-code architecture:

• logical-error suppression across an increasing family of binomial orders;
• repeated correction during a universal set of logical one- and two-mode gates;
• fault-contained preparation, measurement, reset, and ancilla control;
• a decoder and controller meeting scalable real-time requirements;
• end-to-end algorithmic advantage after the complete module cost is counted.

Those are separate milestones. Memory gain, gate fidelity, protected entanglement, and threshold scaling should not be collapsed into one claim.

Common Mistakes

“Finite support means exact correction of physical loss”

Finite support makes state definition and control finite. The finite-time loss channel still has infinitely many Kraus branches and a no-jump exponential.

“Parity identifies exactly one loss”

Parity identifies loss number modulo two. Interpreting odd parity as one loss uses a short-time channel model.

“Equal mean occupation is enough”

Equal means suffice for the diagonal condition of the lowest $\{I,a\}$ example. Higher loss orders and dephasing require higher matched moments and off-diagonal sector separation.

“The modular rotation is a complete stabilizer description”

Its eigenspace is much larger than the two-dimensional code. The finite binomial envelope and logical split remain necessary.

“One mode means one physical component”

Syndrome extraction and recovery generally require a nonlinear ancilla, readout, reset, pumps, and a classical control path.

“A syndrome measurement is a recovery”

It diagnoses a sector. Recovery must also restore the finite superposition or teleport the logical state to a fresh code block.

“A universal encoded gate set is fault tolerant”

Universality concerns ideal reachability. Fault tolerance concerns how errors propagate and whether the complete noisy operation improves with code resources.

“Higher order is automatically better”

Higher order raises occupation, cutoff, syndrome complexity, and recovery duration. At fixed hardware fidelity, a lower-order code can have lower total logical error.

Exercises

1. Normalize the codewords

Show that the even and odd coefficient sums in the binomial code each equal $2^K$.

Solution

The binomial theorem gives

$$(1+x)^{K+1} = \sum_{p=0}^{K+1} \binom{K+1}{p}x^p.$$

At $x=1$,

$$\sum_p\binom{K+1}{p} = 2^{K+1}.$$

At $x=-1$,

$$\sum_p(-1)^p\binom{K+1}{p} =0.$$

Adding and subtracting these equations isolates the even and odd sums:

$$\sum_{p\ {\rm even}}\binom{K+1}{p} = \sum_{p\ {\rm odd}}\binom{K+1}{p} = 2^K.$$

The squared amplitudes in either logical codeword therefore sum to one.

2. Derive the mean occupation

For $K\ge1$, show that both logical codewords have

$$\bar n=\frac{(K+1)(S+1)}{2}.$$

Solution

Differentiate the binomial generating function:

$$\sum_{p=0}^{K+1} p\binom{K+1}{p}x^p = x(K+1)(1+x)^K.$$

For $K\ge1$, evaluation at $x=-1$ shows that the alternating first moment vanishes. Thus the even and odd first-moment sums are equal. Their total at $x=1$ is

$$(K+1)2^K.$$

Each parity sum is therefore $(K+1)2^{K-1}$. Multiplying by the number spacing $S+1$ and the normalization $2^{-K}$ gives

$$\bar n = (S+1)2^{-K} (K+1)2^{K-1} = \frac{(K+1)(S+1)}{2}.$$

3. Verify the lowest-code correction conditions

For

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

verify $P a P=0$ and $P a^\dagger a P=2P$.

Solution

The code has even parity, while $a$ maps every component to odd parity. Therefore every matrix element of $a$ within the code vanishes:

$$P a P=0.$$

For the diagonal product,

$$\begin{aligned} \langle0_L|n|0_L\rangle &= \frac{0+4}{2} =2, \\ \langle1_L|n|1_L\rangle &= 2. \end{aligned}$$

The off-diagonal matrix element vanishes because the number supports are disjoint:

$$\langle0_L|n|1_L\rangle=0.$$

Hence

$$P a^\dagger a P = P n P = 2P.$$

These are the Knill–Laflamme conditions for the error set $\{I,a\}$.

4. Read the modular syndrome

A code has $L=2$, $G=1$, so the minimal $M=S+1$ is four. List the residues for no error, one loss, two losses, and one gain. Explain why they are distinguishable.

Solution

The code begins at residue zero modulo four. Number loss decreases the residue, while gain increases it:

$$\begin{array}{c|c} \text{event} & n\bmod4 \\ \hline \text{no error} & 0 \\ \text{one loss} & 3 \\ \text{two losses} & 2 \\ \text{one gain} & 1 \end{array}$$

All four residues differ. This is the reason for choosing

$$M=L+G+1.$$

A larger error count can wrap around modulo four and become ambiguous, so the interpretation still relies on the declared channel and correction interval.

5. Construct a two-loss code

Use the general formula for $L=2$, $G=0$, and $D=1$. Find $S$, $K$, the codewords, $\bar n$, and $n_{\max}$.

Solution

The minimal parameters are

$$S=L+G=2, \qquad K=\max\{2,0,2\}=2.$$

Since $K+1=3$ and $S+1=3$,

$$\begin{aligned} |0_L\rangle &= \frac{|0\rangle+\sqrt3|6\rangle}{2}, \\ |1_L\rangle &= \frac{\sqrt3|3\rangle+|9\rangle}{2}. \end{aligned}$$

The mean and cutoff are

$$\bar n = \frac{(K+1)(S+1)}{2} = \frac92,$$

and

$$n_{\max} =(K+1)(S+1) =9.$$

The code corrects the declared discrete set $\{I,a,a^2,n\}$, while finite-time performance still depends on recovery and cadence.

6. Expose the no-jump leakage

Define

$$|0_\perp\rangle = \frac{|0\rangle-|4\rangle}{\sqrt2}.$$

Show that, for the lowest code,

$$n|0_L\rangle = 2|0_L\rangle-2|0_\perp\rangle.$$

What does this imply for no-jump evolution?

Solution

Directly,

$$n|0_L\rangle = \frac{4|4\rangle}{\sqrt2}.$$

Using

$$|4\rangle = \frac{|0_L\rangle-|0_\perp\rangle}{\sqrt2},$$

gives

$$n|0_L\rangle = 2|0_L\rangle-2|0_\perp\rangle.$$

The first-order no-jump operator is

$$A_0 \simeq I-\frac{\kappa\Delta t}{2}n.$$

It therefore creates an amplitude outside the code space even when no photon jump is observed. The projected logical component is state independent to first order because $P n P=2P$, but a complete recovery must handle the deformation and higher-order terms.

7. Optimize a toy correction cadence

Suppose the logical error rate per unit time is modeled by

$$\Gamma_{\rm L}(\Delta t) = A\Delta t^L +\frac{q}{\Delta t},$$

where the first term represents uncorrectable data errors and $q$ is the error probability added by each correction cycle. Find the optimal $\Delta t$.

Solution

Differentiate:

$$\frac{d\Gamma_{\rm L}}{d\Delta t} = AL\Delta t^{L-1} -\frac{q}{\Delta t^2}.$$

Setting this to zero gives

$$AL\Delta t^{L+1} =q.$$

Therefore,

$$\Delta t_{\rm opt} = \left( \frac{q}{AL} \right)^{1/(L+1)}.$$

The optimum moves to shorter intervals when uncorrectable data errors grow, and to longer intervals when each recovery cycle is costly. The model is deliberately simplified, but it captures why maximal syndrome frequency is not automatically optimal.

8. Classify a break-even claim

An experiment reports that a corrected lowest-order binomial memory lasts $1.16$ times longer than a Fock-qubit reference and $2.9$ times longer than the uncorrected binomial encoding. It tests only one code order. Which claims are supported?

Solution

If the time, state ensemble, fitting rule, acceptance policy, and uncertainty are matched, the result supports:

• improvement from active correction over the uncorrected encoding;
• break-even against the declared Fock-qubit reference;
• an end-to-end memory result for that device and protocol.

It does not by itself support:

• suppression with increasing binomial-code distance;
• a threshold;
• fault-tolerant logical gates;
• lower processor overhead than another architecture;
• useful algorithm depth.

Those claims require additional scaling, operation, and resource evidence.

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. 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.
3. 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.
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. R. W. Heeres et al., “Implementing a universal gate set on a logical qubit encoded in an oscillator,” Nature Communications 8, 94 (2017), doi:10.1038/s41467-017-00045-1.
7. 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.
8. 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.
9. 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.
10. P. Reinhold et al., “Error-corrected gates on an encoded qubit,” Nature Physics 16, 822–826 (2020), doi:10.1038/s41567-020-0931-8.
11. 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.
12. 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.
13. W. Cai et al., “Protecting entanglement between logical qubits via quantum error correction,” Nature Physics 20, 1022–1026 (2024), doi:10.1038/s41567-024-02446-8.
14. Q. Xu, P. Zeng, D. Xu, and L. Jiang, “Fault-tolerant operation of bosonic qubits with discrete-variable ancillae,” Physical Review X 14, 031016 (2024), doi:10.1103/PhysRevX.14.031016.
15. O. C. Wetherbee, S. Roy, B. Royer, and V. Fatemi, “A mathematical structure for amplitude-mixing error-transparent gates for binomial codes,” Quantum 9, 1890 (2025), doi:10.22331/q-2025-10-21-1890.

Further Connections

• Number States develops the ladder-operator action and number-state normalization used throughout the construction.
• Bosonic Codes supplies channel-level recovery metrics, approximate correction, energy constraints, and comparisons among oscillator code geometries.
• Cat Codes develops the coherent-state branch of rotation-symmetric codes and distinguishes active loss correction from stabilized noise bias.
• Control, Readout, and Calibration develops ancilla mapping, assignment matrices, reset, feedback latency, drift, and calibration loops.
• Error-Correction Case Studies compares the 2019 and 2023 memory benchmarks with surface-code, cat-code, and grid-code evidence under common reporting rules.
• Fault-Tolerant Quantum Computing Frontier places bosonic inner codes inside the larger architecture, gate, decoder, and resource problem.