All right, good morning, and welcome to the last lecture this year on quantum computing.

So as always, just as a reminder, what we are currently discussing.

So in the last lecture, I started introducing quantum error correction.

So that thing is needed because for quantum gates, so the gate error probability,

so the probability that a gate doesn't work as it should is around 1% to 1 per mil currently,

and that means you cannot execute longer codes without things going wrong.

So as you go in the computation, you need to correct errors that occur.

And one simple strategy to do this is the so-called three-qubit repetition code,

which means a logical zero is actually encoded in three qubits that are all in zero,

and the logical one is actually encoded in three qubits that are all ones.

And then what you can do is measure the parity.

So that is a product of two Pauli-Z operators, and whenever,

so that basically measures whether all qubits are in the same state,

and whenever you have a signal that there are two qubits which are not in the same state,

so then the outcome for this measurement would be a minus one.

So this allows you to detect bit flip errors.

However, we also discussed that this code doesn't allow you to detect phase flip errors,

you need to do something more powerful, and one can sort of formalize this strategy with so-called stabilizers.

That's a set of operators.

I call those PK, where K runs from one, just counts these guys,

and I'm assuming there are eight of them, and they leave the logical states invariant,

meaning so if I apply this PK on some state, some logical state psi j,

so here this could be either that guy or that guy, then the result would be the same state,

which means this is an eigenstate with eigenvalue plus one.

And that should be the case for all j, for all eigenstates.

And then obviously also superposition of these logical states is an eigenstate with eigenvalue one.

So this whole thing is useful because if a Pauli error occurs,

so on some qubit there is some Pauli operator acting on this qubit,

which is in a logical state, and all the qubits are in a logical state, so this would then produce some other state.

And then acting with the stabilizer on this other state,

one can write as either plus or minus PK on this logical state,

and that's because the PKs are a product of some stabilizer generators,

which stabilizer generators are a product of Pauli operators.

And two Pauli operators either commute or anticommute, which means here I need to have a plus or a minus sign.

So this is then plus or minus psi tilde.

So basically because that is a stabilizer and has this property,

and therefore I have this sigma ja acting on this logical state, which is the tilde.

So either this is a plus one, then that stabilizer didn't detect the error,

and if it's a minus one, that stabilizer has detected the error.

So for the minus one thing, the error is detected.

And so the trick is, of course, that you have enough stabilizers so that you can detect every error,

which means that if I have n qubits and m stabilizer generators,

then I have k, which is n minus m logical qubits.

That's because each stabilizer generator, you only keep the states in the code space,

which have plus one eigenvalue, and because this is a product of Pauli's,

it can either have an eigenvalue plus one or minus one, so you always kick away half.

So each stabilizer generator divides the number of available states by two,

and therefore if you have n qubits, you have two to the power n states,

then you take two to the power m away, and you're left with two to the power k states,

which means k logical qubits.