I have a code $C1$ that admits native fault-tolerant gates for any element in the Clifford group (for instance via transversal implementation), but that then doesn't have an easy way to perform the $T$ gate.

In practice, to implement the $T$-gate we can use state injection and create a logical ancilla state in the state $|A\rangle=T |+\rangle$.

A way to create the $|A\rangle$ state in a reliable manner is to make use of a code that has a native fault-tolerant $T$ gate. The $15$ qubit code is such example (the $T$-gate is transversal).

In practice, to prepare $|A\rangle$, we then:

  1. Regroup $15$ logical qubits of the code $C1$ and encode with them the logical $|+_L\rangle$ state of the $15$ qubit code (hence each qubit of the $15$ qubit code is a logical qubit of $C1$, itself composed of physical qubits).
  2. Apply a transversal $T$ to this logical qubit (it is equal to a logical $T$ thanks to the $15$ qubit code properties)
  3. Decode the $15$ qubit encoding: we now have a state $|A\rangle$ encoded with the code $C1$, we can perform state injection.

(Of course we have to repeat the procedure to have a reliable state but I skip this un-necessary detail for my question).

My question:

For $C_1$ we do not have a fault-tolerant $T$ gate. However, we need to do a $T$ gate within this code for step 2 of the procedure I described. How is it done? Do we use either one of the following methods? Another thing I am not thinking of?

  1. We implement a non-fault-tolerant $T$ gate within $C_1$ (hence super noisy, but it is not "really" a problem thanks to the logic of magic state distillation). In this case, I would be interested to know which operations are performed on the physical qubits for the surface code to perform this "non fault-tolerant logical $T$ gate" (it probably deserves another question).
  2. We basically do another state injection technique to perform the $T$ gates. This time we will then use an encoding with the $15$ qubit code but each qubit within this code will now be a physical qubit (we are basically at a "lower level" of encoding).

1 Answer 1


You start with physically injected magic states, expanded into $C_1$. In the case of the surface code you could use e.g. Li injection.

Li injection figure 1

The error rate of this part is extremely important, as it limits how few levels of distillation you will need to reach target error rates.

Once you have T states you do T gates in the next distillation level via gate teleportation.

  • $\begingroup$ Thank you very much. I reformulate in my own word (and complement a bit) to check if I understand you properly. Step 1: we initialize a physical qubit in the magic state. Then using the paper you reference you can "expand" it to its encoded version. At this point we could do state injection but it would lead to very noisy $T$ gates. Step 2: we use a distillation protocol to create better magic states. We can use the 15-to-1 protocol and use the magic state of step 1 to create "better" magic states. Step 3: if we are still not satisfied we use the magic states of step 2 to create "better" magic $\endgroup$ Mar 20 at 12:51
  • $\begingroup$ states. And so on until step N where we consider that the fidelity of the magic states (and hence of the T gate) will be good enough. Then we can implement a $T$ gate with a "good enough" fidelity. Would you agree with my reformulation in my own words of your answer and my overall understanding? Thanks a lot! $\endgroup$ Mar 20 at 12:51
  • 1
    $\begingroup$ @StarBucK Yes, that's right. $\endgroup$ Mar 20 at 17:35

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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