Poking Holes and Cutting Corners to Achieve Clifford Gates with the Surface Code

The surface code is currently the leading proposal to achieve fault-tolerant quantum computation. Among its strengths are the plethora of known ways in which fault-tolerant Clifford operations can be performed, namely, by deforming the topology of the surface, by the fusion and splitting of codes, and even by braiding engineered Majorana modes using twist defects. Here, we present a unified framework to describe these methods, which can be used to better compare different schemes and to facilitate the design of hybrid schemes. Our unification includes the identification of twist defects with the corners of the planar code. This identification enables us to perform single-qubit Clifford gates by exchanging the corners of the planar code via code deformation. We analyze ways in which different schemes can be combined and propose a new logical encoding. We also show how all of the Clifford gates can be implemented with the planar code, without loss of distance, using code deformations, thus offering an attractive alternative to ancilla-mediated schemes to complete the Clifford group with lattice surgery.

Popular Summary

Quantum computers have the potential to perform tasks that are intractable with even the most powerful supercomputers. But quantum states are fragile and strongly susceptible to interference from their environment. This introduces errors that could severely limit the scope of quantum computing. Much research has therefore gone into developing error-correcting techniques that also minimize computing resources. One well-studied method uses surface codes, a way of encoding quantum information onto a flat plane. Surface codes are robust to noise, but implementing various computational operations requires tricks that need additional laboratory hardware. We have developed a universal framework that shows how different methods of surface-code computation can be combined and compared to minimize computing resources.

A surface code is described on a square lattice, and in the corners of this lattice lay Majorana modes, which are pointlike objects that describe quantum degrees of freedom. We show a way to move these Majorana modes to manipulate the encoded quantum information. This allows us to implement all Clifford gates, a special set of operations from which a universal quantum computer can be built. Our technique is less demanding on computational resources than existing schemes.

Our framework can describe all known methods of computation with surface codes, which previously seemed distinct and, in some cases, incompatible with one another. We even show how to dynamically transform between different computation schemes. This is helpful for designing flexible computer architectures, and it brings us one step closer to a practical universal quantum computer.

Figure 1

The planar variant of the surface code with two rough boundaries and two smooth boundaries. Qubits lie on the vertices of the square lattice. Diagrams (a) and (b) show the two different types of weight-four stabilizer operators. Diagrams (c) and (d) show two stabilizers that lie at the boundary of the lattice. (e) The logical operator $\overline{Z}$ is the tensor product of Pauli-$Z$ operators extending from the top to the bottom of the lattice. (f) The logical operator $\overline{X}$ is the tensor product of Pauli-$X$ operators along the horizontal dashed line that extends from the left to the right of the lattice.

Figure 2

A hole in the planar code modifies its code space. A hole is shown in the center of the lattice. (a) When a hole is prepared, a new logical operator is produced which consists of a nontrivial cycle of Pauli-$X$ operators that enclose the hole. The qubits that support the logical operator are marked by a thick dashed line. (b) The logical operator shown by label (a) anticommutes with the conjugate logical operator which is composed of the tensor product of Pauli-$Z$ operators that extends from the boundary of the hole to the boundary of the surface. (c) A hole can be produced in the lattice by measuring the qubits in the computational, i.e., Pauli-$Z$, basis.

Figure 3

Two pairs of twist defects on the planar code. Twists appear at the end points of the pink defect lines. (a) The weight-five stabilizer operator of a twist defect, shown up to a phase factor. (b) A modified weight-four stabilizer that lies on the pink line. (c) A logical operator associated with the four twist defects on the lattice. (d) The tensor product of Pauli-$X$ operators on the qubits supported along the dashed line gives the logical operator that anticommutes with that shown at (c).

Figure 4

A schematic diagram of the planar-code lattice with a rough boundary. Strings of Pauli-$Z$ (Pauli-$X$) operators are marked by red (blue) lines, respectively. Diagrams (a) and (b), respectively, show $A_f$ and $B_f$ stabilizer operators. (c) An element of the stabilizer group where a string of Pauli-$Z$ operators follows a trivial path and terminates at the same rough boundary of the lattice. (d) A defect line marked by a dashed white line with two twist defects at its end points. Red strings that cross the defect line change to blue and vice versa. (e) A stabilizer operator that encloses a single twist. The string must wind twice around the twist, which changes the string from red to blue and back to red again to form a closed loop. As mentioned, the stabilizer should also include a complex phase due to the point where the two strings cross, which we do not consider explicitly.

Figure 5

Lattices with different configurations of twist defects but equivalent logical operators. (a) Four twist defects in the center of the lattice. The logical operators are closed loops that enclose pairs of twists. (b) The logical operators shown in (a) multiplied by stabilizer operators that terminate at the boundary, as in Fig. 4, thus giving the logical operator shown in the picture. (c) We consider the lattice shown in (a) and (b), except where the defect lines terminate at the boundary. In this picture, the twist defects lie at the boundaries of the lattice. Importantly, the logical operators are unchanged from those shown in (b). (d) We finally show the lattice where the defect lines are drawn close to the left and right sides of the lattice. Now, the logical operators are equivalent to those in Fig. 1, where a string of Pauli-$X$ operators runs from the left to the right of the lattice and a string of Pauli-$Z$ operators runs from the top to the bottom of the lattice.

Figure 6

Moving the twist defects at the corners of the planar code into the bulk of the lattice. (a) We make single-qubit Pauli measurements along the pink defect line to deform the twist defect from the corner of the planar code to the center of the lattice. Most of the measurements along the line are Pauli-$Y$ operators, but we also use Pauli-$X$ measurements and Pauli-$Z$ measurements to move a twist around a corner. (b,c) Stabilizer operators that are modified by the code deformation at locations where twists are moved around corners. (d) The stabilizer operator that lies at the corner of the lattice where a twist defect has been removed. (e) Two qubits at the corner of the lattice that have been measured in a product basis and are no longer entangled with the code.

Figure 7

A sequence of code deformations that map the logical operator $\overline{Z}$ onto $\overline{Y}$. (a) We move the bottom two twist defects into the center of the lattice. We also show the $\overline{Z}$ string operator in red, which “snakes” between the twist defects at the center of the lattice. (b) We deform the position of one twist defect into the bottom-right corner of the lattice. The logical operator is deformed over the defect line such that it is not supported on any of the qubits where code-deformation measurements move the lowest twist defect from its position in (a) to its position in (b). This deformation moves the logical operator over a defect line and, as such, changes the color of the string. We also multiply the logical operator by a stabilizer that extends from the left-hand side of the lattice to the bottom of the lattice, which is also shown in the figure. (c) A small deformation of the logical operator shown in (b) gives the pictured logical operator. (d) Multiplying the logical operator shown in (c) by a stabilizer that encloses the single twist defect lying at the center of the lattice deforms the logical operator out of the path of the twist, enabling us to move the twist defect at the center of the lattice to the bottom-left corner of the lattice, thus completing the procedure.

Figure 8

Spacetime figure showing the evolution of the logical operator $\overline{X}$ under the exchange of two twists, where the time direction is upwards along the page. The figure shows that the operator is mapped onto the logical operator $\overline{Y}$, which can be seen at the top of the figure. The trajectory of the twist defects is marked by black lines. As in the two-dimensional figures above, red (blue) strings correspond to the world lines of $e$ ($m$) quasiparticle excitations. We continue with the convention we used earlier, where $e$ charges can terminate at the boundary. We depict this by showing red strings diverging away from the twist defects.

Figure 9

By rotating the lattice geometry about an angle of $\pi /4$, we can perform both twist exchange operations without reducing the distance beyond a small constant value. The figure shows a distance $L=9$ lattice. (a,b) Two twist defects that have been deformed into the center of the lattice. (c) The single-qubit measurements we make to move the twist along the bottom of the lattice. (d) A weight-nine logical operator at a moment where the two twists pass each other. The black dashed and dotted lines show the support of conjugate weight-nine logical operators that we find to be minimal in weight.

Figure 10

A surface code that encodes two logical qubits. Logical operators ${\overline{X}}_1$, ${\overline{Z}}_1$, ${\overline{X}}_2$, and ${\overline{Z}}_2$, which act on qubit 1 and qubit 2, are shown. Exchanging the two central qubits along the trajectories shown by the dark grey arrows, which are marked by $e$, entangle the two logical qubits. This exchange can be performed without decreasing the code distance beyond a small constant amount on an $L\times 2L$ lattice with the square geometry we show in Fig. 1.

Figure 11

The code-deformation scheme to entangle a qubit encoded with a pair of holes to a qubit encoded over four twists. At the top of the figure, we show the logical operators for a quadruple-twist qubit encoding, and at the bottom of the figure, we show the logical operators for a hole-pair qubit encoding. We present a scheme to perform a controlled-NOT gate where the qubit encoded with the four twists is the control qubit and the qubit encoded using holes is the target qubit. The black dashed line shows the trajectory that the hole in the middle of the figure must follow to complete a controlled-NOT gate between these qubits.

Figure 12

The deformation of the ${\overline{Z}}_T$ operator under the fault-tolerant entangling operation. (a) The logical operator that terminates at the hole moves with the hole and is thus threaded between the twists. We also point out that the boundary of the hole changes from a rough boundary to a smooth boundary as it is passed across the defect line. As such, we draw a white dashed line around the puncture. (b) Upon moving the puncture back to its initial position, we see that we have wrapped the logical string operator around the lower two twists shown in the figure. One can check that the deformed logical operator is equivalent to ${\overline{Z}}_C{\overline{Z}}_T$, as shown in Fig. 11.

Figure 13

The transformation ${\overline{X}}_C$ onto ${\overline{X}}_C{\overline{X}}_T$ under the code-deformation scheme. Diagram (a) shows how ${\overline{X}}_C$ is deformed around the hole when the hole lies in between the four twists. (b) Once the hole has been deformed around the two lower twists of the lattice and is returned to its initial position, the logical operator ${\overline{X}}_C$ is deformed onto a string operator that is equivalent up to stabilizer multiplication to the logical operator ${\overline{X}}_C{\overline{X}}_T$, as we show in Fig. 11.

Figure 14

Executing the two qubit parity measurements, we need to perform a controlled-NOT gate. Qubits are encoded with quadruples of twists, where the different logical qubits—the control, target, and ancilla—are labeled in the center of each twist quadruple. We measure ${\overline{Z}}_C{\overline{Z}}_A$ by braiding a single hole of a hole-pair qubit around two twists of the control qubit and two twists of the ancilla qubit, as shown in the figure. Upon completing this deformation, measuring the hole-pair qubit reveals the outcome of the parity measurement. We also show the ${\overline{X}}_A{\overline{X}}_T$ operator that we must measure. This is again achieved by braiding one hole of a hole pair, which is prepared in $\overline{X}$ around the loop followed by the ${\overline{X}}_A{\overline{X}}_T$ operator. Measuring ${\overline{Z}}_A$ completes the controlled-NOT gate, up to a Pauli correction.

Figure 15

Using the picture of twists, we can view lattice surgery as a measurement-only approach to performing logical gates between non-Abelian point particles. In bold colors, we show three planar codes, and the ${\overline{Z}}_C{\overline{Z}}_A$ and ${\overline{X}}_A{\overline{X}}_T$ measurements we need to perform lattice surgery are shown in red and blue, respectively. We also show with pale colors the qubits used in the measurement-only scheme above that are not required in the lattice surgery scheme. From this perspective, we see that lattice surgery is a measurement-only topological quantum computation scheme with a significant reduction in resource costs, as we are able to perform the required parity measurements with only $\mathcal{O}(L)$ ancillary physical qubits, which is in contrast to $\mathcal{O}(L^2)$ qubits if we maintain all of the twist defects on the same lattice.

Figure 16

A hybrid qubit is encoded using a pair of holes—one with a rough boundary and one with a smooth boundary—and one pair of twist defects. The two anticommuting logical operators of the hybrid qubit are shown.