The action of the error subgroups $S$ and $S'$ on the encoded space

Question

From https://arxiv.org/pdf/quant-ph/9608006.pdf

$E$ is the group of possible errors in $n$ qubits

$S'$ is a subgroup of $E$ consisting of undetectable errors. These are errors $e$, in which translation by $e$ takes codewords to codewords.

$S$ is a subgroup of $S'$ consisting of errors which have no effect. These are errors which have no impact on the encoded state. $S$ is abelian and every element of $S'$ commutes with $S$.

(Note that in a quantum setting it is possible for a nontrivial error to be indetectable and yet have no impact on the encoded state).

---

I am just slightly confused as to what the explicit action of $S$ and $S'$ is. My understanding is:

• $S'$ consists of the errors that take codewords to codewords and as such are undetectable i.e $$sc_{i}=c_{j}$$, $s\in S$,$c_{i},c_{j}\in C$
• $S$ has no effect on the encoded state and as such, takes codewords to themselves $$sc_{i}=c_{i}$$

However, I think that perhaps my understanding of the action of $S$ is incorrect. Despite having no effect on the encoded state, perhaps that does not mean that it has no effect on individual codewords?

Answer 1

Your conceptions of both $S’$ and $S$ are correct as you’ve written them — don’t doubt yourself too much, you’ve got this :) I think a concrete example will clear up the difference, and I’ll write it in the notation of Roffe’s paper since that notation is more familiar to me.

First, consider a classical repetition code on the bits $\{0,1\}$, resulting in codewords $\{000,111\}$.

• $S’$ has the element $111$, since that flips the codewords. Thinking of other classical codes, note that this set grows as the code grows, because the more codewords there are, the more flip-flopping we can do.
• However, the set $S$ only ever has the zero string; if you change even one bit, you don’t have the same codeword. This is why they write “S is the analogue of the zero subgroup in the classical coding case” in the “QECC via GF(4)” paper.

Now consider the three-qubit code (section 3.1 in Roffe’s paper, if that’s an unfamiliar example). The states to encode are $|\psi \rangle = \alpha | 0 \rangle + \beta | 1 \rangle$ where $|\alpha|^2 + |\beta|^2 = 1$. They are encoded as $|\psi\rangle_L = \alpha|000\rangle + \beta|111\rangle$. Since this code protects against bit-flip errors, the distinction between $S’$ and $S$ comes by looking at phase-flip errors.

• Examples of elements in $S’$ are single $Z$ errors, like $Z_1 := Z \otimes I \otimes I$. An error like this results in the state $$Z_1 |\psi\rangle_L = \alpha|000\rangle - \beta|111\rangle \neq |\psi\rangle_L.$$ So it’s a different state, but still a valid codeword, since $|\alpha|^2 + |-\beta|^2 = 1$.
• Now comes the cool part; in contrast to the classical case, there are nonzero elements which do not affect the codeword. One example is $Z_1 Z_2 := Z \otimes Z \otimes I$, since $$Z_1 Z_2 |\psi\rangle_L = \alpha|000\rangle + (-1)(-1)\beta|111\rangle = \alpha|000\rangle + \beta|111\rangle = |\psi\rangle_L.$$ So not only did $Z_1 Z_2$ map codewords to codewords, but it mapped the codewords to themselves!