After 3 years, here I am again. Hard times, but I will neither complain nor explain. Let me go straight to what matters, for time is still short.

I have just come back from the 10th Topological Quantum Computation Symposium in Leeds. I was invited to talk about my present work on statistical physics of *classical* error-correcting codes and our tentatives to extend it to quantum codes. It was a bit off topic I thought after watching all those talks about anyons, but they insisted to me it was useful anyway. I am not so sure, but I would like to believe so.

I am becoming very interested in TQC, probably because I miss quantum mechanics. Let me explain more or less how it works, or how I understood it. Following John Baez's philosophy, I may be able to clarify my thoughts by doing that.

Topological Quantum Computation is a spinoff of Topological Quantum Codes, which seem to have been first proposed by A. Kitaev in the by now classic paper:

Kitaev's model became known as the **Toric Code**, because it is designed to correct errors in a quantum system which is constructed in the surface of a torus. The Toric Code belongs to a class of quantum error-correcting codes called **Stabilizer Codes**. In this kind of code the codewords *t* correspond to eigenstates |*t>* with eigenvalue 1 of an Abelian group of operators *S* called the **Stabilizer Group** for that particular code such that

*S*|*t>* = |*t*>.

For obvious reasons, |*t>* is said to be stabilized by the code. A more detailed explanation can be found on Nielsen and Chuang's book:

[2] *Quantum Computation and Quantum Information*, Nielsen & Chuang

In the toric code, the codewords are states of a system composed by a square *N* x* N* lattice with qubits (two-level quantum systems) placed on the edges, *not on the vertices*. Opposite boudaries of the square lattice are identified, i.e., periodic boundary conditions are assumed resulting in the surface of a torus, which gives the model its name. The total amount of qubits is 2*k*^2.

The toric code is then defined by a set of star operators *A* and plaquette operators *B*. Each star operator *A_s* is associated with the *s*-th vertex of the lattice and is composed by the tensor product of the four *X* operators (2 x 2 Pauli matrix corresponding to the spin in the *x* direction) acting on the four edges meeting at that vertex. One plaquette operator *B_p* is associated to each square on the lattice and composed by the tensor product of the four *Z* operators (spin in the *z* direction) acting on the edges of the corresponding square. As *X* and *Z* commute for different vertices and anticommute for the same vertex and as each star operator and each plaquette operator has only zero or two edges in common, all *A_s*'s commute with all *B_p*'s. Then we call the toric code the set of states stabilized by all *A_s* and *B_p* simultaneously.

However, the *A*'s and *B*'s are not completely independent and multiplying all operators of one kind together must give the identity. Therefore, the stabilizer group contains 2*k*^2-2 independent generators. Now, the handwaving argument is that each stabilizer condition halves the stabilized vector space for each stabilizer has half of the eigenvalues -1 and the other half +1. The rigorous proof can be found in Nielsen & Chuang's book above. This implies that the stabilized vector space has dimension 2^2, which means that it encodes 2 qubits.

Any Pauli operator that commutes with all the stabilizers sends a codeword to another codeword. These operators can be represented by the product of two other Pauli operators containing respectively only *I*'s and *X*'s and only *I*'s and *Z*'s. These can be represented graphically by *chains*, which are structures composed by the edges in which the *Z*'s act and the edges of the dual lattice that cut the edges of the direct lattice where the *X*'s act. The picture at the side give examples of these chains. It was taken from Kitaev's paper [1].

It turns out that topologically trivial loops, those that can be contracted to a point, correspond to stabilizers, while non-trivial ones do not and therefore change one codeword into another.

This basically defines the toric code. In the next post I will explain how errors can be graphically represented and how they correspond to quasiparticles of a specific Hamiltonian that posses fractional spin, which means, they are *anyons*. * *