# Why can't we implement fault-tolerant single qubit rotations continuously?

My understanding is that in order to implement single-qubit rotations on logical fault-tolerant qubits one has to do smth like discretizing rotations and using $$T$$ gates. So, is it the case that given perfect single-qubit rotations of physical qubits (say, for a classical statevector simulator used to model those), one would still have to use discretized rotations for logical qubits? What would be the intuitive explanation?

There are at least two reasons why we want/need to discretize rotations.

First reason: in an ideal world without errors, performing an arbitrary single qubit rotation at the logical level requires interaction between the physical qubits composing the logical one. As the physical gateset usually does not contain an arbitrary $$n$$-qubit physical gate, we cannot implement a single qubit rotation of an arbitrary angle "in one step".

When we are doing quantum error-correction the quantum state of the qubit at the abstract "logical level", is encoded in an entangled state composed of a given number of physical qubits.

Conceptually, to perform a single qubit logical gate, we would "just" have to apply some big unitary acting upon all these physical qubits. "In general", this unitary will typically make all these physical qubits interact (if you tried to find what operation you need to apply on the physical qubits encoding your logical qubit, this is what the maths would tell you).

Hence, a single qubit rotation at the logical level requires "in general" to make interactions between physical qubits. Now, assuming we can do an arbitrary single qubit rotation at the physical level, we are however typically restricted in the two-qubit (or more) interactions we can do on the quantum hardware (for instance we can do a cNOT but not an arbitrary two-qubit gate physically). For this reason, we would not be able to implement exactly the arbitrary single logical qubit rotation desired easily, even if we can do arbitrary single physical qubit rotations (if you want your logical gate to be composed of "not too many" physical gates, then you cannot implement an arbitrary rotation angle at the logical level). This first part of the explanation is here to give you some intuition of why it is harder to perform single qubit rotation at the logical level.

Second reason: additionnally, this ideal world does not exist. Because errors propagate we are even more restricted on the logical operations we are allowed to do.

What I explained so far assumes perfect qubits. Because the hardware is noisy, we have another constraint: we should avoid at all cost to make different physical qubit within a logical qubit interact with each other. This is somewhat contradictory with what I said just before (but I was explaining the ideal noiseless case). The reason why two physical qubit inside the same logical qubit should not interact between each other is that if it occurs, a single error (for instance a bit-flip) on a physical qubit inside the logical qubit could propagate toward all the physical qubits composing the logical qubit during the execution of the gate. This is bad because error-correcting codes are able to detect and correct error only if a "low" number of physical qubits have been affected by errors. In practice, a code of distance $$d=2t+1$$ can correct up to $$t$$ errors, hence if more than $$t$$ physical qubits have been affected by errors your error-correcting code will in general not be able to fix it. Imagine that a single physical qubit had an error but that during the implementation of the logical gate you perform cNOT between all the physical qubit inside your logical qubit. Then all your physical qubits would be affected by this error and your error-correcting code cannot protect you anymore.

This last requirement of "not making the physical qubit interact with each other" is called transversality (see the answers there). A single qubit logical gate that is transversal will be written as $$G_L = \bigotimes_{i=1}^k G_k$$, where $$k$$ is the number of physical qubit in the logical qubit and $$G_k$$ is a single qubit physical gate acting on the $$k$$'th physical qubit of your logical qubit (by definition the physical qubits in the logical qubit will not interact with such a logical gate). In practice, not all logical gates can be done transversally (the Eastin-Knill theorem forbids it). What we usually have is that some logical gates can be done transversally (often the Clifford gates), and for the rest we use magic-state injection (I won't go in the detail for that, but basically you can prepare a logical ancilla and make it interact with your logical qubit which allows you to do a non-Clifford gate, for instance the $$T \equiv e^{-i \pi/8 Z}$$ gate). Performing Clifford gates + one non Clifford gates allows you to reach universal quantum computing. However, your algorithm will be decomposed in this example on Clifford+T: regarding your original question, it means that you will have to approximate the exact single qubit rotation you want to do.

I hope it gives the rough idea.