Degenerate Codes

Degeneracy is a feature of quantum codes with no classical counterpart: two different errors can have identical effect on the codespace. Far from a defect, degeneracy lets some codes correct more errors than a naive counting argument would allow, and it forces us to refine what "correct an error" really means.

The definition

Recall the Knill–Laflamme conditions $P E_a^\dagger E_b P = \alpha_{ab} P$ with the Hermitian matrix $\alpha$ . A code is non-degenerate if $\alpha$ has full rank — each correctable error maps the codespace to a distinct orthogonal subspace. A code is degenerate if $\alpha$ is singular: there exist distinct correctable errors $E_a \ne E_b$ whose difference acts trivially, i.e. $P E_a^\dagger E_b P = \alpha_{ab} P$ with the same scaling as a stabilizer.

In the stabilizer language the criterion is sharp. Errors $E_a$ and $E_b$ are degenerate when

E_a^\dagger E_b \in \mathcal{S},

their product lies in the stabilizer group. Then $E_a$ and $E_b$ act on every codeword identically (they differ only by an operator that fixes the codespace pointwise), share the same syndrome, and — crucially — the same recovery undoes both.

Why it does not matter which one happened

If $E_a^\dagger E_b \in \mathcal S$ , then applying the recovery for $E_a$ when in fact $E_b$ occurred still returns the state to the codespace correctly: the residual operator $E_a^\dagger E_b$ is a stabilizer and acts as identity on codewords. We never need to distinguish degenerate errors — we only need to remove their common syndrome. This is why a degenerate code can have fewer distinct syndromes than errors and still work.

The Shor code is degenerate

In Shor's $[[9,1,3]]$ code, $Z_1$ and $Z_2$ are distinct weight-one errors, yet $Z_1 Z_2$ is a near stabilizer-equivalent operation on the first block: both merely flip the sign of that block's $(|000\rangle+|111\rangle)$ factor in the same way, so they produce the same effect on the logical state and the same syndrome. The code corrects single-qubit phase errors without giving each its own orthogonal subspace.

Why degeneracy is powerful

Because degenerate codes reuse syndromes, the quantum Hamming bound — derived assuming distinct orthogonal error subspaces — need not apply to them. A degenerate code can in principle pack correctable errors more tightly than $2^k\sum_j \binom{n}{j}3^j \le 2^n$ would allow, beating the non-degenerate floor. Whether degeneracy can asymptotically improve the best achievable rates was a long-standing open problem; it underlies much of the interest in high-rate quantum codes.

A subtlety for fault tolerance

Degeneracy complicates decoding. A decoder must identify the coset of equivalent errors (the syndrome class), not a unique error — many physical errors share a recovery. Good decoders for topological codes (next module) exploit exactly this: they sum probabilities over degenerate error configurations rather than betting on one.

The takeaway

A code is degenerate when distinct correctable errors differ by a stabilizer, $E_a^\dagger E_b \in \mathcal S$ , so they act identically on codewords and share a recovery. Degeneracy is a purely quantum effect that lets codes evade the non-degenerate quantum Hamming bound and reuse syndromes — at the cost of decoders that work with error cosets rather than single errors.