0
$\begingroup$

The threshold estimation of the $[[9,1,3]]$ surface code in stim's getting started tutorial extracts the syndromes by having a single ancilla for each stabilizer generator. It is the same setup as in Google's surface code scaling experiment (see Fig. 1b). So, there is no Shor- / Steane- or Knill-error-correction scheme applied.

Is this still a fault-tolerant scheme for the distance 3 version of the code? Can't an error in an ancilla spread to multiple data qubits and cause a logical error since the distance 3 code can correct only one error?

If it is fault-tolerant why is it? What am I missing?

If it is not fault-tolerant why is the setup still sufficient for threshold estimation / threshold experiments?

$\endgroup$

3 Answers 3

1
$\begingroup$

I think technically, if you want to ensure Fault-Tolerance, indeed you need Shor/Steane/Knill error correction. e.g. in the surface code case, you need weight-4 cat state to do syndrome measurement and according to Daniel Gottesman's definition, one round of measurement consists of measuring all the $X_v,Z_p$ stabilizers, you need to repeat until $t+1$ consecutive rounds of syndromes agree, where $t=\lfloor\frac{d-1}{2}\rfloor$p205 Gottesman. In this case, maybe $t+1$ rounds of MWPM results are the same?

Daniel's criteria for Fault-tolerance is basically, if a Gadget satisfies, there are $r$-errors going into a Gadget and $s$-faults occurring in the Gadget, the Gadget produces no more than $r+s\leq t$ errors. In his book, or also the paper 2, Daniel gives rigorous requirements for fault-tolerance.

I believe based on this, the second paragraph in DaftWullie's answer is not necessarily right because one syndrome measurement is just a small part of the "Gadget" (here I think the "Gadget" is the full measurement procedure), apparently this will blow up if we only have a single ancilla. Of course, you may be able to simplify this repeated measurement thing by using e.g. flag qubits 3, adaptive syndrome measurement 4 or single-shot EC 5.

What Craig says also makes sense. Due to the nature of error correction and fault-tolerance, that it can be pure theory while it's closely connected with experiments, I sometimes also wonder, are these stringent definitions in FT necessary? Maybe it works experimentally that's good enough.

We are likely to get away with these issues if we only work with a single logical qubit, a single code patch. At the end, we want to use hundreds, thousands of logical qubits to have meaningful applications. I'm convinced we need these criteria. At least if we stick with them, theoretically we have guarantee the simulation will work as expected.

$\endgroup$
1
$\begingroup$

What does it mean to have a fault-tolerant setup? This has been done most rigorously for distance 3 codes, in which case a sufficient condition for a gate to be fault tolerant is that it should propagate a single-qubit error to no more than one qubit per logical block. This is so that it can be corrected at the next round of error correction.

For something like the toric code, a single error on an ancilla could get propagated to at most 4 qubits. But that is well below the distance of the code, so it will be error corrected in the next round. (You might worry about the factor of 4 blow-up, but I would suggest not to worry about it too much since you're typically already working in a regime that's well beyond the distance threshold, relying on the idea that almost all errors that occur will still be corrected. If you have a total number of errors that's below the distance, this could propagate to a number of errors that's above the distance, but you're still almost guaranteed that it'll be corrected.) In this sense, the setup is fault tolerant.

$\endgroup$
3
  • $\begingroup$ Yes, I have not specifally asked about the distance 3 version in my question before. I have edited it now. But I don't understand how a propagation to 4 qubits is well below the distance of the [[9,1,3]] surface code. (even 2 qubits would be too much as distance 3 can only correct 1 error, right?) And what do you mean with "4 blow-up"? $\endgroup$
    – qubitzer
    Commented Jun 8 at 8:27
  • $\begingroup$ I was talking about generalities of a large patch of toric/surface code. Sure, any finite part, like [[9,1,3]] might not be handled. $\endgroup$
    – DaftWullie
    Commented Jun 10 at 6:27
  • $\begingroup$ "factor of 4 blow up" means the way that a region of errors could become four times larger as a result of propagation through an error correction cycle. $\endgroup$
    – DaftWullie
    Commented Jun 10 at 6:28
1
$\begingroup$

Is this still a fault-tolerant scheme? Can't an error in an ancilla spread to multiple data qubits and cause a logical error?

Why would "fault tolerance" hinge on whether or not an error in the ancilla can spread to two data qubits? Fault tolerance just means you can tolerate faults. You can still tolerate faults under circuit-error-becomes-two-data-error conditions.

Suppose you have a 31x31 surface code. It can correct any combination of 15 data errors. When a hook error occurs on an ancilla qubit, creating the equivalent of 2 data errors, the circuit does not break. 2 is less than 15, so the error is corrected, and the circuit survives the fault. Fault tolerant.

If you order the circuit wrong, you can make the circuit only survive 7 circuit errors instead of 15 circuit errors. So the fault distance would be 7, instead of the upper bound of 15 set by the code the circuit is implementing. But that just means the circuit's fault distance is 7, not that its fault distance is 1. It can still tolerate 7 faults. It's still fault tolerant. Just not as fault tolerant as possible with a better ordering.

$\endgroup$
3
  • $\begingroup$ Thanks for pointing out the distance aspect. This makes sense to me. But doesn't this leave the question of how the setup is fault-tolerant for the [[9,1,3]] version? (I have now edited my question to ask specifically for that) $\endgroup$
    – qubitzer
    Commented Jun 8 at 8:19
  • $\begingroup$ @qubitzer The fault distance is still 3. The circuit is ordered so that the pairs of data errors the hook errors spread to are aligned in the direction that is irrelevant. $\endgroup$ Commented Jun 8 at 13:34
  • $\begingroup$ So, is it fair to say that for the given circuit, single ancilla qubit errors can only produce combinations of 2-data-qubit errors that happen to be correctable by the code? $\endgroup$
    – qubitzer
    Commented Jun 11 at 13:36

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.