# In quantum computation, if the fidelity is high enough to promise over 50% success rate, is quantum error-correction still needed?

Let's say we have many qubits and gates. The errors happen randomly, for example with a probability of 0.1% at each place(at this place, no quantum error correction is implemented). If the probability of no error occurs in the whole computation process is higher than 50%, we can repeat the computation maybe 100 times and choose the answer that appears most to be the correct one. In this situation, it seems that error correction is not needed.

Do I misunderstand sth?

• Using very simplified logic, with 0.999 probability of no error happening at each gate, after using 1000 gates you have 0.999^1000 = 0.36 probability of no error happening in your computation, which is already less than 50%. Computations for problems of interest take a lot more than a thousand gates, so without error correction the answer is going to be pretty much random Dec 9 '20 at 19:13
• Even with 0.36 success rate, the right answer could still be the majority. Because there are many different wrong answers with less appearing probability. I guess there should be some intrinsic defect for non-error correcting quantum computation. Otherwise, improving fidelity is more technically achievable than error correction Dec 9 '20 at 20:47

The comments said well. There is a difference between quantum error correction and your idea.

In the case of quantum error correction, these codes have a guarantee that if the fidelity of each operation is higher than a code-specified constant, then literally the quantum computation can be expanded with limitation(although if we enlarge the quantum system, the difficulty of maintaining a high fidelity is increased), this is called threshold theorem(see Quantum error correction for beginners, 10.4.).

For your case, if at one place the final possibility that no error occurs is higher than 50%, then what will happen if we double the quantum operations deployed before? Or what if we adjust the $$n$$-qubit case into a $$2n$$-qubit case?

So if the threshold theorem is satisfied, we have a guarantee that the quantum computation works correctly, while in your case the final probability is circuit-specified.

Another difference is that if no error syndrome is detected with a high probability we know that the result is right(and if any syndrome is detected we can correct it), while your idea requires mass repetition from the very beginning.

Finally, there is a branch called quantum error detection(see section 6 of the aforementioned paper), this branch only detect error(you can not infer the error type from the measurement result, but you will know if there is an error), and if an error happens the computation must be repeated. Maybe the analysis of this kind of protocol compared with general quantum error correction can help you.

All Quantum Error Correction does is suppress the probability of error compared to a 'barebones' approach. If you don't use QECC but the error rates are very low one could, in principle, do without this extra layer of suppressions.

However, as already pointed out, the scaling is exponential: for (an unphysical picture of) uncorrelated layers in the computation (let's say $$\sim 10000$$), with an error rate of $$p = 10^{-2}$$, the probability of no error happening is $$(1-p)^{10000} ~= 10^{-42}$$. That's not a lot.

You have the extra insight that we still can go for some 'majority' analysis after repeated runs. After enough repeated runs we gather some statistics, and assume the most often returned answer to be the correct one. However, with the above error rate the number of repetitions needed to get sensible statistics is, quite literally, out of this world.

QECC's generally suppress the error rate with an exponential factor of $$2-3$$; so we get $$(1-p^{2})^{10000} \sim (1-p^{3})^{10000} = 0.37 \sim 0.99$$. That is a tremendous improvement.

Remember, some computations that QC's are envisioned to perform are even hard to validate. Consider, for instance, some very big Hamiltonian, of which we ask the QC to give us its ground state energy. We have no way of checking, with a classical computer, if any returned answer even is the ground state.

So if we have this huge list of different computation outcomes, of which some are supposedly the correct ones, it can be very hard indeed to check if one of those outcomes is actually the correct one.