By using entanglement purification, we can produce a high-fidelity entangled state from several pieces of low-fidelity entangled states. From my study, there is a protocol proposed by Bennett et al.

Further improvements were made by Deutsh Protocol. But if we closely observe these two schemes, we see that they are not particularly great for producing high-fidelity entangled states. Besides, they are based on trial and error, so in my opinion, there should be much more sophisticated schemes. I wonder if someone can help me suggesting some existing efficient schemes regarding this matter. I am a newbie in this field, so please keep this in mind as well. Thank you.


2 Answers 2


Imagine you have $n$ noisy copies of a maximally entangled state, where Alice has one half of each and Bob has the other half. Pick your favourite error correcting code on $n$ qubits that encodes one logical qubit (meaning the one that has the highest error correcting threshold for your particular noise model). This has logical states $|0\rangle_L$ and $|1\rangle_L$.

Alice prepares an $n+1$ qubit state $$ \frac{1}{\sqrt{2}}(|0\rangle|0\rangle_L+|1\rangle|1\rangle_L). $$ She takes the $n$ qubits of the logical state, and teleports each of them through one of the noisy Bell pairs. So, a noisy version of the logical qubits arrives with Bob.

Bob performs error correction and decoding on the qubits he holds. With some probability (defined by your error correcting code and the noise model), correction succeeds, in which case you would have a pure maximally entangled state shared between Alice and Bob. In practice, due to the non-zero failure probability, they'll share a mixture of the 4 possible Bell states, but if you've picked your code correctly, the purity will be much higher.

So, the problem is "simply" transformed into one of finding the best possible error correcting code for your actual noise model. You probably want to assume a noise model that acts on each noisy Bell pair independently. For example, if you took depolarising noise, there are well-known results about how well error correcting codes can possible work. For example, it is reported here that $$ 1=2p\log_2(3)+h(2p) $$ is the behaviour in the asymptotic limit ($n\rightarrow\infty$) for a case where the per-qubit error probability is $p$ and $h(p)$ is the binary entropy function. This should give you a benchmark for how well any finite sized case you choose might be performing. For example, the Toric Code gets pretty tight to this bound (as I tested numerically here, although I imagine there are plenty of other sources!)

  • $\begingroup$ Thank you very much, sir. $\endgroup$ Apr 7, 2022 at 8:24

Any stabilizer code can be used for entanglement purification. Normally stabilizer codes are presented as being encoded, transmitted with noise, and then decoded. Errors are corrected by comparing stabilizer measurements on the encoding side to stabilizer measurements on the decoding side. The transmitted message is in the logical observables of the code. Call this the "transmission ordering".

But the same idea works when comparing stabilizer measurements on the two sides of a set of Bell pairs. The steps are simply re-ordered: noisy Bell pairs are transmitted to the two parties, they both measure the stabilizers of the code on their half of the Bell pairs, and they detect and/or correct errors by comparing the measurements. The corrected entanglement is in the logical observables of the code. Call this the "teleportation ordering".

A major advantage of the teleportation ordering is that you can use error detection instead of error correction. It's fine to discard a suspicious attempt, because you aren't risking an important qubit; just a replaceable Bell pair. Error detecting codes have much better performance (for example, when using a stabilizer code, detecting errors has twice the distance of correcting errors).

Here's one possible strategy for getting to 1-per-billion error rates, parameterized by the input Bell pair fidelity $F$:

  • If $F \leq 0.5$, give up because the states you are sharing are provably not entangled, so it's impossible to purify entanglement out of them. You must improve your physical channel until its fidelity exceeds 50%. Ideally not by a little (e.g. $F=0.51$) but by a lot (e.g. $F=0.9$).
  • If $F \leq 0.999$, use the absolute smallest code that you can: the distance 2 repetition code. You have a choice of three different repetition codes: X basis, Y basis, or Z basis. The code with basis $A$ has a single stabilizer $A \otimes A$. Pick the basis that will detect the most errors, given what you know about the bias in your input noise. This produces output states with a better fidelity $F^\prime$, and with noise biased more towards the basis you checked. Re-apply this overall strategy, treating your outputs as a new input. Generally you will need at least two rep code stages to see the fidelity improve substantially, as otherwise you are not detecting error in all bases.
  • If $F > 0.999$, use the "perfect code"; the [[5,1,3]] code with stabilizers $XZZXI$, $IXZZX$, $XIXZZ$, and $ZXIXZ$. Use it in error detecting mode, where if any of the stabilizers disagree you discard. This will launch you to the desired one error per billion transmissions.

If "X" is the X basis [2,1,2] rep code, "Y" is the Y basis [2,1,2] rep code, "Z" is the Z basis [2,1,2] rep code, and "P" is the [[5,1,3]] code, then the stages of the distillation process can be described by a string like "XZP" meaning "input Bell pairs get checked by X [2,1,2], the survivors of that then get checked by Z [2,1,2], the survivors of that then get checked by the perfect code, the survivors of that are the output".

For a starting fidelity of 0.99, your stages will look something like "XZP". This sequence of stages happens to be a distance 2 Shor code concatenated with the perfect code. It will take ~21 inputs to produce 1 output with ~1e-9 output error rate.

For a starting fidelity of 0.9, your stages will look something like "XYZP". It will take ~54 inputs to produce 1 output with ~1e-9 output error rate.

For a starting fidelity of 2/3, your stages will look something like "XZYZYZP". It will take ~1500 inputs to produce 1 output with ~1e-9 output error rate.

Note that I am assuming the purifying computers are perfect. In practice this would be achieved by having them be fault tolerant quantum computers, so the whole purification process is actually (for example) being performed on data injected into, stored in, and operated on within, surface codes.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.