Tetrationally Compact Entanglement Purification

I’ll be using a digitized noise model of shared EPR pairs. Errors are modelled by assuming that, when an EPR pair is shared, an unwanted Pauli may have been applied to one of its qubits. There are four Paulis that may be applied: the identity Pauli $I$ resulting in the correct shared state $B_{I}=|00\rangle+|11\rangle$, the bit flip $X$ resulting in the state $B_{X}=|01\rangle+|10\rangle$, the phase flip $Z$ resulting in the state $B_{Z}=|00\rangle-|11\rangle$, and the combined bit phase flip $Y$ resulting in the state $B_{Y}=|01\rangle-|10\rangle$.

I will represent noisy EPR pairs using a four dimensional vector of odds. The vector

describes a noisy EPR pair where the odds of the applied Pauli being $I$, $X$, $Y$, or $Z$ are $w:x:y:z$ respectively. Note that this is a degenerate representation: there are multiple ways to represent the same noisy state. The exact density matrix of a noisy state described by an odds vector is:

Note that this noise model can’t represent coherent errors, like an unwanted $\sqrt[9]{X}$ gate being applied to one of the qubits of an EPR pair. Some readers may worry that this means my analysis won’t apply to coherent noise. This isn’t actually a problem, because the purification process will digitize the noise. But, for the truly paranoid, coherent noise can be forcibly transformed into incoherent noise by Pauli twirling. If Alice and Bob have an EPR pair that has undergone coherent noise, they can pick a Pauli $P\in\{I,X,Y,Z\}$ uniformly at random then apply $P$ to both qubits and forget $P$. The density matrix describing the state after applying the random $P$, not conditioned on which $P$ was used, is expressible in the digitized noise model I’m using. Discarding coherence information in this way is suboptimal, but sufficient for correctness.

Often, the exact odds will be inconveniently complicated and it will be beneficial to simplify them even if that makes the state worse. For that purpose, I define $u\xrightarrow{\text{decay}}v$ to mean "a state with odds vector $u$ can be turned into a state with odds vector $v$ via the addition of artificial noise". A sufficient condition for this relationship to hold is for the identity term to not grow and for the error terms to not shrink:

The basic building block used by this paper is distillation with distance 2 rep codes. There are three relevant rep codes: X basis, Y basis, and Z basis. The X basis rep code has the stabilizer $XX$, the logical X observable $XI$, and the logical Z observable $ZY$. The Y basis rep code has the stabilizer $YY$, the logical X observable $XZ$, and the logical Z observable $ZZ$. The Z basis rep code has the stabilizer $ZZ$, the logical X observable $XY$, and the logical Z observable $ZI$. Beware that the choice of observables is slightly non-standard, and that their exact definition matters as it determines how errors propagate through the distillation process. See Figure 1 for circuits implementing these details correctly.

A rep code distillation is performed by Alice and Bob each measuring the stabilizer of the rep code, and comparing their results by using classical communication. If the results differ from the result predicted by assuming they have shared copies of $|00\rangle+|11\rangle$, an error has been detected. Equivalently, an error is detected if the stabilizer of the rep code anticommutes with the combination of the noisy Paulis applied to the input EPR pairs. For example, an X basis rep code will raise a detection event if given a correct EPR pair and a phase flipped EPR pair. Conversely, it won’t detect a problem if given a bit flipped EPR pair or if given two phase flipped EPR pairs.

Stepping back, a rep code distillation takes two noisy EPR pairs as input. It has some chance of detecting an error and discarding. Otherwise it succeeds and produces one output. See Figure 2 for diagrams showing how each rep code catches errors.

To analyze rep code distillation, it’s necessary to be able to compute the chance of discarding and the noise model describing the state output upon success. I’ll use $v\stackrel{{\scriptstyle B}}{{\star}}w$ to represent the probability of a $B$-basis rep code distillation detecting an error. I used sympy to enumerate the cases detected by each rep code and symbolically accumulate the probability of a failure. The probabilities of a distillation failure for each basis are:

I’ll use $u\stackrel{{\scriptstyle B}}{{\oplus}}v$ to represent the state output by distilling a state $u$ against a state $v$ with a basis-$B$ rep code, given that no error was detected. I used sympy to enumerate the cases not detected by each rep code, and symbolically accumulate the weight of each output case. When distillation succeeds, the output states for each basis are:

Note that $u\stackrel{{\scriptstyle B}}{{\oplus}}v$ is left-associative. Also note that all these operators behave as you would expect with respect to decaying: if $a_{1}\xrightarrow{\text{decay}}a_{2}$, and $b_{1}\xrightarrow{\text{decay}}b_{2}$, and all states have less than 50% infidelity, then $\left(a_{1}\stackrel{{\scriptstyle B}}{{\oplus}}b_{1}\right)\xrightarrow{\text{decay}}\left(a_{2}\stackrel{{\scriptstyle B}}{{\oplus}}b_{2}\right)$ and $\left(a_{1}\stackrel{{\scriptstyle B}}{{\star}}b_{1}\right)\leq\left(a_{2}\stackrel{{\scriptstyle B}}{{\star}}b_{2}\right)$. This allows bounds on actual distilled states to be proved via bounds on decayed distilled states.

Purifying with one enormous error detecting code doesn’t work very well. The issue is that, with large codes, the chances of seeing no detection events is extremely small. This can result in over-discarding, where the purification process becomes inefficient because nothing is ever good enough. It’s more efficient to purify with a series of smaller stages, as shown in Figure 3, where each stage applies a small code and only successful outputs are collected to be used as inputs for the next stage.

For example, consider a process where input EPR pairs $u$ are distilled by an X basis rep code, and then survivor states $v$ are distilled by a Z basis rep code to produce final states $w$. I describe this distillation chain using the notation $u\xrightarrow{X}v\xrightarrow{Z}w$. The $[[4,1,2]]$ Shor code [Sho95] is also defined by concatenating a distance two X rep code with a distance two Z rep code, so you may expect a single stage distillation with the [[4,1,2]] code to behave identically. The distillation chain $u\xrightarrow{[[4,1,2]]}w$ does produce the same output as $u\xrightarrow{X}v\xrightarrow{Z}w$, but it succeeds at a slightly slower rate. The issue is that when the $[[4,1,2]]$ distillation detects a Z error, it costs 4 input pairs because the $[[4,1,2]]$ code takes all 4 data qubits in one group. The two stage distillation detects Z errors during the first stage, so a Z error will only costs 2 input pairs.

A simple staging construction that purifies entanglement reasonably well is to alternate between stages that distill using the X basis rep code and stages that distill using the Z basis rep code:

The error suppression of an X stage followed by a Z stage is quadratic, because any single error will be caught by one stage or the other. Furthermore, each stage only needs one qubit of storage because, as soon as two qubits are ready within one stage, they are distilled into one qubit in the next stage. $O(1)$ additional stages cost $O(1)$ additional space to square the infidelity. Therefore, given a target $\epsilon$, alternating between X rep code and Z rep code stages can reach that infidelity using $O(\log\log\frac{1}{\epsilon})$ storage.

In the previous subsection, each stage distilled copies of the output from the previous stage. Distillation was always combining two of the best-so-far state. “Boosting” is an alternative technique, where a good state is improved by repeatedly merging mediocre states into it. (Note: in the literature, “boosting” is more commonly called “pumping” [DB03]). In particular, staging as described in the previous subsection results in states being combined like this:

That kind of merging requires an amount of storage that increases with the amount of nesting. You can instead combine states like this:

Here the result can be built up in a streaming fashion, with identical “booster states” arriving one by one to be folded into a single gradually improving “boosted state”.

The upside of boosting is that it squeezes more benefit out of a state that you are able to repeatedly make. The downside of boosting is that it can only be repeated a finite number of times. The boosted state doesn’t get arbitrarily good under the limit of infinite boosting. It approaches a floor set by the booster state’s error rates. A second downside is that, because each booster state has a fixed chance of failing, the chance of detecting an error and having to restart the boosting process limits to 100% as more boosts are performed. The infidelity floor and the growing restart chance force you to eventually stop boosting and start a new stage.

Suppose you have access to a booster state $A$ where the $X$, $Y$, and $Z$ errors of $A$ are all equal. You are boosting a state where the $X$ and $Z$ terms are equal. The following relationships hold:

In other words: boosting with $A$ using a $Y$ basis rep code additively increases the chance of a $Y$ error and the chance of discarding, but multiplicatively suppresses $X$ and $Z$ errors.

If this boosting process is repeated $\lfloor\sqrt[3]{1/a}\rfloor-1$ times, the output is:

If the state being boosted is $A$ itself, then the result after all these boosts has exponentially smaller $X$ and $Z$ error rates (as long as the infidelity is small enough to begin with, e.g. less than 0.1%):

In this sequence of boosts, the first one is the most likely to discard. The chance of any of the boosts discarding can be upper bounded by multiplying this probability by the number of boosts:

The bias boosting stage creates an enormous disparity between the $Y$ error rate and the other error rates. The bias busting stage fixes this; bringing the $Y$ error rate down to match the others without increasing them by much.

This stage boosts using the biased state $B$ output from the previous stage. This state has equal $X$ and $Z$ terms that are much smaller than its $Y$ term. The boosts alternate between distilling with the X basis rep code and the Z basis rep code:

Assuming the initial infidelity is small enough (e.g. less than 0.1%), the chance of this pair of boosts failing is at most:

The simplification to $10\beta$ is done by knowing that, immediately after a bias boosting stage, $\beta$ will be the largest term and the $\alpha$ and $x$ terms will be orders of magnitude smaller.

Repeating this pair of boosts $\lceil\frac{1}{2}\log_{\beta}(\alpha)\rceil$ times, starting from $B$, reduces all of the error terms below $4\alpha$:

Since bias busting is always applied immediately after bias boosting, it will be the case that $\beta=a^{2/3}$ and $\alpha=\exp(-1/\sqrt[3]{a})$ for some $a$. So the number of repetitions is at most $\frac{1}{2}\log_{\beta}(\alpha)\leq 1/\sqrt[3]{a}$. The chance of discarding across all the bias busting boosts is therefore at most

Ensuring that $10\sqrt[3]{a}$ is less than 50% requires starting from an $a$ below $0.01\%$. You can start boosting from higher error rates $a$, without causing a disastrous discard rate, if you do fewer boosts in the bias boosting and bias busting stages.

An example of a full construction is shown in Figure 4. The first step is to bootstrap from the initial infidelity to an infidelity low enough for the bias boosting and bias busting stages to start working. Bootstrapping is done with unboosted rep code stages. The bases of the rep codes are chosen by brute forcing a sequence that gets all error rates below 0.1% in the fewest steps.

Once the error rate is bootstrapped, the construction begins alternating between bias boosting stages and bias busting stages. The number of repetitions is customized during the first alternation, instead of using the loose bounds specified in previous sections, to get a faster takeoff. Later alternations turn an infidelity of at most $a$ into an infidelity of at most $\exp(-1/\sqrt[3]{a})$. This is not quite an exponential decrease, due to the cube root, but doing two alternations fixes this and guarantees a reduction to an infidelity below $\exp(-1/a)$.

Because each stage uses 1 qubit of storage, and a constant number of stages exponentiates the error rate, each additional exponentiation has $O(1)$ space cost. It takes $O(\log^{\ast}\frac{1}{\epsilon})$ exponentiations to reach an infidelity of $\epsilon$, and therefore the storage needed to reach $\epsilon$ is $O(\log^{\ast}\frac{1}{\epsilon})$.

The last detail to discuss is the time complexity. Because the discard rate at each stage is proportional to the infidelity at that stage, and the infidelity is decreasing so much from stage to stage, the sum of the discard rates across all stages converges to a constant as the number of stages limits to infinity. This avoids one way that time costs can become non-linear versus number of stages. That said, the input-to-output conversion efficiency is not quite asymptotically optimal. Each stage is individually achieving a complexity of $\Theta(\log_{\epsilon_{\text{in}}}\frac{1}{\epsilon_{\text{out}}})$, with a constant factor of input-to-output waste. As the number of stages increases, these waste factors compound. As a result, the time complexity is $\tilde{\Theta}(\log\frac{1}{\epsilon})$ instead of the optimal $\Theta(\log\frac{1}{\epsilon})$.