Although there has been discussions on this1, I still have some questions. I will firstly summarize my understanding of these concepts, threshold, pseudo-threshold (please correct if I am wrong), breakeven and present my questions. Assume we have a consistent noise model:

  1. Threshold. This is usually defined for a family of codes. Roughly speaking, it is the value below which, increasing the code size decreases the logical error rate. For code concatenation, we plot the logical error rate vs physical error rate for various level of concatenation and find the minimum value of $p$ of intersection. For the surface code, we increase size of the code patch $L$ and find the intersection.
  2. Pseudo-threshold. This is defined for a single code. It is the point at which logical error rate < physical error rate.
  3. Breakeven. I'm not very sure about this, but I guess it is, on the experimental side, a full cycle of QECC is performed before the qubits decohere?

My questions:

  1. Definition of "break-even"?
  2. I can't find proper definitions of threshold and pseudo-threshold in the literature. I would like to formulate them in some way, could anyone help?
  3. It seems to me the definition of pseudo-threshold is a more natural definition, and it guarantees QECC will work better than no-QECC. I don't understand why we need "threshold" as defined above, to me it only shows the family of code is kinda "good". In a lot of the cases at the threshold point, logical error rate > physical error rate, which is presumably not what we want. Then the defn doesn't quite make sense.
  4. For example, usually in the surface code, we see plots having curves with different $L$ intersecting at a single point. However, is there any theoretical guarantee they have to intersect at one point? I can't see an obvious reason.
  5. Any relationship between threshold and pseudo-threshold?
  • 2
    $\begingroup$ personally I don't like "threshold" for these reasons : you can put a given code in more than one "family"; these families could have different thresholds so that doesn't tell you anything about the code itself. "pseudo threshold" makes a lot more sense and is well defined for a single code; having "pseudo" in its name understates its importance. $\endgroup$
    – unknown
    Commented May 29 at 16:54

2 Answers 2


The "threshold" is the physical error rate where the footprint needed to reach good logical error rates diverges to infinity. Stay as far away from it as possible.

The "pseudothreshold" refers to the diagonal axes of a plot (i.e. the x+y and x-y axes). Some people like to redundantly draw these axes, in addition to the usual axes, as nice guides for the eye.

"Breakeven" means to make one number lower than another number by adding enough caveats.

  • $\begingroup$ Thanks. And what's the relationship between threshold and pseudothreshold? Also in this case why do we need "threshold"? We don't want larger and larger codes. We only want one code that is good enough and suppresses logical error(so pseudothreshold)? $\endgroup$
    – AndyLiuin
    Commented May 29 at 12:20
  • $\begingroup$ @AndyLiuin The numbers that matter are about what happens as you scale up. For example, you might think a d=3 surface needs a better coherence time than its physical qubits, but it can be worse and you still scale to arbitrarily low error rates by increasing distance. So that's the pseudothreshold being irrelevant. Of the numbers you mentioned, "threshold" is closest to being about scaling. But it only distinguishes ∞ cost from not-∞-cost. You should look at slopes or endpoints, not startpoints. Thresholds are vaguely interesting as you cross them, and then immediately irrelevant. $\endgroup$ Commented May 29 at 18:43

I thought it was good to give some context on how threshold was defined historically. Pseudothreshold / breakeven are more recent and less precisely defined.

Most formally, threshold is a property of a family of QECCs equipped with gadgets for performing universal computation (e.g. to do CNOT, H, T, etc). I like to call the pair of QECC and gadgets a fault-tolerance (FT) scheme. The FT scheme simulates some desired circuit using these gadgets subject to noisy physical operations.

Historically in the QEC literature, a threshold is a particular absolute constant that appears in a threshold theorem (e.g. https://arxiv.org/abs/quant-ph/9906129v1).

To state a threshold theorem requires introducing some parameters: The FT scheme is parameterized by some integer $r \in \mathbb{N}$ that you can think of as indexing the family of QECCs (and also their corresponding gadgets). Further suppose that we also have some noise model parameterized by some value $p \in [0,1)$ (e.g. a depolarizing rate).

The statement of a threshold theorem is roughly as follows: There exists a constant $p^*$ such that

  • for any noise rate $p < p^*$
  • for any** circuit $\mathcal{C}$
  • for any failure probability $\epsilon \in (0,1)$

There exists a family index $r' \in \mathbb{N}$ such that

  • Let $\overline{\mathcal{C}}$ be the simulation of $\mathcal{C}$ by the $r$-th element of the FT-scheme ($r \ge r'$)
  • The output distribution of $\overline{\mathcal{C}}$ (subject to the noise at rate $p$) is within total-variation distance (TVD) $\epsilon$ of the output distribution of $\mathcal{C}$

If you haven't seen TVD before, you can think of it as:

  • With probability $1-\epsilon$, you get a sample from the output of $\mathcal{C}$.
  • With probability $\epsilon$ you get junk.

The constant $p^*$ that appears in the theorem statement is known as the threshold.

This is an asymptotic statement that says for any noise lower than our threshold, we can do arbitrarily error-free computation. How do we get to the modern notion of a threshold? Numerically, it is somewhat conventional to simulate each of the gadgets in isolation and to see that the failure probability of each gadget goes down as $r$ approaches a large number.

It is important that one is absolutely convinced that:

  • Compositions of gadgets also has failure rate going down as $r \to \infty$.
  • The scaling of failure rate as a function of $r$ does not suddenly change behavior past the largest $r$ that you have simulated e.g. flat lining (an "error floor") or increasing.

This second point is why it is important to supplement numerics with a formal analytical argument if the largest $r$ you expect to need to use is larger than the one you have simulated.

** There are some technical restrictions on the circuit.

Remark: Note that the theorem does not say anything about $p \ge p^*$! There is a notion of threshold that appears in the classical information theory literature where the error rate must also go to 1 for $p > p^*$.

  • $\begingroup$ Thanks a lot for the detailed background! and welcome to this SE $\endgroup$
    – AndyLiuin
    Commented May 30 at 6:22

Your Answer

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

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