## 14.6 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^{300}, so we should carefully understand how the Pauli operators

Now fix some stabiliser group^{301} **error syndrome**

The set of Pauli operators that have *zero* syndrome are special, and form a set known as the **normaliser**:
*same* error syndrome *for any* **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 *only* way for

Now for some counting.
Since an error syndrome is exactly an

So the Pauli group is subdivided into error cosets^{302} 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 *any* element of that error coset, we are mapped back to the normaliser.

In fact, there is further substructure^{303} within the normaliser, and this is also reflected in each error family.
Given a Pauli operator **logical syndrome** to be the vector **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

Let’s do some more counting.
Since each logical coset is of size *all* the commutation values, but only a set of

Logical operators specify how to split the codespace, and are representatives of the logical cosets.
In particular, 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 (since all the stabilisers commute), we *cannot* measure the *logical* syndrome (since 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.^{304}
Recall that the stabilisers are generated by *any* pair of these will work as the logical generators

“Correct the Paulis and you correct them all.”↩︎

We saw in Section 14.3 that an

[n,k,d] code hadn-k stabiliser generators, so we preemptively label our generators from1 ton-k .↩︎We will see that this structure is exactly that of a

*subgroup*, and that it will be sufficient to just look at the values on the generators when defining the logical syndrome.↩︎Here we’re going to repeat some things that we already said in Sections 14.4 and 14.5.↩︎