So, Shor's code isn't *perfect*. But, it's still pretty awesome. Let's analyze it further. It's nice to look at Shor's code as follows:

The inner part highlights the key layers of the three-qubit bit-flip code that are utilized in each block of Shor's code, and the outer part is like a "stretched" version of the three-qubit phase flip code that spans all three blocks. We already proved that Shor's code can decode Pauli-$Z$ errors, but we can see why this is the case conceptually because of the outer part. On top of this, it even makes sense why Shor's code can only tell you in which *block* a Pauli-$Z$ occurred — it's as if each block is now a logical qubit for a logical three-qubit phase flip code. Use this way of looking at Shor's code to try and solve the next problems. --- ***Exercise E.3.2.*** Show that Shor's nine-qubit code can correct the Pauli errors given in parts (a) and (b). That is, you need to show that the input state $\vert \psi \rangle$ remains unaltered after passing through the entire circuit. **Note:** We're not testing if the error syndrome is *unique* for each error. (a) $\left(\bigotimes_{i=0}^{j-1} \mathbb{I}_i \right) \otimes X_j \otimes \left( \bigotimes_{i = j+1}^{8} \mathbb{I}\right)$ (b) $\left(\bigotimes_{i=0}^{j-1} \mathbb{I}_i \right) \otimes Y_j \otimes \left( \bigotimes_{i = j+1}^{8} \mathbb{I}\right)$

(a) Solution.

Right before the error occurs, we have the following quantum state: $$ \begin{align*} \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 3} + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 3}. \end{align*} $$ To accurately propagate the state through the circuit, it matters where the error goes. Rather than doing this 9 different times, let's do it once and then justify the other 8 cases. Let's consider the case in which the error affects qubit 0 — the register belonging to $\vert \psi \rangle$: $$ \begin{align*} \alpha \left( \vert 100 \rangle + \vert 011 \rangle \right)\left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 2} + \beta \left( \vert 100 \rangle - \vert 011 \rangle \right)\left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 2}. \end{align*} $$ Now we apply the two "columns" of CNOT gates: $$ \begin{align*} \alpha \left( \vert 111 \rangle + \vert 011 \rangle \right)\left( \vert 000 \rangle + \vert 100 \rangle \right)^{\otimes 2} + \beta \left( \vert 111 \rangle - \vert 011 \rangle \right)\left( \vert 000 \rangle - \vert 100 \rangle \right)^{\otimes 2}. \end{align*} $$ Now the Toffoli gates in each block: $$ \begin{align*} \alpha \left( \vert 011 \rangle + \vert 111 \rangle \right)\left( \vert 000 \rangle + \vert 100 \rangle \right)^{\otimes 2} + \beta \left( \vert 011 \rangle - \vert 111 \rangle \right)\left( \vert 000 \rangle - \vert 100 \rangle \right)^{\otimes 2}. \end{align*} $$ Next up are the Hadamards in each block, and we'll do some simplifications: $$ \begin{align*} & \alpha \left( \vert \texttt{+}11 \rangle + \vert \texttt{-}11 \rangle \right)\left( \vert \texttt{+}00 \rangle + \vert \texttt{-}00 \rangle \right)^{\otimes 2} + \beta \left( \vert \texttt{+}11 \rangle - \vert \texttt{-}11 \rangle \right)\left( \vert \texttt{+}00 \rangle - \vert \texttt{-}00 \rangle \right)^{\otimes 2} \\ =& \alpha \vert 011 \rangle \vert 000 \rangle^{\otimes 2} + \beta \vert 111 \rangle \vert 100 \rangle^{\otimes 2} \\ =& \alpha \vert 011 \rangle \vert 000 \rangle \vert 000 \rangle + \beta \vert 111 \rangle \vert 100 \rangle \vert 100 \rangle \end{align*} $$ Now for the two CNOT gates at the end: $$ \begin{align*} &\alpha \vert 011 \rangle \vert 000 \rangle \vert 000 \rangle + \beta \vert 111 \rangle \vert 000 \rangle \vert 000 \rangle \\ =& (\alpha \vert 0 \rangle + \beta \vert 1 \rangle) \vert 11000000 \rangle. \end{align*} $$ And, finally, the Toffoli gate, which actually does nothing. So, our final state is: $$ \begin{align*} & (\alpha \vert 0 \rangle + \beta \vert 1 \rangle) \vert 11000000 \rangle \\ =& \vert \psi \rangle \vert 11000000 \rangle. \end{align*} $$ Nice — our starting state is recovered. Now, how do we justify that our state is recovered regardless of where the Pauli-$X$ error occurs? We saw that in the three-qubit bit-flip code that the inner part of Shor's code should correct Pauli-$X$ errors in each block. So, we're covered! You can go ahead and verify this if you'd like.

(b) Solution.

This one is actually much more elegant to prove/justify now that we've seen how Shor's code handles Pauli-$X$ and $Z$ errors. First, note that $Y = iXZ$. A Pauli-$Y$ error is a phase-flip and bit-flip error combined (modulo a factor of $i$ that doesn't really matter).

Click the toggle to see more details.

Consider the result of applying a Pauli-$Y$ operator on a general 1-qubit state: $$ \begin{align*} Y (\alpha \vert 0 \rangle + \beta \vert 1 \rangle) &= (i \alpha \vert 1 \rangle - i \beta \vert 0 \rangle) \\ &= i (\alpha \vert 1 \rangle - \beta \vert 0 \rangle). \end{align*} $$ Let's do away with that pesky global phase of $i = e^{i\tfrac{\pi}{2}}$ and look at what's actually happening. It appears as though applying the Pauli-$Y$ operator flips the phase — like $Z$ — *and* flips the bit — like $X$: $$ \begin{align*} Y \vert 0 \rangle =& i\vert 1 \rangle \overset{\text{mod $i$}}{=} \vert 1 \rangle \\ Y \vert 1 \rangle =& -i\vert 0 \rangle \overset{\text{mod $i$}}{=} -\vert 0 \rangle. \end{align*} $$ A Pauli-$Y$ error is exactly like a phaseflip and bitflip combined.

So, in (a) we showed that the inner part corrects $X$ errors and previous to that we said that the outer part corrects $Z$ errors. Put the inner and outer parts together, and we get that $Y$ errors are decodable.

--- Unsurprisingly, because the inner part is corrects bit-flip errors and is repeated in each block, Shor's code provides a unique error syndrome $\vert s_e \rangle$ for every Pauli-$X$ error. The same can be said for Pauli-$Y$ errors. You can verify this if you wish. On the note of unique error syndromes, let's take a moment to think about what else is possible with Shor's code. Assume that an error occurred such that the state is decodable, i.e. the output of Shor's code is $\vert \psi \rangle \vert s_e \rangle$. For the examples that we will look at, $\vert s_e \rangle$ is an 8-qubit basis state, meaning that it could be one of a possible $2^8 = 256$ states. With the single-qubit errors we've looked at so far, we've covered a possible 22 error syndromes: - Pauli-$Z$ errors give 3 unique error syndromes - Pauli-$X$ errors give 9 unique error syndromes - Pauli-$Y$ errors give 9 unique error syndromes - No error occurring gives a unique error syndrome (trivial case) There are $256 - 22 = 234$ other error syndromes that we haven't seen. Now, this doesn't mean that Shor's code can tell you where $256$ different errors occurred. That said, it should definitely make you curious to see if Shor's code can decode more than just single-qubit Pauli errors. --- ***Exercise E.3.3.*** Explain your reasoning for whether or not Shor's code can decode errors given in parts (a), (b), and (c). Does the input state $\vert \psi \rangle$ remain unaltered after passing through the entire circuit? Bonus points for answering if the error syndrome for that error type is unique. Make sure you consider the single-qubit errors we looked at previously; some multi-qubit errors might yield the same error syndrome. **Note:** You don't (shouldn't) have to show much math. (a) Two Pauli-$Z$ errors in the same block on different qubits. (b) Two Pauli-$Z$ errors in different blocks. (c) A Pauli-$X$ error and a Pauli-$Z$ error in the same block. (d) A Pauli-$X$ error and a Pauli-$Z$ error in different blocks.

(a) Solution.

Right before the error occurs, we have the following state: $$ \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 3} + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 3}. $$ Applying two Pauli-$Z$ errors in the same block amounts to nothing happening. For example, $$ \begin{align*} Z_0 Z_1 \left( \vert 000 \rangle + \vert 111 \rangle \right) &= Z_0\left( \vert 000 \rangle - \vert 111 \rangle \right) \\ &= \left( \vert 000 \rangle + \vert 111 \rangle \right). \end{align*} $$ Since 2 Pauli-$Z$ errors in the same block effectively cancel each other, Shor's code can decode such errors. As for the error syndrome being unique, however, this isn't the case. Since the error is as if exactly nothing happened, its error syndrome will show as much.

(b) Solution.

Right before the error occurs, we have the following state: $$ \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 3} + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 3}. $$ Applying two Pauli-$Z$ errors in different block will flip the phase of the $\vert 111 \rangle$ state in each block. For example, $$ \alpha \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle + \vert 111 \rangle \right) + \beta \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle - \vert 111 \rangle \right). $$ Now, let's just say $\tilde{\alpha} = \beta$ and $\tilde{\beta} = \alpha$: $$ \begin{align*} &\tilde{\beta} \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle + \vert 111 \rangle \right) + \tilde{\alpha} \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle - \vert 111 \rangle \right) \\ &= \tilde{\alpha} \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle - \vert 111 \rangle \right) + \tilde{\beta} \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle + \vert 111 \rangle \right) \end{align*} $$ Now, go back and look at the case of just a single Pauli-$Z$ error: $$ \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle - \vert 111 \rangle \right) + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 2}\left( \vert 000 \rangle + \vert 111 \rangle \right) $$ Looks pretty similar, right? And, since Shor's code really doesn't care about the values of $\alpha$ and $\beta$, these two scenarios are effectively the same — one Pauli-$Z$ error is the same as two Pauli-$Z$ errors for Shor's code. So yes, two Pauli-$Z$ errors in different blocks are decodable. But they give no new error syndromes since they're the exact same as the single Pauli-$Z$ error ones. So, you can't even tell if a single Pauli-$Z$ error happened or if two happened in different blocks.

(c) Solution.

Right before the error occurs, we have the following state: $$ \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 3} + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 3}. $$ An $X$ and a $Z$ error in the same block will flip a phase and flip a qubit. What else have we looked at that flips a phase and flips a qubit? A Pauli-$Y$ error, which we know is decodable. Now, even though the $X$ and $Z$ error occur on different qubits, the result is still the same. Let's say this occurs in block 2 on qubits 3 ($X$ error) and 4 ($Z$ error): $$ \begin{align*} \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)\left( \vert 100 \rangle - \vert 011 \rangle \right)\left( \vert 000 \rangle + \vert 111 \rangle \right) + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)\left( \vert 100 \rangle + \vert 011 \rangle \right)\left( \vert 000 \rangle - \vert 111 \rangle \right). \end{align*} $$ The same would happen — modulo a global phase of $i$ — if a $Y$ error was placed in block 2. Therefore, an $X$ and a $Z$ error occurring in the same block is decodable. However, because of the equivalency to a $Y$ error in the same block, we see no new error syndromes — you wouldn't be able to tell if the error was a single $Y$ error or an $X$ and a $Z$ error.

(d) Solution.

The fact that the errors are in different blocks allows for some liberties to be taken. We could simply say that because the inner part of each block the $X$ error gets taken care of, and then because of the outer part the $Z$ error gets taken care of. Maybe that isn't satisfactory for you, so let's just prove it. Right before the error occurs, we have the following state: $$ \alpha \left( \vert 000 \rangle + \vert 111 \rangle \right)^{\otimes 3} + \beta \left( \vert 000 \rangle - \vert 111 \rangle \right)^{\otimes 3}. $$ Let's say an $X$ error occurs in block 1 on qubit 1 and a $Z$ error occurs in block 3 on qubit 7: $$ \alpha \left( \vert 010 \rangle + \vert 101 \rangle \right)\left( \vert 000 \rangle + \vert 111 \rangle \right)\left( \vert 000 \rangle - \vert 111 \rangle \right) + \beta \left( \vert 010 \rangle - \vert 101 \rangle \right)\left( \vert 000 \rangle - \vert 111 \rangle \right)\left( \vert 000 \rangle + \vert 111 \rangle \right). $$ Then we have the CNOTs and Toffolis: $$ \alpha \left( \vert 010 \rangle + \vert 110 \rangle \right)\left( \vert 000 \rangle + \vert 100 \rangle \right)\left( \vert 000 \rangle - \vert 100 \rangle \right) + \beta \left( \vert 010 \rangle - \vert 110 \rangle \right)\left( \vert 000 \rangle - \vert 100 \rangle \right)\left( \vert 000 \rangle + \vert 100 \rangle \right). $$ The three Hadamard gates: $$ \begin{align*} &\alpha \left( \vert \texttt{+}10 \rangle + \vert \texttt{-}10 \rangle \right)\left( \vert \texttt{+}00 \rangle + \vert \texttt{-}00 \rangle \right)\left( \vert \texttt{+}00 \rangle - \vert \texttt{-}00 \rangle \right) + \beta \left( \vert \texttt{+}10 \rangle - \vert \texttt{-}10 \rangle \right)\left( \vert \texttt{+}00 \rangle - \vert \texttt{-}00 \rangle \right)\left( \vert \texttt{+}00 \rangle + \vert \texttt{-}00 \rangle \right) \\ &= \alpha \vert 010 \rangle \vert 000 \rangle \vert 100 \rangle + \beta \vert 110 \rangle \vert 100 \rangle \vert 000 \rangle. \end{align*} $$ The last two CNOTs and Toffoli gates: $$ \begin{align*} &\alpha \vert 010 \rangle \vert 000 \rangle \vert 100 \rangle + \beta \vert 110 \rangle \vert 000 \rangle \vert 100 \rangle \\ &= \vert \psi \rangle \vert 10000100 \rangle \end{align*} $$ Nice! So those errors are decodable. Interestingly, there are a possible 21 different configurations of an $X$ in one block and a $Z$ error in another. Of those error configurations, some will give the same syndrome because Shor's code can only resolve down to the block in which a $Z$ error occurs. However, Shor's code can tell you which qubit had a single $X$ error. These two ideas put together mean that for an $X$ error occuring on any qubit, the three possible $Z$ errors that could occur in one different block will give the same syndrome. For example, an $X$ error on qubit 0 and a $Z$ error on qubits 3, 4, or 5 will give the same syndrome. In all, 9 of the possible error configurations will yield a unique error syndrome.

--- *Phew!* That's quite a bit of 1s and 0s. You can keep going and see if Shor's code can decode 3-, 4-, 5-, etc. qubit errors. We'll leave that to you for fun.

Codercise E.3.1 - Generating errors

Codercise E.3.2 - The circuit for Shor's code

Codercise E.3.3 - Decoding Pauli Errors

Codercise E.3.4 - What about Y errors?

Codercise E.3.5 - Unique error syndromes

Codercise E.3.6 - What can Shor decode?

Shor's famous nine-qubit code

Error syndromes in Shor's code

Recovering the state