Quantum Erasure Channels: A Missing Qubit Is Not a Reset

Quantum Erasure Channels: A Missing Qubit Is Not a Reset

Model a flagged erasure with three output states, test it in NumPy, and see why detecting loss preserves surviving coherence but does not recover a missing qubit.

A lost qubit is not the same thing as a qubit in state |0>. That sounds obvious until a simulator quietly replaces one with the other.

The difference matters because an erasure comes with a useful piece of information: the receiver knows which transmission failed. That flag does not recover the missing quantum state, but it changes what a decoder can know without measuring the surviving data.

Let's build the smallest useful model and see exactly what the flag buys us.

Give loss its own state

A qubit lives in the span of |0> and |1>. The ideal quantum erasure channel adds a third, orthogonal output state, which we will call |e>.

For an input density matrix rho and a state-independent erasure probability p, the output is

E_p(rho) = (1 - p) V rho V† + p |e><e|,

where V embeds the two-dimensional input into the first two coordinates of the three-dimensional output. The output basis is ordered |0>, |1>, |e>.

The channel has two mutually exclusive outcomes. With probability 1 - p, the state arrives unchanged in the qubit subspace. With probability p, it is replaced by |e>. This is a probabilistic mixture, not a coherent superposition of arrival and loss.

The orthogonal erasure state is the defining feature in Bennett, DiVincenzo, and Smolin's original treatment. It represents an ideal, reliably distinguishable loss flag. It need not mean a device literally has a third controllable energy level; a vacuum outcome or an explicit loss register can play that role in an appropriate physical model.

Detect loss without asking whether the qubit is zero

Consider the two projectors

P_ok = |0><0| + |1><1|

and

P_erased = |e><e|.

This measurement asks whether the output lies inside the qubit subspace. It does not distinguish |0> from |1> within that subspace.

For an ideal erasure channel, an accepted output has conditional state V rho V† whenever 1 - p is nonzero. If the input was a superposition, the surviving branch retains that superposition. The probability of acceptance does not depend on its amplitudes.

An erasure outcome is different. The receiver gets |e>, independent of rho. Knowing that a state was lost is not the same as knowing what it was. No operation on that flag alone can reconstruct every possible unknown input.

This is also why checking a loss flag is not equivalent to measuring the data in the computational basis. A Z measurement can distinguish |0> from |1> and destroy their coherence. The ideal flag measurement only separates the entire qubit subspace from an orthogonal failure subspace.

Build the channel in NumPy

Rectangular Kraus operators make the change of output dimension explicit. Each operator below maps two input coordinates to three output coordinates.

import numpy as np

p = 0.25
V = np.array([[1, 0], [0, 1], [0, 0]], dtype=complex)
e = np.array([0, 0, 1], dtype=complex)

K_ok = np.sqrt(1 - p) * V
K_0 = np.sqrt(p) * np.outer(e, [1, 0])
K_1 = np.sqrt(p) * np.outer(e, [0, 1])
kraus = [K_ok, K_0, K_1]

# Trace preservation is checked on the input space.
assert np.allclose(
    sum(K.conj().T @ K for K in kraus), np.eye(2)
)

plus = np.array([1, 1], dtype=complex) / np.sqrt(2)
rho = np.outer(plus, plus.conj())
out = sum(K @ rho @ K.conj().T for K in kraus)

P_ok = V @ V.conj().T
accepted = P_ok @ out @ P_ok
p_ok = np.trace(accepted).real
conditional = accepted / p_ok  # Valid here because p_ok > 0.

print("Erasure output:")
print(np.round(out.real, 3))
print(f"Survival probability: {p_ok:.3f}")
print("Surviving qubit is unchanged:", np.allclose(
    V.conj().T @ conditional @ V, rho
))

# Compare with replacement by |0> in the original qubit space.
zero = np.array([1, 0], dtype=complex)
reset_mix = (1 - p) * rho + p * np.outer(zero, zero.conj())
print("Unflagged replacement output:")
print(np.round(reset_mix.real, 3))

The output is

Erasure output:
[[0.375 0.375 0.   ]
 [0.375 0.375 0.   ]
 [0.    0.    0.25 ]]
Survival probability: 0.750
Surviving qubit is unchanged: True
Unflagged replacement output:
[[0.625 0.375]
 [0.375 0.375]]

The upper-left block is the original |+> density matrix multiplied by 0.75. Conditioning on survival divides that block by 0.75 and restores the original normalization. The final coordinate stores the 0.25 erasure probability, not a third amplitude of the surviving qubit.

The second matrix models a different channel: with probability p, replace the input by |0> without retaining a flag. Its replacement outcome overlaps the valid qubit space, so a receiver cannot reliably identify every replacement without additional information. There is no orthogonal failure slot to inspect.

These are exact density-matrix calculations, not sampled hardware results. At p = 1, the accepted branch has zero probability and must not be normalized.

Why a flag helps, but does not make quantum loss free

An error-correcting code can distribute logical information across several physical carriers. A reliable loss record tells the decoder which locations need attention. It does not tell the decoder the missing amplitudes, nor does it guarantee that an arbitrary code can recover from that loss pattern.

There is a useful warning against equating survival fraction with quantum communication rate. For independent uses of this ideal qubit erasure channel, its unassisted asymptotic quantum capacity is

Q = max(0, 1 - 2p) qubits per channel use.

At p = 0.25, 75% of individual transmissions survive, but the unassisted capacity is 0.5 qubits per use, not 0.75. Capacity describes the best asymptotic rate for reliably transmitting arbitrary quantum information with encoding and decoding across many uses. It is not the success probability of our one-qubit example.

The same original paper distinguishes that resource setting from one with free two-way classical communication, whose quantum capacity is 1 - p. Those are different communication tasks, not conflicting formulas. The capacity statements assume the ideal memoryless channel, not arbitrary correlated loss or imperfect flag detection.

The practical lesson is smaller than a capacity theorem: represent failure information honestly. If your model claims to simulate a flagged erasure, preserve the flag. Replacing loss with an ordinary |0> changes the channel and throws away precisely the information that makes an erasure special.