# What are the models of quantum computation?

It seems that quantum computing is often taken to mean the quantum circuit method of computation, where a register of qubits is acted on by a circuit of quantum gates and measured at the output (and possibly at some intermediate steps). Quantum annealing at least seems to be an altogether different method to computing with quantum resources1, as it does not involve quantum gates.

What different models of quantum computation are there? What makes them different?

To clarify, I am not asking what different physical implementations qubits have, I mean the description of different ideas of how to compute outputs from inputs2 using quantum resources.

1. Anything that is inherently non-classical, like entanglement and coherence.
2. A process which transforms the inputs (such as qubits) to outputs (results of the computation).

## 6 Answers

### The adiabatic model

This model of quantum computation is motivated by ideas in quantum many-body theory, and differs substantially both from the circuit model (in that it is a continuous-time model) and from continuous-time quantum walks (in that it has a time-dependent evolution).

Adiabatic computation usually takes the following form.

1. Start with some set of qubits, all in some simple state such as $\lvert + \rangle$. Call the initial global state $\lvert \psi_0 \rangle$.
2. Subject these qubits to an interaction Hamiltonian $H_0$ for which $\lvert \psi_0 \rangle$ is the unique ground state (the state with the lowest energy). For instance, given $\lvert \psi_0 \rangle = \lvert + \rangle^{\otimes n}$, we may choose $H_0 = - \sum_{k} \sigma^{(x)}_k$.
3. Choose a final Hamiltonian $H_1$, which has a unique ground state which encodes the answer to a problem you are interested in. For instance, if you want to solve a constraint satisfaction problem, you could define a Hamiltonian $H_1 = \sum_{c} h_c$, where the sum is taken over the constraints $c$ of the classical problem, and where each $h_c$ is an operator which imposes an energy penalty (a positive energy contribution) to any standard basis state representing a classical assignment which does not satisfy the constraint $c$.
4. Define a time interval $T \geqslant 0$ and a time-varying Hamiltonian $H(t)$ such that $H(0) = H_0$ and $H(T) = H_1$. A common but not necessary choice is to simply take a linear interpolation $H(t) = \tfrac{t}{T} H_1 + (1 - \tfrac{t}{T})H_0$.
5. For times $t = 0$ up to $t = T$, allow the system to evolve under the continuously varying Hamiltonian $H(t)$, and measure the qubits at the output to obtain an outcome $y \in \{0,1\}^n$.

The basis of the adiabatic model is the adiabatic theorem, of which there are several versions. The version by Ambainis and Regev [ arXiv:quant-ph/0411152 ] (a more rigorous example) implies that if there is always an "energy gap" of at least $\lambda > 0$ between the ground state of $H(t)$ and its first excited state for all $0 \leqslant t \leqslant T$, and the operator-norms of the first and second derivatives of $H$ are small enough (that is, $H(t)$ does not vary too quickly or abruptly), then you can make the probability of getting the output you want as large as you like just by running the computation slowly enough. Furthermore, you can reduce the probability of error by any constant factor just by slowing down the whole computation by a polynomially-related factor.

Despite being very different in presentation from the unitary circuit model, it has been shown that this model is polynomial-time equivalent to the unitary circuit model [ arXiv:quant-ph/0405098 ]. The advantage of the adiabatic algorithm is that it provides a different approach to constructing quantum algorithms which is more amenable to optimisation problems. One disadvantage is that it is not clear how to protect it against noise, or to tell how its performance degrades under imperfect control. Another problem is that, even without any imperfections in the system, determining how slowly to run the algorithm to get a reliable answer is a difficult problem — it depends on the energy gap, and it isn't easy in general to tell what the energy gap is for a static Hamiltonian $H$, let alone a time-varying one $H(t)$.

Still, this is a model of both theoretical and practical interest, and has the distinction of being the most different from the unitary circuit model of essentially any that exists.

### Measurement-based quantum computation (MBQC)

This is a way to perform quantum computation, using intermediary measurements as a way of driving the computation rather than just extracting the answers. It is a special case of "quantum circuits with intermediary measurements", and so is no more powerful. However, when it was introduced, it up-ended many people's intuitions of the role of unitary transformations in quantum computation. In this model one has constraints such as the following:

1. One prepares, or is given, a very large entangled state — one which can be described (or prepared) by having some set of qubits all initially prepared in the state $\lvert + \rangle$, and then some sequence of controlled-Z operations $\mathrm{CZ} = \mathrm{diag}(+1,+1,+1,-1)$, performed on pairs of qubits according to the edge-relations of a graph (commonly, a rectangular grid or hexagonal lattice).
2. Perform a sequence of measurements on these qubits — some perhaps in the standard basis, but the majority not in the standard basis, but instead measuring observables such as $M_{\mathrm{XY}}(\theta) = \cos(\theta) X - \sin(\theta) Y$ for various angles $\theta$. Each measurement yields an outcome $+1$ or $-1$ (often labelled '0' or '1' respectively), and the choice of angle is allowed to depend in a simple way on the outcomes of previous measurements (in a way computed by a classical control system).
3. The answer to the computation may be computed from the classical outcomes $\pm 1$ of the measurements.

As with the unitary circuit model, there are variations one can consider for this model. However, the core concept is adaptive single-qubit measurements performed on a large entangled state, or a state which has been subjected to a sequence of commuting and possibly entangling operations which are either performed all at once or in stages.

This model of computation is usually considered as being useful primarily as a way to simulate unitary circuits. Because it is often seen as a means to simulate a better-liked and simpler model of computation, it is not considered theoretically very interesting anymore to most people. However:

• It is important among other things as a motivating concept behind the class IQP, which is one means of demonstrating that a quantum computer is difficult to simulate, and Blind Quantum Computing, which is one way to try to solve problems in secure computation using quantum resources.

• There is no reason why measurement-based computations should be essentially limited to simulating unitary quantum circuits: it seems to me (and a handful of other theorists in the minority) that MQBC could provide a way of describing interesting computational primitives. While MBQC is just a special case of circuits with intermediary measurements, and can therefore be simulated by unitary circuits with only polynomial overhead, this is not to say that unitary circuits would necessarily be a very fruitful way of describing anything that one could do in principle in a measurement-based computation (just as there exists imperative and functional programming languages in classical computation which sit a little ill-at-ease with one another).

The question remains whether MBQC will suggest any way of thinking about building algorithms which is not as easily presented in terms of unitary circuits — but there can be no question of a computational advantage or disadvantage over unitary circuits, except one of specific resources and suitability for some architecture.

• MBQC can be seen as the underlying idea behind some error correcting codes, such as the surface code. Mainly in the sense that the surface code corresponds to a 3d lattice of qubits with a particular set of CZs between them that you then measure (with the actual implementation evaluating the cube layer by layer). But perhaps also in the sense that the actual surface code implementation is driven by measuring particular stabilizers. – Craig Gidney Sep 17 '18 at 15:51
• However, the way in which the measurement outcomes are used differ substantially between QECCs and MBQC. In the idealised case of no or low rate of uncorrelated errors, any QECC is computing the identity transformation at all times, the measurements are periodic in time, and the outcomes are heavily biased towards the +1 outcome. For standard constructions of MBQC protocols, however, the measurements give uniformly random measurement outcomes every time, and those measurements are heavily time-dependent and driving non-trivial evolution. – Niel de Beaudrap Sep 17 '18 at 15:57
• Is that a qualitative difference or just a quantitative one? The surface code also has those driving operations (e.g. braiding defects and injecting T states), it just separates them by the code distance. If you set the code distance to 1, a much higher proportion of the operations matter when there are no errors. – Craig Gidney Sep 17 '18 at 16:07
• I would say that the difference occurs at a qualitative level as well, from my experience actually considering the effects of MBQC procedures. Also, it seems to me that in the case of braiding defects and T-state injection that it is not the error correcting code itself, but deformations of them, which are doing the computation. These are certainly relevant things one may do with an error corrected memory, but to say that the code is doing it is about the same level as saying that it is qubits which do quantum computations, as opposed to operations which one performs on those qubits. – Niel de Beaudrap Sep 17 '18 at 16:21

### The Unitary Circuit Model

This is the best well-known model of quantum computation. In this model one has constraints such as the following:

1. a set of qubits initialised to a pure state, which we denote $\lvert 0 \rangle$;
2. a sequence of unitary transformations which one performs on them, which may depend on a classical bit-string $x\in \{0,1\}^n$;
3. one or more measurements in the standard basis performed at the very end of the computation, yielding a classical output string $y \in \{0,1\}^k$. (We do not require $k = n$: for instance, for YES / NO problems, one often takes $k = 1$ no matter the size of $n$.)

Minor details may change (for instance, the set of unitaries one may perform; whether one allows preparation in other pure states such as $\lvert 1 \rangle$, $\lvert +\rangle$, $\lvert -\rangle$; whether measurements must be in the standard basis or can also be in some other basis), but these do not make any essential difference.

### Quantum circuits with intermediary measurements

This is a slight variation on "unitary circuits", in which one allows measurements in the middle of the algorithm as well as the end, and where one also allows future operations to depend on the outcomes of those measurements. It represents a realistic picture of a quantum processor which interacts with a classical control device, which among other things is the interface between the quantum processor and a human user.

Intermediary measurement is practically necessary to perform error correction, and so this is in principle a more realistic picture of quantum computation than the unitary circuit model. but it is not uncommon for theorists of a certain type to strongly prefer measurements to be left until the end (using the principle of deferred measurement to simulate any 'intermediary' measurements). So, this may be a significant distinction to make when talking about quantum algorithms — but this does not lead to a theoretical increase in the computational power of a quantum algorithm.

• I think this should go with the "unitary circuit model" post, they are both really just variations of the circuit model, and one does not usually really distinguish them as different models – glS Mar 26 '18 at 17:20
• @gIS: it is not uncommon to do so in the CS theory community. In fact, the bias is very much towards unitary circuits in particular. – Niel de Beaudrap Mar 26 '18 at 20:00

### Discrete-time quantum walk

A "discrete-time quantum walk" is a quantum variation on a random walk, in which there is a 'walker' (or multiple 'walkers') which takes small steps in a graph (e.g. a chain of nodes, or a rectangular grid). The difference is that where a random walker takes a step in a randomly determined direction, a quantum walker takes a step in a direction determined by a quantum "coin" register, which at each step is "flipped" by a unitary transformation rather than changed by re-sampling a random variable. See [ arXiv:quant-ph/0012090 ] for an early reference.

For the sake of simplicity, I will describe a quantum walk on a cycle of size $2^n$; though one must change some of the details to consider quantum walks on more general graphs. In this model of computation, one typically does the following.

1. Prepare a "position" register on $n$ qubits in some state such as $\lvert 00\cdots 0\rangle$, and a "coin" register (with standard basis states which we denote by $\lvert +1 \rangle$ and $\lvert -1 \rangle$) in some initial state which may be a superposition of the two standard basis states.
2. Perform a coherent controlled-unitary transformation, which adds 1 to the value of the position register (modulo $2^n$) if the coin is in the state $\lvert +1 \rangle$, and subtracts 1 to the value of the position register (modulo $2^n$) if the coin is in the state $\lvert -1 \rangle$.
3. Perform a fixed unitary transformation $C$ to the coin register. This plays the role of a "coin flip" to determine the direction of the next step. We then return to step 2.

The main difference between this and a random walk is that the different possible "trajectories" of the walker are being performed coherently in superposition, so that they can destructively interfere. This leads to a walker behaviour which is more like ballistic motion than diffusion. Indeed, an early presentation of a model such as this was made by Feynmann, as a way to simulate the Dirac equation.

This model also often is described in terms of looking for or locating 'marked' elements in the graph, in which case one performs another step (to compute whether the node the walker is at is marked, and then to measure the outcome of that computation) before returning to Step 2. Other variations of this sort are reasonable.

To perform a quantum walk on a more general graph, one must replace the "position" register with one which can express all of the nodes of the graph, and the "coin" register with one which can express the edges incident to a vertex. The "coin operator" then must also be replaced with one which allows the walker to perform an interesting superposition of different trajectories. (What counts as 'interesting' depends on what your motivation is: physicists often consider ways in which changing the coin operator changes the evolution of the probability density, not for computational purposes but as a way of probing at basic physics using quantum walks as a reasonable toy model of particle movement.) A good framework for generalising quantum walks to more general graphs is the Szegedy formulation [ arXiv:quant-ph/0401053 ] of discrete-time quantum walks.

This model of computation is strictly speaking a special case of the unitary circuit model, but is motivated with very specific physical intuitions, which has led to some algorithmic insights (see e.g. [ arXiv:1302.3143 ]) for polynomial-time speedups in bounded-error quantum algorithms. This model is also a close relative of the continuous-time quantum walk as a model of computation.

• if you want to talk about DTQWs in the context of QC you should probably include references to the work of Childs and collaborators (e.g. arXiv:0806.1972. Also, you are describing how DTQWs work, but not really how you can use them to do computation. – glS Mar 26 '18 at 17:23
• @gIS: indeed, I will add more details at some point: when I first wrote these it was to quickly enumerate some models and remark on them, rather than give comprehensive reviews. But as for how to compute, does the last paragraph not represent an example? – Niel de Beaudrap Mar 26 '18 at 20:05
• @gIS: Isn't that work by Childs et al. actually about continuous-time quantum walks, anyhow? – Niel de Beaudrap Oct 29 '18 at 20:22

# Quantum annealing

Quantum annealing is a model of quantum computation which, roughly speaking, generalises the adiabatic model of computation. It has attracted popular — and commercial — attention as a result of D-WAVE's work on the subject.

Precisely what quantum annealing consists of is not as well-defined as other models of computation, essentially because it is of more interest to quantum technologists than computer scientists. Broadly speaking, we can say that it is usually considered by people with the motivations of engineers, rather than the motivations of mathematicians, so that the subject appears to have many intuitions and rules of thumb but few 'formal' results. In fact, in an answer to my question about quantum annealing, Andrew O goes so far as to say that "quantum annealing can't be defined without considerations of algorithms and hardware". Nevertheless, "quantum annealing" seems is well-defined enough to be described as a way of approaching how to solve problems with quantum technologies with specific techniques — and so despite Andrew O's assessment, I think that it embodies some implicitly defined model of computation. I will attempt to describe that model here.

### Intuition behind the model

Quantum annealing gets its name from a loose analogy to (classical) simulated annealing. They are both presented as means of minimising the energy of a system, expressed in the form of a Hamiltonian: \begin{aligned} H_{\rm{classical}} &= \sum_{i,j} J_{ij} s_i s_j \\ H_{\rm{quantum}} &= A(t) \sum_{i,j} J_{ij} \sigma_i^z \sigma_j^z - B(t) \sum_i \sigma_i^x \end{aligned} With simulated annealing, one essentially performs a random walk on the possible assignments to the 'local' variables $s_i \in \{0,1\}$, but where the probability of actually making a transition depends on

• The difference in 'energy' $\Delta E = E_1 - E_0$ between two 'configurations' (the initial and the final global assignment to the variables $\{s_i\}_{i=1}^n$) before and after each step of the walk;
• A 'temperature' parameter which governs the probability with which the walk is allowed to perform a step in the random walk which has $\Delta E > 0$.

One starts with the system at 'infinite temperature', which is ultimately a fancy way of saying that you allow for all possible transitions, regardless of increases or decreases in energy. You then lower the temperature according to some schedule, so that time goes on, changes in state which increase the energy become less and less likely (though still possible). The limit is zero temperature, in which any transition which decreases energy is allowed, but any transition which increases energy is simply forbidden. For any temperature $T > 0$, there will be a stable distribution (a 'thermal state') of assignments, which is the uniform distribution at 'infinite' temperature, and which is which is more and more weighted on the global minimum energy states as the temperature decreases. If you take long enough to decrease the temperature from infinite to near zero, you should in principle be guaranteed to find a global optimum to the problem of minimising the energy. Thus simulated annealing is an approach to solving optimisation problems.

Quantum annealing is motivated by generalising the work by Farhi et al. on adiabatic quantum computation [arXiv:quant-ph/0001106], with the idea of considering what evolution occurs when one does not necessarily evolve the Hamiltonian in the adiabatic regime. Similarly to classical annealing, one starts in a configuration in which "classical assignments" to some problem are in a uniform distribution, though this time in coherent superposition instead of a probability distribution: this is achieved for time $t = 0$, for instance, by setting $$A(t=0) = 0, \qquad B(t=0) = 1$$ in which case the uniform superposition $\def\ket#1{\lvert#1\rangle}\ket{\psi_0} \propto \ket{00\cdots00} + \ket{00\cdots01} + \cdots + \ket{11\cdots11}$ is a minimum-energy state of the quantum Hamiltonian. One steers this 'distribution' (i.e. the state of the quantum system) to one which is heavily weighted on a low-energy configuration by slowly evolving the system — by slowly changing the field strengths $A(t)$ and $B(t)$ to some final value $$A(t_f) = 1, \qquad B(t_f) = 0.$$ Again, if you do this slowly enough, you will succeed with high probability in obtaining such a global minimum. The adiabatic regime describes conditions which are sufficient for this to occur, by virtue of remaining in (a state which is very close to) the ground state of the Hamiltonian at all intermediate times. However, it is considered possible that one can evolve the system faster than this and still achieve a high probability of success.

Similarly to adiabatic quantum computing, the way that $A(t)$ and $B(t)$ are defined are often presented as a linear interpolations from $0$ to $1$ (increasing for $A(t)$, and decreasing for $B(t)$). However, also in common with adiabatic computation, $A(t)$ and $B(t)$ don't necessarily have to be linear or even monotonic. For instance, D-Wave has considered the advantages of pausing the annealing schedule and 'backwards anneals'.

'Proper' quantum annealing (so to speak) presupposes that evolution is probably not being done in the adiabatic regime, and allows for the possibility of diabatic transitions, but only asks for a high chance of achieving an optimum — or even more pragmatically still, of achieving a result which would be difficult to find using classical techniques. There are no formal results about how quickly you can change your Hamiltonian to achieve this: the subject appears mostly to consist of experimenting with a heuristic to see what works in practise.

### The comparison with classical simulated annealing

Despite the terminology, it is not immediately clear that there is much which quantum annealing has in common with classical annealing. The main differences between quantum annealing and classical simulated annealing appear to be that:

• In quantum annealing, the state is in some sense ideally a pure state, rather than a mixed state (corresponding to the probability distribution in classical annealing);

• In quantum annealing, the evolution is driven by an explicit change in the Hamiltonian rather than an external parameter.

It is possible that a change in presentation could make the analogy between quantum annealing and classical annealing tighter. For instance, one could incorporate the temperature parameter into the spin Hamiltonian for classical annealing, by writing $$\tilde H_{\rm{classical}} = A(t) \sum_{i,j} J_{ij} s_i s_j - B(t) \sum_{i,j} \textit{const.}$$ where we might choose something like $A(t) = t\big/(t_F - t)$ and $B(t) = t_F - t$ for $t_F > 0$ the length of the anneal schedule. (This is chosen deliberately so that $A(0) = 0$ and $A(t) \to +\infty$ for $t \to t_F$.) Then, just as an annealing algorithm is governed in principle by the Schrödinger equation for all times, we may consider an annealing process which is governed by a diffusion process which is in principle uniform with tim by small changes in configurations, where the probability of executing a randomly selected change of configuration is governed by $$p(x \to y) = \max\Bigl\{ 1,\; \exp\bigl(-\gamma \Delta E_{x\to y}\bigr) \Bigr\}$$ for some constant $\gamma$, where $E_{x \to y}$ is the energy difference between the initial and final configurations. The stable distribution of this diffusion for the Hamiltonian at $t=0$ is the uniform distribution, and the stable distribution for the Hamiltonian as $t \to t_F$ is any local minimum; and as $t$ increases, the probability with which a transition occurs which increases the energy becomes smaller, until as $t \to t_F$ the probability of any increases in energy vanish (because any of the possible increase is a costly one).

There are still disanalogies to quantum annealing in this — for instance, we achieve the strong suppression of increases in energy as $t \to t_F$ essentially by making the potential wells infinitely deep (which is not a very physical thing to do) — but this does illustrate something of a commonality between the two models, with the main distinction being not so much the evolution of the Hamiltonian as it is the difference between diffusion and Schrödinger dynamics. This suggests that there may be a sharper way to compare the two models theoretically: by describing the difference between classical and quantum annealing, as being analogous to the difference between random walks and quantum walks. A common idiom in describing quantum annealing is to speak of 'tunnelling' through energy barriers — this is certainly pertinent to how people consider quantum walks: consider for instance the work by Farhi et al. on continuous-time quantum speed-ups for evaluating NAND circuits, and more directly foundational work by Wong on quantum walks on the line tunnelling through potential barriers. Some work has been done by Chancellor [arXiv:1606.06800] on considering quantum annealing in terms of quantum walks, though it appears that there is room for a more formal and complete account.

On a purely operational level, it appears that quantum annealing gives a performance advantage over classical annealing (see for example these slides on the difference in performance between quantum vs. classical annealing, from Troyer's group at ETH, ca. 2014).

### Quantum annealing as a phenomenon, as opposed to a computational model

Because quantum annealing is more studied by technologists, they focus on the concept of realising quantum annealing as an effect rather than defining the model in terms of general principles. (A rough analogy would be studying the unitary circuit model only inasmuch as it represents a means of achieving the 'effects' of eigenvalue estimation or amplitude amplification.)

Therefore, whether something counts as "quantum annealing" is described by at least some people as being hardware-dependent, and even input-dependent: for instance, on the layout of the qubits, the noise levels of the machine. It seems that even trying to approach the adiabatic regime will prevent you from achieving quantum annealing, because the idea of what quantum annealing even consists of includes the idea that noise (such as decoherence) will prevent annealing from being realised: as a computational effect, as opposed to a computational model, quantum annealing essentially requires that the annealing schedule is shorter than the decoherence time of the quantum system.

Some people occasionally describe noise as being somehow essential to the process of quantum annealing. For instance, Boixo et al. [arXiv:1304.4595] write

Unlike adiabatic quantum computing[, quantum annealing] is a positive temperature method involving an open quantum system coupled to a thermal bath.

It might perhaps be accurate to describe it as being an inevitable feature of systems in which one will perform annealing (just because noise is inevitable feature of a system in which you will do quantum information processing of any kind): as Andrew O writes "in reality no baths really help quantum annealing". It is possible that a dissipative process can help quantum annealing by helping the system build population on lower-energy states (as suggested by work by Amin et al., [arXiv:cond-mat/0609332]), but this seems essentially to be a classical effect, and would inherently require a quiet low-temperature environment rather than 'the presence of noise'.

### The bottom line

It might be said — in particular by those who study it — that quantum annealing is an effect, rather than a model of computation. A "quantum annealer" would then be best understood as "a machine which realises the effect of quantum annealing", rather than a machine which attempts to embody a model of computation which is known as 'quantum annealing'. However, the same might be said of adiabatic quantum computation, which is — in my opinion correctly — described as a model of computation in its own right.

Perhaps it would be fair to describe quantum annealing as an approach to realising a very general heuristic, and that there is an implicit model of computation which could be characterised as the conditions under which we could expect this heuristic to be successful. If we consider quantum annealing this way, it would be a model which includes the adiabatic regime (with zero-noise) as a special case, but it may in principle be more general.