
Concentrate One Entangled Pair: A Local Filter with a Success Flag
Use a local filter to turn a known uneven pure pair into a Bell pair on success. Verify both outcomes in NumPy and see why Bob needs a classical flag.
Alice and Bob share a pure entangled pair, but its two Schmidt weights are unequal. Can they turn it into a perfect Bell pair without bringing their qubits together?
They can try. A local filter on Alice's qubit can produce a Bell pair in a heralded subset of runs. The price is failure in the remaining runs. Keeping that success flag in the calculation is what makes the protocol physical.
Start with a known, uneven pair
Use the state:
|psi> = sqrt(lambda)|00> + sqrt(1-lambda)|11>
1/2 <= lambda < 1
Alice owns the first qubit and Bob the second. The basis and lambda are known, and the amplitudes shown are real and nonnegative. The squared amplitudes lambda and 1-lambda are the Schmidt weights.
At lambda = 1/2, this is already the Bell state (|00> + |11>)/sqrt(2). As lambda approaches one, the state becomes less entangled. At exactly one it is a product state, which is why that endpoint is excluded from our Bell-pair conversion example.
Local unitary gates can change the Schmidt bases, but not the Schmidt weights. Equalizing unequal weights therefore needs something other than a deterministic unitary on Alice's qubit.
The original entanglement-concentration paper by Bennett and colleagues describes a single-pair approach called the Procrustean method: attenuate the larger component and keep only the successful outcomes. Unlike some many-copy concentration protocols, this filter requires the initial bias to be known.
Attenuate the larger component
Alice performs a two-outcome generalized measurement. Its success and failure Kraus operators are:
Ks = diag(sqrt((1-lambda)/lambda), 1)
Kf = diag(sqrt((2lambda-1)/lambda), 0)
Here diag(a,b) means the two-by-two diagonal matrix with entries a and b. The operators satisfy Ks†Ks + Kf†Kf = I, so together they account for all outcomes. The dagger denotes conjugate transpose.
Only Alice's qubit is filtered. Bob's operation is the identity. On the success branch:
(Ks tensor I)|psi> = sqrt(1-lambda)(|00> + |11>)
p_success = 2(1-lambda)
The vector on the right is unnormalized. Its squared norm is the probability of success. Dividing by sqrt(p_success) gives the Bell state.
On failure, the unnormalized vector is sqrt(2lambda-1)|00>. Its probability is 2lambda-1, and its normalized state is the unentangled product |00> whenever that probability is nonzero.
For lambda = 0.8, Ks is diag(0.5,1). It halves the larger amplitude, rather than increasing the smaller one. The filter succeeds with probability 0.4 and fails with probability 0.6. At lambda = 0.5 the failure outcome has zero probability and must not be normalized.
A generalized measurement can be implemented by coupling Alice's qubit to a local ancilla and measuring that ancilla. It is not a unitary gate on Alice's qubit alone, and it need not reveal whether the retained pair is in |00> or |11>. Revealing that which-component information would destroy the coherence we want to keep.
Check both branches in NumPy
The tensor order below is Alice first, Bob second. The basis order is |00>, |01>, |10>, |11>. The code evaluates an ideal measurement model, not a hardware implementation or a Monte Carlo experiment.
import numpy as np
lam = 0.8
psi = np.array([np.sqrt(lam), 0, 0, np.sqrt(1-lam)], complex)
I = np.eye(2, dtype=complex)
Ks = np.diag([np.sqrt((1-lam)/lam), 1]).astype(complex)
Kf = np.diag([np.sqrt((2*lam-1)/lam), 0]).astype(complex)
assert np.allclose(Ks.conj().T @ Ks + Kf.conj().T @ Kf, I)
bell = np.array([1, 0, 0, 1], complex) / np.sqrt(2)
rho_after = np.zeros((4, 4), dtype=complex)
for label, K in [("success", Ks), ("failure", Kf)]:
branch = np.kron(K, I) @ psi
probability = np.vdot(branch, branch).real
rho_after += np.outer(branch, branch.conj())
print(f"{label}: probability={probability:.3f}")
if probability > 1e-12:
conditional = branch / np.sqrt(probability)
if label == "success":
assert np.isclose(abs(np.vdot(bell, conditional))**2, 1)
else:
assert np.allclose(conditional, [1, 0, 0, 0])
# Axes: Alice row, Bob row, Alice column, Bob column.
rho_bob = np.trace(rho_after.reshape(2, 2, 2, 2), axis1=0, axis2=2)
print("Bob without the flag:", np.round(np.diag(rho_bob).real, 6))
assert np.allclose(rho_bob, np.diag([lam, 1-lam]))
Output:
success: probability=0.400
failure: probability=0.600
Bob without the flag: [0.8 0.2]
The branch probabilities are obtained before normalization. Normalizing each branch first and then pretending both are equally likely would describe a different, incorrect process.
Why Bob needs the flag
Alice tells Bob which runs succeeded using ordinary classical communication. They keep those pairs and discard the others.
If the outcome is ignored, the joint state is not a perfect Bell pair. In this example it is:
0.4 |Phi+><Phi+| + 0.6 |00><00|
Bob's reduced state, without Alice's flag, remains diag(0.8,0.2), exactly as it was before her local measurement. Within the successful subset it is I/2; within the failed subset it is |0><0|. Those conditional ensembles average back to the original reduced state.
Bob cannot sort the subsets using the flag before the flag arrives. The local filter therefore does not provide faster-than-light signalling. It changes which joint pairs are retained, not the statistics Bob can observe from his unsorted qubits alone.
Concentration is not a free entanglement upgrade
A successful pair has more entanglement than the original pair, but local operations and classical communication do not increase entanglement on average. Failure runs count too. Selecting only successes does not erase the cost of the discarded pairs.
This example concerns a known, partially entangled pure state. It is not a recipe for purifying an arbitrary noisy mixed state, and it differs from protocols that process several noisy pairs to retain a cleaner one. A review of pure-state entanglement concentration explains that distinction and the role of local filters.
The useful programming habit is simple: write the success operator, write its complementary failure operator, calculate each probability from the unnormalized branch, and only then condition on the result you keep. The success flag is part of the protocol, not an optional annotation.