Adiabatic graph-state quantum computation

Consider a system with a time-varying Hamiltonian H(t) and ground state $|{{E}_{0}}(t)\rangle$. If at t = 0 we prepare a system in $|{{E}_{0}}(0)\rangle$, and change the Hamiltonian slowly enough, then at time τ we will finish in the state $|{{E}_{0}}(\tau )\rangle$ with high probability. In this case, 'slow' means that the evolution satisfies the adiabatic criterion [21], which roughly says that the system will remain in the ground state provided that the evolution satisfies

$$\begin{eqnarray}&&\frac{\langle {{E}_{m}}(t)|\dot{H}(t)|{{E}_{0}}(t)\rangle }{{{E}_{m}}(t)-{{E}_{0}}(t)}\ll 1\end{eqnarray} \tag{ 1 }$$

for all m and $0\leqslant t\leqslant \tau$. After such an adiabatic evolution, the final state is ${{{\rm e}}^{{\rm i}{{\gamma }_{B}}(\tau )}}{{{\rm e}}^{-{\rm i}\int _{0}^{\tau }E(t^{\prime} ){\rm d}{{t}^{\prime }}}}|{{E}_{0}}(\tau )\rangle$, where $-{\rm i}\int _{0}^{\tau }E(t^{\prime} ){\rm d}t^{\prime}$ is the dynamical phase and ${\rm i}{{\gamma }_{B}}(\tau )=-\int _{0}^{\tau }\langle {{E}_{0}}({{t}^{\prime }})|{{\dot{E}}_{0}}\rangle {\rm d}t^{\prime}$ is the Berry or Pancharatnam phase [22, 23]. The dynamical phase vanishes under cyclic evolutions, where $H(0)=H(\tau )$ and can be removed by a local gauge transformation $|{{\tilde{E}}_{0}}(t)\rangle ={{{\rm e}}^{-{\rm i}\int _{0}^{\tau }E({{t}^{\prime }}){\rm d}{{t}^{\prime }}}}|{{E}_{0}}(t)\rangle$, however the Berry phase does not vanish under cyclical evolutions or local gauge transformations, and depends only on the path taken through parameter space during the evolution. The Berry phase has proved important when describing many phenomena in condensed matter systems, such as the anomalous quantum hall effect [24].

Berry phases can also be generalized to situations where H(t) has ground space of d degenerate energy levels, labelled $|E_{0}^{\alpha }\rangle$, where $1\leqslant \alpha \leqslant d$. In this case, the same process will not in general lead to a global phase, but instead transforms the ground space by a rotation ${{U}_{\alpha \beta }}(t)=\mathcal{T}{\rm exp} \left( -\int _{0}^{t}\langle E_{0}^{\alpha }(t^{\prime} )|\dot{E}_{0}^{\beta }(t^{\prime} )\rangle {\rm d}t^{\prime} \right)$. This is called a holonomy [25], and for systems over which we have adequate control it is possible to use these holonomies to produce universal rotations on information encoded in the ground space, and so provides a way to perform quantum computation. This method is called HQC [7, 8]. It is also possible to perform HQC, where $H(0)\ne H(\tau )$, this is known as open-loop HQC [9].

Typically HQC is performed using an adiabatic evolution (although this is not a necessary condition [26]), but is a very different way of computation compared to the 'standard' adiabatic quantum computation (AQC) protocol proposed by Farhi et al [27]. The AQC protocol starts with a system prepared in the ground state of a simple initial Hamiltonian H₀, such as a uniform magnetic field, and then the Hamiltonian is slowly changed to a complicated 'problem Hamiltonian' H_p whose ground state encodes the problem to be solved (e.g., finding the ground state of an Ising spin glass is NP-hard [28]). In HQC, it is not the ground state itself that encodes the answer to the problem but the sequence of operations that have been performed within a degenerate subspace. The eigenstates of the Hamiltonian can be completely known at all times, as can the energy gap profile. AQC has a built in noise reduction mechanism since there is always an energy gap between the ground and states, however achieving fault tolerance in AQC is still an ongoing problem (see e.g. [29]). HQC also has some gap protection (although due to the degeneracy in the ground state the protection is not the same as for AQC), and some protection from control errors (see e.g. [30]). There are also known schemes to implement fault-tolerant HQC [31].

Since HQC involves degenerate ground spaces, the form of the adiabatic theorem shown in equation (1) is not appropriate since it is derived for singly degenerate states. For the purposes of this paper the following form of the adiabatic theorem is valid [32]; consider a linear interpolation between two Hamiltonians H₀ and H_p. The time dependent Hamiltonian of this transition is $H(t)=(1-\frac{t}{\tau }){{H}_{0}}+\frac{t}{\tau }{{H}_{p}}$ so that the transition is finished at $t=\tau$. To simplify the notation, we introduce a parameter $s=\frac{t}{\tau }$, and we denote the eigenvalues of H(s) as E_n(s). Then if we start in the ground state of H₀, the final state will be close in the l₂ norm to the ground subspace of H_p provided the adiabatic run time τ satisfies

$$\begin{eqnarray}&&\tau \geqslant \mathop{{\rm max} }\limits_{0\leqslant s\leqslant 1}\left( \frac{c(\delta )||\dot{H}|{{|}^{1+\delta }}}{\varepsilon {{\Delta }^{2+\delta }}} \right),\end{eqnarray} \tag{ 2 }$$

where $\Delta ={{{\rm min} }_{n}}|{{E}_{n}}(s)-{{E}_{0}}(s)|$, $0\lt \delta \leqslant 1$, $\parallel M\parallel$ is the operator norm, defined as the largest absolute eigenvalue of M, and $c(\delta )$ is a parameter depending only on δ. Although it is tempting to set $\delta \to 0$, this isnʼt possible without the adiabatic time diverging, since ${{{\rm lim} }_{{{\delta }_{\to }}0}}\;c(\delta )=\infty$ [32]. So δ is taken as some fixed, small positive number.

In MBQC an entangled resource state is measured sequentially and adaptively. We consider graph states as our entangled resource states (see e.g. [33] for other possible resources). To create this resource state, qubits are prepared in a $|+\rangle =(1/\sqrt{2})(|0\rangle +|1\rangle )$ state, and controlled-phase (CZ) operations are performed between neighbouring qubits. To perform a computation on this resource state, single qubit measurements in bases $\{|{{+}_{{{\theta }_{j}}}}\rangle \langle {{+}_{{{\theta }_{j}}}}|,|{{-}_{{{\theta }_{j}}}}\rangle \langle {{-}_{{{\theta }_{j}}}}|\}$ are performed, where $|{{\pm }_{\theta }}\rangle :=\;\frac{1}{\sqrt{2}}(|0\rangle \pm {{{\rm e}}^{{\rm i}\theta }}|1\rangle ),$ and where ${{\theta }_{j}}$ is the measurement angle for qubit j. The measurement will have a random outcome $\pm 1$, however by adapting future measurements on other qubits this randomness can be corrected for. The deterministic output of the computation is either encoded in the quantum state of the unmeasured qubits (that is, the quantum output), or in the classical measurement outcomes [3, 34], with the former case giving a unitary evolution on the encoded information.

For example, consider a system of two qubits, A and B. Qubit A is prepared in a state $|\phi \rangle =\alpha |0\rangle +\beta |1\rangle$, whilst qubit B initially prepared in state $|+\rangle$. Performing a CZ gate between them entangles the input and results in the state $|{{\psi }_{AB}}\rangle =\alpha |0\rangle |+\rangle +\beta |1\rangle |-\rangle$. Note that by preparing A in state $|\phi \rangle$ instead of $|+\rangle$, we are able to encode information in the chain, so we call A the input to the chain, and since B is the system where the information will be at the end of the computation, we call this the output. We can rewrite the state $|{{\psi }_{AB}}\rangle$ as

$$\begin{eqnarray}\begin{array}{rcl} |{{\psi }_{AB}}\rangle & = & \frac{1}{\sqrt{2}}|{{+}_{\theta }}\rangle (\alpha |+\rangle +{{{\rm e}}^{-{\rm i}\theta }}\beta |-\rangle )+\frac{1}{\sqrt{2}}|{{-}_{\theta }}\rangle (\alpha |+\rangle -{{{\rm e}}^{-{\rm i}\theta }}\beta |-\rangle ) \\ {} & = & \frac{1}{\sqrt{2}}|{{+}_{\theta }}\rangle \tilde{H}{{U}_{z}}(\theta )|\phi \rangle +\frac{1}{\sqrt{2}}|{{-}_{\theta }}\rangle X\tilde{H}{{U}_{z}}(\theta )|\phi \rangle , \\ \end{array}\end{eqnarray} \tag{ 3 }$$

where ${{U}_{z}}(\theta )$ is a rotation about the z-axis by angle θ, and $\tilde{H}$ is a Hadamard gate. Now consider performing a $|{{\pm }_{\theta }}\rangle$ measurement on qubit A. If the outcome is $|{{+}_{\theta }}\rangle$, the state of qubit B is $\tilde{H}{{U}_{z}}(\theta )|\phi \rangle$, and if the outcome is $|{{-}_{\theta }}\rangle$ the state of qubit B is $X\tilde{H}{{U}_{z}}(\theta )|\phi \rangle$. If we apply a Pauli X correction on qubit B when the measurement outcome is $|{{-}_{\theta }}\rangle$, then both outcomes will be the same. In this way corrections allow for a deterministic implementation of the unitary operation $\tilde{H}{{U}_{z}}(\theta )|\phi \rangle$.

More general computation in MBQC can be depicted using graphs. Qubits prepared in the $|+\rangle$ state are represented by vertices V on a graph G, and the edges E represent which pairs of qubits have been acted on by a CZ gate. The state resulting from these operations is called a graph state, $|G\rangle$. The graph state of the cluster state, which is a universal resource for MBQC [3], is the two-dimensional (2D) square lattice (see figure 1). Graph states can also be defined using the stabilizer formalism [35], where it is defined as the state which satisfies the stabilizer eigenequations

$$\begin{eqnarray}&&{{K}_{v}}|G\rangle =|G\rangle \forall v\in V,\end{eqnarray} \tag{ 4 }$$

where a stabilizer generator is associated to each vertex v,

$$\begin{eqnarray}&&{{K}_{v}}={{X}_{v}}\mathop{\prod }\limits_{w\sim v}{{Z}_{w}}.\end{eqnarray} \tag{ 5 }$$

Here X_v, Y_v, Z_v are the Pauli matrices acting on site v, and the notation $v\sim w$ means that v and w are connected by an edge. The K_v generate the stabilizer group $S=\langle {{\{{{K}_{v}}\}}_{v}}\rangle$. The same group can be found by choosing different generators, for example $S=\langle {{\{{{K}_{\alpha }}{{K}_{v}}\}}_{v}}\rangle$ (for some arbitrary fixed vertex α), and indeed the graph state is stabilized by the set of generators ${{\{{{K}_{\alpha }}{{K}_{v}}\}}_{v}}$ as well. This flexibility of choice will be useful later on.

Zoom In Zoom Out Reset image size

As in the example above for a quantum input/quantum output computation, we can extend the definition to include input qubits, labelled I. In this case the stabilizer generators (5) are defined on non-inputs only. This is referred to as an open graph state. During a computation all vertices are measured except the output vertices, labelled O. In this work we are concerned with computations for quantum inputs and outputs, so we will be using open graph states from now on.

In order for a measurement pattern on a graph state to be able to be correctable such that the output is the same regardless of the measurement outcomes, it is sufficient (although not in general necessary) for the graph to have gflow [36, 37]. Gflow is an incredibly useful tool in MBQC that has been used to study parallelism [16, 18], the translation between MBQC and the circuit model [16, 38] and the emergence of causal order in MBQC [39]. Gflow allocates a time ordering over the vertices on a graph state and a gflow function g(v) which tells us which vertices are affected by the measurement outcome of vertex v and which qubits can be used to correct for this. It is defined for measurements in any of the three planes, (X, Y), (X, Z) or (Y, Z), in a generalization of the example presented earlier. In this paper, we focus on measurements in the (X, Y) plane, as results for measurements in other planes will follow in a similar fashion, although, for completeness we present the definition of gflow for all planes.

The notation $v\lt w$ is used to represent that vertex v is measured before vertex w, and v = w to indicate that v and w can be measured at the same time. We say that a set of vertices U is oddly (evenly) connected to a vertex v if there is an odd (even) number of edges connecting U and v. The definition of gflow is then: Gflow.

Definition 1 Given an open graph state G with inputs I, outputs O, edges E and vertices V, we say it has gflow if there exists a gflow function g and a time ordering $\lt$ over V such that, for all $v\in V$ which are not outputs:

• All qubits w in g(v) are in the future of v, i.e. $v\lt w$ for all $w\in g(v)$.
• If $w\leqslant v$, and $v\ne w$, then w is evenly connected to all qubits in g(v).
• — (X, Y) plane: $v\notin g(v)$, and g(v) is oddly connected to v.
  • — (X, Z) plane: $v\in g(v)$, and g(v) is oddly connected to v.
  • — (Y, Z) plane: $v\in g(v)$, and g(v) is evenly connected to v.

Given a gflow g, the associated correction required after measurement of vertex ν with result ${{r}_{\nu }}$ is

$$\begin{eqnarray}&&{{\left( {{\prod }_{\mu \in g(\nu )}}{{K}_{\mu }} \right)}^{{{r}_{\nu }}}}.\end{eqnarray} \tag{ 6 }$$

In [40] it is shown that if an open graph has gflow then it is possible to run an MBQC from input I to output O. Indeed if we ask that the corrections work for all measurement angles on the planes, the existence of a gflow is necessary and sufficient. Finding out if a graph has gflow can be done in polynomial time [41]. Furthermore, the gflow defines a valid measurement pattern, which may allow some qubits to be measured at the same time. Any qubits which can be measured simultaneously are said to be in the same layer of the computation. More formally;

Definition 2 A layer of a computation is defined as any (non-output) qubits in a measurement pattern which can be measured at the same time.

We denote the layers as L_k, and we use L(v) to denote the layer that vertex v is in. For example, for the gflow defined on the graph in figure 1, the layers are given by ${{L}_{k}}=\{{{a}_{k}},{{b}_{k}},{{c}_{k}},{{d}_{k}},{{e}_{k}}\}$, for $k\lt 6$, and $L({{a}_{k}})=L({{b}_{k}})={{L}_{k}}$ etc. We further denote $v\leqslant {{L}_{k}}$ for vertices in L_k or earlier layers, similarly for $v\geqslant {{L}_{k}}$. Using the concept of layers, we can define the depth for MBQC;

Definition 3 The depth of an MBQC with gflow is the number of rounds of measurements in the measurement pattern, or equivalently the number of layers in a measurement pattern.

In general this depth will be different depending on which gflow we are using (there can be more than one—indeed we will see in section 3.2 an example where many gflows can be realized). Since we can think of gflow as a directed graph superimposed on an undirected graph, an equivalent and perhaps more intuitive definition is that the depth is the longest possible path along these directed edges.

The depth is effectively the time needed for the quantum part of the computation. To decrease this quantum time one is interested in pushing as many measurements together as possible to reduce the number of computational steps [16, 18]. This is achieved by what is called the maximally delayed gflow [41]. However, this is done at the expense of increasing the classical time needed to process the measurement results, which increases for larger gflow. The techniques of gflow thus give rise to a trade-off between the classical and quantum time for the computation [16, 18]. As we will see in the example in section 3.2 this trade-off can be great, so that for some cases all the time of the computation can be shifted to the classical processing except some constant quantum part. This trade-off is characterized in [18] in terms of circuits with fanout.

We end this subsection with some further definitions which will be important in the theorem later on, and are illustrated in figure 1.

Definition 4 The size $|g(v)|$ of a gflow is the number of qubits for which the product of the stabilizers over $g(v)$, ${{\prod }_{v\in g(v)}}{{K}_{v}}$, is non-trivial.

E.g. for the cluster-state, there is only one vertex in g(v), and since each stabilizer generator acts on up to five qubits, the size of the gflow is 5.

Definition 5 A gflow line is a directed edge from a vertex v to an element of g(v). The set of gflow lines generates a directed graph over the set of vertices of the original graph (see for example figure 1).

An adiabatically driven open-loop holonomic approach to MBQC was proposed in [6]; adiabatic cluster-state quantum computation. The approach is similar to that used in [31] for closed-loop HQC. First note that generating a cluster state is equivalent to initializing in the ground state of the Hamiltonian:

$$\begin{eqnarray}&&{{H}_{0}}\equiv -\gamma \mathop{\sum }\limits_{v\in V}{{K}_{v}},\end{eqnarray} \tag{ 7 }$$

where γ parametrizes the strength of the interactions and K_v are cluster-state stabilizer generators. Indeed this is also true if we replace the $\{{{K}_{v}}\}$ by any set of generators of the stabilizer group. This will be useful later when extending to general graph states with gflow.

The computation protocol in [6] proceeds first by preparing the system in the ground state of H₀, which could be done by preparing the system in the ground state of a uniform magnetic field and adiabatically changing to H₀. Then each stabilizer generator is replaced by a rotated Pauli-X operator ${{X}^{{{\theta }_{v}}}}=|{{+}_{\theta }}\rangle \langle {{+}_{\theta }}|-|{{-}_{\theta }}\rangle \langle {{-}_{\theta }}|={{{\rm e}}^{-{\rm i}{{\theta }_{v}}{{Z}_{v}}/2}}{{X}_{v}}{{{\rm e}}^{{\rm i}{{\theta }_{v}}{{Z}_{v}}/2}}={{{\rm e}}^{-{\rm i}{{\theta }_{v}}{{Z}_{v}}}}{{X}_{v}}$ (see table 1 ), in analogy to the measurements in MBQC. This can be done one-by-one, or at the same time. If done one-by-one, the time for each individual replacement is independent of the computation, so that the total time scales with N. If all the replacements are done at the same time it becomes difficult to get analytical bounds on the time, however numerical studies suggest that the energy gap scales inversely with the number of qubits [42].

Table 1.  An illustration of the method to perform single qubit operations in adiabatic cluster-state quantum computation in 1D; arrows indicate an adiabatic transition from one operator to the other.

	T1	T2	T3	...	TN−2	TN−1
	$\downarrow$
Step 1	X1	T2	T3	...	TN−2	TN−1
		$\downarrow$
Step 2	X1	X2	T3	...	TN−2	TN−1
			$\downarrow$
⋮				⋮
					$\downarrow$
Step $N-2$	X1	X2	X3	...	XN−2	TN−1
						$\downarrow$
Step $N-1$	X1	X2	X3	...	XN−2	XN−1

This model allows for implementation of single qubit rotations and CNOT gates, and so is universal for quantum computation [43]. For the purposes of this paper, we will often use twisted stabilizer generators $K_{n}^{\theta }$, defined as

$$\begin{eqnarray}&&K_{n}^{{{\theta }_{n}}}=X_{n}^{{{\theta }_{n}}}\mathop{\prod }\limits_{n\sim m}{{Z}_{m}}.\end{eqnarray} \tag{ 8 }$$

We use these to form an initial Hamiltonian ${{H}_{0}}=-\gamma {{\sum }_{v\in \mathcal{V}}}K_{v}^{{{\theta }_{n}}}$. Then instead of adiabatically replacing the stabilizer generators by $X_{n}^{{{\theta }_{n}}}$ operators, they are replaced by X_n operators, and the resulting computation is the same. The advantage of using the twisted picture is that certain results become clearer compared to the untwisted version. Note that, although this choice of stabilizer generators does not really affect the analogous MBQC protocol, in adiabatic cluster-state quantum computation these stabilizer generators are different physical Hamiltonians which must get realized.

We now look at the single qubit rotation to illustrate the main ideas and introduce a few concepts. Details of doing a controlled-NOT gate are in the appendix, which completes the set of universal gates [6]. To perform single qubit rotations in the adiabatic cluster-state model, consider a twisted one-dimensional (1D) cluster state. The stabilizer generators for such a state are

$$\begin{eqnarray}&&K_{v}^{{{\theta }_{v}}}={{Z}_{v-1}}X_{v}^{{{\theta }_{v}}}{{Z}_{v+1}}\quad v=2,\ldots ,N-1;\ \ {{K}_{N}}={{Z}_{N-1}}X_{N}^{{{\theta }_{N}}}.\end{eqnarray} \tag{ 9 }$$

To fit with the notation used in [6], we will use slightly different operators $\{{{T}_{v}}\}$, where ${{T}_{v}}:=K_{v+1}^{{{\theta }_{v+1}}}$. The initial Hamiltonian is then

$$\begin{eqnarray}&&{{H}_{0}}\equiv -\gamma \mathop{\sum }\limits_{v=1}^{N-1}{{T}_{v}}.\end{eqnarray} \tag{ 10 }$$

H₀ has a doubly degenerate ground state, which we can use to encode a qubit. For example, we can define logical states $|0{{\rangle }_{L}}$ and $|1{{\rangle }_{L}}$ as

$$\begin{eqnarray}&&|0{{\rangle }_{L}}:=\mathop{\prod }\limits_{v\sim w}{\rm C}{{{\rm Z}}_{(v,w)}}|0{{\rangle }_{1}}\mathop{\otimes }\limits_{n\gt 1}|{{+}_{{{\theta }_{n}}}}{{\rangle }_{n}},\ \ |1{{\rangle }_{L}}:=\mathop{\prod }\limits_{v\sim w}{\rm C}{{{\rm Z}}_{(v,w)}}|1{{\rangle }_{1}}\mathop{\otimes }\limits_{n\gt 1}|{{+}_{{{\theta }_{n}}}}{{\rangle }_{n}}\end{eqnarray} \tag{ 11 }$$

and similarly $|\pm {{\rangle }_{L}}:=\;\frac{1}{\sqrt{2}}{{(|0\rangle }_{L}}\pm |1{{\rangle }_{L}})$ and $|\pm {\rm i}{{\rangle }_{L}}:=\;\frac{1}{\sqrt{2}}{{(|0\rangle }_{L}}\pm {\rm i}|1{{\rangle }_{L}})$. Preparing the ground state in a superposition $\alpha |0{{\rangle }_{L}}+\beta |1{{\rangle }_{L}}$ corresponds to attaching an input $\alpha |0\rangle +\beta |1\rangle$ to the cluster state in the MBQC picture. The protocol proceeds by adiabatically replacing the T₁ with X₁ (see table 1), so that the time-dependent Hamiltonian is

$$\begin{eqnarray}&&H(s)=-\gamma (1-s){{T}_{1}}-\gamma s{{X}_{1}}-\gamma \mathop{\sum }\limits_{n=2}^{N-1}{{T}_{n}},\end{eqnarray} \tag{ 12 }$$

where $0\leqslant s\leqslant 1$. After this process, the information is encoded in the new degenerate ground space of $H(1)$, and the information originally encoded in $\{|{{0}_{L}}\rangle$, $|{{1}_{L}}\rangle \}$ has been transformed.

Rather than following how the information transforms by following how the ground state evolves, one can follow how the computation proceeds in terms of the logical operators X_L, Y_L, and Z_L, which for H₀ are

$$\begin{eqnarray}&&{{X}_{L}}\equiv {{X}_{1}}{{Z}_{2}},\quad \qquad {{Y}_{L}}\equiv {{Y}_{1}}{{Z}_{2}},\quad \qquad {{Z}_{L}}\equiv {{Z}_{1}}.\end{eqnarray} \tag{ 13 }$$

Following the transformations of these operators is equivalent to following how the ground states transform, and can be simpler to deal with. In this picture, encoding an arbitrary input state is equivalent to applying the field ${{H}_{{\rm field}}}=\alpha {{X}_{L}}+\beta {{Y}_{L}}+\gamma {{Z}_{L}}$.

To see how the information is transformed by the adiabatic substitution in (12), the logical operators are multiplied by stabilizers (since they act as identity) until they commute with X₁ (i.e., the logical operators are put in a form which is conserved during the adiabatic transformation). X_L already commutes with X₁, but Z_L doesnʼt so we multiply by T₁:

$$\begin{eqnarray}&&{{Z}_{L}}\to {{Z}_{1}}{{T}_{1}}=X_{2}^{{{\theta }_{2}}}{{Z}_{3}}.\end{eqnarray} \tag{ 14 }$$

Then, after setting ${{X}_{1}}\to \mathbb{1}$ since we are in the +1 eigenstate of X₁, the logical operators become

$$\begin{eqnarray}&&{{X}_{L}}\to {{Z}_{2}},\qquad \quad {{Z}_{L}}\to X_{2}^{{{\theta }_{2}}}{{Z}_{3}}.\end{eqnarray} \tag{ 15 }$$

Now defining new logical operators in the same way as in equation (13):

$$\begin{eqnarray}&&X_{L}^{\prime }\equiv {{X}_{2}}{{Z}_{3}},\qquad \quad Z_{L}^{\prime }\equiv {{Z}_{2}}.\end{eqnarray} \tag{ 16 }$$

Expressing X_L and Z_L in terms of these new logical operators, we can see that the information has been moved one step along the chain and transformed by $U_{2}^{(L)}{{\tilde{H}}^{(L)}}$, where ${{\tilde{H}}^{(L)}}$ is a Hadamard operation acting in the logical subspace, and $U_{v}^{(L)}:=\;{\rm exp} [-{\rm i}{{\theta }_{v}}{{Z}_{L}}/2]$ is a logical Z rotation (cf the example in section 2.2). At the next step we replace T₂ with X₂, and so on from left to right down the chain (see table 1 for an illustration of this). Finally the information is encoded in the Nth qubit, with the information transformed by the operation $U_{{\rm tot}}^{(L)}$, where

$$\begin{eqnarray}&&U_{{\rm tot}}^{(L)}={{\tilde{H}}^{(L)}}\mathop{\prod }\limits_{v=N-2}^{2}(U_{v}^{(L)}{{\tilde{H}}^{(L)}}),\end{eqnarray} \tag{ 17 }$$

and since $U_{v}^{(L)}={\rm exp} [-{\rm i}{{\theta }_{v}}{{Z}_{L}}/2]$, this will depend on the sequence of angles $\{{{\theta }_{v}}\}$ used (following [6] we set ${{\theta }_{1}}=0$ for convenience).

Since we are doing adiabatic transformations, the speed of the computation is limited by the ratio of the energy gap and $||\dot{H}(s)||$. For the Hamiltonian in (12), this is given by (see appendix B)

$$\begin{eqnarray}&&\tau \geqslant {{\tau }_{0}}:=\;\frac{c(\delta )}{\varepsilon {{2}^{1+\delta /2}}\gamma },\end{eqnarray} \tag{ 18 }$$

where $0\lt \delta \leqslant 1$, and is the error in the adiabatic evolution. For the remainder of this paper we will compare adiabatic evolution time to this time ${{\tau }_{0}}$, so this is our definition of one unit of time for the adiabatic computation.

In AGQC, given an open graph state with gflow $(g,\lt )$, and measurement angles $\{{{\theta }_{v}}\}$, we start in the ground state of the initial Hamiltonian

$$\begin{eqnarray}&&{{H}_{0}}=-\gamma \mathop{\sum }\limits_{v}{{T}_{v}},\end{eqnarray} \tag{ 19 }$$

where the T_v are products of the twisted stabilizer generators,

$$\begin{eqnarray}&&{{T}_{v}}:=\mathop{\prod }\limits_{w\in g(v)}K_{w}^{{{\theta }_{w}}},\end{eqnarray} \tag{ 20 }$$

$\forall v\notin O$. Hence the ground state corresponds to the twisted open graph state (an open graph state where the vertices are rotated according to the measurements). Preparing the system in the ground state of H₀ could be done by starting in the ground state of a magnetic field, and adiabatically evolving to H₀. This initial Hamiltonian can also be computed efficiently from the graph and gflow, since each T_v can be calculated in a time that scales as $O({\rm log} ({{{\rm max} }_{v}}|g(v)|))$ using the methods in [44]. For simplicity we take the number of inputs to be equal to the number of outputs $|I|=|O|$, but all statements and proofs can be easily extended to the cases $|O|\gt |I|$ ($|O|\lt |I|$ is not allowed as this would mean information is lost). The final Hamiltonian will be ${{H}_{f}}=-\gamma {{\sum }_{v}}{{X}_{i}}$, and the transition will be done in steps, as in the cluster-state case. Indeed if the graph is a cluster (2D lattice) our model reduces to adiabatic cluster-state quantum computation (and ${{T}_{v}}={{K}_{g(v)}}$, as g(v) contains only one element).

To perform the computation, the T_v can be replaced one-by-one in an order that doesnʼt violate the gflow, or those in the same layer can be replaced all at once. Replacing them one-by-one will take N steps of time ${{\tau }_{0}}$. When replacing layer by layer, the adiabatic transition for the kth step is governed by the interpolation Hamiltonian

$$\begin{eqnarray}&&{{H}_{{{L}_{k}}}}(s)=-\gamma \left( \mathop{\sum }\limits_{v\lt {{L}_{k}}}{{X}_{v}}+\mathop{\sum }\limits_{v\gt {{L}_{k}}}{{T}_{v}} \right)-\gamma \left( \mathop{\sum }\limits_{v\in {{L}_{k}}}(1-s){{T}_{v}}+s{{X}_{v}} \right)\end{eqnarray} \tag{ 21 }$$

$$\begin{eqnarray}&&=(1-s){{H}_{k-1}}+s{{H}_{k}},\end{eqnarray} \tag{ 22 }$$

where

$$\begin{eqnarray}&&{{H}_{k}}=\gamma \left( -\mathop{\sum }\limits_{v\leqslant {{L}_{k}}}{{X}_{v}}-\mathop{\sum }\limits_{v\gt {{L}_{k}}}{{T}_{v}} \right).\end{eqnarray} \tag{ 23 }$$

Note that ${{[{{X}_{u}},{{T}_{v}}]}_{u\ne v}}=0$ for any $u,v\in {{L}_{k}}$. Using this property and the analysis in appendix B, we see that the time taken to perform the adiabatic evolution of Hamiltonian ${{H}_{{{L}_{k}}}}(s)$ scales with $\Omega (|{{L}_{k}}{{|}^{1+\delta }})$, where $0\lt \delta \leqslant 1$. Interestingly the dependence of the time on $|{{L}_{k}}|$ does not come from the energy gap Δ, which remains constant and independent of $|{{L}_{k}}|$, rather it comes from the norm $||\dot{H}||$, which scales as $|{{L}_{k}}|$. In this way we can replace all operators T_v in the same layer simultaneously, but the adiabatic runtime for each layer scales as the size of each layer $|{{L}_{k}}|$. This point highlights a subtlety of the adiabatic theorem as applied here—the time is dominated by the norm $\parallel \dot{H}\parallel$, not the energy gap Δ as is more commonly the case.

Now consider what happens to the information when we replace all T_v operators defined above with an X_v operator, in the order given by gflow. This can be seen by multiplying logical operators with stabilizers in such a way that the logical operators commute with all the adiabatic 'measurements' [6] (as illustrated for the 1D chain graph in section 2.3). If there are any Z_v or Y_v operators which appear in a logical operator α, the gflow conditions guarantee that multiplying these terms by T_v will either give the identity or an X_v operator at vertex v, and the new logical operator will commute with any X_w for $w\leqslant v$. This means that it is possible to update the logical operators ${{\alpha }_{L}}$, to ${{\tilde{\alpha }}_{L}}$ such that $[{{\tilde{\alpha }}_{L}},{{X}_{v}}]=0$ for all v which are not outputs, and where $\alpha =X,Y,Z$. The output of the computation is encoded in these final logical operators, after setting ${{X}_{v}}\to {{\mathbb{1}}_{v}}$ for all v which are non-outputs.

To see that this performs the same computation as in MBQC, consider performing MBQC on a twisted graph state. If we start with the logical operators ${{X}_{L}},{{Z}_{L}}$ of the MBQC resource state, and update these logical operators ${{\alpha }_{L}}$, to ${{\tilde{\alpha }}_{L}}$ such that $[{{\tilde{\alpha }}_{L}},{{X}_{v}}]=0$ for all v, then all measurements in the X basis commute with these operators. Therefore if we start in the +1 eigenstate of the logical operators, after the measurements the final state will be the +1 eigenstate of ${{\tilde{\alpha }}_{L}}$ (after corrections have been applied). Indeed, the procedure outlined above for updating the logical operators is essentially the same process given by gflow for tracing the logical operators in MBQC in the Heisenberg picture as in [45], thus the computation is clearly identical.

This is summarized in the following theorem.

Theorem 1. Any measurement based computation on an open graph state $|G\rangle$ of N qubits which is the ground state of a Hamiltonian H and which has gflow g and depth d can be efficiently converted into an adiabatically driven computation for which

• The adiabatic computation can be done in d steps, where the energy gap for each step is the same, and $||\dot{H}||=|{{L}_{j}}|$ for the jth step. Thus the time to perform the jth step is $\Omega (|{{L}_{j}}{{|}^{1+\delta }})$, where $0\lt \delta \leqslant 1$.
• The maximum degree of the initial Hamiltonian, ${{k}_{{\rm max} }}$, is equal to the maximum gflow size : ${{k}_{{\rm max} }}=|g(v){{|}_{{\rm max} }}$.
• The initial Hamiltonian can be computed efficiently.

For example, for adiabatic cluster-state quantum computation on a rectangular graph qubits with r rows and d columns, $g(v)=v+r$, ${{T}_{v}}={{K}_{v+r}}$, $|g(v)|\leqslant 5$ and there are d layers, with each layer containing r qubits, so the time for each layer scales as $\Omega (|r{{|}^{1+\delta }})$.

In the above theorem we have performed the computation step-by-step mimicking the measurement pattern in MBQC. We could also replace all of the T_v operators at the same time regardless of which layers they are in, and the resulting computation would be the same, however the results in [42] suggests that the energy gap for such an evolution would shrink polynomially in the depth. Since it is desirable to keep the gap as large as possible to provide protection against errors, and since it is hard to find (analytically or numerically) the energy gaps of systems other than simple 1D chains when doing a one step transition, we do not follow this approach here.

Note that, for all known universal graphs there is a gflow for which $|g(v)|$ is bounded, so typically the degree will also be bounded. However this is not necessarily the case for all families of graphs; in some cases it can scale with the number of inputs (we will see an example of this in section 3.2). This raises an important question: Do we regard this increase in degree as a free resource, or is there a cost associated with it? The evidence to date would suggest that the latter is true, since typically in nature we only see two-body interactions, with higher degree interactions resulting as a low energy approximation. We take this approach in our model, and assume that degree is bounded and such high degree Hamiltonians must be simulated. There are known methods for constructing such large degree operators from two-local operators using perturbation gadgets [19, 46–48]. In particular we use the results from [19], that we can create k-local Hamiltonians H_k using a perturbative Hamiltonian acting on rk ancilla qubits and n computational qubits (r is the number of terms in Hamiltonian with degree k, which we consider as being fixed). The result is that the effective Hamiltonian, apart from some overall energy shift, is

$$\begin{eqnarray}&&{{\tilde{H}}_{{\rm eff}}}=\frac{-k{{(-\lambda )}^{k}}}{(k-1)!}{{H}_{k}}\otimes {{P}_{+}}+O({{\lambda }^{k+1}}),\end{eqnarray} \tag{ 24 }$$

where ${{P}_{+}}$ is a projector on the space of r ancilla qubits, projecting each one into the $|+\rangle$ state, and the perturbation converges provided that $\lambda \lt \frac{k-1}{4k}$.

This energy gap decreases exponentially with k, therefore if we make the reasonable assumption that interactions in nature are limited to two (or a finite number) of bodies, then if the degree is allowed to scale with N, this imposes a prohibitive cost in that the minimum energy gap of the system shrinks exponentially, and so therefore the adiabatic time grows exponentially. This is not a general result, since (as far as the authors are aware) there is no general theorem saying that the gap must shrink when approximating k-body Hamiltonians, but it is a intuitive result that we would expect to be true.

In the previous subsection we saw how any MBQC computation with gflow can be mapped to a HQC. We now explore how the trade-off between quantum and classical time seen in MBQC [37] translates into this adiabatically driven model. First, as an illuminating example, consider the graph in figure 2 which was presented in [37] and gives rise to a trade-off between classical and quantum times in MBQC. Many different gflows can be defined on this graph, in particular a family of gflows can be defined as

$$\begin{eqnarray}{{g}^{r}}(v)=\left\{ \begin{array}{ccccccccccccccc} \{N+v,\ldots ,N+v+r-1\}, & \quad {\rm if}\;\;v+r-1\leqslant N, \\ \{N+v,\ldots ,2N\}, & \quad {\rm if}\;\;v+r-1\gt N, \\ \end{array} \right.\end{eqnarray} \tag{ 25 }$$

where $1\leqslant r\leqslant N$. For a gflow g^r, r measurements can be performed simultaneously, interspersed by classical processing. Corrections on qubits will be of the form ${{X}^{{{s}_{1}}+{{s}_{2}}+\cdots {{s}_{m}}}}$, where the s_m are binary variables accounting for the measurement outcomes. Thus the classical processing involves a binary sum of the results of these r measurement outcomes, and so takes time $O({\rm log} r)$ [49]. There is also classical processing required on the outputs, which involves the same number of terms to be added and so can also be done in time $O({\rm log} r)$ (each output requires addition of r binary variables or less, and these additions can be done in parallel). Since we can perform r measurements simultaneously, the measurement depth d^r is given by ${{d}^{r}}=\left \lceil \frac{N}{r}\right \rceil$, and the size of the gflow is $|{{g}^{r}}(v)|\leqslant r+2$.

Zoom In Zoom Out Reset image size

The two extreme cases are where r = 1 or r = N. The former is just where each measurement is performed one-by-one (${{d}^{1}}=N$), with no addition of binary variables in between. The latter is where we can perform all measurements simultaneously (d^N = 1), but we must perform corrections on the outputs which take time $O({\rm log} N)$. g^N is called the maximally delayed flow associated with this graph, whilst g¹ is the minimally delayed flow [41]. Since classical computation is typically a cheap resource, it is usually desirable to shift as much computation into classical processors as possible, and so in MBQC the optimal gflow to choose would be the maximally delayed gflow.

Following the conversion of these gflows into an adiabatically driven computation, we can perform the computation in d adiabatic steps, where the time to perform the jth layer scales as $\Omega (|{{L}_{j}}{{|}^{1+\delta }})$, and the maximum degree is given by the influencing volume. Thus g^r is converted into an adiabatic computation which has d^r steps, and each step takes $\Omega ({{r}^{1+\delta }})$ time, and the Hamiltonian degree $k=r+2$. In the most extreme case, g^N is converted into an adiabatic computation which takes one step, but this step takes $\Omega ({{N}^{1+\delta }})$ time to complete, and the Hamiltonian degree is proportional to N. In all cases the total time for computation is $\Omega ({{N}^{1+\delta }})$.

In this way the trade-off in quantum time (d^r) versus classical time (${\rm log} (r)$) that is facilitated by the use of gflow in MBQC, translates to a trade-off between the number of steps $({{d}^{r}})$ and the degree of the initial Hamiltonian (r), as well as the norm $||\dot{H}||$ ($\leqslant r+2$). However, even though the minimum energy gap is kept constant, the fact that the norm $||\dot{H}||$ scales with N means that there is no overall gain in time for the adiabatic computation. This result highlights the subtlety in the adiabatic theorem; although the minimum energy gap is the same for graphs of different flow, the size of $||\dot{H}||$ changes and leads to a dependence of the adiabatic time on the number of elements in a gflow. We also see that whereas in MBQC there is an advantage in using maximally delayed gflow, there is no such advantage for the AGQC case. Indeed, given that the maximally delayed gflow is accompanied by large (possibly unbounded) degree operators, and these Hamiltonians are likely to incur an exponentially decreasing energy gap, in AGQC it is better to use the minimally delayed gflow instead.

In MBQC it is only possible to perform measurements in one step for certain computations. A natural question to ask is whether or not the trade-off seen above in the application of theorem 1 to the zig-zag graph extends to more general computations, and can be extended to allow any computation to proceed in a constant time at the expense of high degree. If there was a way of implementing arbritrary computations instantly at the expense of increasing the degree only, then under reasonable assumptions this would imply an upper bound on the energy gap required for simulating such high degree operators. Such an upper bound would give an important fundamental limitation on the cost of large degree Hamiltonians, which does not currently exist.

To perform an AGQC on an arbitrary graph in one step, following the logic leading to theorem 1, we must find a transformation of the stabilizers ${{T}_{v}}\to {{\tilde{T}}_{v}}$ such that all of the ${{\tilde{T}}_{v}}$ stabilizers satisfy the commutation relations

$$\begin{eqnarray}&&[{{\tilde{T}}_{v}},{{X}_{w}}]=0\;\;{\rm for}\;{\rm all}\;\;v\ne w\;{\rm in}\;V\backslash O.\end{eqnarray} \tag{ 26 }$$

Then all of the stabilizers ${{\tilde{T}}_{v}}$ can be replaced at the same time, provided the adiabatic runtime scales as $\Omega (|N{{|}^{1+\delta }})$.

This transformation can be achieved by multiplying the ${{\tilde{T}}_{v}}$ stabilizers together. Gflow always allows such a procedure, since whenever a stabilizer T_w contains a Z_v or Y_v operator, these can be multiplied by T_v, giving identity or X_v, respectively, such that the resulting stabilizer commutes with X_v. Here we define a specific choice of such a procedure to make all stabilizers commute with all Pauli X operators. To update stabilizer T_v, we start in layer ${{L}_{n+1}}$, where ${{L}_{n}}=L(v)$, and proceed as follows; (1) if T_v contains a Z_w or Y_w term such that $w\in {{L}_{n+1}}$, multiply by T_w. (2) Proceed to the next layer, as determined by the time order. Iterate until the outputs are reached. (3) The final updated stabilizers are denoted ${{\tilde{T}}_{v}}$.

However, creating a Hamiltonian in this way is polynomially equivalent to simulating the computation by following the evolution of the logical operators (see e.g. [45]), which we have already used in our discussion of making general measurement patterns adiabatic. Or to put it another way, this procedure is only efficient for certain classes of operations. For Clifford operations the procedure takes polynomial time; if we have N qubits in total, we will have to perform one updating sweep per qubit, each sweep involves a search over at most N stabilizers to see whether they commute or anti-commute, and the cost of testing if a stabilizer commutes or not will be O(N) since each stabilizer contains at most N terms, so the overall procedure takes $O({{N}^{2}})$ steps. For general angles the procedure takes an exponential amount of time, since at every step we replace a Z_v operator with a ${{Z}_{v}}{{T}_{v}}={{{\rm e}}^{-{\rm i}{{\theta }_{v+1}}{{Z}_{v+1}}}}{{X}_{v+1}}{{Z}_{v+2}}$ term, so every update converts a Z term into three new terms after expanding the exponent. If we start off with a stabilizer containing n Z operators, then after r sweeps we will have $O({{3}^{r}}n)$ operators to search through.

In addition, during this update procedure, we multiply every Z_w operator by ${{T}_{v}}=\prod _{w\in g(v)}^{{}}K_{w}^{{}}$. So following this procedure, each ${{\tilde{T}}_{v}}$ operator will have Pauli Xʼs in positions g(w) for every Z_w that has been have corrected for. The only parts that will contribute to the degree of ${{\tilde{T}}_{v}}$ are situated at vertices which can be arrived at by following a path on which a non-gflow line is preceded and followed by a gflow line. Following the discussion in section 3.1 we expect the simulation of these Hamiltonians to be very prohibitive.

As noted in section 3.1, an alternative way to perform all operations in one step is to just replace all stabilizers at once, without changing the form of the stabilizers, and we would expect the energy gap to shrink polynomially in N for AGQC [42]. This alludes to another complementary trade-off between the energy gap and the number of steps in the computation.

In summary, we see that in AGQC it is always possible to perform the computation in one step, at the expense of increasing $||\dot{H}||$ and the degree of operators in the initial Hamiltonian. This means that there is no decrease in the overall computation time. In addition, the process of finding the initial Hamiltonian is closely linked to the classical simulation of the computation itself, and thus can also only be efficiently calculated for simple cases such as Clifford computations. We see that reducing the number of steps in the computation has no advantage in overall computation time. Furthermore, given the exponentially decreasing energy gap for the known methods of simulating large-degree operators, this suggests that the optimal way to perform AGQC is to keep the degree as low as possible, which in general means as many steps as possible. In the language of MBQC, this corresponds to using the minimally-delayed gflow for the computation.

We start with an N-qubit 1D chain with $N-1$ stabilizer generators (i.e. one qubit is encoded in the chain), and we consider replacing one stabilizer generator by one Pauli operator in a different order to the corresponding measurement pattern in MBQC. As a physical motivation we may imagine that we have some experimental apparatus which is limited to only applying the T and X operators, and which can turn them on in any combination. We would like to find orders of replacements which keep the system in the 2D logical subspace, and we might expect from MBQC that changing the order will in some way disrupt the computation. As an example, consider a four-qubit chain with all angles set to zero (i.e. with untwisted stabilizer generators). The system is initialized in the ground state of the Hamiltonian

$$\begin{eqnarray}&&{{H}_{0}}=-{{T}_{1}}-{{T}_{2}}-{{T}_{3}}.\end{eqnarray} \tag{ 27 }$$

Clearly it is possible to replace ${{T}_{2}}\to {{X}_{2}}$ out of order, since $[{{T}_{1}},{{X}_{2}}]=0$. However, if T₃ is replaced with X₃ out-of-order, this leads to the time-dependent Hamiltonian

$$\begin{eqnarray}&&H(s)=-{{T}_{1}}-{{T}_{2}}-(1-s){{T}_{3}}-s{{X}_{3}},\quad \;{\rm with}\;0\leqslant s\leqslant 1.\end{eqnarray} \tag{ 28 }$$

At s = 1, this Hamiltonian has a ground state degeneracy of 4, i.e. the degeneracy doubles. However, there is a constraint in that the operator ${{T}_{1}}{{T}_{3}}$ commutes with H(s) for all s and so the eigenstate of ${{T}_{1}}{{T}_{3}}$ is conserved throughout the evolution. Therefore, since the system starts in the +1 eigenspace of ${{T}_{1}}{{T}_{3}}$, it will also end in the +1 eigenspace of ${{T}_{1}}{{T}_{3}}$. So although the gap closes, the transitions between these degenerate eigenstates are forbidden and so the logical subspace is preserved.

Now consider replacing T₁ in (28) with X₁. Throughout this evolution, ${{T}_{1}}{{T}_{3}}$ no longer commutes with H(s), and so unless there is a stabilizer generator that can be multiplied with ${{T}_{1}}{{T}_{3}}$ to make it commute with H(s), the evolution is no longer constrained to the +1 eigenspace of ${{T}_{1}}{{T}_{3}}$. It is easy to check that there are no remaining stabilizer generators which satisfy this property, since this requires a generator with a Z₁ term (and T₁ cannot be used since it doesnʼt commute with X₃ or X₁). Since at the very start of the ${{T}_{1}}\to {{X}_{1}}$ evolution, the energy gap is zero and the subspace is no longer preserved, this means the information now leaks out of the subspace unless the evolution time $\tau \to \infty$. Thus the computation fails at the final step for this ordering. Note that this happens whether or not T₂ is replaced by X₂; the key part was the fact that there were no stabilizer generators left to multiply ${{T}_{1}}{{T}_{3}}$ with to make it commute with H(s).

Extending this to larger chains, whenever T_n is replaced with X_n such that $n\gt 2$, the evolution is still constrained to the +1 eigenspace of ${{T}_{n-2}}{{T}_{n}}$. If this 'hidden' stabilizer anticommutes with the next Pauli replacement X_m, then provided we can multiply by ${{T}_{m-2}}$ the subspace is still preserved. But since at some point we need to replace ${{T}_{1}}\to {{X}_{1}}$ or ${{T}_{2}}\to {{X}_{2}}$, and there are no other stabilizer generators to multiply with to make sure that the 'hidden' stabilizer still commutes with H(s), the computation fails as there will be zero energy gap and a non-zero matrix element to leak out of the 2D logical subspace.

Similar behaviour can be seen when the angles $\{{{\theta }_{v}}\}$ are all odd multiples of $\pi /2$ (corresponding to Y measurements). Again, using untwisted stabilizer generators, consider a Hamiltonian on three sites, $H={{T}_{1}}+{{T}_{2}}$. After replacing ${{T}_{2}}\to {{Y}_{2}}$, the system is still in a 2D subspace since $[{{T}_{1}}{{T}_{2}},H(s)]=0$ and so the subspace where ${{T}_{1}}{{T}_{2}}$ has eigenvalue +1 is preserved. However, after replacing ${{T}_{1}}\to {{Y}_{1}}$, there are no stabilizer generators which can be chosen, and so the computation fails at the last step. This argument can similarly be extended to larger chains, and just like in the above case we will find that once we reach the boundary the computation time has to go to infinity to avoid leakage.

Similar behaviour is also seen for the CNOT gate proposed in [6] and discussed in appendix A. Consider two rows of qubits, labelled a and b, with three columns numbered from left to right. The initial Hamiltonian is

$$\begin{eqnarray}\begin{array}{rcl} {{H}_{{\rm CNOT}}} & = & -{{T}_{a1}}-{{T}_{a2}}-{{T}_{b1}}-{{T}_{b2}} \\ {} & {} & -{{Z}_{a1}}{{X}_{a2}}{{Z}_{a3}}{{Z}_{b2}}-{{Z}_{a2}}{{Z}_{b1}}{{X}_{b2}}{{Z}_{b3}}-{{Z}_{a2}}{{X}_{a3}}-{{Z}_{b2}}{{X}_{b3}}. \\ \end{array}\end{eqnarray} \tag{ 29 }$$

Although ${{T}_{a2}}\to {{X}_{a2}}$ can be replaced out of order without leaking out of the four-dimensional subspace (since the operator ${{T}_{b1}}{{T}_{a2}}$ is conserved), then when ${{T}_{a1}}\to {{X}_{a1}}$ is replaced afterwards, the computation fails. Thus we have seen that, with this approach, the only replacements in 1 dimension which can preserve the subspace are replacements with X_n with $n\leqslant 2$, and replacements by Y_n with $n\leqslant 1$, and no out-of-order measurements are possible for the CNOT gate.

What about more general angles? Since both X_n and Y_n measurements fail when $n\gt 2$, and any general measurement is a superposition of X and Y measurements, we might expect that any general measurement fails for $n\gt 2$. So we try replacements starting on the second site for general angles, i.e. replacements of the form

$$\begin{eqnarray}&&-\mathop{\sum }\limits_{n=1}^{N-1}{{T}_{n}}\to -{{T}_{1}}-X_{2}^{{{\theta }_{2}}}-\mathop{\sum }\limits_{n=3}^{N-1}{{T}_{n}}.\end{eqnarray} \tag{ 30 }$$

The energy gap ${{\Delta }_{1}}$ for such a process is given by

$$\begin{eqnarray}&&{{\Delta }_{1}}({{\theta }_{2}},s)=\sqrt{2(1-s+{{s}^{2}})+\Gamma ({{\theta }_{2}},s)}-\sqrt{2(1-s+{{s}^{2}})-\Gamma ({{\theta }_{2}},s)},\end{eqnarray} \tag{ 31 }$$

where $\Gamma (\theta ,s)\equiv \sqrt{2{{s}^{2}}{\rm cos} 2{{\theta }_{2}}+(4-8s+6{{s}^{2}})}$. For a given ${{\theta }_{2}}$, this reaches a minimum at $s=(1-\frac{1}{2}{\rm cos} {{\theta }_{2}})$. Thus for all ${{\theta }_{2}}$, the minimum energy gap $\Delta _{1}^{{\rm min} }$ is given by

$$\begin{eqnarray}&&\Delta _{1}^{{\rm min} }({{\theta }_{2}})={{\Delta }_{1}}\left( {{\theta }_{2}},1-\frac{1}{2}{\rm cos} {{\theta }_{2}} \right).\end{eqnarray} \tag{ 32 }$$

Over all possible ${{\theta }_{2}}$ values, $\Delta _{1}^{{\rm min} }({{\theta }_{2}})$ is largest for ${{\theta }_{2}}=l\pi ,s=1/2$, and goes to zero when ${{\theta }_{2}}=(2l+1)\pi /2,s=1$, where l is an integer.

So we see that, for angles ${{\theta }_{2}}$ such that the minimum energy gap remains non-zero, it is possible to perform the computation out-of-order. While the information remains in a protected subspace, it is also necessary to check if the information is transformed in the expected way. To see this, we start with the logical operators ${{X}_{L}}\equiv {{X}_{1}}{{Z}_{2}},\ {{Z}_{L}}\equiv {{Z}_{1}}$ (excluding Y_L since ${{Y}_{L}}={\rm i}{{Z}_{L}}{{X}_{L}}$). Using the method in [6], these operators are multiplied by stabilizers to make them commute with the 'measurements'. The appropriate transformation for the above case would be

$$\begin{eqnarray*}&&{{X}_{L}}\to {{X}_{L}}{{T}_{2}}={{X}_{1}}X_{3}^{{{\theta }_{3}}}{{Z}_{4}},\end{eqnarray*}$$

$$\begin{eqnarray}&&{{Z}_{L}}\to {{Z}_{L}}{{T}_{1}}={{{\rm e}}^{-{\rm i}{{\theta }_{2}}{{Z}_{2}}}}{{X}_{2}}{{Z}_{3}}\to {{{\rm e}}^{-{\rm i}{{\theta }_{2}}{{Z}_{2}}{{T}_{2}}}}{{X}_{2}}{{Z}_{3}}={{{\rm e}}^{-{\rm i}{{\theta }_{2}}X_{3}^{{{\theta }_{3}}}{{Z}_{4}}}}{{X}_{2}}{{Z}_{3}}.\end{eqnarray} \tag{ 33 }$$

This is exactly the same transformation we would make in the normal computation, except two steps have been performed at once. Both of these logical operators are in a form which commute with X₁ and X₂, so they commute with the time-dependent Hamiltonian, and so, for example, if the system starts in the +1 eigenstate of X_L, it will end up in the +1 eigenstate of $X_{3}^{{{\theta }_{3}}}{{Z}_{4}}$.

In summary, we have seen that if we simply replace T_n stabilizer generators with X_n operators one-by-one on a 1D chain, we are extremely restricted in what we can do, and reordering is only possible using measurement angles which are not odd multiples of $\frac{\pi }{2}$. In particular, in a 1D chain, we can only start by replacing the stabilizer at the first site or the second site. The information stored in the chain is transformed in the same way in both cases, however the latter only works for ${{\theta }_{2}}\ne (2n+1)\frac{\pi }{2}$, and the energy gap depends on ${{\theta }_{2}}$ so the speed of the adiabatic substitution must vary.

We have seen that the initial approach to re-ordering the operations works only for a limited case. This is perhaps expected, as the way we have performed the out-of-order operations so far is not a proper reflection of what happens in MBQC. For instance, in MBQC measuring a qubit destroys any entanglement on edges connected to that qubit. This is clearly not true above, since we end up with Hamiltonians containing terms such as ${{T}_{1}}+{{T}_{2}}+{{X}_{3}}$. So a more natural way to perform the out-of-order measurements would be to remove all entanglement to measured qubits, or just remove all anticommuting terms entirely [50]. Take the chain considered above:

$$\begin{eqnarray}&&{{H}_{0}}=-{{T}_{1}}-{{T}_{2}}-{{T}_{3}}.\end{eqnarray} \tag{ 34 }$$

Now if T₃ is replaced by X₃, any other operators which anticommute with X₃ are also removed, i.e. the final Hamiltonian is

$$\begin{eqnarray}&&{{H}_{1}}=-{{T}_{2}}-{{X}_{3}}.\end{eqnarray} \tag{ 35 }$$

Notice that the operator ${{T}_{1}}{{T}_{3}}$ is still conserved, as in the previous subsection. Instead of replacing T₁ with X₁, $-{{X}_{1}}$ can be added to the Hamiltonian, and the system is still constrained to be within a 2D subspace. This would also work if we had instead just removed all entanglement to site 3 (except T₂ can be left untouched since it commutes with X₃), i.e.

$$\begin{eqnarray}&&{{H}_{1}}=-{{Z}_{1}}{{X}_{2}}-{{T}_{2}}-{{X}_{3}}.\end{eqnarray} \tag{ 36 }$$

The energy gap will still be the same when we introduce X₁ in equation (35) to when we replace ${{Z}_{1}}{{X}_{2}}\to {{X}_{1}}$ in equation (36), since the Hamiltonian is of the form $(1-s){{Z}_{1}}\otimes A+s{{X}_{1}}$ and so has energy gap $2\eta =2\sqrt{1-2s+2{{s}^{2}}}$ (appendix B).

Similar results hold for Y measurements or the CNOT gate, so that Clifford operations can be performed in any order. Note that if more than one operator is replaced at the same time, the number of anticommuting terms increases, and based on the numerical studies in [42], if the number of anticommuting terms scales with n we would expect the energy gap to be polynomial in $1/n$.

In summary, we have seen that Clifford operations can be done in any order, provided that either the stabilizer generators are modifed so that the entanglement to 'measured' sites is destroyed, or any stabilizer generators which anticommute with the measurement operator are removed entirely. This is in contrast to the method in the previous subsection, in which the stabilizer generators did not reflect what happens in MBQC, and in which the re-ordering is limited to performing alternating measurements from left to right. In both of the approaches considered, Clifford operations cannot be performed all in one step, since we would expect the energy gap to decrease polynomially in the number of stabilizer generators we replace.