Quantum picturalism for topological cluster-state computing

Topological quantum computing is a way of allowing precise quantum computations to run on noisy and imperfect hardware. One implementation uses surface codes created by forming defects in a highly-entangled cluster state. Such a method of computing is a leading candidate for large-scale quantum computing. However, there has been a lack of sufficiently powerful high-level languages to describe computing in this form without resorting to single-qubit operations, which quickly become prohibitively complex as the system size increases. In this paper we apply the category-theoretic work of Abramsky and Coecke to the topological cluster-state model of quantum computing to give a high-level graphical language that enables direct translation between quantum processes and physical patterns of measurement in a computer - a"compiler language". We give the equivalence between the graphical and topological information flows, and show the applicable rewrite algebra for this computing model. We show that this gives us a native graphical language for the design and analysis of topological quantum algorithms, and finish by discussing the possibilities for automating this process on a large scale.


Introduction
Quantum computations running on physically realistic hardware will always be susceptible to error. Components fail, quantum systems decohere, and operations are performed imperfectly. Because of the fragility of quantum data, these errors need to be corrected for any large-scale computation to succeed [1]. Topological quantum computing is a scheme that allows precise quantum algorithms to be performed using noisy and imperfect physical implementations [2]. Single quantum bits (or qubits) are encoded topologically, in the global state of a set of qubits, rather than locally definable systems. The required degrees of freedom are produced either by creating defects in a lattice or excitations from a ground state. This encoding enables the logical and physical qubit levels to be split, enabling physical errors to be corrected. While there are standard patterns of defects or excitations that can be used to produce the action of gates on logical qubits, the reverse operation has been difficult: given a particular pattern, what algorithm does it produce? If we deform a pattern will it still give the same output? Which other patterns produce the same algorithm? Are there better ways of combining the standard patterns into large-scale algorithms to allow us to optimise for a given set of resources? Up to now, answering such questions has required fine-grained calculation of individual physical states, becoming intractable for even small numbers of qubits.
In this paper we introduce a graphical "compiler language" for topological quantum computing, enabling us to translate directly between patterns of defects and logical gate operations at a large scale, without needing to calculate the state of individual qubits. We will use a form of what is known as quantum picturalism: a graphical language for defining quantum processes that is intuitively simple and yet supports direct calculation from diagrams alone [3,4,5]. Quantum picturalism has had a great deal of success in simplifying and elucidating various aspects of quantum theory, in particular within the field of quantum computation. The successor to Penrose's tensor diagram calculus [6], quantum picturalism emerges when quantum mechanical processes are defined as elements in a dagger-symmetric monoidal category [7,8], and it is this relation that underwrites the diagrams as a calculus rather than merely a graphical representation. Diagrams that are re-writes of each other according to the given ruleset are mathematically identical; diagrammatic equivalence both entails and is entailed by algebraic equivalence, lending diagram re-writes the status of equations.
We show in this paper that quantum picturalism also has another property, this time specific to topological computing: that the geometric layout of diagrams exactly matches the physical patterns within a topological algorithm. By re-writing the diagrams we can directly produce different physical layouts for the same algorithm, and conversely any defect pattern can be analysed by converting it directly to a diagram, which can then be re-written into a 'normal form', showing the implemented gate sequence. Provided only that the defects are well-formed, this is performed at purely a logical level, requiring no single-(physical) qubit operators.
Topological quantum computing (QC) comes in two distinct yet related forms.
Either elementary particles, known as anyons, are formed as excited states of an exotic Hamiltonian [9,10], or else defects are defined with respect to highly-entangled lattices of physical qubits in what are called surface codes [11,12]. In both cases, gates are produced by braiding the defects/excitations, thereby changing the topology of the system and hence the encoded information. In this paper we will concentrate for the sake of concreteness on the surface code implementation of topological QC, where qubits are formed by creating holes (the defects) within a regular cluster state of entangled qubits. Logical states therefore are comprised of the state of many physical, entangled, qubits. Errors on individual systems can be both detected and corrected, thus protecting the encoded logical qubits. Computation proceeds by sequential measurements of the cluster state, making this a form of error-corrected measurement-based quantum computing (MBQC) [13]. Quantum picturalism has already found significant success in the analysis and construction of measurement-based quantum protocols. Category-theory based diagrammatics demonstrates the structural connections between MBQC and the circuit model, using the rewrite rules of the graphical language to transform MBQC processes to the diagrams associated with the equivalent quantum circuits [14]. It can also be used to determine the correctness of a given measurement pattern, and whether it can be implemented deterministically or not [15]. One particularly interesting result states that, although quantum picturalism represents processes rather than states of individual qubits, there is nevertheless an equivalence between the physical geometry of a given cluster state and the geometry of the diagram representing the process of creating it [15]. It has previously been suggested that a similar geometrical equivalence is also present in topological cluster-state computing, particularly in 3 dimensions [16]. When first introduced, attention was drawn to the apparent similarities between the defect geometries and that of the processes represented in quantum picturalism. However, at the time there was not a sufficiently rich pictorial language in which to describe the defects and define this postulated identity.
In this paper we use the recently-developed red/green calculus of observables [17,3] to demonstrate the topological equivalence of the defect lines in 3D cluster state computing and the equivalent category-theoretic flow diagrams. We first introduce the calculus ( §2), then show how topological QC can be cast into red/green form in §3. We show how the rewrite rules of the calculus define a single data flow line from the multiple qubits comprising the defect and correlation surface, and give simple graphical descriptions of logical operators, including stabilizers, around them. We give the graphical representations of braiding between qubits, and the roles played in the computation by the primal and dual lattices. We finish by discussing the use of the calculus as an automated design and analysis tool for topolgical algorithms. In this paper we will concentrate on the graphical representation, and not require knowledge of the underlying mathematics of monoidal categories and Frobenius algebras. The reader is reminded, though, that diagrams are formed from a fully rigorous calculus, and that each picture represents in itself a well-defined equation or mathematical expression.

Quantum picturalism
We outline here a simplified form of the red/green calculus of [17,3]. The diagrams represent processes rather than qubits: a straight line is the identity operation, and the other elements more complex processes. They therefore describe the dependencies of the processes within quantum protocols: processes joined by lines depend on each other, with the output of one becoming the input of the next. All such processes can be composed : a single input and output given for them (we will see that this is the basis for many of the rules). Formally, for a process P 1 that maps i inputs to j outputs, and a second process P 2 mapping j inputs to k outputs, the composition of the two P 1 • P 2 maps i inputs to k outputs. We adopt the convention of time running from top to bottom. Scalar normalisation is neglected throughout. The fundamental elements in the formalism are the X and Z observables (this makes the red/green calculus a natural choice for use with cluster state computing, which is usually described using the X and Z stabilizers). Figure 1(a) shows state preparation in the two bases. Conversely, figure 1(b) shows measurement in these bases. Measurement in quantum picturalism is always "post-selected" on the result of the measurement, and conventionally taken to represent the '+1' outcome. The final element is the Hadamard box, shown in figure 1(c), which converts between them. Defining the Hadamard box in this form also introduces the notion that given process can have more that one input or output (that is, many straight lines either emerging or entering). Again, these demonstrate the way different processes depend on each other, and enable us to compose their effects.
We can now give the first example of composition rules for these elements. The diagrams in figure 2 can all be read as "what happens to the output when the same    process is repeated twice?". Figure 2(a) is immediately obvious: applying a Hadamard operator twice is the same as applying the identity operator. The remaining composition rules should become evident as we continue to introduce the scheme. The most important composition rule for these elements is the spider rule, figure  3. This takes m inputs to n outputs dependent on the phases of the intervening nodes. The diagram here can be described by |0 ⊗n 0| ⊗m + e i(α+β) |1 ⊗n 1| ⊗m . When red nodes approach a green spider, we can see that they are 'copied', figure 4. In each case the green node is δ green = |00 0| + |11 1|, which takes |0 → |00 , |1 → |11 . All these rules hold with green and red colours reversed, and the {|0 , |1 } basis swapped for the {|+ , |− }. These 'copying' operations can be read intuitively as showing what operations on the n outputs is equivalent to the single operation shown on the single input. Recalling that vertices represent processes rather than qubits will avoid any potential confusion with the no-cloning theorem.
As a first application of the calculus, we can give the representations of some familiar quantum gates. Figure 5 shows the controlled-NOT (CNOT) and controlled-Z (CZ) gates. An unusual and useful feature of the red/green calculus is that lines between qubits are non-directional. As an example, we can 'read' the CNOT in figure 5(a). The green node copies the input on the left-hand qubit rail in the computational basis, as δ green above, and the red copies the {|+ , |− } basis. If we define the left and right vertical rails as 1 and 3, and the centre as 2, then we have the action of the diagram as where |ψ 13 has support only on the Hilbert space of qubits 1 and 3. We can see that this is the action of the CNOT gate. From this we can derive the representation of the CZ gate, using the gate equivalence CNOT = H 2 CNOT H 2 . Figure 5(b) shows the representation of this, and the final 'normal form' after applying the re-write rule of figure 1(c).

Topological cluster state computing
The cluster state computing scheme of [16] combines the principles of MBQC with topological error correction. It is a 3D version of the surface code [12,18]: the two dimensions of the cross-section of the lattice encode the qubit data, and the depth of the lattice is the 'simulated time' dimension [19]. The cluster state is created by initialising all qubits in the |+ = |0 + |1 state, then performing CZ operations between nearest neighbours, thus determining the geometry. Defects are formed and braided within a 3D cluster state by measuring qubits within the defect boundaries in the Z basis (thus removing them from the lattice). Computation proceeds with the remaining qubits in the next cross-section being measured out in the X basis at the next timestep. Note that, while it is common to talk about the defects as logical qubits, they do not in themselves contain any information (being physical qubits removed from the lattice). Rather, the qubits surrounding the defect support the correlation surface, which contains the qubit data. These surface codes have several desirable properties for using them in quantum computing implementations. They can correct the highest proportion of errors in hardware (detection errors, decoherence, etc) of any well-defined implementationover 1% error can be tolerated in each component in the computer [20]. The codes also only require nearest neighbouring quantum components to be coupled to form the cluster lattice, removing any need for long-range entanglement. Several architectural designs are in development for both the 2D and 3D topological codes [21,22], and recent experimental advances bring a scalable cluster-state computer closer to reality [23].

Stabilizers
The natural (non-graphical) mathematical description for cluster state computing is in terms of the stabilizers of the system [24]. These are operators of which the system is in an eigenstate. As a first application of the graphical formalism to cluster state computing, we will show how these are represented in the red/green calculus. Figure  6 gives the X and Z operators within the calculus. We can see that there is a close relationship between the stabilizer operators and the red and green elements of the calculus; however, the exact nature is slightly subtle. To see this, we will work through the example of figure 7 in detail, giving the stabilizers for the Bell state |00 + |11 . First we prepare the state by performing a CNOT on the state |+ |0 . In figure  7(a) we prepare the two states. Figure 7(b) shows the application of the CNOT after the state preparation (remember that time runs from top to bottom), and then applications of the composition rules of figures 2(a) and 2(b). Then we look at the operators XX (figure 7(c)) and ZZ (figure 7(d)). These are stabilizers of the system if we can rewrite the state after their addition as the same state as before. The rewrite processes are shown in the figures. The first re-write is an application of the rules given by figure 4(b) and its colour-inverse, and the second is an application of the spider rule. This is crucial for intuitively being able to 'read off' the stabilizers for a (cluster) state: operators need to be grouped in pairs with a node of the same colour with no phase.

Cluster state structure
We can now look at the structure of cluster states within the pictorial language. Two important prior results lay the groundwork. Firstly, that any cluster state can be represented pictorially by a geometrically identical diagram [15]. Secondly, that this diagram is two-colourable with red and green vertices [15]. Figure 8 demonstrates these properties. The two colourations given are equivalent; the choice of which to use is a  notational decision. Note that as we have a two-dimensional physical cluster, we are representing process time as going "into the page", using short diagonal lines. The 3D cluster state in the Raussendorf scheme is made up of basic cells, as shown in figure 9 along with the associated red/green diagram, with a particular choice of colouring. The 'legs' from each qubit represent the process time edges (the reader will appreciate the difficulties of drawing four-dimensional diagrams). The cluster, being tiled from the simple element, is self-similar at a spacing of half a cell; these are known as the primal and dual lattices. These have a nice representation in the graphical language, as primal lattice cells are the colour-reverse of the dual lattice cells (this H ✲ ✲ Figure 11. Measuring out one face qubit in a cluster cell. Figure 12. Creating a defect through the cluster. emphasises the freedom of choice of a colouring, as long as all choices in the same set of work are compatible). Figure 10 shows both primal and dual cells in the lattice, and how they connect. A particularly nice aspect of representing this cluster in this diagrammatic form is that we can 'read off' the lattice stabilizers from the red/green colouring. For example, the set of X operators on each red qubit in figure 9 is a stabilizer of the cluster. This can be easily verified by inputting a 'red π' node to each existent red node.

Defects and measurement
Logical qubits are defined in the cluster state by defects, measuring out the central qubit in the face of a line of successive cluster cells. Figure 11 shows the effect on one cell of producing a defect; as we know, the measurement has the effect of removing the measured qubit from the lattice, and this is shown in the corresponding diagram. Figure  11 shows the measurement on one face (the final step in an application of the re-write rule of figure 4(c)), and figure 12 shows the whole cell.
We can see from this diagram that we are left with a "tube" of four qubits at each crossection of the lattice, alternating red and green. Again it is instructive to consider the stabilizers for this tube: Z on the green face nodes at the beginning and end of the tube, and X on red nodes on the intervening cells, as marked on figure 12. This is indeed exactly the correlation surface surrounding a defect, and the entity that in fact encodes a logical qubit in the model. Each qubit in the surface is connected to one at   Figure 14. Measurement of the cluster stabilizer. An even number (here two) of the individual red qubits have the measurement outcome -1 ("green π"), but the diagram re-writes to the same normal form as figure 13.
an "earlier computational time", and one at a "later computational time". The four qubits in the centre of each cell are connected together by four other qubits into a ring. If we create a larger defect by measuring out more qubits, this ring becomes larger and connects together more than four 'lines' of physical qubits into the correlation surface.
With the physical qubits within the defects measured out in the Z basis, computation proceeds by measuring all other qubits in the X basis. The outcome of this on one part of a cell (post-selected on the result of the stabilizer measurement; see §3.4) is shown in figure 13; it is trivial to generalise this. This is an extremely important result: the action of the measurement reduces the 4D open process graph to a 3D closed process graph that is topologically isomorphic to the physical cluster and defect.
We will see that this is the key factor in using the pictorial language for describing logical defects.

Error correction
We have noted that, in order to perform the re-writes in figure 13, we post-select on measurement results. What is meant by this is that the re-write as given is formally a short-hand for a more complicated graphical calculation involving the interplay of quantum and classical information. For full details, the reader is directed to [3, §3.3.4 and §12]. The convention is to represent the measurement in the diagrams as giving the '+1' outcome in the relevant basis; we now need to show that the diagrams we have thus derived are fully general for all potential measurement outcomes.
In the present scheme, as is the case in standard measurement-based computation, the state of the system may be changed given the outcomes of measurements. In ✲ ✲ ✲ Figure 15. Using the copying and then spider rules to create a single logical qubit line from a cluster defect.
topological cluster-state computing, the X-basis measurements that occur at each step of computational time should, in the case of no cluster errors, give a sequence of results of a given parity [19,§VII]. The six qubits in the centre of each face of a cell should measure out to give the combined parity of the measurements as +1. If we consider the primal (blue) cell in figure 10 then that parity requirement means that an even number of the six red face qubits are measured with "green π" (-1 outcome) rather than simply a green node (+1 outcome) in figure 13. It is easy to see that the subsequent even number of "red π" nodes in the final diagram will cancel, leaving the same post-measurement diagram, figure 14.
There is therefore a single normal form diagram for the ideal cluster after measurement, regardless of the results of the individual qubit measurements. The error correction scheme of the topological model uses the results of the measurement to find when cluster qubits deviate from the correct state. Corrections are then applied that return the state to the desired eigenstate (see for example [19,§VII]). We need therefore to remember when using the red/green calculus that re-writes of the form figure 13 occur based on the used of active error correction techniques.

Creating a logical qubit calculus
We can now use this result to look at how the topology of the defect strands is represented within the graphical language. In order to show that the geometries of defect strands and red/green graphs are identical, we will construct the lattice with defects in the calculus, and then demonstrate the structure re-writes to a single logical qubit line per defect that follows the geometry of that defect. We will also show that process time and computational time now agree. We will show how primal and dual lattices behave, and construct single-qubit operators. Finally we will construct a CNOT gate from the calculus and show that it agrees with the CNOT used in the topological model.
We start by applying the red/green rewrite rules to the cluster diagram with defect, figure 12. Figure 15 shows the key result from re-writing a single cell. The graph layout has been changed to make the rewrites easier to discern: the four green vertices at the top and bottom are the four face vertices of a cell. Note that we have only been able to apply the re-write rules in this form on the three-dimensional graph rather than the initial four-dimensional one, showing how key the result of the previous section is. The final result from the rewrites is a single logical qubit line, along the same geometry Figure 16. A ring of physical Z operations becomes the logical Z L operator. Figure 17. A chain of physical Z operations becomes the logical X L operator.
as the physical defect. The top-bottom process time line is now isomorphic with the computational time into the depth of the lattice. The most important rewrite tool used is the spider rule -it then becomes simple to see that any number of qubit lines will collapse into a single logical line centred on the defect. A simple extension of this, using the spider rule again, makes it evident that two defects in an entangled pair, as is used to represent one logical qubit in topological cluster-state QC, will also collapse to a single qubit line.
Within the topological cluster model, the stabilizer operations X and Z on the logical qubit are implemented as physical Z operations ("green π") on rings and chains of qubits around or adjacent to defects. A ring is shown in figure 16. On the particular colouration that we had for the original cell, this becomes the logical operator Z L on the logical qubit. A chain of Z operators is shown in figure 17. In the cell itself, what changes is the phase of one of the centre red nodes. This then gives the logical operator X L on the qubit by straightforward application of the rewrites.
If we choose a cell on the conjugate lattice, then all colours are reversed. Matching the use in [19], the red qubit lines as shown in figures 15-17 represent logical qubits on the dual lattice. Green qubit lines would represent logical qubits on the primal lattice. In that case, it is straightforward to verify that Z L is constructed from Z chains, and X L from rings.
We can therefore view the primal lattice as supporting green logical nodes, and the dual as supporting red nodes. This highlights an important part of the topological model: there is no straightforward logical Hadamard operator. From the diagrams we can see that what a Hadamard operator would mean is a movement of the qubit from primal to dual lattice or vice versa. This is indeed what the very complex Hadamard procedure shown in [18] performs. When using the red/green calculus for cluster state topological QC, we must bear this in mind: there is no logical H-box in the implementation, only the red and green nodes.
One place where this is seen straightforwardly is in the CNOT operation. In the  topological model this is performed when the correlation surface from a qubit on the primal lattice (control) intersects with the correlation surface of a dual lattice qubit (target). Writing that using the primal and dual qubit diagrams leads us to propose the diagram for the logical CNOT operation shown in figure 18. Compare this now with figure 5(a): this is indeed the CNOT gate in the red/green calculus.

Double defects
So far we have concentrated on logical qubits created using a single defect line. This has the disadvantage as a topological implementation that logical operators then have to be defined with respect to the external boundaries of the lattice. The standard method of avoiding this is to define logical qubits as pairs of defects, creating in the case of a pair of primal defects the logical entangled state α|00 + β|11 , which is in itself taken as an encoding of the logical state α|0 + β|1 . Logical operators then become either rings of physical Z operators around one of the defects, or chains of operators between the two defects [16]. A double defect logical qubit is shown in the diagram of figure 19. In the usual fashion, this has been created from a single large defect that is then split. Simple applications of the spider rule then reduce this to the single logical flow line of the single defect, as in figure 15. Showing the logical operators in such a system is not as π π π π ✲ π π ✲ π π ✲ π Figure 20. A ring of phyical Z operators on one defect becomes the logical Z L operator.
π π ✲ π Figure 21. A chain of phyical Z operators betwen the two defects becomes the logical X L operator.
straightforward, however. The logical Z operation acts only on one of the defects, but the logical X requires operations that touch the pair. We can see how this distinction arises in the qubit calulus, figures 20 and 21. Creating the logical X L from a chain of operators is straightforward as the chain changes both defects identically. The ring of operators around a single defect affects both defects the second defect through the 'copying' action of the red nodes on a "green π" operator, enabling the Z operator to propagate to the second defect.

Homology
Homological equivalence plays an important role in topological computing. Equivalent patterns of defects implement the same algorithm, and this method can be used to rewrite circuits according to various rules [16, §2]. This same notion is present in quantum picturalism, described intuitively as "only the topology matters" [3]: continuously deforming diagrams does not change the processes represented. It is not, however, immediately obvious that we can derive this from the red/green calculus alone for topological QC. There are two main steps in using the pictorial representation: first we re-write the diagrams of individual physical qubits to give logical qubit diagrams, and then those logical qubit diagrams themselves can be re-written into others. If we are to change the geometrical structure of the defects to a homologically identical one, then this will in general change the relative positions of the qubits that are to be measured out to form defects. In particular, they will in general take up different relative positions in the z-dimension (depth) of the cluster in homologically equivalent defect patternsthat is, they will be measured out at different relative computational times. Recall that we can only begin to re-write the physical qubit diagram once the measurement has happened; this means that the order in which the rewrite rules are applied to the nodes making up the logical qubit line is changed.
In general, the red/green calculus and related systems are not insensitive to the order in which rewrite rules are applied. The relevant property of the system is called confluence: for all sequences of the set of reduction relations (rewrites) in a language, if any permutation of a given rewrite sequence yields the same output form as any other, then the language is confluent. It is known that, in general, the red/green calculus is not confluent [25]. However, it is also known that confluence in the calculus is broken only by a single rule, the bialgebra re-write rule. Without the bialgebra rule the red/green system is confluent [25]. The scheme that we've presented does not rely on the bialgebra rule to rewrite physical to logical qubit diagrams; these re-writing results are therefore unchanged under a different order of application of the re-writes, and therefore do not change when the physical geometry of the defect patterns are changed.
This leaves us with an important restriction on the use of the red/green calculus in topological computing. At no stage can the bialgebra rule be used for rewriting, either for diagrams of physical qubit processes or when re-writing logical qubit lines.

Automated design and reasoning
One particular consequence of the use of the red/green calculus to describe topological QC is that process re-writing is available at two separate levels. Re-writing is an important tool as it enables us to give different patterns of measurements in the cluster that implement the same algorithm, and also because it allows us to demonstrate the algorithm implemented by a given -potentially highly complex -sequence of defect patterns.
The first type, a re-writing of the logical qubit diagrams, allows us to define multiple physically implementable measurement patterns for a given algorithms. These can then be used in optimisation procedures, given a particular set of constraints. There has been this ability in the topological model previously, given by the homological re-write rules of [16]. The red/green re-writes can supplement topologically simple re-writes, allowing for circuit identities that are not necessarily continuous deformations of each other. This greater variety of applicable re-writes is particularly important for circuit optimisation problems, which will in general be performing some form of search over a set of potential circuit implementations.
The second form of re-writing, that of finding the equivalent logical pattern from a set of measurements on individual qubits, gives a powerful method for verifying the algorithm implemented without calculating and manipulating stabilizers or other state descriptors for each separate physical qubit. Even for small lattice sizes working through sets of stabilizers can become technically prohibitive -even for a relatively small code distance, the cross-section of the lattice can be of the order of a a few hundred qubits square, and while we can easily lay out standard measurement patterns for an algorithm on that lattice, verifying the result of an arbitrary measurement pattern through stabilizer operations is unfeasible.
For these larger numbers of qubits, of course, even the rewriting would be impractical to perform by hand. However, the red/green calculus lends itself very naturally to automation, given the particular set of re-write rules. A tool for automatic re-writes has already been developed [26], giving a first hint of the possibilities available for automatic design and verification tools for quantum algorithms were similar tools to be developed for individual physical implementations. Such tools may in the future play a vital role in compiling quantum programs to run on specific physical systems under their individual design constraints.

Conclusions
In this paper we demonstrate the use of the diagrammatic representation of quantum picturalism as a high-level language to describe the patterns of excitation in topological cluster-state quantum computing. We have shown that qubit lines in the categorytheory based red/green calculus are geometrically identical with the physical defect lines within the cluster used to implement a given algorithm. In doing this, we have demonstrated the structure of large-scale cluster states within the calculus, and given a representation for stabilizers. Using the pictorial language has enabled us to give intuitively straightforward descriptions of elements in the topological model such as the primal and dual lattice, logical qubits, operators and homology, and brings out aspects of the information flow within the model that are opaque in standard treatments.
The structural equivalence between the defect patterns and category-theory diagrams is somewhat surprising. The diagrammatic language represents processes rather than qubits as vertices in its graphs. What the equivalence tells us is that it is fundamentally these processes that are represented in topological cluster-state QC: it is not, structurally, a model of single qubits evolving over time. Instead, such a situation is simulated using many entangled qubits (or qubit regions) to represent processes on an abstract "logical qubit". Entanglement between these qubits simulates the persistence and evolution of a single qubit over time. At a fundamental level, topological clusterstate QC is described by a process algebra rather than a qubit algebra.
As well as such fundamental implications, the use of quantum picturalism for topological QC opens several avenues for the design and verification of quantum algorithms on cluster states, and the ability to automate these procedures (vital when large numbers of physical qubits are involved). Diagrams can be translated directly to patterns of measurement on individual qubits, and vice versa, making the red/green calculus a true 'compiler language' for topological QC: as well as enabling high-level reasoning, it also allows us to implement the high-level concept directly in the physical structure of the cluster state. The circuit and pattern rewriting capabilities of the red/green calculus lend themselves naturally to automation, one tool for which already exists within the community.
This work opens up new possibilities for both the topological model and the category-theoretic framework. The fact that the defects in the 3D topological model can be seen as a physical instantiation of the logical flows in category-theory based diagrammatics gives a direct physical model and application for quantum picturalism. Conversely, we now have a language that is both graphical and native to the topological model to describe computations, without needing to transform back to the circuit model. Quantum picturalism may in fact end up as the first deployed quantum programming language.