The ZX calculus is a language for surface code lattice surgery

TL;DR

This paper shows that the ZX calculus provides an exact, diagrammatic language for representing, designing, and optimizing surface code lattice surgery operations in quantum computing, enabling new, efficient protocols.

Contribution

It establishes a formal correspondence between lattice surgery operations and ZX calculus, enabling novel, efficient, and configurable quantum protocols.

Findings

ZX calculus matches lattice surgery operations exactly

ZX diagrams can represent correction operations natively

Re-write rules produce novel lattice surgery procedures for T gates and CNOTs

Abstract

A leading choice of error correction for scalable quantum computing is the surface code with lattice surgery. The basic lattice surgery operations, the merging and splitting of logical qubits, act non-unitarily on the logical states and are not easily captured by standard circuit notation. This raises the question of how best to design, verify, and optimise protocols that use lattice surgery, in particular in architectures with complex resource management issues. In this paper we demonstrate that the operations of the ZX calculus -- a form of quantum diagrammatic reasoning based on bialgebras -- match exactly the operations of lattice surgery. Red and green "spider" nodes match rough and smooth merges and splits, and follow the axioms of a dagger special associative Frobenius algebra. Some lattice surgery operations require non-trivial correction operations, which are captured natively in the use of the ZX calculus in the form of ensembles of diagrams. We give a first taste of the power of the calculus as a language for lattice surgery by considering two operations (T gates and producing a CNOT ) and show how ZX diagram re-write rules give lattice surgery procedures for these operations that are novel, efficient, and highly configurable.

Figures

Equations

$$\begin{array}{c}\text{includegraphics}\\ \text{(a)}\end{array}$$

$$\tilde{\mathsf{M}}_{R}(\rho)\,=\,\Bigl{(}K_{0,R}^{\phantom{\dagger}}\,\rho\,K_{0,R}^{\dagger}\otimes\left|\texttt{+1}\right\rangle\!\!\left\langle\texttt{+1}\right|_{M}\Bigr{)}\,+\,\Bigl{(}K_{1,R}^{\phantom{\dagger}}\,\rho\,K_{1,R}^{\dagger}\otimes\left|\texttt{-1}\right\rangle\!\!\left\langle\texttt{-1}\right|_{M}\Bigr{)}$$

$${}\!\!\!\!\begin{aligned} \begin{aligned} \includegraphics[angle={-90}]{ZXfigs/prepX.pdf}\end{aligned}\quad&\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/prepX-alpha.pdf}\end{aligned}&\qquad\;\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/prepZ.pdf}\end{aligned}\quad&\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/prepZ-alpha.pdf}\end{aligned}&\qquad\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/projX.pdf}\end{aligned}\quad&\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/projX-alpha.pdf}\end{aligned}&\qquad\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/projZ.pdf}\end{aligned}\quad&\begin{aligned} \includegraphics[angle={-90}]{ZXfigs/projZ-alpha.pdf}\end{aligned}\end{aligned}\!\!\!\!$$

$$\displaystyle\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={-90}]{ZXfigs/rotZ.pdf}\end{aligned}$$

$$\displaystyle\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={-90}]{ZXfigs/rotX.pdf}\end{aligned}$$

$$\biggl{[}\begin{aligned} ~{}\\[-10.76385pt] \;\;\includegraphics[angle={-90}]{ZXfigs/prepBlank-alpha.pdf}\;\;\\[-10.76385pt] ~{}\end{aligned}\biggr{]}^{\textstyle\dagger}=\;\;\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={-90}]{ZXfigs/projBlank-minalpha.pdf}\;\\[-10.76385pt] ~{}\end{aligned}\;;\qquad\biggl{[}\begin{aligned} ~{}\\[-10.76385pt] \;\;\includegraphics[angle={-90}]{ZXfigs/rotBlank-alpha.pdf}\;\;\\[-10.76385pt] ~{}\end{aligned}\biggr{]}^{\textstyle\dagger}=\;\;\begin{aligned} ~{}\\[-8.61108pt] \includegraphics[angle={-90}]{ZXfigs/rotBlank-minalpha.pdf}\;\\[-10.76385pt] ~{}\end{aligned}\;;\qquad\biggl{[}\begin{aligned} ~{}\\[-15.0694pt] \;\;\includegraphics[angle={-90}]{ZXfigs/splitBlank-alpha.pdf}\;\;\\[-10.76385pt] ~{}\end{aligned}\biggr{]}^{\textstyle\dagger}=\;\;\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={-90}]{ZXfigs/mergeBlank-minalpha.pdf}\\[-10.76385pt] ~{}\end{aligned}\;.$$

$$\displaystyle\smash{\begin{aligned} ~{}\\[-17.22217pt] \includegraphics[angle={-90}]{ZXfigs/basicCNOT.pdf}\\[-12.91663pt] ~{}\end{aligned}}\;\;\;{}={}$$

$$+|1⟩⟨1|\otimes ⟨1|\text{+}⟩\otimes |\text{+}⟩⟨\text{+}|+|1⟩⟨1|\otimes ⟨1|\text{-}⟩\otimes |\text{-}⟩⟨\text{-}|$$

$$=$$

$$2\pi$$

$$\displaystyle{}\mspace{-18.0mu}\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/handbagBlank-left.pdf}\end{aligned}\quad=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/handbagBlank-right.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/rotBlank.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/spindleBlank.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={90}]{ZXfigs/handbagBlank-left.pdf}\end{aligned}\;\;\;=\quad\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={90}]{ZXfigs/handbagBlank-right.pdf}\end{aligned}\;\;;$$

$$\displaystyle\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeBlank-twist.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeBlank-long.pdf}\end{aligned}\;\;;\qquad\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={90}]{ZXfigs/mergeBlank-twist.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={90}]{ZXfigs/mergeBlank-long.pdf}\end{aligned}\;\;;$$

$$\displaystyle\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[angle={-90}]{ZXfigs/assocBlank-left.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-17.22217pt] \includegraphics[angle={-90}]{ZXfigs/assocBlank-right.pdf}\end{aligned}\;\;;\qquad\begin{aligned} ~{}\\[-8.61108pt] \includegraphics[angle={90}]{ZXfigs/assocBlank-left.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={90}]{ZXfigs/assocBlank-right.pdf}\end{aligned}\;\;;$$

$$\displaystyle\begin{aligned} ~{}\\[-26.90964pt] \includegraphics[angle={-90}]{ZXfigs/zcurveBlank.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/bneckBlank.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-26.90964pt] \includegraphics[angle={-90}]{ZXfigs/scurveBlank.pdf}\end{aligned}\;\;.$$

$$\displaystyle{}\mspace{-18.0mu}\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/in3out1.pdf}\end{aligned}\;:=\;\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/assocBlank-left.pdf}\end{aligned}\;=\;\begin{aligned} ~{}\\[-17.22217pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/assocBlank-right.pdf}\end{aligned}\,\,;$$

$$\displaystyle\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/in1out3.pdf}\end{aligned}\;:=\;\begin{aligned} ~{}\\[-8.61108pt] \includegraphics[scale={0.75},angle={90}]{ZXfigs/assocBlank-left.pdf}\end{aligned}\;=\;\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[scale={0.75},angle={90}]{ZXfigs/assocBlank-right.pdf}\end{aligned}\,\,;$$

$$\displaystyle\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/in2out2.pdf}\end{aligned}\!\;:=\,\begin{aligned} ~{}\\[-26.90964pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/zcurveBlank.pdf}\end{aligned}\,=\,\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/bneckBlank.pdf}\end{aligned}\,=\,\begin{aligned} ~{}\\[-26.90964pt] \includegraphics[scale={0.75},angle={-90}]{ZXfigs/scurveBlank.pdf}\end{aligned}\,\,.\;\;\mspace{-18.0mu}$$

$$\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/splitZ-phase-in.pdf}\end{aligned}\;\;=\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/splitZ-phases-out.pdf}\end{aligned}\qquad\qquad\qquad\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/splitX-phase-in.pdf}\end{aligned}\;\;=\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/splitX-phases-out.pdf}\end{aligned}$$

$$\displaystyle\;\begin{aligned} \begin{aligned} ~{}\\[-19.37494pt] \includegraphics[angle={-90}]{ZXfigs/phaseCommute-b.pdf}\end{aligned}\end{aligned}$$

$$\displaystyle\;\;\;\;\quad\Big{\updownarrow}$$

$$\displaystyle\begin{aligned} \begin{aligned} ~{}\\[-19.37494pt] \includegraphics[angle={-90}]{ZXfigs/phaseCommute-a.pdf}\end{aligned}\end{aligned}\;\longleftrightarrow{}$$

$$\displaystyle\begin{aligned} ~{}\\[-10.76385pt] \includegraphics[angle={-90}]{ZXfigs/piZ.pdf}\end{aligned}$$

$$\displaystyle\begin{aligned} \begin{aligned} ~{}\\[-19.37494pt] \includegraphics[angle={-90}]{ZXfigs/Z1commuteCNOT-a.pdf}\end{aligned}\end{aligned}$$

$$\displaystyle\begin{aligned} \begin{aligned} ~{}\\[-19.37494pt] \includegraphics[angle={-90}]{ZXfigs/Z2commuteCNOT-a.pdf}\end{aligned}\end{aligned}$$

$$K_{1,R}=|\text{+}⟩⟨\text{-+}|+|\text{-}⟩⟨\text{+-}|$$

$$K_{1,R}\;\;=\;\;\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-lcorr.pdf}\end{aligned}\qquad\biggl{(}\text{respectively,}\quad K_{1,R}\;\;=\;\;\begin{aligned} ~{}\\[-17.22217pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-rcorr.pdf}\end{aligned}\;\biggr{)}.$$

$$K_{1,S}\;\;=\;\;\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-lcorr.pdf}\end{aligned}\qquad\biggl{(}\text{respectively,}\quad K_{1,S}\;\;=\;\;\begin{aligned} ~{}\\[-15.0694pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-rcorr.pdf}\end{aligned}\;\biggr{)}.$$

$${\mathsf{M}}_R$$

$$\Biggl{\{}\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-pos.pdf}\end{aligned}\;\;\text{\Large\raisebox{-11.16pt}{,}}\;\;\;\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-lcorr.pdf}\end{aligned}\;\;\Biggr{\}}\qquad\text{or}\qquad\Biggl{\{}\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-pos.pdf}\end{aligned}\;\;\text{\Large\raisebox{-11.16pt}{,}}\;\;\;\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-rcorr.pdf}\end{aligned}\;\;\Biggr{\}}$$

$$\Biggl{\{}\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-pos.pdf}\end{aligned}\;\;\text{\Large\raisebox{-11.16pt}{,}}\;\;\;\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-lcorr.pdf}\end{aligned}\;\;\Biggr{\}}\qquad\text{or}\qquad\Biggl{\{}\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-pos.pdf}\end{aligned}\;\;\text{\Large\raisebox{-11.16pt}{,}}\;\;\;\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-rcorr.pdf}\end{aligned}\;\Biggr{\}}$$

$${\mathsf{M}}_R$$

$$\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-lbyp.pdf}\end{aligned}\qquad\qquad\text{or}\qquad\qquad\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={-90}]{ZXfigs/mergeX-rbyp.pdf}\end{aligned}$$

$$\begin{aligned} ~{}\\[-30.1388pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-lbyp.pdf}\end{aligned}\qquad\qquad\text{or}\qquad\qquad\begin{aligned} ~{}\\[-12.91663pt] \includegraphics[angle={-90}]{ZXfigs/mergeZ-rbyp.pdf}\end{aligned}$$

$$\begin{aligned} ~{}\\[-43.05542pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby4-pos.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-piby4.pdf}\end{aligned}\;.$$

$$\begin{aligned} ~{}\\[-47.36096pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby4-neg.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby4-neg-a.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-piby4-conj.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-minpiby4.pdf}\end{aligned}\;.$$

$$\begin{aligned} ~{}\\[-43.05542pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby2-pos.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-piby2.pdf}\end{aligned}\;.$$

$$\begin{aligned} ~{}\\[-47.36096pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby2-neg.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/phaseInject-piby2-neg-a.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-25.83325pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-piby2-conj.pdf}\end{aligned}\quad=\quad\begin{aligned} ~{}\\[-34.44434pt] \includegraphics[angle={-90}]{ZXfigs/rotZ-minpiby2.pdf}\end{aligned}\;.$$

$$\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/scurveCNOT.pdf}\end{aligned}\;\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/basicCNOT.pdf}\end{aligned}$$

$$\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/basicCNOT.pdf}\end{aligned}\;\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/zcurveCNOT.pdf}\end{aligned}\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/prep-zbell-CNOT.pdf}\end{aligned}\;\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/prep-xbell-CNOT.pdf}\end{aligned}\;\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/proj-zbell-CNOT.pdf}\end{aligned}\;\;\;=\;\;\;\begin{aligned} ~{}\\[-21.52771pt] \includegraphics[angle={-90}]{ZXfigs/proj-xbell-CNOT.pdf}\end{aligned}$$

$$\displaystyle\begin{gathered}~{}\\[-21.52771pt] \includegraphics[scale={0.8},angle={-90}]{ZXfigs/scurveCNOT.pdf}\end{gathered}\qquad$$

Full text

1 Introduction

With the development of (small-scale, noisy) devices, quantum computing is in the midst of moving from concept to mature technology [31, 26]. As we try to determine how best to make quantum technology scalable, it becomes apparent that new theoretical tools would be useful, both to organise the components of quantum computers, and to reason effectively about the way that these systems are constructed.

A key element of any such large-scale fault-tolerant architecture is quantum error correction [46, 44]. Currently the technique of choice for flexibility and efficient use of resources is the surface code with lattice surgery [5, 30, 23]. The surface code, in this case, encodes a single logical qubit in the state of many entangled qubits in a single planar surface (a quantum memory). Error detection and correction are performed by the repeated measurement of stabilizers across the surface, to track how noise affects the encoded data. Lattice surgery operations are performed by splitting surfaces into two or more (using measurements), and by merging two or more surfaces together (by further stabilizer measurements).

An intriguing feature of lattice surgery operations is that they necessarily involve quantum transformations of memories by CPTP maps which are not unitary transformations. Two-qubit operations in the previously-standard circuit model, such as a CNOT , may be realised deterministically in lattice surgery, using classical processing similar to that involved in standard teleportation. However, the basic split and merge operations themselves do not rest easily with the standard unitary circuit model. The absence of a notation or language specifically for lattice surgery has made it hard efficiently to design, verify, and compile novel surgery patterns. It has also lead to the occasional misrepresentation of lattice surgery as a method for merely simulating unitary gates, rather than a set of computational primitives in its own right. Previous methods for representing lattice surgery include as square patches [29], moving squares around in a ‘game’ style [39], and as 3D space-time figures in CAD software [25]. In all cases, these representations get visually and technically unwieldy very quickly, making design, optimisation, and particularly verification (that a lattice surgery procedure is doing what we think) challenging.

In this paper we link the operations of lattice surgery directly to a pre-existing diagrammatic language for quantum computing: the ZX calculus. Developed over the last ten years, the ZX calculus (sometimes referred to simply as “ZX”) is an abstract graphical language for tensor networks that is complete for quantum mechanics [12, 28]. We show in this paper how the lattice surgery primitives of split and merge — including their non-deterministic byproduct operations — are precisely captured by some of the simplest diagrams of this calculus. In order to do this, we also give a more fine-grained analysis of lattice surgery operations and corrections than appears in the pre-existing literature. The ZX calculus is therefore a language for lattice surgery, meaning that results of work on the calculus can be imported directly for use with lattice surgery.

Unlike circuit notation, the ZX calculus is indeed a calculus: a formal language, with meaning-preserving rules for how those diagrams may be transformed, without the need to transcribe those operations as exponentially large matrices (even for full pure-state QM, that cannot be efficiently simulated using e.g. stabilizer notation [27]). By such transformations of these diagrams — corresponding to different sets of lattice surgery procedures that implement the same operation — new protocols may thus be discovered. We give examples of re-writing diagrams for CNOT and T-gate operations to demonstrate this technique. In the process, we discover six novel CNOT implementations in lattice surgery, and significantly reduce the operational overhead of the T-gate implementation.

The use of the ZX calculus for surface codes with lattice surgery makes the manipulation of error corrected operations visually intuitive, and capable of verification at large scales. As these operations will likely form the basic operations that a fault-tolerant device will use at the logical level, ZX therefore becomes the natural language and logic for programming large-scale quantum computing technologies.

2 The planar surface code

The planar surface code uses a 2D lattice segment, in which every edge of the lattice (between neighbouring vertices) is associated with a qubit [5, 24, 15, 44]. These physical qubits encode a single logical qubit’s worth of information in their (generally highly-entangled) joint state. For a lattice of $n$ qubits there are $n-1$ stabilizers (operators for which the state of the lattice is a positive $+1$ eigenstate), fixing a subspace which encodes a single degree of freedom (the logical qubit) across the physical qubits.

Figure 1(a) shows a distance-3 planar surface code lattice (the distance of a code is the weight of the smallest non-trivial error which cannot be detected by the code). The black circles correspond to physical qubits; everything else in the diagram is an aid to the eye. A planar code lattice has two types of boundary: rough (here, left and right) and smooth (here, top and bottom). The stabilizers are defined in terms of local relationships forming “plaquettes”. In this paper we use the convention that the term “plaquette” refers to any set of qubits, either on the boundary of a face or surrounding a vertex of the lattice. Specifically, the operators ${Z\otimes Z\otimes Z\otimes Z}$ around each face (such as the blue-shaded set of four qubits), and ${X\otimes X\otimes X\otimes X}$ around each vertex (such as the brown shaded region). For plaquettes on the surface boundary, the corresponding stabilisers are $Z\otimes Z\otimes Z$ or $X\otimes X\otimes X$. Figure 1(a) has 13 physical qubits, and 12 plaquettes/stabilizers. The codespace is the simultaneous $+1$ eigenstate of all of the stabilisers: taken as multi-qubit observables, these operators can be measured without changing the encoded “lattice state”.

The information of the logical qubit is accessed through logical operators, as shown in Figure 1(b). Any horizontal chain of $Z$ operators starting and finishing on (separate) rough boundaries is a logical $Z_{L}$ operator, and any vertical chain of $X$ operators between smooth boundaries is a logical $X_{L}$ operator. These operations commute with all of the stabilizers, and so preserve the code. The significance of the $Z_{L}$ and $X_{L}$ operators is two-fold. Firstly, they realise operations on the encoded logical qubit. For instance, a bit-flip of the logical qubit is accomplished via a sequence of physical $X$ operations on qubits forming a chain between smooth boundaries (the $X_{L}$ operator). The logical operators act secondly as measurable observables of the encoded data itself, encoding specific logical states. For instance, if a chain of qubits between rough boundaries are measured out in the $Z$ basis, then the product of the measurement results $\pm 1$ is the eigenvalue of the logical $Z_{L}$. If the result is $+1$ then the logical state was $\left|0\right\rangle_{L}$, and if $-1$ then it was $\left|1\right\rangle_{L}$.

Regular measurements of the stabilizers allow for error detection and correction by detecting changes to their eigenvalues. A Pauli $X$ or $Z$ error on a physical qubit flips the eigenvalue of the state to $-1$, for the stabilisers of the opposite type which act on that qubit ($Y$ errors affect both types of stabilisers). A “string” of identical Pauli errors connecting qubits by horizontal and vertical steps will only flip stabilizers at the endpoints of the string. In practise, we avoid explicitly correcting errors (which adds noise owing to imperfections of the correcting gates), and instead keep track of the accumulated errors classically. This information is referred to as a “Pauli frame” [37], and plays the role of a reference frame which indicates how information is stored in the error-affected memory. We refer to the usual reference frame of the surface code, in which the encoded state is a $+1$ eigenstate of every “plaquette operator” (i.e. the state is literally stabilised by those operators) as the positive (Pauli) frame. Pauli frames require updating not only owing to error, but also after some lattice surgery operations, described below.

3 Lattice surgery

Lattice surgery is a method of combining or decomposing planar surface-coded memories, to perform multi-qubit operations on the encoded information111The other method for planar codes is transversal [15], requiring more operations and/or connectivity. Other procedures for surface codes involve introducing defects into the lattice, and braiding [43, 22] or twisting them [3], or by code deformation [4]. [30]. There are two types of surgery operation, split and merge, which can be either “rough” or “smooth”. These operations all change the number of memories present, necessarily introducing discontinuities in the Pauli frames of these memories. By accounting appropriately for these changes in the reference frames, we may regard the effect of “split” operations on the encoded state as a single CPTP map from density operators on $\mathcal{H}\cong\mathbb{C}^{2}$ to operators on $\mathcal{H}\otimes\mathcal{H}$; and “merge” operations as taking a density operator on $\mathcal{H}\otimes\mathcal{H}$ and producing one on $\mathcal{H}$.

3.1 Splitting

Figure 2(a) illustrates a rough split. For greater clarity, the memory is shown with a greater width than height, though this is not required. We perform $Z$ measurements on the intermediate purple qubits (shown crossed out). The result is two new planar surface memories, each encoding a qubit, with a boundary where the column of measured qubits used to be. Most of the stabilizers in the new “daughter” memories will be the same operators (and have the same eigenvalues) as in the original “mother” memory. However, along the boundary the daughter memories will have modified stabilisers of weight $3$ rather than $4$, and some of these may end up in the $-1$ eigenstate, requiring correction to complete the logical operation.

Let $X_{L}^{\smash{(0)}}$ represent a logical $X$ operator on the mother memory, and $X_{L}^{\smash{(1)}}$ and $X_{L}^{\smash{(2)}}$ represent logical $X$ operators on the left and right daughters (similarly for $Z_{L}^{\smash{(0)}}$, $Z_{L}^{\smash{(1)}}$, and $Z_{L}^{\smash{(2)}}$). Note that $X_{L}^{\smash{(1)}}$ and $X_{L}^{\smash{(2)}}$ both commute with the measurements of the split operation, so the expected value of either $X_{L}^{\smash{(1)}}$ or $X_{L}^{\smash{(2)}}$ is equal to $X_{L}^{\smash{(0)}}$ before the split: $X_{L}^{\smash{(0)}}\equiv X_{L}^{\smash{(1)}}\equiv X_{L}^{\smash{(2)}}$. The $Z_{L}^{\smash{(0)}}$ operator, however, is distributed across the two new surfaces. As $Z_{L}^{\smash{(0)}}$ commutes with the split procedure and yields $Z$ operators across both memories, it decomposes as $Z_{L}^{\smash{(0)}}\equiv Z_{L}^{\smash{(1)}}Z_{L}^{\smash{(2)}}$. In particular, if subsequently measured, the outcome of measuring $Z_{L}^{\smash{(1)}}Z_{L}^{\smash{(2)}}$ is the same as measuring $Z_{L}^{\smash{(0)}}$ before the split: $\langle Z_{L}^{\smash{(1)}}Z_{L}^{\smash{(2)}}\rangle=\langle Z_{L}^{\smash{(0)}}\rangle$.

If all measurement outcomes of the split are $+1$, then no corrections are applied. However, if one or more measurements give $-1$, as in Figure 2(b), this produces matching pairs of $Z$-plaquette stabilizers on the boundaries of each daughter memory that are in the $-1$ eigenstate (shaded blue). We adapt the Pauli frames (simulating a correction) by a chain of physical $X$ operations linking to the top boundary (purple chain). The lower boundary could also be used; the difference would be equivalent to a logical $X_{L}^{\smash{(i)}}$ operation. However, the split has copied $X_{L}^{\smash{(0)}}$, so the daughters are in an eigenstate of $X_{L}^{\smash{(1)}}\otimes X_{L}^{\smash{(2)}}$. As long as the same boundary is chosen for both, the correction strategies differ only by the stabilizer operation $X_{L}^{\smash{(1)}}\otimes X_{L}^{\smash{(2)}}$ and therefore are equivalent. In this way, we may accommodate the changes in Pauli frame introduced by the measurements, and represent the effect of the split operation on the logical state as a unitary embedding on density operators $\mathsf{S}_{R}(\rho)\,=\,U_{R}^{\phantom{\dagger}}\,\rho\,U_{R}^{\dagger}$ , where $U_{R}\,=\,\left|\texttt{++}\right\rangle\!\!\left\langle\texttt{+}\right|\,+\,\left|\texttt{--}\right\rangle\!\!\left\langle\texttt{-}\right|$.

A smooth split performs the corresponding operation while interchanging $Z$ and $X$, and the horizontal and vertical axes. Performing $X$ measurements along a row which does not quite reach the two rough boundaries, we obtain two memories where (by adapting the Pauli frames appropriately) the observables on the original and new memories satisfy $Z_{L}^{\smash{(0)}}\equiv Z_{L}^{\smash{(1)}}\equiv Z_{L}^{\smash{(2)}}$ and $X_{L}^{\smash{(0)}}\equiv X_{L}^{\smash{(1)}}X_{L}^{\smash{(2)}}$. The effect on the logical state is then another embedding on density operators $\mathsf{S}_{S}(\rho)\,=\,U_{S}^{\phantom{\dagger}}\,\rho\,U_{S}^{\dagger}$ , where $U_{S}\,=\,\left|00\right\rangle\!\!\left\langle 0\right|\,+\,\left|11\right\rangle\!\!\left\langle 1\right|$.

3.2 Merging

A rough merge (illustrated in Figure 3) joins two “parent” memories along their rough edges. An intermediate column of qubits (initially here in the $\left|\texttt{+}\right\rangle$ state, although the $\left|\texttt{0}\right\rangle$ state can also be used) is added, and $X$-plaquette operators are measured across this join. The result is a single “child” memory, whose Pauli frame is the union of the frames of the parent surfaces, corrected for the outcomes of the plaquette measurements across the join.

Let us denote the logical $X$ operators on either parent by $X_{L}^{\smash{(1)}}$ and $X_{L}^{\smash{(2)}}$, and the logical $X$ on the child memory as $X_{L}^{\smash{(3)}}$ (similarly for $Z_{L}^{\smash{(i)}}$). Measuring the $X$-plaquette operators across the join and taking the product of the outcomes is equivalent to measuring the two columns of $X$ operators on either side of the divide. These are the $X_{L}^{\smash{(i)}}$ logical operators. The action of the rough merge therefore realises a ${X_{L}^{\smash{(1)}}\otimes X_{L}^{\smash{(2)}}}$ measurement. This removes a degree of freedom, destroying any information carried by expectation values of the observables $Z_{L}^{\smash{(1)}}$ or $Z_{L}^{\smash{(2)}}$ alone. However, the new $Z_{L}^{\smash{(3)}}$ operator has support on a chain of $Z$ operators the entire width of the surface: $Z_{L}^{\smash{(3)}}={Z_{L}^{\smash{(1)}}\otimes Z_{L}^{\smash{(2)}}}$. This commutes with ${X_{L}^{\smash{(1)}}\otimes X_{L}^{\smash{(2)}}}$, and so is unchanged by the merge. The new basis states (the positive and negative eigenstates of $Z_{L}^{\smash{(3)}}$) arise from the previous ones, $\left|00\right\rangle_{12},\left|11\right\rangle_{12}\mapsto\left|0\right\rangle_{3}$ and $\left|01\right\rangle_{12},\left|10\right\rangle_{12}\mapsto\left|1\right\rangle_{3}$: this effectively computes the XOR of the labels of the standard basis states (and similarly for superpositions of these basis states).

The action of the rough merge on the $X_{L}^{\smash{(i)}}$ operators is more subtle. Consider the case where both parent surfaces are in the positive frame. Measuring $X_{L}^{\smash{(1)}}X_{L}^{\smash{(2)}}$ by performing the merge tells us whether the parent $X_{L}$ operators are the same ($+1$) or different ($-1$): we call this the outcome of the merge. In the “positive branch” ($+1$ outcome), all possible $X_{L}$ operators on the child surface are identical: $X_{L}^{\smash{(1)}}\equiv X_{L}^{\smash{(2)}}\equiv X_{L}^{\smash{(3)}}$. If, however, the $X_{L}^{\smash{(1)}}X_{L}^{\smash{(2)}}$ measurement outcome is $-1$ (the “negative branch”), we have $X_{L}^{\smash{(1)}}\equiv-X_{L}^{\smash{(2)}}$. It is as if one half of the child memory is subject to a string of $Z$ errors. The choice to correct from the join either to the left or to the right boundary represents a choice of what logic the merge implements. Either $X_{L}^{\smash{(3)}}\equiv X_{L}^{\smash{(1)}}\equiv-X_{L}^{\smash{(2)}}$, or $X_{L}^{\smash{(3)}}\equiv X_{L}^{\smash{(2)}}\equiv-X_{L}^{\smash{(1)}}$, depending on whether we adapt the Pauli frame of the child memory using a chain of $Z$ operations to the right or to the left respectively. These choices differ by a $Z_{L}^{\smash{(3)}}$ operation, corresponding to the difference in reference frames.

Described as a CPTP map, the logical transformation of the rough merge is a map from two-qubit density operators to one-qubit density operators $\mathsf{M}_{R}(\rho)\,=\,K_{0,R}^{\phantom{\dagger}}\,\rho\,K_{0,R}^{\dagger}+K_{1,R}^{\phantom{\dagger}}\,\rho\,K_{1,R}^{\dagger}$. Each Kraus operator $K_{b,R}$ is the transformation in the case of a $M=(-1)^{b}$ measurement outcome of $X_{L}^{\smash{(1)}}X_{L}^{\smash{(2)}}$. If we represent the classical outcome $M=\pm 1$ itself by a decohered quantum system, the operation is a channel

[TABLE]

where the $M$ system heralds the effect on the merged parent memories.

The form of the Kraus operators $K_{0,R}$ and $K_{1,R}$ depends on the choice of reference frame for the child surface. In both cases, we have for the outcome $M=+1$ the Kraus operator $K_{0,R}\;=\;\left|\texttt{+}\right\rangle\!\!\left\langle\texttt{++}\right|\;+\;\left|\texttt{-}\right\rangle\!\!\left\langle\texttt{--}\right|$. Depending on whether one adapts the Pauli frame of the child on the left or the right for the outcome $M=-1$, we respectively obtain the Kraus operator $K_{1,R}\;=\;\left|\texttt{+}\right\rangle\!\!\left\langle\texttt{-+}\right|\;+\;\left|\texttt{-}\right\rangle\!\!\left\langle\texttt{+-}\right|$ or $K_{1,R}\;=\;\left|\texttt{+}\right\rangle\!\!\left\langle\texttt{+-}\right|\;+\;\left|\texttt{-}\right\rangle\!\!\left\langle\texttt{-+}\right|$. This represents the effect of the rough merge for all measurement outcomes, as a CPTP map.

A smooth merge performs the corresponding operation, interchanging the horizontal and vertical axes, and also $Z$ and $X$. An interstitial row of qubits are prepared in the $\left|0\right\rangle$ state, and performing $Z$-plaquette measurements across a horizontal join between two parent memories realises a measurement of $Z_{L}^{\smash{(1)}}Z_{L}^{\smash{(2)}}$ with outcome $M=\pm 1$. The observables on the original and new memories satisfy $X_{L}^{\smash{(3)}}\equiv X_{L}^{\smash{(1)}}X_{L}^{\smash{(2)}}$, and either $Z_{L}^{\smash{(3)}}\equiv Z_{L}^{\smash{(1)}}\equiv Z_{L}^{\smash{(2)}}$ (if $M=+1$, i.e. the positive branch) or $Z_{L}^{\smash{(3)}}\equiv\pm Z_{L}^{\smash{(1)}}\equiv\mp Z_{L}^{\smash{(2)}}$ (if $M=-1$, where the signs depend on the choice of Pauli frame for the child memory). The effect on the logical state is a CPTP map $\mathsf{M}_{S}(\rho)\,=\,K_{0,S}^{\phantom{\dagger}}\,\rho\,K_{0,S}^{\dagger}+K_{1,S}^{\phantom{\dagger}}\,\rho\,K_{1,S}^{\dagger}$ where $K_{0,S}$ is realised if $M=+1$ and $K_{1,S}$ if $M=-1$. We have $K_{0,S}\;=\;\left|0\right\rangle\!\!\left\langle 00\right|\;+\;\left|1\right\rangle\!\!\left\langle 11\right|$ and (depending on how we adapt the Pauli frame of the child memory) one of the two choices $K_{1,S}\;=\;\left|0\right\rangle\!\!\left\langle 10\right|\;+\;\left|1\right\rangle\!\!\left\langle 01\right|$ or $K_{1,S}\;=\;\left|0\right\rangle\!\!\left\langle 01\right|\;+\;\left|1\right\rangle\!\!\left\langle 10\right|$.

The operations of lattice surgery are very different from those usually found in discussions of quantum computing. Describing split and merge operations with standard circuits is unwieldy, as they are explicitly non-unitary; the merge operation in particular is intrinsically non-deterministic. As one may realise a CNOT by a smooth split of the control qubit, followed by a rough merge with the target [30], lattice surgery is usually presented as a way of realising operations in the unitary circuit model. However, a native language of splitting and merging for design, verification, and optimization of lattice surgery protocols would be valuable for the effective management of resources involving these operations [29].

4 The ZX calculus

The ZX calculus is a notation together with a system of transformations, for reasoning about tensors in terms of complementary bases [11, 12]. The ZX calculus can fruitfully be applied to certain processes in quantum information theory: specifically, the standard model of the calculus (using eigenstates of the Pauli $X$ and $Z$ operators) is effective for reasoning about stabilizer-like quantum operations [1], which are useful for describing transformations of Pauli observables. In this section, we provide a brief introduction to the “ZX calculus” suitable for a non-specialist reader who is familiar with the quantum circuit model. (A more complete introduction is available from Refs. [47] and [12].)

4.1 Using ZX diagrams to denote tensors

The notation of the ZX calculus consists of graphs with coloured nodes — which represent operations, including preparations and projections — connected by edges, representing qubits. These graphs denote tensors in the same way that circuit diagrams do, and can often be interpreted as a sequence of linear operators acting on a state-vector. (In the ZX diagrams of this article, the time axis runs left to right.) In its simplest form, the ZX calculus includes nodes of only two colours — conventionally red and green, where ‘red’ is the darker shade — representing two choices of basis in which information may be stored and transformed. For example, preparations and measurements may be denoted by

[TABLE]

where each diagram fragment represents the operator written below it.222More precisely, the diagrams of Eqn. (2) actually represent operators $\sqrt{2}\left|0\right\rangle$, $\sqrt{2}\!\!\>\left\langle 0\right|$, $\sqrt{2}\left|\texttt{+}\right\rangle$, $\sqrt{2}\!\!\>\left\langle\texttt{+}\right|$ , and so forth: see e.g. Ref. [2]. This distinction is unimportant to our results, and the cumulated scalar $2^{k/2}$ for a diagram can be easily inferred from its topology.

(Setting $\alpha=\pi$ in each case yields the state or projector orthogonal to the corresponding unlabelled node; we omit angles as labels when they are multiples of $2\pi$.) The other basic nodes of the ZX calculus are as follows:

[TABLE]

Note that each of these nodes come in adjoint pairs, as follows (blank nodes denote either red or green, with the same colour throughout each equation):

[TABLE]

We can generalise the nodes above to ones with larger in-degree and out-degree (conventionally known as “spiders” [13]), which for any given angle $\alpha$ corresponds to ${\left|0\right\rangle^{\!\otimes k}+\mathrm{e}^{i\alpha}\left|1\right\rangle^{\!\otimes k}}$ for the green nodes, and ${\left|\texttt{+}\right\rangle^{\!\otimes k}+\mathrm{e}^{i\alpha}\left|\texttt{-}\right\rangle^{\!\otimes k}}$ for the red nodes (taking the transpose of those tensor factors representing inputs rather than outputs). Considering nodes merely as tensors, it is not important whether a given wire represents a “bra” or a “ket”; we may be agnostic about their direction, and even allow them to run vertically without ambiguity as to how to evaluate the tensor contraction with an index of another tensor.

Note that the left-hand diagrams of Eqn. (3) are $Z$ and $X$ rotations, respectively. Then nodes of degree $2$ suffice to describe arbitrary single-qubit operations by their Euler decomposition. To show how we may represent arbitrary unitary operators with this notation, it suffices to demonstrate a decomposition of a CNOT operator. We may do this up to a scalar factor in the ZX notation as follows:

[TABLE]

To represent CNOT exactly using ZX, we would multiply this by a scalar factor of $\sqrt{2}$, e.g by including a diagram fragment which is equivalent to the scalar $\sqrt{2}$. Such scalar factors are often omitted as a minor abuse of notation when describing operators using the ZX calculus, but they play an important role for our results, in understanding such diagrams as representing Kraus operators. In similar ways to (5) we may represent any unitary operator with the ZX calculus, using standard results in circuit decomposition.

4.2 Properties of the ZX calculus

As a tensor notation, the ZX calculus enjoys several convenient properties which correspond to abstract representations of equality tests and copying in either in the $Z$ or the $X$ eigenbases.

[TABLE]

These properties allow us to reduce nodes of higher in- and out-degree in arbitrary ways, using the nodes of Eqns. (2) and (3), so long as the composite diagram has the correct in- and out-degree and the same total angle [12, Ch. 8.6.1]. For instance, using Eqns. (6c) and (6d), we may without confusion define nodes of degree 4 from compositions of nodes of degree 3 (where again we require that mod $2\pi$ sum of the phases remains constant through each equation):

[TABLE]

We may recursively define nodes of any degree in this way. This is the so-called Spider Law, and also allows us to simplify diagrams by merging nodes of degree $1$ and $2$ of the same colour by adding their angles [12, Ch. 9.4]. Eqn. (6a) also allows for simplification by reducing the number of nodes: for instance, if the sum of the angles is a multiple of $2\pi$, the resulting operation simply represents the identity operator $\mathbbm{1}$, in which case we may remove the node without changing the meaning of the diagram.

Finally, for angles $\alpha=k\pi$ for integer $k$, we may describe a simple rule for commuting nodes of degree $2$, past differently coloured nodes of degree $3$:

[TABLE]

The reflection of Eqn. (8) about the vertical axis also holds, and represents the sense in which the nodes of one colour correspond to simple arithmetic operations on information stored in the “distinguished basis” of the other colour. These rules in effect provide a reduced instruction set for transformation and evaluation of tensors, which is well-suited for automated reasoning about equivalence of quantum procedures [33].

4.3 A simple demonstration of how to use the ZX calculus

We now provide simple illustrations of the way in which the ZX calculus can be used as a tool for computation, by demonstrating an elementary fact about the stabiliser formalism. Our aim here is not to argue that the ZX calculus is in some way a superior tool to prove this result, but instead to demonstrate how the ZX calculus produces this result — and in so doing, demonstrate the transformations which we use in our results. (For a more complete introduction to ZX, the interested reader is invited to refer to Refs. [47] or [12].)

Our demonstration is to show how to derive how to commute Pauli operators past CNOT gates, using the “Spider Rule” (the higher-level result following from Eqns. (6) allowing one to merge any two connected nodes of the same colour) together with Eqn. (8). The Spider Rule describes how we can merge, or split, two nodes of the same colour while keeping the total phase the same (mod $2\pi$). For example, with a node of degree $3$ and a node of degree $2$, where the node of degree $3$ happens not to have a phase of zero, we have:

[TABLE]

where the white nodes again stand for either red or green nodes (the same colour throughout). This effectively allows us to “commute” a degree 2 node past a degree 3 node of the same colour. Furthermore Eqn. (8) essentially describes how $X$ and $Z$ operators propagate between controls and targets of CNOT gates, as degree-2 nodes with a $\pi$ phase are either $X$ or $Z$ operators:

[TABLE]

We may then verify, (i.e., compute from first principles) how to commute $Z$ and $X$ operators past a CNOT gate:

[TABLE]

The equations (expressed as rewritings of diagrams) in the left-hand column represent how $Z$ operators commute with the control of a CNOT , and propagate from the target to the control CNOT ; the equations of the right-hand column represent how $X$ operators commute with the target of a CNOT , and propagate from the control to the target of a CNOT . Thus, in the ZX calculus, the propagation of Pauli operators is a consequence of the rules for how the two colours of nodes interact, and can be demonstrated without matrix calculations.

5 Lattice surgery in the ZX calculus

Having in hand an account of lattice surgery using encoded Kraus operators, and given the presentation above of the tensors involved in the standard model of the ZX calculus, it should be clear that there are considerable similarities between them. A lattice “split” operation copies information represented in one of two bases, as shown in Section 3.1. This mirrors the action of Eqn. (8): for instance, a red $1$-to-$2$ node copies a green $\pi$-rotation, representing both how a change in the input maps to an output, and also how an input $Z$ observable is equivalent to a product of $Z$ observables at the output. It has also been previously observed that the red node in the CNOT of Eqn. (5) acts as an XOR [12, Ch. 5.3.5], which is also the action of a rough merge. We thus appear to have an equivalence between red degree-$3$ nodes in the ZX calculus with rough lattice surgery operations, and between green degree-$3$ nodes and smooth operations.

We now make this equivalence precise and explicit, demonstrating that the actions of lattice surgery on encoded data essentially form a model of the ZX calculus. The precise nature of the equivalence requires us to describe the merge operations in terms of ensembles of simple diagrams, which yield byproduct operations associated with the heralded outcomes of the merge process. The ZX calculus then provides us with a way to simplify the descriptions of these byproduct operations, allowing us to account for them in much more complicated procedures than the standard realisation of the CNOT gate.

In what follows, a lattice surgery procedure is a composition of the maps $\mathsf{M}_{S}$ and $\mathsf{M}_{R}$ (albeit possibly using different conventions for updating the Pauli frame in each instance) with $\mathsf{S}_{S}$ and $\mathsf{S}_{R}$, and preparations of fresh qubits prepared in states $\left|g_{\alpha}\right\rangle\propto{\left|0\right\rangle+\mathrm{e}^{i\alpha}\left|1\right\rangle}$ and $\left|r_{\alpha}\right\rangle\propto{\left|\texttt{+}\right\rangle+\mathrm{e}^{i\alpha}\left|\texttt{-}\right\rangle}$.

Lemma 1**.**

The effect on the logical state space of a surface code of a smooth split, and of the positive branch of a smooth merge, are given by the operators associated with the green degree-3 nodes in Eqn. (3) for $\alpha=0$; and similarly for the rough split/merge operations and the red degree-3 nodes.

Proof.

For the split operations, this follows from the equality of the operators associated to the $1$-to-$2$ nodes in Eqn. (3) for $\alpha=0$, and the corresponding Kraus operators $U_{S}$ and $U_{R}$ (respectively) of the unitary embeddings $\mathsf{S}_{S}$ and $\mathsf{S}_{R}$ of Section 2. Similarly, the Kraus operators $K_{0,S}$ and $K_{0,R}$ (respectively) of the merge operators $\mathsf{M}_{S}$ and $\mathsf{M}_{R}$ of Section 3 are equal to the operators associates to (respectively) the green and the red $2$-to-$1$ nodes in Eqn. (3). ∎

The preceding observation about identical pairs of linear operators, has the following consequence on how we can reason about compositions of operations in lattice surgery:

Corollary 2**.**

The positive branches of lattice surgery procedures (i.e. conditioned on $+1$ outcomes of all merge operations) provide a model for the equational theory of the ZX calculus without projections, in which nodes of degree $2$ or $3$ have an angle of [math].

In particular: if we let

$\begin{aligned} \leavevmode\hbox to5.78pt{\vbox to11.16pt{\pgfpicture\makeatletter\hbox{\hskip 2.89096pt\lower-5.58192pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{}\pgfsys@moveto{1.82666pt}{0.0pt}\pgfsys@curveto{1.82666pt}{1.00883pt}{1.00883pt}{1.82666pt}{0.0pt}{1.82666pt}\pgfsys@curveto{-1.00883pt}{1.82666pt}{-1.82666pt}{1.00883pt}{-1.82666pt}{0.0pt}\pgfsys@curveto{-1.82666pt}{-1.00883pt}{-1.00883pt}{-1.82666pt}{0.0pt}{-1.82666pt}\pgfsys@curveto{1.00883pt}{-1.82666pt}{1.82666pt}{-1.00883pt}{1.82666pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{}}{}{{}{}} {{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{{}}{{}}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}\pgfsys@moveto{-1.43306pt}{1.43306pt}\pgfsys@curveto{-2.57997pt}{2.57997pt}{-2.69096pt}{3.75993pt}{-2.69096pt}{5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{}{}} {{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{{}}{{}}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}\pgfsys@moveto{1.43306pt}{1.43306pt}\pgfsys@curveto{2.57997pt}{2.57997pt}{2.69096pt}{3.75993pt}{2.69096pt}{5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{{}{}}{}} {}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}\pgfsys@moveto{0.0pt}{-2.02666pt}\pgfsys@lineto{0.0pt}{-5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}\end{aligned}$

 denote the action of the unitary embedding $U_{S}$ (respectively, $U_{R}$) on encoded data realised by a smooth (resp. a rough) split,

$\begin{aligned} \leavevmode\hbox to5.78pt{\vbox to11.16pt{\pgfpicture\makeatletter\hbox{\hskip 2.89096pt\lower-5.58192pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{}\pgfsys@moveto{1.82666pt}{0.0pt}\pgfsys@curveto{1.82666pt}{1.00883pt}{1.00883pt}{1.82666pt}{0.0pt}{1.82666pt}\pgfsys@curveto{-1.00883pt}{1.82666pt}{-1.82666pt}{1.00883pt}{-1.82666pt}{0.0pt}\pgfsys@curveto{-1.82666pt}{-1.00883pt}{-1.00883pt}{-1.82666pt}{0.0pt}{-1.82666pt}\pgfsys@curveto{1.00883pt}{-1.82666pt}{1.82666pt}{-1.00883pt}{1.82666pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{}}{}{{}{}} {{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{{}}{{}}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}\pgfsys@moveto{1.43306pt}{-1.43306pt}\pgfsys@curveto{0.77225pt}{-0.77225pt}{2.69096pt}{-2.26314pt}{2.69096pt}{-5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{}{}} {{}{}{{}}{}}{{}{}}{{}} {{}{}{{}}{}}{{{}}{{}}}{{}}{{{}}{{}}}{}{{}}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}{}{}\pgfsys@moveto{-1.43306pt}{-1.43306pt}\pgfsys@curveto{-0.77225pt}{-0.77225pt}{-2.69096pt}{-2.26314pt}{-2.69096pt}{-5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{{}{}}{}} {}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}\pgfsys@moveto{0.0pt}{2.02666pt}\pgfsys@lineto{0.0pt}{5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}\end{aligned}$

 denote the action of the Kraus operator $K_{0,S}$ (resp. $K_{0,R}$) on encoded data realised in the positive branch by a smooth (resp. a rough) merge,

\begin{aligned} \leavevmode\hbox to12.57pt{\vbox to11.78pt{\pgfpicture\makeatletter\hbox{\hskip 10.48378pt\lower-5.89182pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {{}} {{{}{}{{}}{}}}{{{}}}{{{{}}{{}}}}{{}}{{{ }}}\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{ }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{{}{}}}{{}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-7.15077pt}{-2.5588pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\rotatebox{90.0}{\footnotesize\alpha}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{}}{}{{{}{}}{}} {}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}\pgfsys@moveto{0.0pt}{-0.17334pt}\pgfsys@lineto{0.0pt}{5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{{}{}}{}} {}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}\pgfsys@moveto{0.0pt}{0.17334pt}\pgfsys@lineto{0.0pt}{-5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{}}{}{{{}}{}{}{}{}{}{}{}{}}\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@moveto{1.88367pt}{0.0pt}\pgfsys@curveto{1.88367pt}{1.04033pt}{1.04033pt}{1.88367pt}{0.0pt}{1.88367pt}\pgfsys@curveto{-1.04033pt}{1.88367pt}{-1.88367pt}{1.04033pt}{-1.88367pt}{0.0pt}\pgfsys@curveto{-1.88367pt}{-1.04033pt}{-1.04033pt}{-1.88367pt}{0.0pt}{-1.88367pt}\pgfsys@curveto{1.04033pt}{-1.88367pt}{1.88367pt}{-1.04033pt}{1.88367pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}\!\end{aligned}

denote an $R_{x}(\alpha)$ gate (resp. a $R_{z}(\alpha)$ gate), and

\begin{aligned} \leavevmode\hbox to12.57pt{\vbox to11.78pt{\pgfpicture\makeatletter\hbox{\hskip 10.48378pt\lower-5.89182pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }{{}} {{}} {{{}{}{{}}{}}}{{{}}}{{{{}}{{}}}}{{}}{{{ }}}\hbox{\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{{{}}}{{}}{}{}{}{}{}{}{}{}{}{ }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{0.0pt}{0.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}}\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{{}{}}}{{}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-7.15077pt}{-2.5588pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\rotatebox{90.0}{\footnotesize\alpha}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} {{}}{}{{{}{}}{}} {}{{{{{}}{}{}{}{}{{}}}}}{{}}{}{}{}\pgfsys@moveto{0.0pt}{-0.17334pt}\pgfsys@lineto{0.0pt}{5.38193pt}\pgfsys@stroke\pgfsys@invoke{ } {{}}{}{{}}{}{{{}}{}{}{}{}{}{}{}{}}\pgfsys@beginscope\pgfsys@invoke{ }\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@invoke{ }\definecolor[named]{pgffillcolor}{rgb}{1,1,1}\pgfsys@color@gray@fill{1}\pgfsys@invoke{ }{}\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@moveto{1.88367pt}{0.0pt}\pgfsys@curveto{1.88367pt}{1.04033pt}{1.04033pt}{1.88367pt}{0.0pt}{1.88367pt}\pgfsys@curveto{-1.04033pt}{1.88367pt}{-1.88367pt}{1.04033pt}{-1.88367pt}{0.0pt}\pgfsys@curveto{-1.88367pt}{-1.04033pt}{-1.04033pt}{-1.88367pt}{0.0pt}{-1.88367pt}\pgfsys@curveto{1.04033pt}{-1.88367pt}{1.88367pt}{-1.04033pt}{1.88367pt}{0.0pt}\pgfsys@closepath\pgfsys@moveto{0.0pt}{0.0pt}\pgfsys@fillstroke\pgfsys@invoke{ } \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}\!\end{aligned}

denote (up to an extra factor of $\sqrt{2}$) preparation of a $\left|g_{\alpha}\right\rangle$ state (resp. a $\left|r_{\alpha}\right\rangle$ state), then these operations satisfy all of the properties of Eqns. (4) and (6). More complicated green or red nodes (including nodes of degree $>1$ with non-zero angles) can then be realised using the Spider Law [12, Ch. 9.4], describing them as the effect of compositions of split and merge operations in the positive branch.

The qualification “in the positive branch” in Corollary 2 is significant, and relates to the normalisation of the diagram in Eqn. (5). Omitting the correction operations needed to realise CNOT deterministically, the standard lattice-surgical realisation of CNOT  [30] is by the composition $(\mathbf{1}\otimes\mathsf{M}_{R})(\mathsf{S}_{S}\otimes\mathbf{1})$. We may associate to this composition a pair of Kraus operators $(I\otimes K_{0,R})(U_{S}\otimes I)$ and $(I\otimes K_{1,R})(U_{S}\otimes I)$, where the positive branch corresponds to the first of these. A simple calculation reveals that $(I\otimes K_{0,R})(U_{S}\otimes I)=\tfrac{1}{\sqrt{2}}\,\mathrm{CNOT}$, which reflects the fact that the positive branch occurs with probability $\tfrac{1}{2}$ and realises a CNOT operation on all input states. From this standpoint, the subnormalisation of Eqn. (5) is a feature of ZX notation, not a bug: it captures not only the way in which states transform in the positive branch of a lattice-surgery procedure, but also the $2$-norms of the Kraus operators which govern the transformation.

This motivates a view of simple ZX diagrams as denoting Kraus maps of lattice surgery procedures. It remains to describe how to represent the “negative branch” of rough and smooth merges.

Lemma 3**.**

[TABLE]

Proof.

By calculation of the operators, from Eqn. (3). ∎

Corollary 4**.**

[TABLE]

Proof.

This follows from the previous Lemmata concerning the equality of the Kraus operators. ∎

Remark.

In practise, it is likely to prove convenient to analyse the operators $\mathsf{M}_{S}$ and $\mathsf{M}_{R}$ with annotated ZX diagrams [18], in which we allow nodes whose phases are not necessarily constants, and may include variables whose values may only be determined during the computation (e.g. as with the results of a measurement).

[TABLE]

The purpose of associating the operations of lattice surgery with simple (annotated) ZX diagrams is two-fold: (a) to allow us to reason about more diverse compositions of lattice surgery operations using compositions of the diagrams, and (b) to allow us to relate more complex ZX-diagrams to lattice surgery procedures which may be used to realise them. For (b), it suffices to produce a simple ZX diagram which is equivalent, and then consider how this diagram may be realised using (a). We have already glimpsed how (a) might be done in Corollary 2 for the positive branch of any lattice surgery procedure; the following extends this to arbitrary outcomes of the merges:

Theorem 5**.**

Lattice surgery procedures model randomly-constructed simple ZX diagrams, in which gadgets realising $2$-to-$1$ nodes are selected from either one of the pairs of operations of Eqn. (14a) for rough merges, and from either one of the pairs of operations of Eqn. (14b) for smooth merges; and the probability of each diagram is given by its 2-norm.

Proof.

Each pair of diagrams from Eqns. (13) describes Kraus operators of $\mathsf{M}_{S}$ and $\mathsf{M}_{R}$ (as determined by a conventional choice of procedure to update the Pauli frame). A single gadget selected from one of these pairs is modelled by a lattice merge of the appropriate sort, for which the diagram represents a Kraus operator. Composing such maps (and others) to produce a simple ZX diagram represents the effect of composing the Kraus operators for the lattice merge operations with those of split operations, and preparation of qubits in the $\left|g_{\alpha}\right\rangle$ and $\left|r_{\alpha}\right\rangle$ states. These form Kraus operators for the entire lattice surgery procedure. The 2-norm of the diagram then corresponds to the probability of the Kraus operator (i.e. the particular merge outcomes) being realised. ∎

6 Consequences of the equivalence

We have described a tight connection between the ZX calculus and lattice surgery. Splitting and merging can be written in terms of degree-3 nodes (including correction operations if necessary); realised as Kraus operators of lattice surgery procedures. The use of ZX as a tool for manipulating lattice surgery diagrams has a huge number of potential applications. To begin with, almost all work on the ZX calculus can now be applied directly to lattice surgery. In particular, known equivalences under re-writing in the calculus now have an interpretation in terms of equivalence of lattice surgery patterns. For example, the Frobenius laws of Eqn. (6) can now be imported and read directly as referring to equivalent set of split and merge operations. The standard re-write axioms of the calculus give further pattern equivalences. To give a flavour of the power of this re-writing system, we here detail two examples where ZX diagrammatic equivalence gives novel lattice surgery procedures: for non-Clifford rotations, and the CNOT (as a subroutine).

6.1 Lattice surgery T gate

Magic states permit the realisation of logical operations outside of the Clifford group on surface codes, allowing for (approximately) universal quantum computing [6]. In the surface code, they may be distilled to high fidelity, injected into a code surface, and then used to perform teleported rotation gates [22], as these cannot be performed transversally [20]. A $T$ gate uses a magic state and teleportation to perform a $\pi/4$ rotation. The usual presentation of the teleported $T$ gate involves a CNOT and measurement (see e.g. [8]). However, the ZX calculus allows us to give a more efficient procedure for lattice surgery.

Consider the state $\left|A\right\rangle\propto{\left|0\right\rangle+\mathrm{e}^{i\pi/4}\left|1\right\rangle}$. In a teleported $T$ gate this is used to perform a $Z$-rotation $R_{z}(\pi/4)=\left|0\right\rangle\!\!\left\langle 0\right|+\mathrm{e}^{i\pi/4}\left|1\right\rangle\!\!\left\langle 1\right|$. In the ZX calculus the $\left|A\right\rangle$ state is represented by a green $\pi/4$ preparation node, and the $R_{z}(\pi/4)$ operation by a green $\pi/4$ degree-2 node. As an application of Eqn. (6), we have

[TABLE]

By Corollary 2, the left-hand diagram represents the positive branch of a smooth merge of an $\left|A\right\rangle$ state with an input state. Using Lemma 3 and Eqn. (6), the negative branch of this procedure is described by

[TABLE]

As with a standard $T$ gate [22, §6], the rotation to correct this to $+\pi/4$ uses $\left|Y\right\rangle\propto{\left|0\right\rangle+\mathrm{e}^{i\pi/2}\left|1\right\rangle}$:

[TABLE]

The negative branch of this operation is:

[TABLE]

This can now be corrected, if necessary, by a phase flip. The $T$ gate has now become simple merging with magic states.333The alternative convention for the negative branch of merges works equally well (see Section B. of the Appendix).

Note that the above ZX analysis also holds if we interchange red and green nodes: we thus also obtain a procedure for $R_{x}(\pi/4)$ rotations as well. Procedures for smaller-angle rotations can similarly be found, which can then be used for the most efficient magic state compilations [7].

6.2 Realising CNOT gates

The original lattice surgery procedure for the CNOT gate is a smooth split of the control, followed by a rough merge of one of the daughter memories with the target [30, §4.1], followed by appropriate corrections depending on the outcome of the measurements in the merge procedure. Compare the positive branch of this procedure (using Corollary 2) to the (subnormalised) representation of CNOT from Eqn. (5):

[TABLE]

These two presentations are clearly topologically equivalent. By considering other topologically equivalent presentations of the coloured graph of Eqn. (5), and how those graphs describe operations which may be decomposed as ZX diagrams, we may obtain a further set of procedures, all of which implement the CNOT in the positive branch (in the Appendix we show how we may realise CNOT operations in the negative branch for each of these procedures, as well as for that given in Eqn. (19)):

[TABLE]

From left to right: the second of these diagrams describes a rough split of the target followed by a smooth merge with the control; the third and fourth show the creation of an intermediary Bell pair $\left|\Phi^{+}\right\rangle\propto{\left|00\right\rangle+\left|11\right\rangle}={\left|\texttt{++}\right\rangle+\left|\texttt{--}\right\rangle}$, the two halves of which are merged with the control and target respectively; and the final two describe splits to both control and target qubits (smooth and rough respectively), with a simulated Bell projection $\left\langle\Phi^{+}\right|\propto\left\langle 00\right|+\left\langle 11\right|=\left\langle\texttt{++}\right|+\left\langle\texttt{--}\right|$ on a pair of the daughter memories.

Thus, by minor variations of ZX diagrams, we obtain a proliferation of different procedures to realise a CNOT by lattice surgery procedures — of which only the one illustrated in Eqn. (19) has previously appeared in the literature. This gives an indication of the breadth of compilation flexibility that the use of the ZX calculus will bring to the surface code with lattice surgery.

7 Conclusions

We have demonstrated how the ZX calculus acts as a precise and fundamental description of the splitting and merging operations of lattice surgery on the planar surface code. Merge operations output a bit of information, and this is used to determine which out of a set of possible diagrams describe the post-merge state. Sometimes, as with the case of the constructed CNOT gate, these possible diagrams differ by logical Pauli corrections. However, this is not in general the case. Previously there was no easy, systematic way to describe these Pauli frame updates in the high-level language used (i.e., the circuit model). With the use of the ZX calculus, there is now a high-level notation, together with rules to calculate with that notation. This allows one to straightforwardly describe the Pauli frame information associated with a lattice surgery procedure, as well as how that information propagates under further operations.

Lattice surgery fits precisely the structure of the ZX calculus in the “positive branch”, i.e., when merge measurement outcomes are $+1$. Merge and split operations — whether rough (corresponding to red nodes) or smooth (green) — are related through the dagger structure of the calculus. A rough merge is a retraction (inversion by post-composition) of a rough split, and equivalently for smooth merges and splits. Legs of nodes, which represent different parent or child surfaces, may be interchanged; this is the commutative structure. The specialness axioms also follow, as does associativity. Because of this, multi-input/output “spiders” may be defined. In lattice surgery terms, this is a simultaneous splitting or merging into/from multiple surfaces. Multi-surface splitting was described in the original paper on lattice surgery [30]; now, however, we can prove what effect such operations have on the encoded data, and how they interact with each other. In particular, the ability to describe the byproducts in the “negative branches”, and when they can be corrected, will make it possible to determine which multi-node operations can be deterministically performed.

We have focussed in this paper on lattice surgery within the surface code. The question of a similar representation for other codes is an interesting question. In colour code lattice surgery, for example, $Y$-basis merging appears [38] (see also [39]): this may motivate the development of a calculus closely related to the ZX calculus in which such merges have a similarly direct representation. In other ways, ZX already has proven its worth as a language for the broad class of codes known as coherent parity check codes (which includes the CSS construction) [10]; and an early use of automated theorem proving in the calculus was verify correctness of the Steane code [17]. Ways in which ZX may be used as a notation to describe the use of stabilizer codes is an important area of ongoing further research.

There are a number of uses for the work presented here; the following is by no means exhaustive. Firstly, an immediate application is the use of ZX as the basis of an intermediate representation in compilers for near-term error corrected quantum devices. Such devices, based for example on architectures such as [41, 40], have strictly limited resources. Compiling protocols to CNOT operations wastes valuable operations; using ZX we can now compile to precisely the operations that such a device will in practice implement. The use of ZX, and automated tools [36], for compilation is an ongoing larger research project, including optimisations for Clifford circuits [21], circuit simplification [19] including routing and topological constraints [34, 14], and state-of-the-art T-count reductions at the time of writing [35]. Secondly, the ZX calculus can be used as a quantum protocol design tool. Through lattice surgery, the ZX calculus expresses another circuit-like model of quantum computing which we may attempt to realise through practical operations. The ZX calculus allows us to explore new techniques for quantum protocols, which may not be as naturally expressed by unitary circuits (such as in measurement-based quantum computing [16]), for computation and also networking/communication [32, 45] and large-scale qubit registers [9] There is a large amount of work on the calculus that can now be imported for use with lattice surgery; the new procedures given in this paper will be the first of many examples. With the equivalence between ZX and lattice surgery fixed, it will now be possible to take a diagram in the ZX calculus, re-write it, and then interpret that diagram as a lattice surgery procedure — which will include a definition of determinism in diagrams. The equivalence shown in this paper allows us to analyse lattice surgery procedures, to determine how a ZX transformation may practically be realised. This will include the question of time-ordering (including simultaneity) of compiled operations.

There are further uses of the ZX/lattice surgery equivalence. By producing ZX-compiled lattice surgery procedures for known algorithms and protocols, not only can we potentially simplify procedures significantly, but also a different logic can be applied to analyse how these protocols behave. ZX from its beginnings was introduced as another logic to analyse and design further quantum algorithms and protocols. By expanding the space of design tools, we expand what can be thought of in quantum computing. With a physical model of the ZX calculus in the operations of lattice surgery, this programme has an important role to play in realising near-term error corrected quantum devices.

Acknowledgements

Many thanks to Ross Duncan and Aleks Kissinger for many useful and interesting discussions on the topic of this paper, and to anonymous reviewers at QPL for comments on an earlier version.

NB is supported by the EPSRC National Hub in Networked Quantum Information Technologies (NQIT.org). DH was supported by EPSRC under Grant EP/L022303/1.

Appendix

In this Appendix we show how the correction operations for the CNOT procedures of Eqns. (19) and (20) equate to logical Pauli corrections on the control and/or target qubit, and also show how the choice of convention for adapting merge operations in $T$-state injection does not introduce any essential difficulties.

A. CNOT patterns

Eqns. (19) and (20) describe transformations of logical qubits which are realised in the “positive branch” of lattice surgery procedures involving various merges, splits, preparations, and projections, which may be inferred from the topology of the diagram involved. Below, we describe other possible evolutions which those procedures may realise, for different conventional choices of the Kraus operations $K_{1,S}$ or $K_{1,R}$ for the “negative” branch of the merge operations involved.

In each case, the transformations realised differ from the transformations realised in the positive branch only by logical Pauli operations (represented by green and/or red $\pi$-nodes). These logical Pauli operators are heralded by the outcome of the merge operations, and can therefore be tracked or corrected. This demonstrates that these protocols are not sensitive to the convention used for adapting the Pauli frame of the child memory in any given merge operation.

A.1. Smooth split control, rough merge with target.

[TABLE]

A.2. Rough split target, smooth merge with control.

[TABLE]

A.3. Create intermediary Bell pair then merge with control and target.

By preparing a single-qubit state in the $\left|0\right\rangle$ state and then performing a smooth split, or preparing a single-qubit $\left|\texttt{+}\right\rangle$ state and then performing a rough split, we may create a Bell pair, expressed alternatively as \tfrac{1}{\sqrt{2}}\bigl{(}\left|00\right\rangle+\left|11\right\rangle\bigr{)} or \tfrac{1}{\sqrt{2}}\bigl{(}\left|\texttt{++}\right\rangle+\left|\texttt{--}\right\rangle\bigr{)}. We may represent this state by a curved wire producing two outputs, or “cup” — representing the fact that the coefficients of this tensor are the same as that of the identity matrix — if we are willing to account for the fact that this representation is super-normalised by a factor of $\sqrt{2}$ (as with the representations of $\left|0\right\rangle$ and $\left|\texttt{+}\right\rangle$ described in Eqn. (2)). We may then use this to realise a CNOT operation (with some probability) by performing a smooth and a rough merge. These merge operations may independently yield the transformation for the positive branch (realising a Kraus operator $K_{0,\ast}$) or the negative branch (realising a Kraus operator $K_{1,\ast}$).

In the following, we illustrate only the analysis in which both merges yield the positive branch, or the negative branch. (The cases where one merge yields the positive branch and one the negative branch are easier, but otherwise similar.)

[TABLE]

A.4. Split control and target, and simulate an intermediary Bell measurement.

The adjoint of the above diagrams — involving preparing the state $\left|\Phi^{+}\right\rangle$ and then merging the two halves into the control (smooth merge) and target (rough merge) — corresponds to a procedure in which we perform a smooth split operation on the control, a rough split operation on the target, and then perform a Bell measurement involving a child memory of each of these splits to obtain the outcome $\left|\Phi^{+}\right\rangle$. (The “projector” $\sqrt{2}\left\langle\Phi^{+}\right|$ is represented by a “cap”, or a curved wire with two inputs, again representing the fact that as a tensor it has the same coefficients as the identity matrix.) As we cannot perform this measurement deterministically, we may simulate it using one of two different merge procedures:

[TABLE]

In each case, both the merge and the measurement yields non-deterministic results. The measurement nodes illustrated here (representing $\left\langle\texttt{+}\right|$ or $\left\langle 0\right|$ respectively, up to scalar factors) both have a phase of [math]; the alternative outcome in each case is a phase of $\pi$ (representing $\left\langle\texttt{-}\right|$ or $\left\langle 1\right|$, respectively). We may represent the possible outcomes of the measurement using a phase $b\pi$, depending on a bit $b\in\{0,1\}$ which indicates the result of the measurement. This will allow us to reduce the possible transformations to the positive branch, regardless of the outcome of the measurement.

(a) Bell measurement using a smooth merge

[TABLE]

(b) Bell measurement using a rough merge

[TABLE]

B. Magic state merge patterns

In Section 6.1, we demonstrate how to realise a $T$ rotation by merging a magic state with an input qubit. In this Section, we demonstrate that — similarly to the realisations of CNOT  above — the choice of convention for the negative branch of the merge does not introduce any essential difficulties in the interpretation of $T$ gate teleportation as being realised by merge operations.

The effect of the positive branch of the merge operation is the same as illustrated in Eqn. (15) regardless of the convention for the negative branch; we show that the opposite convention to (the left-hand side of) Eqn. (16) for the negative merge is equivalent. In that alternative convention, the red $\pi$-node appears on the opposite input to the $2$-to-$1$ node than the magic state, yielding the transformation

[TABLE]

This operator differs from the operation on the right-hand side of Eqn. (16) by a red $\pi$ node, which is an $X$ operation; the two procedures then differ only by a NOT operation controlled on the merge outcome.

Notice that the effect of the negative branch described by Eqn. (27) corresponds to the $T$ gate teleportation procedure of [42, Fig. 10.25], but without realising this operation in terms of a CNOT  gate in the form of a decomposition such as in Eqn. (5). This also demonstrates a simple example of the usefulness of the ZX calculus to simplify quantum information processing procedures, as follows. If we express the effect of the negative branch shown in Eqn. (16) in a form similar to [42, Fig. 10.25], the role of the control and target are swapped. (The target in the new circuit is still the qubit which is measured.) Interestingly however, it omits the classically-controlled NOT correction. By the interchangeability of the two conventions for adapting the Pauli frame in a merge operation, the ZX calculus thus allows us to arrive at a protocol that is simpler to realise — even for a well-established procedure in quantum information processing.