5
$\begingroup$

Notation

$$X \equiv \sigma_x \qquad Z \equiv \sigma_z$$

Introduction

The surface code is a quantum error correction code. In the surface code, we have a two-dimensional grid of qubits each coupled to its four nearest neighbors. As shown in Fig. 1, within a row or column, every other qubit is alternatingly a data or measure qubit. On each round of the surface code's error correction mechanism, the measure qubits each measure the 4-way parity of either $X$ or $Z$ of their four neighboring data qubits.

The essence of the surface code is contained in the fact that these measurements do not completely collapse the state of the grid. This can be seen in a 2-qubit example. The two measure qubits highlighted in Fig 1 measure the two operators $$X_A X_B \quad \text{and} \quad Z_A Z_B \, . $$ These operators commute, so there are in fact simultaneous two-qubit eigenstates of those parity operators. In fact, those eigenstates are precisely the four two-qubit Bell states.

Question

We know that in the the two qubit case, there are four possible eigenstates of the parity measurements, i.e. the Bell states. What are the eigenstates with more than two qubits?

As an example, we could consider a small patch of the surface code that looks like this:

X o X
o Z o

where o means a data qubit, X means a measure-X qubit, and Z means a measure-Z qubit. Another "simple" case could be

o X o X
Z o Z o
o X o X
Z o Z o

with periodic boundary conditions.


Figure 1

$\endgroup$
  • $\begingroup$ The important property you want is not quite "not collapsed". You want there to be multiple admissible pure states. You then encode qubits into the amplitudes of these admissible states. As a rule of thumb, assuming you don't do anything dumb, if you have N data qubits and M check qubits, then there are 2^(N-M) admissible states (i.e. there are N-M logical qubits available). $\endgroup$ – Craig Gidney Jan 12 '18 at 0:48
  • $\begingroup$ @CraigGidney Yeah that's why the title says "states". $\endgroup$ – DanielSank Jan 12 '18 at 1:02
  • $\begingroup$ Your notation/convention for "surface code" feels non-standard to me. The way I know it is, I guess, without the "measure" qubits -- just qubits on the edges of a square lattice, which (without error) satisfy X^4 and Z^4 parity constraints across vertices/plaquettes, respectively. In that case, the eigenstates of error syndromes are states with (anyonic) excitations on every vertex/plaquette with an error. $\endgroup$ – Norbert Schuch Jan 12 '18 at 16:52
  • $\begingroup$ @NorbertSchuch Yeah that's a "theorist's" view whereas I drew an "experimentalist's" view showing the elements that actually do the parity measurements. It doesn't matter: rotate my drawing $\pi/4$ and focus only on the blue qubits and you'll see your view. Could you perhaps convert your statement about anyonic excitations to an answer? $\endgroup$ – DanielSank Jan 12 '18 at 17:13
  • $\begingroup$ My issue is that I'm not sure what kind of answer to you want for a "What are the eigenstates" questions. Do you want an explicit formula for a large system? Or do you want to understand sth. about its structure? I mean, the states written in a local basis are quite a mess, since they are highly entangled (that's exactly the point, of course). $\endgroup$ – Norbert Schuch Jan 12 '18 at 17:58
2
$\begingroup$

Let's take your example:

X o X
o Z o

So three data qubits (the o's). Let's label them 0, 1, 2, left to right. This little surface code involves measuring the operators $X_0X_1$, $Z_0Z_1Z_2$, $X_1X_2$. Working out explicit states is straightforward. Start with the all 0 state, as this is a simultaneous +1 eigenstate of all Z parity operators:

$$|000 \rangle \, .$$

Then systematically build a state that is also the +1 eigenstate of all X parity operators. First $X_0X_1$:

$$\frac{1}{\sqrt{2}}(|000\rangle + X_0 X_1|000\rangle) = \frac{1}{\sqrt{2}}(|000\rangle + |110\rangle)$$

Then $X_1X_2$:

$$\frac{1}{2}[(|000\rangle + |110\rangle) + X_1X_2(|000\rangle + |110\rangle)] = \frac{1}{2}(|000\rangle + |110\rangle + |011\rangle + |101\rangle) \, .$$

To obtain the state that is the -1 eigenstate of any particular parity operator, find a path of Pauli operators that anticommutes only with it, and apply these operators to the state. For example, $Z_0$ anticommutes only with $X_0X_1$, so the simultaneous -1 eigenstate of $X_0X_1$ and +1 eigenstate of both $Z_0Z_1Z_2$ and $X_1X_2$ is:

$$\frac{1}{2}(|000\rangle - |110\rangle + |011\rangle - |101\rangle) \, .$$

At least one such path exists for every parity operator, and it doesn't matter which path you choose, you'll always get the same state.

$\endgroup$
  • $\begingroup$ This is a nice recipe for generating quiescent states. Is there a known useful way to write down the state for a grid that's bigger than the little three-qubit one used here as an example? The quantum ket notation with each qubit in a line isn't well matched to the 2D coupling we find in the surface code. $\endgroup$ – DanielSank Jan 12 '18 at 5:52
  • $\begingroup$ Sure, just write down a list of signed parity operators. Negative parity operators indicate the underlying state is the -1 eigenstate of the positive version. Since you can easily generate an explicit state corresponding to this list, you just work with the list of operators and never worry about the explicit form of the state. This parity operator list can be manipulated easily to effectively implement Clifford gates. There are even more efficient ways of representing these states using graphs, but that's significantly more complicated (arxiv.org/abs/quant-ph/0504117). $\endgroup$ – QComputers Jan 14 '18 at 20:52

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.