Surface Code Stabilizers on a 2D Lattice

Hello! Welcome to your next lesson in our deep dive into fault-tolerant quantum computing.

In our last lesson, we put the finishing touches on our understanding of the Steane code by implementing its syndrome measurement and correction protocol. We saw how its CSS structure allows for the separate and efficient detection of bit-flip and phase-flip errors. The Steane code is a powerful example of a quantum error-correcting code, but its structure implies a high degree of connectivity between qubits, which can be challenging to engineer in physical hardware.

Today, we turn our attention to the surface code, arguably the most studied and promising candidate for building a large-scale, fault-tolerant quantum computer. Its primary appeal lies in its layout on a 2D grid, requiring only interactions between neighboring qubits. This geometric locality makes it a natural fit for many leading quantum hardware platforms.

Our learning outcome for this lesson is to: Define the surface code on a 2D lattice by specifying the stabilizer generators for plaquette and vertex operators.

We will start with an idealized version of the code on a torus to build intuition, and then move to the more practical planar version with boundaries. By the end, you'll be able to describe the fundamental building blocks of this crucial error-correcting code.

1. The Toric Code: A Foundation on a Torus

The simplest and most elegant version of the surface code is the toric code, which was originally proposed by Alexei Kitaev. It's defined on a 2D square lattice with periodic boundary conditions, effectively wrapping the lattice into a torus. This conveniently eliminates any boundary effects, allowing us to focus on the core structure.

In this construction, the physical qubits reside on the edges of the lattice. The code itself is defined not by its basis states, but by its stabilizer group. As we saw with the Steane code, these are operators whose +1 eigenspace forms the protected codespace. For the toric code, the stabilizer group is generated by two types of local operators:

1. Vertex Operators (Star Operators): For each vertex s on the lattice, we define an operator $A_s$ as the product of Pauli-$X$ operators on all qubits adjacent to that vertex. Since each vertex has four edges connected to it, this is a weight-4 operator.
   $A_s={\prod }_{i\in \text{star}(s)}{X}_i$

2. Plaquette Operators (Face Operators): For each face p (or plaquette) on the lattice, we define an operator $B_p$ as the product of Pauli-$Z$ operators on all qubits forming the boundary of that plaquette. This is also a weight-4 operator.
   $B_p={\prod }_{j\in \text{boundary}(p)}{Z}_j$

The following video provides an excellent introduction to this concept.

A crucial requirement for a set of stabilizer generators is that they must all mutually commute. This ensures they can be measured simultaneously. Let's consider why the toric code generators commute:

• Two vertex operators, $A_s$ and $A_{s^{\prime }}$, always commute because they are products of Pauli-$X$ operators.
• Similarly, two plaquette operators, $B_p$ and $B_{p^{\prime }}$, always commute as they are products of Pauli-$Z$s.
• A vertex operator $A_s$ and a plaquette operator $B_p$ are more interesting.
  • If they do not share any qubits, they trivially commute.
  • If they do share qubits, they will always share exactly two (see the diagram below). An $X$ operator from $A_s$ and a $Z$ from $B_p$ anticommute: $XZ=-ZX$. Since they overlap on two qubits, we get two sign flips, (-1) * (-1) = 1, and the operators as a whole commute.

A vertex operator $A_s$ (product of four $X$s, in red) and a plaquette operator $B_p$ (product of four $Z$s, in blue) either share zero qubits or two qubits. In the latter case, the two anticommutations cancel, so $A_s{B}_p=B_p{A}_s$.

The video you just watched continues to explain this exact point.

2. The Planar Surface Code: Introducing Boundaries

While the toric code is theoretically clean, physical quantum computers have edges. This brings us to the planar surface code, which is defined on a finite 2D grid with boundaries.

The core idea remains the same: we have vertex and plaquette stabilizers. However, the operators at the boundaries must be modified because there are fewer neighboring qubits.

• The bulk stabilizers (those not touching a boundary) remain weight-4, just like in the toric code.
• The boundary stabilizers have a lower weight. For example, a vertex on the edge of the grid might only be connected to three qubits, resulting in a weight-3 $X$ operator. A plaquette at a corner might only be bounded by two qubits, yielding a weight-2 $Z$ operator.

This modification is a simple but crucial step in making the code practical.

3. A Common Layout and Formal Definitions

While the picture of qubits on edges is the origin of the code, a more common representation in recent literature places all qubits (both data and ancilla) on the vertices of a checkerboard lattice. This layout is often more direct when considering experimental implementations.

In this layout:

• Data qubits occupy one set of squares on the checkerboard.
• Ancilla qubits, used for measuring the stabilizers, occupy the other set.
• Z-type plaquette stabilizers are measured by ancillas in the center of a "face" of four data qubits.
• X-type vertex stabilizers are measured by ancillas in the center of a "star" of four data qubits.

The image below, from a research paper on surface code decoding, illustrates this modern convention.

To make this precise, we can read the formal definition of these operators from the paper itself. Given your preference for original sources, this paper will be a useful reference as we proceed.

As described in the paper, for the bulk of the lattice, the stabilizer generators are:

• Vertex operator: $V_{i,j}=X_{i-1,j}{X}_{i,j-1}{X}_{i,j+1}{X}_{i+1,j}$
• Plaquette operator: $P_{i,j}=Z_{i-1,j}{Z}_{i,j-1}{Z}_{i,j+1}{Z}_{i+1,j}$

Here, the indices $(i,j)$ refer to the location of the ancilla qubit that measures the stabilizer, and the other indices refer to the surrounding data qubits. At the boundaries, as the paper notes, these operators are modified by simply removing the Pauli terms corresponding to absent qubits.

Conclusion

In this lesson, we have laid the groundwork for understanding the surface code by defining its fundamental structure. We've moved from the idealized toric code to the practical planar code and established the identity of its stabilizer generators.

Key Takeaways:

• The surface code is a topological stabilizer code defined on a 2D lattice, making it suitable for hardware with only local connectivity.
• The qubits are arranged on a grid, and the code is defined by a set of local stabilizer generators.
• There are two types of generators: vertex operators (products of Pauli-$X$s) and plaquette operators (products of Pauli-$Z$s).
• In the bulk of the lattice, these are typically weight-4 operators. On a planar code with boundaries, the stabilizers at the edges have a lower weight (e.g., 2 or 3).

Preview of the next lesson:
Now that we have defined the stabilizers, the next logical step is to see how they are used to detect errors. In the next lesson, we will implement the syndrome measurement circuits for the surface code. You will see how errors create pairs of "excitations" (violated stabilizers) that mark the endpoints of error chains on the lattice, which forms the basis for the decoding problem.