## 14.4 Logical operators …

*Here we are going to use the abstract group theory that we developed back in Sections 7.5 and 7.6, but there are other ways of explaining this material.*
*In Section @(logical-operators-differently) we tell the same story from a different point of view, so if you find this section confusing then don’t worry — you can always come back to it after reading the other one!*
*It’s always a good idea to have multiple viewpoints.*

We have been slowly building up towards constructing quantum error-correction codes using the stabiliser formalism, but there is one major detail that we have yet to mention.
You will perhaps have noticed that we haven’t written out what the stabiliser states actually *are*, nor what the encoding circuits look like.
There is a simple reason for this: at this point, we don’t actually know!
There’s a little more work to be done — the stabilisers have provided us with a two-dimensional space, but if we have

The **stabilises** a (non-zero) **stabiliser group**; using a little bit of group theory, we characterised all possible stabiliser groups by showing that they are exactly the abelian subgroups of **normaliser**
**centraliser**

If ^{293}, then any element

Since the cosets of

The cosets of **logical operators**, and any representative of a coset is an **implementation** for that logical operator.

Let’s try to understand this in the context of an example: the three-qubit code from Section 13.1. The diagram from Section 7.2 was useful in describing this example, so we repeat it as Figure 14.5 below.

To use the terminology of error-correction codes, we are taking our codespace to be^{294}

The (orthogonal) basis vectors of the codespace **logical states**, and are usually taken to be the encodings of

In general^{295}, the logical states will be *superpositions* of states, but we still sometimes refer to them as codewords.

In our example of the three-qubit code, we have the two logical states **logical 0** and

**logical**1 , which we denote by

*logical*

*logical*

*logical*

The normaliser of *is* the smallest weight logical *if P is some implementation of a logical operator, then so too is SP for any S\in\mathcal{S}*.
In the example above, we see that

Generally, for any CSS code encoding a single qubit into

Even more generally, for any ^{296}

Just a warning before moving on: this discussion might make logical states sound pointlessly simple — logical **??** that

For us here, the stabilised subspace

V_\mathcal{S} is exactly the codespace, and the stabilisers generating\mathcal{S} are exactly the elementsG_r\in\mathcal{P}_n constructed from the rows ofH as at the start of Section 14.3.↩︎We want to encode a single qubit, which lives in a two-dimensional space (spanned by

|0\rangle and|1\rangle ), so it makes sense that we want our codespace to also be two-dimensional.↩︎Note that the logical states for the three-qubit code are actually

*not*superpositions. This reflects the fact that this code is really just a classical repetition code — it only protects against one type of error — embedded into the quantum world.↩︎Proving this is a bit of a task!↩︎