15-to-1 distillation protocol in lattice surgery: doesn't the potential rejection of the level-1 magic states makes it last longer than $15$ timestep?

Question

Overview of my question

I am following Litinsky's paper, and I would like to better understand how the duration of the level-2 15-to-1 distillation protocol is being estimated. Litinsky's says that it will last for $15$ clock cycles, but for me this is only a lower bound because level-1 magic states might be rejected: I wish to understand him better.

---

Below are the important figures to understand the problem.

I consider the 15-to-1 distillation protocol, which circuit is represented below.

Basically, by using $15$ magic states of probability of error $p$, we can, upon post-selection, create a magic state of probability of error $35p^3$. Here, $15$ should be read as $4+11$, where $4$ represents the magic state on the left of this image, and $11$ are the magic states used to implement each of the $11$ $T$-gates in yellow (see for instance this post to understand how these $T$ gates are implemented with the magic state).

In practice, going from $p \to 35p^3$ might not be enough to run the algorithm we like (the error rate might still be too high). Hence, we can re-iterate the process and take $15$ purified magic states (error $35p^3$) to create $1$ magic state of error proba $35(35p^3)^3$. It can be done through with the layout below, which I comment afterwards.

The blue circle on the upper left represent the tiles implementing the circuit on Fig 15 (the exact way the protocol is done can be seen on Fig 17c)) in Litinsky's paper. The tile "5" is where the purified magic state (error proba $35p^3$) is located. Then, we move it to the red slot. The tiles in red perform the second level of distillation (putting the error to $35(35p^3)^3$).

Overall, because it takes $11$ timesteps to create a level-1 magic state, and we have $11$ level-1 magic state distillation blocks (look at fig 19), assuming the level-1 magic states are always accepted, we will have one level-1 magic state ready each timestep.

The level-2 magic state requires $11+4$ level-1 magic states, so it can be completed in $15$ timesteps.

My question:

This reasonning that the level-2 distillation lasts for $15$ timesteps relies upon the assumption that the level-1 magic state are always accepted. In practice, it might take longer (because sometime you reject the level-1 magic state). Said differently, because there is a non-zero probability that the level-1 magic state is rejected, the production rate for the level-1 magic state in this layout/protocol is less than 1 per timestep, implying that the level-2 distillation protocol will take more than $15$ timesteps. Do you agree with me?

In practice, my explanation are based on my intepretation of Litinsky's text, but he never mentions the assumption that the level-1 magic state are always accepted in his reasonning about timesteps. This is why I want to check whether or not the protocol will take more than $15$ timesteps in practice, because of the level-1 magic state rejections.

Answer 1

Yes, it takes slightly longer on average due to discards. If the injection error rate is 0.1%, then your first stage factory will discard 1-0.999^15 ~= 1.5% of the time. Accounting for this increases the conversion ratio from 15:1 to around 15.3:1. So not really a big difference. You can do the same analysis for the second stage factory but it discards so rarely it's totally negligible on the rates.

The main trouble with discarding is not its impact on rates. Going from 15 to 15.3 is not a big deal. The big deal is just making sure failures are local, and don't spread into later stages. For example, suppose that a first stage factory discarding caused the second stage factory to fail because a required missing input didn't show up (starvation). That would cause 20% of second stage factory runs to fail due to starvation! You instead want the second stage factory to pause and wait for a substitute input whenever an input was discarded. But that means you need to do dynamic routing of states while the factory runs, and you want to slightly overbuild the level 1 stages so there's extra states in a buffer or queue that can be used to prevent stalls.

Note you can re-arrange the factory so you get one of the potential error signals after the 8'th state has been injected, instead of at the end. This lets you abort some failed runs earlier, reducing the cost of a discard. But it's a pretty negligible effect because discards are so rare.