Logical operators (a different approach)
We have said a few times now that the main challenge in finding good quantum error-correction codes often lies in finding “good commuting sets of stabilisers”, so let’s take this seriously and try to rediscover the definitions from Sections 14.4 and 14.5 by starting with just commutativity.
Again, we already know that the Pauli matrices provide a useful basis with respect to which we can decompose the effects of any quantum channel, so we should carefully understand how the Pauli operators P\in\mathcal{P}_n interact with any error-correcting code.
For this, we introduce the notation
c(P,\sigma)
\coloneqq
\begin{cases}
0
&P \text{ and } \sigma \text{ commute}
\\1
&P \text{ and } \sigma \text{ anticommute}
\end{cases}
for any Pauli operator P and any other operator \sigma.
A particularly nice thing about this choice of definition (as opposed to taking c(P,\sigma)\in\{\pm1\}, say) is that we can write
P\sigma
= (-1)^{c(P,\sigma)} \sigma P.
Furthermore, this function has a nice relation on products: writing \oplus to mean addition \ \mathrm{mod}\ 2, we can see that
c(P,\sigma\tau)
= c(P,\sigma) \oplus c(P,\tau)
which reminds us of the fact that two anticommuting operators multiplied together produce a commuting operator.
Now fix some stabiliser group \mathcal{S}=\langle g_1,\ldots,g_{n-k}\rangle.
We define the error syndrome \underline{e}_P of a Pauli operator P to be the vector of all the values c(P,g_i), i.e.
\underline{e}_P
= \big( c(P,g_1), \ldots, c(P,g_{n-k}) \big).
It follows from the the above relation of how c(P,-) turns products into sums that
\underline{e}_{P\sigma}
= \underline{e}_P\oplus\underline{e}_\sigma.
The set of Pauli operators that have zero syndrome are special, and form a set known as the normaliser:
N(\mathcal{S})
\coloneqq \big\{ P\in\mathcal{P}_n \mid c(P,\sigma)=0\text{ for all }\sigma\in\mathcal{S} \big\}.
Since all elements of the stabiliser \mathcal{S} commute with one another, we know that \mathcal{S}\subseteq N(\mathcal{S}), but in general the normaliser is strictly larger.
Now, by the definition of the normaliser and the multiplicative property of c(P,-), if some Pauli operator P has a particular error syndrome \underline{e}_P then P\sigma has the same error syndrome for any \sigma\in N(\mathcal{S}).
This lets us gather together the Pauli operators into sets, which we call the error cosets, consisting of those Pauli operators which all have the same error syndrome.
By the above, these can be described by some representative operator P, along with all other P\sigma for \sigma\in N(\mathcal{S}), since the only way for P and Q to have the same error syndrome is for them to satisfy Q=P\sigma for some \sigma\in N(\mathcal{S}).
Now for some counting.
Since an error syndrome is exactly an n-bit string, there are 2^{n-k} possible different error syndromes.
Each error coset is, by construction, of size |N(\mathcal{S})|.
All together, the error cosets contain every single Pauli operator, of which there are 4^n.
With this, we can calculate the size of the normaliser:
N(\mathcal{S})
= 4^n/2^{n-k}
= 2^{n+k}.
So the Pauli group is subdivided into error cosets by the normaliser, and every Pauli in the same coset has the same error syndrome.
If we perform a syndrome measurement after passing through some noisy channel and get the result \underline{e}, then the effect of the channel is collapsed to being a linear combination of the terms inside the error coset corresponding to the error syndrome \underline{e}.
By applying any element of that error coset, we are mapped back to the normaliser.
In fact, there is further substructure within the normaliser, and this is also reflected in each error family.
Given a Pauli operator P\in N(\mathcal{S}) in the normaliser, we define its logical syndrome to be the vector \underline{\ell}_P of all the values c(P,\sigma), where \sigma ranges over N(\mathcal{S}).
Note that, for any \tau\in\mathcal{S}, we have \underline{\ell}_P=\underline{\ell}_{P\tau}.
Again, this splits the normaliser Pauli operators into sets, which we call the logical cosets, each being defined by having the same logical syndrome.
The error cosets divide up the Pauli group, with the normaliser as one specific example; the logical cosets divide up the normaliser, with the stabiliser as one specific example — see Figures 7.2 and 14.7.
Each operator that’s in the normaliser but not in the stabiliser preserves the codespace (because it doesn’t change the error syndrome), but it must do something non-trivial inside the codespace (because it’s not in the stabiliser).
It thus acts on the logical, encoded, qubits, and so we call it a logical operator.
Moreover, these logical operators either commute or anticommute with one another.
This should remind you of the Pauli operators themselves, and, indeed, we choose to associate these logical operators with logical Pauli operators.
Which are which?
Well, the choice is still arbitrary, as long as we get the relative commutation properties correct: it should be the case that c(Z_L,X_L)=1, for example.
In the case of a CSS code, there are always Z-type representatives that we can choose to take as the logical Z, and X-type representatives for the logical X.
Let’s do some more counting.
Since each logical coset is of size |\mathcal{S}|=2^{n-k}, there must be |N(\mathcal{S})|/|\mathcal{S}|=4^k logical cosets, each corresponding to one of the 4^k logical Pauli operators on k qubits, and each described uniquely by a logical syndrome vector \underline{\ell}, and in such a way that every possible value of \underline{\ell} is accounted for.
However, recall that \underline{\ell}_P=\underline{\ell}_{P\tau} for any \tau\in\mathcal{S}.
This means that we don’t need to record all the commutation values, but only a set of 2k many values, so that \ell\in\{0,1\}^{2k}.
All in all, we can choose any linearly independent set of values we want for the generators, as long as we recall that any operator will commute with itself, and we require the symmetry c(\sigma,\tau)=c(\tau,\sigma).
For example, we could take
\begin{bmatrix}
\underline{\ell}_1
\\\underline{\ell}_2
\\\vdots
\\\underline{\ell}_{2k}
\end{bmatrix}
= \begin{bmatrix}
0 & 1
\\1 & 0
\end{bmatrix}^{\oplus k}
which would naturally select pairs (\underline{\ell}_{2n-1},\underline{\ell}_{2n}) as having the correct commutation relations necessary for them to act as logical Z and logical X for the n-th logical qubit.
Logical operators specify how to split the codespace, and are representatives of the logical cosets.
In particular, the \pm1 eigenstates of Z_L define the logical codewords.
Generically, these codewords are superpositions of basis states.
We emphasise out one final important point before returning to the example of the three-qubit repetition code.
While we can measure the error syndrome (all the stabilisers commute), we cannot measure the logical syndrome (not all the logical operators commute).
Indeed, we must not even try — measuring just one such value is equivalent to performing a measurement of the logical qubit, destroying the superposition of the very state with which we’re trying to compute!
So, back to the example of the three-qubit code from Section 13.1.
Recall that the stabilisers are generated by ZZ\mathbf{1} and \mathbf{1}ZZ.
The normaliser is the set of Pauli operators that commute with all these stabilisers, which we can succinctly write as
N(\mathcal{S})
= \langle ZZ\mathbf{1},\mathbf{1}ZZ\rangle \times \{\mathbf{1},XXX,YYY,ZZZ\}
which already depicts the structure of the logical cosets: they are represented by XXX, YYY, and ZZZ.
Using these representatives, we can evaluate the commutation properties:
\begin{array}{c|ccc}
c(-,-) & XXX & YYY & ZZZ
\\[0.25em]\hline
\\[-1em]XXX & 0 & 1 & 1
\\YYY & 1 & 0 & 1
\\ZZZ & 1 & 1 & 0
\end{array}
From this we can see that any pair of these will work as the logical generators Z_L and X_L, since they all satisfy the required property of c(Z_L,X_L)=1 and c(Z_L,Z_L)=c(X_L,X_L)=0.
In other words, although it’s “natural” to define Z_L\coloneqq ZZZ and X_L\coloneqq XXX, we could just as well decide to set Z_L\coloneqq XXX and X_L=YYY!