Can someone explain what is the threshold and the pseudo threshold of a Quantum Error Correction Code , for instance the 9-qubit code, and how to calculate it using the stabilizer formalism simulation .

I'm familiar with quantum information and quantum circuit and beginners to quantum error correction codes, when i studied the Shor's 9-qubit code and my supervisor asked me to calculate the pseudo-threshold of the 9-qubit code using stabilizer formalism, I didn't found any simple explanation to initiate my research, all I found is related with fault tolerance

  • $\begingroup$ more context and information about your current understanding of the subject would significantly improve the question $\endgroup$
    – glS
    Commented Jul 14, 2020 at 8:48
  • $\begingroup$ @glS thank you, I updated my question $\endgroup$
    – El-Mo
    Commented Jul 14, 2020 at 17:40

2 Answers 2


The first answer discusses what the pseudothreshold is and how to find it, but I will try to give a few details on the difference between thresholds and pseudothresholds, since your first question does ask for both definitions.

In quantum error correction (QEC), a logical qubit is encoded in many physical qubits. Given some underlying physical error rate $p$, there will be a corresponding logical error rate $\bar{p}$. If we are smart with our encoding and can make hardware that is "good enough", then ideally $\bar{p} < p$ below some $p_{th}$ for the physical error rate.

When simulating QEC codes, if one type of circuit component (like a single qubit gate) is assumed to fail with some rate $p$, we might obtain a plot like the one below (left). The parameter $L$ refers to the code concatenation; $L=0$ means no QEC, $L=1$ means each logical qubit is encoded with a set of physical qubits, $L=2$ means each of the $L=1$ physical qubits itself is encoded, etc. Notice that there is clean crossover (i.e. all curves intersect the $L=0$ curve at the same point, the threshold), below which using higher levels of concatenation improves the logical error rate of the code with respect to the physical error rate ($\gamma$ is used as the rate symbol here).

But in more complicated models we might allow different circuit components (1-qubit vs. 2-qubit gates, ancilla vs. data wires, etc.) to fail with different error rates, which leads to a more complicated set of curves (right image). Each concatenation curve intersects the $L=0$ curve at a different point, so you cannot just find the threshold of, say, the $L=1$ code and then scale up to higher $L$--you will actually make the code worse, because you only found a pseudothreshold. Instead, you need to simulate many values of $L$ and infer some kind of asymptotic behavior in the curves to get a rough estimate of where it is truly safe to scale up.

In summary, the left image represents the situation where all pseudothresholds are the same and are equal to the true threshold, and the right image represents a more realistic situation where the use of a more complex error model requires us to study the limiting behavior of a family of pseudothresholds.

enter image description here

I took these details and image from this paper.

  • $\begingroup$ awesome explanation. in practice, how to calculate the pseudo threshold of the 9-qubits code using the stabilizer formalism Mr @chrysaor4 $\endgroup$
    – El-Mo
    Commented Jul 19, 2020 at 18:26
  • $\begingroup$ If you want to use stabilizers, then I suppose you need to simulate the circuit with some error rate, decode the stabilizer syndromes, and apply the inferred corrections, which is outside the scope of what I wanted to explain in my answer. You might find this guide useful as a starting point: qiskit.org/textbook/ch-quantum-hardware/… $\endgroup$
    – chrysaor4
    Commented Jul 19, 2020 at 19:15
  • $\begingroup$ I gave you the bounty because your explanations was simple so thank you $\endgroup$
    – El-Mo
    Commented Jul 26, 2020 at 16:43

So the general definition of pseudothreshold is when the logical qubit outperforms a physical qubit.

If your error model is idling error, for example, you want to find the physical value of T1 and T2 for which the physical qubits lifetime is lower than the logical qubit's lifetime.

The easiest way to calculate this would be to write a simulation of the circuits for Shor's code, and then measure it's performance at different values and find the intersection point between the logical error curve and physical error curve.

If you want to calculate it on pencil and paper, write out the error channel you want to work with, and see what error patterns lead to logical errors vs not, and then see.

A simple example would be a channel: $$E(\rho) = (1-p)I\rho I + p Z\rho Z$$

To have a logical error in Shor's 9 qubit code, you need two Z errors on a single GHZ state. So you can apply this error to all qubits, knowing the physical qubit experiences a Z error with probability p, and find the probability of a logical Z error on the encoded qubit as a function of p. The value of p where the logical error rate exceeds p is the pseudothreshold.

  • $\begingroup$ i didn't fully understand you, specially the "T1 and T2" part, and also I wish if you provide more clarifications about the part of simulation, I'll be Thankful $\endgroup$
    – El-Mo
    Commented Jul 19, 2020 at 18:31
  • $\begingroup$ quantumcomputing.stackexchange.com/questions/9752/… is a quick explanation of T1 and T2, they are essentially lifetimes for qubit states against different error processes. For simulation you should pick one (cirq/qiskit have good documentation) and then write up the circuits needed to measure the parities for the stabilizers of the 9-qubit code. This is well explained in arxiv.org/pdf/1302.3428.pdf $\endgroup$ Commented Jul 19, 2020 at 20:32

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.