Universal MBQC with generalised parity-phase interactions and Pauli measurements

We introduce a new family of models for measurement-based quantum computation which are deterministic and approximately universal. The resource states which play the role of graph states are prepared via 2-qubit gates of the form $\exp(-i\frac{\pi}{2^{n}} Z\otimes Z)$. When $n = 2$, these are equivalent, up to local Clifford unitaries, to graph states. However, when $n>2$, their behaviour diverges in two important ways. First, multiple applications of the entangling gate to a single pair of qubits produces non-trivial entanglement, and hence multiple parallel edges between nodes play an important role in these generalised graph states. Second, such a state can be used to realise deterministic, approximately universal computation using only Pauli $Z$ and $X$ measurements and feed-forward. Even though, for $n>2$, the relevant resource states are no longer stabiliser states, they admit a straightforward, graphical representation using the ZX-calculus. Using this representation, we are able to provide a simple, graphical proof of universality. We furthermore show that for every $n>2$ this family is capable of producing all Clifford gates and all diagonal gates in the $n$-th level of the Clifford hierarchy.


Introduction
Measurement-based quantum computation (MBQC) describes a family of alternative models to the quantum circuit model, where one starts with a highly entangled resource state and performs all computation via measurements. While individual measurements introduce non-determinism, a deterministic quantum computation can be recovered by allowing future operations depend on past measurement outcomes, a concept known as feed-forward. The most prevalent model of MBQC is the one-way model, first described by Briegel and Raussendorf [13], which makes use of cluster states or more generally graph states and single-qubit measurements. Graph states are a family of stabiliser states which can be described by an undirected graph, where each edge represents a pair of qubits entangled via a controlled-Z operation. Since they are stabiliser states, any computation involving just Pauli measurements will be efficiently classically simulable, due to the Gottesman-Knill theorem [1]. In fact, any computation involving Pauli measurements can be done in a single time-step [12]. Hence, the entire computational power of the one-way model comes from introducing non-stabiliser measurements to a computation. It is natural to ask if we can invert this problem: is it possible to obtain universal computation by means of a non-stabiliser resource state and just Pauli measurements? We give a positive answer to this question by introducing a new measurement-based model based on two-qubit Mølmer-Sørensen (MS) interactions [14], i.e. unitary gates of form: and single-qubit Pauli X and Z measurements. We call this the MSPM model. The resource states we define, called MS-graph states, contain two kinds of edges, 'single edges' produced by applying M x (π/4) gates on neighbouring qubits and 'double edges' produced by M x (π/2) = M x (π/4) 2 . In this way, we introduce a new kind of resource which shares many of the same properties of traditional graph states. Indeed MS-graph states with only double edges are equivalent to graph states, up to local Clifford unitaries. However, MSgraph states additionally yield the ability to selectively inject π/4 phases into computations via nodes connected by single edges, giving universality with just Pauli measurements.
Notably, this dichotomy gives a clean separation of the efficiently simulable parts of the computation and the rest. In deriving a universal scheme for computation with MS-graph states, we will note the feed-forward is only required in the vicinity of single edges. So, much like the case in the one-way model, the entire 'Clifford' part of the computation can be done in a single time step.
We focus on MS gates because they are a popular primitive two-qubit entangling gate in hardware implementations of quantum computation, such as ion trap qubits [3,9] and (up to a global change of basis X ↔ Z), in transmon-based superconducting qubits [15]. We comment briefly toward the end of the paper on near-future prospects of implementing this scheme using the latter.
Related work. This work relies heavily on the ZX-calculus [6,2] as a tool for representing and simplifying qubit calculations. In particular, we use a variation of the elegant translation from graph states and measurement patterns into ZX-diagrams given by Duncan and Perdrix [8] to prove the correctness of our computation scheme. To give a proof of completeness, we introduce 'hairy brickwork states', which are inspired by the brickwork states introduced in [4] to provide universal computation in the one-way model with measurements limited to the XY plane. Alternative models to the one-way model have been considered, notably a broad range of models by Gross et al [10], which even include a variation on graph states using two-qubit interactions that are equivalent to M x (π/4). However, our approach is distinct in that we use very limited measurements and rely on the fact that MS-graph states are a more powerful resource than standard graph states. Our scheme also has the property of the one-way model that all errors can be corrected via feed-forward, eliminating the need for 'trial-until-success' strategies used by [10] to implement computations on a wide variety of resource states.

Preliminaries on ZX-notation
To derive a universal set of measurement patterns for the MSPM model, it is convenient to use ZX-notation, which is a superset of the usual quantum circuit notation. It is used to depict linear maps from qubits to qubits, put together in the usual way via composition and tensor product. We will provide a brief overview. For a (very) in-depth reference see [7]. The only operations in ZX-notation are swap gates, identities, and special linear maps called spiders. These come in two varieties, Z-spiders depicted as white dots: α ... ... := |0 · · · 0 0 · · · 0| + e iα |1 · · · 1 1 · · · 1| and X-spiders depicted as grey dots: α ... ... := |+ · · · + + · · · +| + e iα |− · · · − − · · · −| A special case is when spiders have a single input and output, in which case they form Z-phase and X-phase gates: Note that we adopt the convention for α such that the Pauli Z and X gates are obtained as Z(π) and X(π), respectively. Another special case is when α = 0, in which case we omit the label: ... ... := |0 · · · 0 0 · · · 0| + |1 · · · 1 1 · · · 1| ... ... := |+ · · · + + · · · +| + |− · · · − − · · · −| In particular when these phaseless spiders have single input and output they are the identity: Phaseless spiders can be thought of as a generalisation of the GHZ state to a linear map. Indeed the Z-spider with 0 inputs and 3 outputs is the usual GHZ state (up to normalisation): Furthermore, the |0 and |+ states are just one-legged spiders: The |1 and |− states are these states followed by respectively a Z(π) and X(π) gate: Note that hence forth we will ignore non-zero scalar factors, as they will not enter into our calculations and cease to write ∝. While spiders are typically non-unitary, and hence not quantum gates, they can be used to construct a universal family of quantum gates. We already saw Z-and X-phase gates, while the CNOT gate can be constructed as follows: Note that we can write horizontal connections between spiders without ambiguity, because: More generally, rather than treating a ZX-diagram as a (rigid) circuit consisting of spiders and swap gates, we can treat it as an undirected graph, again without ambiguity. That is, whenever two ZX-diagrams are isomorphic as undirected graphs, they describe the same linear operator. Furthermore, ZX-notation admits a very useful set of rewrite rules, which are collectively referred to as the ZX-calculus. The ZX-calculus has a couple of variations. We'll only need a few rules here. The first two are the spider-fusion rules, which says adjacent spiders of the same colour fuse together, and their phases add: This implies in particular that Z and X phase gates commute through spiders of the same colour. Pauli Z and X gates can be pushed through spiders of the opposite colour, but they change the sign of the angle: We'll also use that the Hadamard gate is self-inverse and that it can be built from Z and X phase gates: Since it interchanges the Z and X bases, it acts as a colour-changer for spiders: We also get the following equality, which we will use throughout the paper: and the same thing with the colours reversed. A final property that we will use is the strong complementarity of the Z and X bases of a qubit, which translates to the following diagrammatic rules: Combining the rightmost equation with the other rules yields a more general version, for any a ∈ {0, 1} and α ∈ [0, 2π): ...

MS in ZX
We now derive a simple expression for MS gates in ZX-notation. We will first derive M z (α) = exp(−i α 2 Z ⊗ Z) and then transform the Z's to X's via Hadamard gates. It is easy to check that as a matrix in the computational basis, we have: which can be obtained from: by interchanging the third and fourth computational state (|10 and |11 ) via pre-and post-composing with CNOTs: This simplifies as a routine calculation in the ZX-calculus (see e.g. [7]): where we repeatedly used spider fusion and in the second to last step we used the strong complementarity of the Z and X spiders.
To get the expression of M x (α) = exp(−i α 2 X ⊗ X) we simply pre-and post-compose with Hadamards, which reverses the colours: The appearance of the 'virtual qubit', i.e. the state being input between the two wires is quite suggestive. We can interpret this node as a magic state that is waiting to be applied to one of its neighbouring (actual) qubits to introduce a phase. More specifically, if we prepare the second qubit in the |0 state and then measure it in X basis, this results in either the |+ or |− state, which is exactly like the application of a magic state with some correction applied depending on the measurement result: If we take α = π 2 we can rewrite the expression of M x ( π 2 ) in the ZX-calculus a bit further: Written in this way it is clear that the gate is equivalent, up to single-qubit Clifford unitaries to the controlled-Z gate CZ, which is represented in ZX-notation as:

The MSPM Model
We now introduce a model of computation based on Mølmer-Sørensen gates and Pauli measurements (MSPM). An MS-graph state is described by an undirected graph with two kinds of edges: either a single edge or a double edge: A single edge describes the application of an M x (π/4) gate, whereas a double edge describes the application of an M x (π/2) = M x (π/4) 2 gate. An MS-pattern is an MS-graph state where each node is labelled by a measurement expression of the form "b ← φ(a 1 , . . . , a n )" where b is a fresh name called the output value and φ is a classical function from boolean variables a 1 , . . . , a n to a single boolean value. In this case, we say for each a i that b depends on a i . An MS-pattern is well-founded if there are no cyclic dependencies between variables, such as in the followinn pattern: As with MBQC patterns, these expressions do not have any explicit time-ordering, but there are restrictions on the order in which measurements can be made, due to dependencies on prior outcomes, i.e. feed-forward. As a matter of convention, we will typically draw earlier measurements below later ones, i.e. 'time' flows upward.
Computations are performed as follows:

1.
A qubit is initialised in the |0 state for each vertex in an MS-graph state.
2. M x ( π 4 ) is applied to every pair of qubits connected by a single edge and M x ( π 2 ) = M x ( π 4 ) 2 is applied to every pair connected by a double edge. ← φ(a 1 , . . . , a n )", where the values a 1 , . . . , a n are known, measure in the Z-basis if φ(a 1 , . . . , a n ) = 0 and the X-basis otherwise. In either case, store the measurement result in b.

4.
Optionally, perform some classical post-processing on the measurement results.
As with the one-way model, the two-qubit gates all commute, so the order of application is irrelevant, leaving only the undirected graph structure.
To show that this model is universal, we will compose smaller patterns into larger ones. In order to do this, we give a notion of MS-pattern fragment analogous to the notion given for the one-way model. An MS-pattern fragment is just like an MS-pattern, with the exception that we additionally identify two (not necessarily disjoint) subsets of vertices I, O ⊆ V which respectively correspond to inputs and outputs. Inputs correspond to qubits that can be in an arbitrary state, rather than the fixed state |0 . Ouputs correspond to qubits which remain unmeasured after the application of the pattern-fragment.
Each vertex in I is labelled with an input error expression of the form: "(z, x) ← " for fresh variables z and x which captures whether a Z or X error is being fed forward into this vertex. It is also labelled with a measurement expression as usual, unless it is also an output. Measurement choice functions φ in the MS-fragment are allowed to depend on these input errors as well as other measurements occurring within the fragment.
Each vertex in the output set O is labelled by an expression of the form: " ← (ζ, ξ)" consisting of a pair of classical functions ζ, ξ which again can depend on the input errors and the results of measurements in the MS-fragment. Vertices in O are not measured so they do not contain a measurement expression.
Here is an example of a pattern fragment: We say a MS-pattern fragment implements a gate G if, for any input state of the form: X x Z z |ψ , performing the pattern fragment yields X ξ Z ζ G |ψ . This extends in the natural way to gates with multiple input/output qubits: Composing MS-pattern fragments then results in the composition of their associated gates, hence it suffices for the sake of universality to show we can implement a universal set of quantum gates via MS-pattern fragments.

Computing gates from patterns
There is an evident translation between MS-graph states and ZX diagrams, which is very similar to the one given in [8]. Qubits become grey dots with a single output and single/double edges become edges decorated by the appropriate phases as follows: It will be convenient to deform the right-hand side to match the topology of the associated MS-graph state, in which case we can drop the qubit labels: Note that all of the wires with a free end correspond to outputs, so there is no need to draw them exiting to the right of the diagram.
To compute the result of a measurement pattern, we post-compose with the appropriate effects { 0| , 1|} for Z-measurements and { +| , −|} for X-measurements, which we will write more conveniently as: This enables us to write patterns (without feed-forward) as a single ZX-diagram: We could also represent the feed-forward within the diagram (e.g. by conditionally applying Hadamard gates to outputs), but for our purposes, it will be simpler just to do some simple case-distinctions. Finally, pattern fragments can be expressed by not measuring outputs, and adding a new input wire for each input: In order to implement a gate G, we should show that the right-hand side above, precomposed with possible Pauli errors, implements G followed by some possible Pauli errors. Representing possible Pauli errors as follows:  (7) and (9). This is a common theme in the ZX-calculus, and comes from the fact that basis elements of one colour can be described as spiders of the other colour (cf. equation (1)).
The simplest non-trivial example of a pattern fragment implements a single S := Z(π/2), gate: The bottom qubit is the input of the expression. We always measure it in the Z basis (a ← 0) which gives us a measurement result a. We record the incoming Z and X error in the variables z and x. The resulting Z error at the end is now z ⊕ a ⊕ x ⊕ 1, and the X error is x ⊕ a. We can show the correctness of this fragment by performing translation (8) and reducing using the ZX-calculus: where all steps are spider-fusion except ( * ), which uses equation (4) and ( * * ), which is the standard Clifford commutation law of S † X ∝ XZS † . This commutation follows straightforwardly from (2).
We'll now introduce a more versatile MS-graph state piece, shaped like an 'E', which can implement a variety of single-qubit gates. The first pattern fragment in the E-shape implements an X(π/4) gate, i.e. an HT H gate: Note that now the basis in which the qubit e is measured depends on the incoming Z error and one of the measurement results in the pattern fragment itself. Let's translate this to the ZX-calculus ignoring for the moment being the Pauli errors that could be at the beginning of the fragment: We used equation (6) to introduce the Hadamards above. Now we measure a, c and d in the Z-basis and b in the X-basis, each of which can introduce a π phase of their respective colour: The goal of this pattern is to introduce a π/4 phase. We see that now we either have π/4 or −π/4. If we measure e in the Z-basis, it gets cut off the main structure, but if we measure it in the X-basis it introduces an extra π/2 phase. So, if we got π/4 (in this case, when b = 0), we measure e in the Z-basis: (c ⊕ d ⊕ 1)π and otherwise we measure e in the X-basis: (a ⊕ e ⊕ 1)π so that we indeed implement a π/4 X-rotation with some Pauli X and Z error depending on the measurement outcomes. In the presence of of some starting Pauli X and Z errors, the same procedure can be done by being careful to track where the errors spread. Tracking these errors correctly gives the pattern fragment that we started out with. If we decide to measure e in the opposite basis (so in the X basis when b = 0 and the Z basis when b = 1), we can implement a HT † H gate. Classical control is really what determines the sign of our rotations.
Using the same pattern fragment, but with a different set of measurements on the 'hairs' of the fragment we can implement some different operators. For instance, if we measure a, b, c and e in the Z basis and d in the X basis we get a Hadamard gate: In a similar way we can also produce an HSH-gate by measuring qubit e in the X basis and the rest in the Z basis.
The following fragment implements a two-qubit gate: which we will refer to as a CX-gate. Though this is not an actual CNOT gate, it is however locally Clifford equivalent to a CNOT gate, which means it suffices to prove universality. Note that the top and bottom qubits act as both inputs and outputs, so they are not measured. We measure a in the X-basis, and b in the Z-basis. Writing the resulting diagram out in ZX-calculus (again ignoring incoming Pauli errors for the moment) we get: Now we can use the conversion rule for Hadamards on the middle part: Pauli errors propagate through a CX in the following way: and in exactly the same way for the other input. Putting the above derivation together with this error propagation gives the pattern fragment as specified above.
This pattern fragment implementing CX has the additional property that if we measure b in the X basis instead of the Z basis, it disconnects. It doesn't matter in which basis we measure a, but let's take it to be the Z basis. This pattern fragment is In ZX notation (ignoring incoming Pauli's): Hence, the choice of measurement basis for b 'switches' the CX gate on or off.

Proof of Universality
In the previous section we've constructed a pattern fragment that can implement a HT H gate and an H gate depending on the chosen measurements. Combining these, we can produce H and T , which suffice to approximate any single-qubit unitary. Combining this with the entangling gate we demonstrated at the end of the previous section suffices for universality. It only remains to combine these patterns into a configuration that allows us to combine them arbitrarily. We will construct a fragment that is a combination of the simple blocks described above which fits neatly into a 2D square lattice. If we simply compose two of the 'E'-shaped blocks from the previous section with a CX block rotated 90 degrees we get: where the i's denote inputs and o's denote outputs. These bricks however don't fit together in a square lattice, since there is no useful tiling we can produce without some qubits overlapping. However, we can solve this problem by considering a slightly larger brick: While our primitive computational 'brick' doesn't seem to be particularly canonical, the fact that it is missing some edges from a square lattice could have advantages when thinking about space-limited architectures. For instance, with a bit of folding, this 16-qubit pattern fits nicely into the 17-qubit 'ninja star' design of the superconducting chip proposed in [15], which is designed primarily for implementing a 17-qubit surface code: This means that a proof of concept for this computational model is potentially close at hand.

Conclusions and further work
We presented a novel graph state that leads to universal quantum computation using just measurements in two bases. The interactions needed to make such a graph state are available in both ion trap and superconducting quantum computing hardware which means proofs of concept could be implemented in a short timeframe. However, it remains unclear if such a measurement-based scheme would yield benefits over the circuit model on such architectures. One avenue of future work is to explore the applicability of the MSPM scheme to quantum optics, which has already seen successful implementations of the one-way model [16].
In the scheme we gave, each of the qubits whose measurement depends on previous outcomes is a correction involved in implementing a single T -gate. Hence, the number of required measurement/feed-forward cycles is clearly related to the T -depth (plus 1) of the associated circuit. We intend to make this relationship precise and relate to similar results known for the one-way model concerning pattern depth and parallelisation of measurements.
Another avenue of future work is to understand the general properties of feed-forward in MS-graph states. For instance, concepts like Flow and gFlow [5,11] are likely to apply with little modification to the 'double edge' portion of an MS-graph state, so it will be interesting to see if this can be extended.
Finally, there is an intriguing link between the form of an MS-gate derived in equation (5) and quantum computing with magic states. For instance on n qubits, repeated application of 2-qubit MS gates can be used to introduce O(n 2 ) 'virtual magic states' like the one shown in (5), so it is natural to ask if this could be used to extract some advantage for magic state distillation, and hence fault-tolerant computation.
Acknowledgements: This work is supported by the ERC under the European Union's Seventh Framework Programme (FP7/2007-2013) / ERC grant n o 320571. The authors