Quantum Computation

Barry C. Sanders∗
Institute for Quantum Science and Technology, University of Calgary,
2500 University Drive NW, Calgary, Alberta, Canada T2N 1N4
(Dated: August 13, 2024)
arXiv:2408.05448v1 [quant-ph] 10 Aug 2024

This chapter summarizes quantum computation, including the motivation for in-
troducing quantum resources into computation and how quantum computation is
done. Finally, this chapter articulates advantages and limitations of quantum com-
putation, both fundamental and practical.

I. INTRODUCTION

Computation is about transforming input information to output information [1]. Infor-

mation comprises symbols as an alphabet, usually represented by finite strings of binary
n−1
digits (bits) b = (bk )k=0 ∈ {0, 1}n , but could be distributions thereof [2], although radically
different informational foundations such as real numbers R [3] are possible. Informational
transformations are governed by a well defined logical process, founded on the basic logical
steps inherent in the physical realisation of the information-processing machine such as a
Turing machine, which serves as a model for deterministic computation based on recursive
functions [4]. These logical processes could be about solving equations [5], or executing
an algorithm according to basic arithmetic or logical operations on a computer, which is a
programmable machine capable of executing sequences of such operations, or instructions.
The framework of computer science separates computational problems into types that in-
clude decision, function, search, optimisation, and feasibility problems. Problems can be
computable or not [6] and have different complexity [7], which are studied in theoretical
computer science.
As information is physical [8, 9], treating the Turing machine as a physical device is
consequently convenient, and then quantum computation enters by quantizing the classical
physics describing that machine [10]. Superpositions of information states are thus possible,
∗
[email protected]; +1-403-210-8462
 2

and ideal processing of such quantum information states can be described by unitary trans-
formations, followed by quantum measurements with their probabilistic nature. The logical
foundation differs for quantum computation compared to classical (i.e., using non-quantum
physics) computation—Boolean logic is replaced by quantum logic.
This chapter focuses on quantum computation, with computational problems, and there-
fore input and output, being classical, but the computational processing of this information
being in the quantum domain, hence involving quantum logic operations.

II. BOOLEAN AND REVERSIBLE COMPUTATION

Computation is conveniently understood in terms of Boolean algebra, which formalises

processing logical propositions mathematically. A k-ary Boolean function f : {0, 1}k →
{0, 1} : b 7→ f (b) represents a decision problem, also known as a (formal) language, with
k = 1 for unary and k = 2 for binary functions. The unary functions are identity 1, which
leaves the bit unchanged, and NOT, or ‘negation’, which flips: ¬b ← b ⊕ 1 for ⊕ summation
modulo 2, ¬ for negation and ← for ‘gets’.
In Boolean logic, a literal comprises both a logical variable b ∈ {0, 1} and its negation ¬b.
Binary functions include ⊕ for ‘exclusive or’ and ∧ (conjunction) and ∨ (disjunction) for
logical ‘and’ and ‘or’ operations, respectively. A Boolean function f is decidable if the out-
put is true (0) conditioned on the proposition itself is true, and false (1) conditioned on the
proposition itself is false. Ideally, a program accepts input and delivers an output represent-
ing the solution to the problem in a finite number of steps and then halts. However, some
problems, such as the halting problem [11] are undecidable (not every problem corresponds
to a program that halts after a finite number of steps), hence uncomputable, because either
of these conditions fails.
Consider any n-bit Boolean function f . Remarkably, a k-ary value K ≥ 2 can be fixed
such that f can be solved via a composition of k-ary Boolean functions with k ≤ K functions
independent of the choice of n. This universal set of k ≤ K generating operations is the
‘instruction set’, and the composition of these k-ary functions is the ‘circuit’ to solve f .
Moreover, certain k-ary functions, such as NAND (¬ ◦ ∧ with ◦ signifying composition
of functions), are universal in the sense that compositions of this binary function alone
generates any circuit.
 3

From Boolean functions, we can build the notion of Boolean circuits. A Boolean circuit
is a finite directed acyclic graph [12], whose vertices comprise n input bits and a universal
set of Boolean gates (with the number of such gates being the circuit size) and has output
bits. The Boolean circuit can be designed to compute Boolean function f , which implies
just one output bit, and the length of the circuit is the maximum number of edges to go
from an input to an output gate. Circuit-depth complexity for f is the minimum of these
maximum lengths over all Boolean circuits designed to compute f .
Time in computation is related to circuit depth. Measuring time in this way is valuable
for studying computational complexity as this time depends on the logical operations and
not on how fast the physical hardware, such as the speed of a particular implementation of
NAND, is. If a Turing machine computes f in time T (n), then a Boolean circuit can solve f
in depth Õ(T (n)) [13], meaning the same time scaling up to logarithmic factors with Õ as
explained in Eq. (2).
The space resource of a circuit refers to the number of bits required for the logical circuit.
Time-space trade-offs exist such that more or less space could be used to decrease or increase,
respectively, the computational time as circuit depth. Resource consumption is quantified
by the computational cost, which need not be unique.
A computational problem is defined over instances; for example the problem of factoring
semiprime numbers (numbers expressible as pq with p, q ∈ P for P the set of prime num-
bers) accepts different semiprime instances such as 3763 = 53 × 71 and 5141 = 53 × 97.
Computational complexity studies how the (usually worst-case) cost of solving the problem
increases as the size of the instance, measured as the minimum number n of bits to specify
the instance, grows.
For studies of asymptototic computational complexity, resource scaling in the large-
instance limit is important. Bachmann-Landau notation [14] is used, with O(g(x)) defined
by
{f (x)|∃M > 0, x0 ∈ R : |f (x)| ≤ Mg(x)∀x ≥ x0 } . (1)

We define
[
polyx := O(xc ), Õ(f (x)) := O (f (x)polylogx) (2)
c∈R+

with the latter known as soft-O notation that incorporates polynomial-of-logarithm factors
with polylog being ‘poly’ over ‘log’.
 4

Complementary to big-O (1), o(g(x)) is defined by

{f (x)|∀M > 0∃a ∈ R : 0 ≤ f (x) < Mg(x)∀x > a} (3)

meaning that f (x) is smaller than g(x) for large x. For lower bounds [15], the relation

g(x) ∈ Ω(f (x)) ⇔ f (x) ∈ O(g(x)), (4)

which defines Ω, is useful, and

Θ(f (x)) := O(f (x)) ∩ Ω(f (x)) (5)

expresses tight bounds. With respect to computational complexity, the number of bits n
replaces x ∈ R in these expressions, and we use Bachmann-Landau notation [14] in discussing
complexity of classical and quantum algorithms and classical here.
A decision problem, or language L, is deemed to be tractable if both space and time
costs scale as polyn by Cobham’s Thesis [16]; i.e., L is in complexity class P meaning
polynomial (henceforth ‘poly’ for short) time on a Turning machine; P⊆PSPACE, which
means poly space (memory), and PSPACE contains all complexity classes within what is
known as the polynomial-time hierarchy [17]. Conversely, L is ‘hard’ if all known algorithms
are superpolyn, i.e., cannot be bounded in poly time so ‘superpolynomial’ in the worst-case
scenario.
As a special case of hard problems, the complexity class NP refers to nondeterministic
poly-time, meaning L is solved in poly time on a nondeterministic Turing machine. A nonde-
terministic Turing machine conducts a brute-force search by allowing a multitude of actions
in parallel in contrast to the deterministic case with fixed action, and accepting the input
if any branch of actions halts with an accept condition. The probabilistic Turing machine
is a special case of a non-deterministic Turing machine wherein a probability distribution is
provided to make weighted stochastic choices of computational transitions at each state.
Tractable computation on a nondeterministic Turing machine is equivalent to being com-
putationally hard to solve but easy to verify on a (deterministic) Turing machine. Obviously,
P⊆NP, but whether P=NP is a famous open problem [18]. With respect to any complexity
class C, L0 is C-Hard if every L ∈C can be reduced in poly time to L0 , and L is C-complete
if L0 is both C-hard and a member of C. NP-complete is an important example relevant to
combinatorial optimisation [19] and to approximate optimisation [20].
 5

The probabilistic Turing machine model deliberately leads to erroneous results: some-
times accepting strings that should be rejected and vice versal. Formally, L is recognised
by the probabilistic Turing machine if, given probability ε, a string in L and a string not
in L are accepted or rejected with probability 1 − ε, respectively. The complexity class
BPP corresponds to languages for ε = 2/3 (and PP, or probabilistic polynomial-time, for
any ε > 1/2 [21], which contains NP). Obviously, P⊆BPP, but whether the widely believed
equality P=BPP is true is an open problem.
The Boolean satisfiability problem (SAT)—deciding the existence of an assignment of
values to a Boolean expression of literals such that the output is true—is an important type
of computation [22] with special significance for quantum computation [23]. Expressed in
conjunctive normal form, k-SAT is expressed as a conjunction (∧) of fixed-length clauses
with each clause a disjunction (∨) of k literals. Not only is 2-SAT∈P [24], but 2-SAT∈NL-
complete [25] as well, with NL meaning use of a logarithmic amount of space on a nondeter-
ministic Turing Machine. In contrast, 3-SAT∈NP-complete and is pertinent for combinatorial
optimization as finding the exact optimal solution is typically NP-complete.
Reversible computation [26] provides a valuable bridge from concepts of computation
based on Boolean logic to concepts of quantum computation [27, 28]. One impetus for
reversible computation arises from Maxwell’s demon, which enables studying entropy and
the second law of thermodynamics [29]. From Szilard’s information engine incorporating
Maxwell’s demon [30], Landauer connected information to thermodynamics by showing that
erasure is physical [8].
Reversible computation shows that bit erasure can be postponed so the full computation
can be achieved in a logically reversible way with the solution plus the ‘garbage’ bits at the
output potentially serving as the input with the reversed version of the computation map-
ping this solution to the original input. For a finite machine undergoing a large number of
computations, erasures are eventually needed to recoup space from garbage for useful infor-
mation. However, energy consumption requirements per computational step can approach
zero in a reversible computer.
Reversible computation is achieved by embedding the Boolean function f into a reversible
function as

F : {0, 1}n+1 → {0, 1}n+1 : (b, b′ ) 7→ (b, b′ ⊕ f (b)) (6)

 6

for {0, 1}n+1 := {0, 1}n × {0, 1}, making reversible computation equivalent to permuta-
tion [31]. Analogous to Boolean logic, F can be decomposed into a sequence of reversible
k-ary logic gates, with k independent of the choice of n. Whereas the binary NAND gate
suffices as a universal gate for Boolean logic, a ternary gate, mapping three bits to three
bits, is the smallest value for k in reversible logic.
The Toffoli, or controlled-controlled-not gate (CCNOT) is one such universal gate [27]
with Cι NOT mapping ι control bits and one target bit to the same state unless all control
bits are 1 in which case the target bit flips. Another universal gate is the Fredkin [32],
or controlled-SWAP, gate [33]. Thus, following the language established for Boolean logic,
each of CCNOT and CSWAP is a cardinality-one universal instruction set for reversible
computation. As for Boolean logic, decomposing logical circuits into the same kind of circuit
allows careful comparison on relative complexity between different reversible functions F .

III. QUANTUM FUNDAMENTALS

We begin with a brief mathematical description of nonrelativistic quantum mechanics [34].

A state is a normalised positive linear functional on a unital C∗ algebra (comprising linear
operators on a Hilbert space with the ∗ operation representing adjoint, typically † in physics).
Representing linear operators on Hilbert space is achieved by the Gel’fand-Naimark-Segal
construction [35, 36], and each state can be uniquely identified with a positive semi-definite
trace-class (‘density’) operator of unit trace by requiring equivalence between expectation
values for representations of operators and the functional acting on the operator.
In the case of quantum bits (‘qubits’ [37]), states are density operators on a tensor product
of two-dimensional Hilbert spaces: H2n . Pure states are idempotent operators and thus can
represented by vectors in H2n , which is isomorphic to projective complex space of dimension
2n − 1, i.e., P2n−1 (C), with 2n the overall Hilbert-space dimension and subtraction of one for
the constraint on norm. Each multiqubit state is thus representable as a complex unit-length
vector of length 2n.
In Dirac notation, a qubit string is
X
|ψin = ψb |bi , (ψb ) ∈ P2∗−1 (C), (7)
b∈{0,1}n

with {|bi} the ‘computational basis states’ of H2n , i.e., basis vectors labelled by bit strings.
 7

Henceforth, we do not explicitly normalise the states if norm-1 is implied. Two useful
examples of non-product states are ‘ebits’ (maximally entangled pair of qubits) |0 b1 i +
(−1)b0 |1 1 − b1 i. The Hadamard gate maps H |bi 7→ |0i + (−1)b |1i, and normalisation is
implicit in both cases. Each multi-qubit gate is representable in Md (C), meaning a d × d
complex matrix, where d = 2n for n qubits. The distance between two normalised multiqubit
states (7) is the ‘quantum angle’ arccos |hψ ′ |ψi| corresponding to the Fubini-Study metric
for H [38].
On an ideal quantum computer, n qubits are transformed by unitary maps, i.e., isometries
on Hilbert space: U |ψin with U ∈ M2n (C) a representation of a group element in SU(2n ).
The unitary map U is generated by a self-adjoint Hamiltonian operator H that describes
the dynamical physical system yielding this gate, and U forms a strongly continuous one-
parameter unitary group over time t. The distance between two operators, say A and A′
(need not be unitary), is dis(A, A′ ) := kA − A′ k for kAk := supk|ψik=1 kA |ψik the spectral
norm [39].
Whereas Boolean and reversible-logic functions are exactly decomposable to a sequence of
instruction gates, with the universal instruction set having just one universal gate, a related
decomposition theorem for quantum computation [40] yields a sequence that only approxi-
mately realizes U and requires at least two instruction gates. The Solovay-Kitaev theorem,
as formulated by Dawson and Nielsen [40], conveys that, given a universal instruction set
for SU(d) and accuracy ǫ > 0, ∃c > 0 such that, ∀U ∈SU(d), a sequence of instruction
gates of depth O (logc (1/ǫ)) exists such that the unitary map so generated has a distance,
based on operator norm, not greater than ǫ. We write log for logarithm in base 2 as the
default. Succinctly, any universal instruction set generates a polylog(1/ǫ)-depth quantum
circuit approximating U, and, furthermore, the classical algorithm to generate this sequence
is also polylog(1/ǫ), with an even smaller constant c than for the circuit depth [40].
A choice is made regarding which quantum instruction gates to include, with one common
choice being [41]    
 1 1 √ 
H=   / 2, T := diag(1, ω8), CNOT (8)
 1 −1 

for ωd the dth principal root of unity. Alternatively, combining H with CCNOT whose
representation is in M8 C), which is universal by itself for reversible computation, provides a
universal instruction set for quantum computation. Physically, the universal instruction set
 8

{H, T, CNOT} is convenient as only single- and two-body interactions are involved, whereas
CCNOT involves more challenging three-body interactions.

IV. QUANTUM ALGORITHMS AND HEURISTICS

In this section we consider quantum algorithms [42], quantum state generation and quan-
tum heuristics, which tend to be grouped together under the term ‘quantum algorithms’. An
algorithm is the means by which a computer solves a well posed computational problem and
comprises (a perhaps empty) input, an output and a procedure. A procedure is expressed
as a finite sequence of instructions based on a formal language and incurs finite cost.
On the other hand, heuristics are techniques for solving hard problems exactly or ap-
proximately, such as for search or optimisation types of problems, but are not guaranteed
to succeed for finite cost. Heuristics are valuable for solving NP-hard problems. A meta-
heuristic is technique for devising or choosing or tuning a heuristic for attempting to solve
optimisation or machine learning problems approximately [43], with simulated annealing for
approximate global optimisation one important example of a metaheuristic.
As discussed in §II, reversible computation is permutation; extending reversible compu-
tation to quantum computation leads to permutations being replaced by unitary transfor-
mations. The algorithmic procedure acting on a n qubits is then described by a unitary
mapping U on H2n . Approximate quantum computation is achieved by realising approxi-
mate U ′ such that dis(U, U ′ ) < ǫ. The approximation U ′ must be achievable as a quantum
circuit with computational cost that grows as polylogn, i.e., efficient and known as ‘speedup’.
We shall next discuss important cases of quantum algorithms [44, 45].
Shor’s quantum factoring algorithm, the most celebrated of all quantum algorithms, was
inspired by Simon’s algorithm [46]. Simon’s algorithm solves the following oracle problem,
with an oracle black box being a system (e.g., a subroutine) that accepts inputs and yields
outputs with an unspecified procedure. Cost is typically quantified by queries rather than
in terms of time-space resources [42]. Given oracle f : {0, 1}n → {0, 1}n, subject to the
promise that ∃s ∈ {0, 1}n such that

f (x) = f (y) ⇐⇒ x ⊕ y ∈ {0n , s} ∀x, y ∈ {0, 1}n , (9)

Simon’s problem is to compute s with the fewest oracle queries possible and can be converted
 9

to a decision problem by rewriting the task as distinguishing whether s = 0n or not. Impor-

tantly, Simon’s problem yields an exponential oracle separation between the two complexity
classes, namely BPP and BQP, which is the quantum version of BPP.
Simon’s algorithm can be contrasted with the Bernstein-Vazirani algorithm [47], which
also proves a separation between BPP and BQP but not exponentially. The Bernstein-
Vazirani algorithm accepts an oracle with input x ∈ {0, 1}n and yields a single-bit output
x ⊙ h (with Hadamard multiplication notation, which is element-wise vector or matrix mul-
tiplication) with the task being to find the hidden string h ∈ {0, 1}n . Quantumly, a single
query suffices [47]; classically, O(n) queries to the oracle are required.
The Bernstein-Vazirani algorithm is itself a specialisation of the Deutsch-Jozsa algo-
rithm [48]. The Deutsch-Jozsa algorithm employs an oracle that accepts an n-bit input and
yields a single-bit output subject to the promise that all 2n possible outputs are either the
same (constant case) or half yield output 1 and the other half yield 0 (balanced case). The
task is to decide whether the oracle is constant or balanced, which can be solved quantumly
with just one query in contrast to two queries for the n = 1 deterministic classical algo-
rithm [10] and expn queries for general n [48]; However, the task can be achieved with O(1)
queries with a probabilistic algorithm so the Deutsch-Jozsa algorithm yields an exponential
speedup over P but not over BPP.
Shor’s algorithm delivers superpolyn speedup for factoring any n-bit number N (n =
⌈log N⌉) compared to the best-known classical algorithms [49, 50], which shows that the
computationally hard problem of integer factoring is tractable using quantum computation.
Specifically, Shor’s algorithm for factoring an n-bit integer N executes in O(n3 ) time [49, 50],
subsequently reduced to Õ(n2 ) [51], which subexponentially outperforms the best known
classical algorithm based on the general number sieve, whose complexity is [52]
 h i 1/3
∼ 2Õ(n )
1/3 2/3
O exp c (log n) (log log n) (10)

for c ∈ R+ , and the soft-O notation in the exponent on the right-hand side captures the log
and log log terms in the exponent on the left-hand side of Eq. (10).
Shor’s algorithm comprises the following steps. Given N ∈ Z+ , choose random a ∈
[N]and compute gcd(a, N); terminate if gcd(a, N) 6= 1 or else solve the order-finding prob-
lem, namely compute the smallest period r such that
N
fN (x + r) = fN (x) = ax . (11)
 10

N
This order-finding problem is solved by Shor’s quantum algorithm, with = meaning equal
N
modulo N. Start over if the resultant minimum r is odd; else proceed. If ar/2 = −1, start
over; else return gcd ar/2 ± 1, N and halt. Shor’s integer factoring algorithm dramatically

affects cybersecurity, particularly on breaking the Rivest-Shamir-Adleman (RSA) public-

key encryption [53]. Minimising r is the classical computational bottleneck that leads to
superpolyn scaling for classical computation.
Shor’s quantum period-finding algorithm works as follows. Two input qubit strings with k
source qubits and n target qubits satisfy

N 2 ≤ 2k ≤ 2N 2 , n = ⌈N⌉ (12)

with k chosen to ensure more than N 2 terms in the sum. Only r distinct values of aq mod N
are possible.
The first step is
k −1
2X
k+n−1
H ⊗k
|0i |1i 7→ |qi |0in−1 |1i (13)
q=0

with the input state being all qubits in the |0i except that the last target qubit is |1i. An
interesting fact is that the same transformation of |0ik is achieved by the quantum Fourier
transform (QFT)
k −1
2X
qq ′
|qi 7→ ωQ |q ′ i , (14)
q ′ =0

following the convention of implicit state normalisation. Note that the inverse QFT, i.e.,
qq ′
−qq ′
QFT−1 , is obtained by replacing ωQ with ωQ .
The next step in the quantum circuit is to execute the quantum subcircuit for order-
finding, which can conveniently be viewed as an oracle problem. The order-finding oracle
yields the order r of a group in a full oracle-free circuit. For some quantum algorithms
discussed below, the oracle approach and query cost is vital to showing quantum advantage,
but, for Shor’s algorithm and its variants, the oracle is replaced by an explicit quantum
subcircuit and costs are expressed in space and time.
For quantum order-finding, the oracle is replaced by a subcircuit that executes a quantum
version of classical exponentiation by squaring [54]. This quantum subcircuit [55] performs
|q, 0i 7→ |q, aq mod Ni with |q, 0i having q as a label for the source qubit string and the
second label 0 for the target qubit string. Thus, the output quantum state from the order-
 11

finding subcircuit is
k −1
2X r−1 X
k−1
X
q
|q, a mod Ni = |rq + p, ap mod Ni , (15)
q=0 p=0 q=0

with this final form convenient to show how terms can be grouped together due to the
modular exponent term in the target qubits. Most of the quantum cost for Shor’s algorithm
is in executing this quantum subcircuit.
The next step of Shor’s algorithm is to apply QFT−1 to this output state, which yields
r−1 X
X r−1
ωr−pq |kq, ap mod N i . (16)
p=0 q=0

Measuring only the source qubit string s suffices to infer r: discarding the s = 0 case, s is
highly likely to be a multiple of k with coefficients from 1 to r − 1. An efficient number of
repeats of this process suffices to estimate r with high confidence [56].
Quantum speedup for order finding also applies to other computational problems. One
case is the discrete logarithm problem, posed as accepting a, b, N ∈ {0, 1}n with the promise
N
that ∃s : b = as , and the task is to find s, which can be achieved in polyn time [50] compared
to superpolyn classically. Quantum computers can solve the discrete logarithm problem on
elliptic curves using Shor’s technique [50], thereby breaking elliptic curve cryptography [29,
57, 58].
Another case concerns solving Pell’s Equation

x2 − dy 2 = 1, x, y, d ∈ Z, (17)

with d not a square. The computational problem is

 √ 
(x1 , y1) = min x + y d : d ∈ {0, 1}n , (18)

√
which is uniquely identified by ⌊R⌉ with R := log(x1 + y1 d). Whereas computing ⌊R⌉ is
superpolyn, Hallgren’s quantum algorithm finds ⌊R⌉ in polyn time [59], which breaks the
Buchman-Williams cryptosystem [60].
The Abelian Hidden Subgroup Problem [61] is regarded as the heart of Shor’s and related
algorithms and yields a superpolyn speedup over the best classical alternative. Formally, the
problem is described by considering a finitely generated Abelian group G and a subgroup H
 12

with G/H being finite along with a function f : G → X, for some set X. Furthermore G
‘hides’ H; i.e.,
∀g, g ′ ∈ G, f (g) = f (g ′) ⇔ gH = g ′ H. (19)

The task is to find a set of generators for H via queries to f ; this is solvable on a quantum
computer using O(log |G|) queries, whereas classically Ω(|G|) are required [57, 62], although
solving in one query is possible for some instances [63].
Significant effort has been dedicated to devising quantum algorithms for speeding up solu-
tions to non-Abelian hidden subgroups, with successful quantum speedup in some cases [64]
and important implications for problems such as graph isomorphism in the symmetric-group
case [65] or some lattice problems for the dihedral-group (symmetry group of the n-sided
polygon) case [66] with the computational cost for finding a hidden subgroup of the di-
√
hedral group reduced to 2O(log n) in the quantum case compared to the classical cost of
√
O( n) [67]. This algorithm was further extended to be subexponential in time and polyno-
mial in space [68].
Although Shor’s algorithm and the variants discussed above can be posed as oracular
algorithms, the analyses above typically consider space and time cost. On the other hand,
the quantum search algorithm [69] is naturally posed as an oracle problem. This quantum
algorithm for unstructured search finds, with high probability, the unique oracle input whose
output is 1 (all other N − 1 oracle outputs are 0 although extendable to multiple 1 [70]).
First the procedure creates a uniform superposition of states and then applies the quan-
tum oracle |xi 7→ (−1)f (x) |xi, which changes the phase of the marked state. After suffi-
ciently many iterations, the quantum search algorithm halts and resultant quantum states
are measured, with measurement of the marked state being highly likely: A high probabil-
√
ity of determining the marked state is achieved with just O( N ) queries to the quantum
oracle [71] compared to the classical requirement of O(N) queries to the classical oracle f .
The quantum search algorithm is optimal [71, 72].
Importantly, although the search-algorithm improvement is only quadratic with respect
to query complexity, the quadratic improvement is provable, whereas Shor’s algorithm is
subexponentially better but based on polynomial hierarchy [17] arguments rather than on
a formal proof. The quantum search algorithm has amplitude estimation [73–75] at its core
and is at the core of quadratically sped-up quantum algorithms such as for enhancing the
classical 3-SAT algorithm [76].
 13

Another type of task for a quantum computer is to simulate Hamiltonian-generated evo-

lution on a system with n degrees of freedom for the Hamiltonian H promised to have
certain properties. These properties could include being row-computable, which means that
the elements of each row of the Hermitian matrix representing H are computable, per-
haps efficiently. Another property could be that the Hamiltonian is k-local, which means
H = m
P
j=1 Hj for each Hj a Hamiltonian acting on up to k qubits. Yet another would be

that every row of H contains at most d nonzero entries, meaning that it would have to be
d-sparse.
The problem of quantum simulation, or quantum-state generation [77], originates with
Feynman’s motivation for quantum computation [78]. One major focus of application is
simulating chemical dynamics [79]. Hamiltonian-generated unitary evolution is described
by unitary map U = exp(−iHt) (setting ~ = 1). This evolution is used to map any input
state to its H-evolved form after time t. The quantum circuit for simulating this evolution
can be achieved with a poly(n, t)-depth quantum circuit [77, 80–82], hence efficient with
respect to these quantities and not believed to be efficient classically.
Generating the quantum state as a solution is a step towards solving a computational
problem but is not the full solution as the end point does not yield an output string as the
solution. For example, finding the ground-state energy of a k-local Hamiltonian is important
for physics and chemistry but this problem is hard to solve. To understand this hardness,
we consider the complexity class QMA. Roughly speaking QMA is to BQP what NP is to
BPP (or to P itself if BPP=P). Solving the ground state of a k-local Hamiltonian is QMA-
complete for k ≥ 2 [83] (but in P for k = 1). Other applications such as simulating chemical
dynamics [79] have been explored.
This complexity result for finding the ground state is analogous to the maximum satisfia-
bility problem (MAX-SAT), which is an optimisation extension of SAT. The task for MAX-
SAT is to determine the maximum number of clauses of a given Boolean formula expressed
in conjunctive normal form that can be made true. For more than one clause, MAX-SAT
is NP-complete. For quantum computation, an extension of MAX-SAT to weighted MAX-
SAT [84] is important. Given a Boolean formula in conjunctive normal form, with each
clause assigned a non-negative weight, the task is to assign values to the variables that
maximize the combined weight of the satisfied clauses.
One application of quantum-state generation has been as a system-of-linear-equations
 14

(SLEP ) solver [85]. This ‘HHL’, or SLEP, problem [86], accepts an oracle description
of A ∈ Mn (R) and an efficient description of a vector b (not to be confused with the
bit string defined earlier) and an accuracy parameter ε. The task is to compute some
property of f (A)b for an efficiently computable function f . Suppose that A is a polylogn-
sparse Hermitian matrix. Furthermore, suppose A has condition number κ that, generically,
quantifies sensitivity of a function’s output to variation of input. Specifically, for Ax = b
(noting that kAk is A’s largest singular value and, if A is square, kA−1 k is A’s smallest
singular value), the ratio of the fractional error of x to the fractional error of b has an upper
bound of κ := kAk · kA−1 k [87].
Under these assumptions, some expectation values of operators with respect to f (A)b
can be approximated by quantum computation in O(κ2 log n) time within poly(1/ε) achiev-
ing poly(1/ε) accuracy [86]/ The HHL algorithm can be extended to non-sparse matrices but
require pre-computation [88, 89]. Practical applications such as for recommendation sys-
tems [88] and principal component analysis [90] were later shown to be solvable in poly time
by classical randomised algorithms (known as dequantising quantum algorithms) in 2019 [91]
and in 2021 [92], respectively. By similar means, the application of the SLEP method to
quantum algorithms for singular-value transformation [93, 94] were also dequantised [95],
showing the immense challenge in taking the HHL algorithm all the way to practical appli-
cations.
Many more quantum algorithms have been constructed and their complexities analysed,
but this discussion conveys some of the key concepts in studies of quantum algorithms
and complexity. Another large area of quantum computation research concerns quantum
heuristics for optimisation. Especially prominent amongst these heuristics is the ‘Quantum
Approximate Optimization Algorithm’, or QAOA for short, applied to approximate solutions
of combinatorial optmisiation problems [96, 97]. Early on, this heuristic achieved a better
approximation ratio than any known polynomial-time classical algorithm to a to a Bounded
Occurrence Constraint Problem [98]. Subsequently, an efficient classical algorithm that
achieves the hardness-of-approximation limit for the approximation ratio was achieved [99].
The quantum-circuit, or gate-based, approach to quantum algorithms is not the only
way to perform quantum computation. Other approaches include measurement-based, or
one-way, quantum computation [100], quantum walks [101], and topological quantum com-
putation [102], but equivalences between these approaches and the quantum circuit model
 15

are known. One alternative approach, however, began with a presumption of inequivalence:
adiabatic quantum computation [103, 104].
Following the adiabatic theorem (but bearing in mind caveats [105]), which posits that
a system in a ground state remains in that state if the evolution is sufficiently slow, adi-
abatic quantum computation is about commencing with an easy-to-prepare ground state
of some Hamiltonian and evolving the system slowly to a new Hamiltonian whose ground
state encodes the solution to a problem, generally one pertinent to combinatorial optimi-
sation. Adiabatic quantum computation was tested for small instances of an NP-complete
problem with indications that adiabatic quantum computation could be advantageous for
NP-complete problems [104].
For the minimum eigenvalue gap γ between the ground and first excited states, the
run time of an adiabatic process is O(1/γ 3 ) [106], which can be improved to Õ(1/γ 2 ) if the
evolution is sufficiently smooth [107]. Adiabatic quantum computation is divided into two
types: stochastic vs non-stochastic Hamiltonian, with the stochastic Hamiltonian being
represented by a matrix whose off-diagonal elements in the standard basis are are real and
non-positive [108]. Adiabatic quantum computation with non-stochastic Hamiltonians is at
least as efficient as quantum circuits, whereas restricting to stochastic Hamiltonians is likely
weaker than using quantum circuits [109] but likely better than classical computation [110].

V. CONCLUSIONS

This chapter reviews essential fundamentals of classical computation and quantum me-
chanics to be able to convey concisely the essence of quantum computation. The material
covered is not exhaustive but rather explains some of the major advances since inception of
the field and aims to convey the key concepts. The quantum algorithm zoo [45] is an excel-
lent source of comprehensive information about all quantum algorithms, and this chapter is
partially meant to provide a useful primer for being able to read the material in this zoo.
The industrial side of quantum computation must contend with the parlous state of
current quantum computer technologies and so runs whatever quantum algorithms and
heuristics are promising and feasible on existing devices. Consequently much of the material
here is beyond the reach of existing commercial quantum computers. The basics of build-
ing a quantum computer are not covered here but can be studied from other sources [111].
 16

Existing quantum computers are said to be following the noisy intermediate-scale quan-
tum paradigm [112, 113], which constitutes a valuable step towards large scalable quantum
computers of the future.

[1] M. Sipser, Introduction to the Theory of Computation, 3rd ed. (Cengage Learning, Boston,
2012).
[2] W.-W. Zhang, Y. R. Sanders, and B. C. Sanders, Channel discord and distortion,
New J. Phys. 23, 083025 (2021).
[3] L. Blum, M. Shub, and S. Smale, On a theory of computation and complexity
over the real numbers: NP-completeness, recursive functions and universal machines,
Bull. Amer. Math. Soc. 21, 1 (1989).
[4] A. Turing, 58On Computable Numbers, with an Application to the Entscheidungsproblem
(1936), in The Essential Turing (Oxford University Press, 2004).
[5] J. Thomson, Mechanical integration of linear differential equations of the second order with
variable coefficients, Proc. R. Soc. Lond. XXIV, 262 (1876).
[6] T. Radó, On non-computable functions, Bell Labs Tech. J. 41, 877 (1962).
[7] O. Goldreich, Computational Complexity: A Conceptual Perspective (Cambridge University
Press, New York, 2008).
[8] R. Landauer, Irreversibility and heat generation in the computing process,
IBM J. Res. Dev. 5, 183 (1961).
[9] C. H. Bennett, Logical reversibility of computation, IBM J. Res. Dev. 17, 525 (1973).
[10] D. Deutsch, Quantum theory, the Church-Turing principle and the universal quantum com-
puter, Proc. R. Soc. Lond. A 400, 97 (1985).
[11] S. C. Kleene, Introduction to Metamathematics, University series in higher mathematics (van
Nostrand, 1952).
[12] J. Bang-Jensen and G. Z. Gutin, Classes of digraphs, in
Digraphs: Theory, Algorithms and Applications (Springer London, London, 2009) pp.
31–86.
[13] N. Pippenger and M. J. Fischer, Relations among complexity measures,
J. ACM 26, 361 (1979).
 17

[14] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to Algorithms, 3rd

ed. (MIT Press, 2009).
[15] D. E. Knuth, Big omicron and big omega and big theta, SIGACT News 8, 18 (1976).
[16] A. Cobham, The intrinsic computational difficulty of functions, in Logic, methodology and
philosophy of science, Proc. 1964 International Congress, Studies in logic and the foundations
of mathematics, edited by Y. Bar-Hillel (North-Holland, Amsterdam, 1965) pp. 24–30.
[17] L. J. Stockmeyer, The polynomial-time hierarchy, Theor. Comput. Sci. 3, 1 (1976).
[18] L. Fortnow, The status of the P versus NP problem, Commun. ACM 52, 78 (2009).
[19] E. L. Lawler, J. K. Lenstra, A. H. G. Rinnooy Kan, and D. B. Shmoys, The Traveling
Salesman Problem: A Guided Tour of Combinatorial Optimization (Wiley, 1991).
[20] S. Sahni and T. Gonzalez, P-complete approximation problems, J. ACM 23, 555 (1976).
[21] J. Gill, Computational complexity of probabilistic turing machines, SIAM J. Comput. 6, 675
(1977).
[22] V. V. Vajirani, Approximation Algorithms (Springer-Verlag, Berlin, 2001).
[23] S. Bravyi, Cross Disciplinary Advances in Quantum Computing (American Mathematical
Society, 2011) Chap. Efficient algorithm for a quantum analogue of 2-SAT.
[24] M. R. Krom, The decision problem for a class of first-order formulas in which all disjunctions
are binary, Math. Log. Q. 13, 15 (1967).
[25] M. R. Garey and D. S. Johnson, Computers and Intractability: A Guide to the Theory of
NP-completeness (Freeman, San Francisco, 1979).
[26] C. H. Bennett, Notes on the history of reversible computation,
IBM J. Res. Dev. 44, 270 (2000).
[27] T. Toffoli, Reversible computing, in Automata, Languages and Programming, edited by
J. de Bakker and J. van Leeuwen (Springer, Berlin, 1980) pp. 632–644.
[28] K. S. Perumalla, Introduction to Reversible Computing, Computational Science (Chapman
& Hall/CRC, 2013).
[29] K. Maruyama, F. Nori, and V. Vedral, Colloquium: The physics of Maxwell’s demon and
information, Rev. Mod. Phys. 81, 1 (2009).
[30] K. J. Ray and J. P. Crutchfield, Variations on a demonic theme: Szilard’s other engines,
Chaos 30, 093105 (2020).
[31] J. Carette, R. P. James, and A. Sabry, Chapter two - embracing the laws of physics: Three
 18

reversible models of computation (Elsevier, 2022) pp. 15–63.

[32] E. Fredkin and T. Toffoli, Conservative logic, Int. J. Theor. Phys. 21, 219 (1982).
[33] T. Sasao and K. Kinoshita, Conservative logic elements and their universality, IEEE Trans.
Comput. (1979).
[34] F. Strocchi, An Introduction to the Mathematical Structure of Quantum Mechanics: A Short
Course for Mathematicians, 2nd ed., Advanced Series in Mathematical Physics (World Sci-
entific, Singapore, 2008).
[35] I. Gelfand and M. Neumark, On the imbedding of normed rings into the ring of operators in
Hilbert space, Rec. Math. [Mat. Sbornik] N.S. 12, 197 (1943).
[36] I. E. Segal, Irreducible representations of operator algebras, Bull. Amer. Math. Soc. 53, 73
(1947).
[37] B. Schumacher, Quantum coding, Phys. Rev. A 51, 2738 (1995).
[38] D. C. Brody and L. P. Hughston, Geometric quantum mechanics,
J. Geom. Phys. 38, 19 (2001).
[39] J. Watrous, The Theory of Quantum Information (Cambridge University Press, Cambridge,
2018).
[40] C. M. Dawson and M. A. Nielsen, The Solovay-Kitaev algorithm, Quantum Inf. Comput. 6,
81 (2006).
[41] A. Barenco, C. H. Bennett, R. Cleve, D. P. DiVincenzo, N. Margolus, P. Shor,
T. Sleator, J. A. Smolin, and H. Weinfurter, Elementary gates for quantum computation,
Phys. Rev. A 52, 3457 (1995).
[42] M. Mosca, Quantum algorithms, in Encyclopedia of Complexity and Systems Science, edited
by R. A. Meyers (Springer, New York, 2009) pp. 7088–7118.
[43] L. Bianchi, M. Dorigo, L. M. Gambardella, and W. J. Gutjahr, A survey on metaheuristics
for stochastic combinatorial optimization, Nat. Comput. 8, 239 (2009).
[44] A. Montanaro, Quantum algorithms: an overview, npj Quantum Inf. 2, 15023 (2016).
[45] S. Jordan, The quantum algorithm zoo (2023).
[46] D. Simon, On the power of quantum computation, SIAM J. Comput. 26, 1474 (1997).
[47] E. Bernstein and U. Vazirani, Quantum complexity theory, SIAM J. Comput. 26, 1411
(1997).
[48] D. Deutsch and R. Jozsa, Rapid solution of problems by quantum computation,
 19

Proc. R. Soc. Lond. A 439, 553 (1992).

[49] P. W. Shor, Algorithms for quantum computation: Discrete logarithms and factoring, in
Proc. 35th Annual Symposium on Foundations of Computer Science, SFCS ‘94’ (1994) pp.
124–134.
[50] P. W. Shor, Polynomial-time algorithms for prime factorization and discrete logarithms on
a quantum computer, SIAM J. Sci. Comput. 26, 1484 (1997).
[51] D. Beckman, A. N. Chari, S. Devabhaktuni, and J. Preskill, Efficient networks for quantum
factoring, Phys. Rev. A 54, 1034 (1996).
[52] C. Pomerance, A tale of two sieves, Not. Am. Math. Soc. 43, 1473 (1996).
[53] R. Rivest, A. Shamir, and L. Adleman, A method for obtaining digital signatures and public-
key cryptosystems, Commun. ACM 21, 120 (1978).
[54] S. Gueron, Efficient software implementations of modular exponentiation,
J. Cryptogr. Eng. 2, 31 (2012).
[55] I. L. Markov and M. Saeedi, Constant-optimized quantum circuits for modular multiplication
and exponentiation, Quantum Inf. Comput. 12, 0361 (2012).
[56] Y. R. Sanders, (2023), private communication.
[57] D. Boneh and R. J. Lipton, Quantum cryptanalysis of hidden linear functions, in
Advances in Cryptology — CRYPTO ’95 , Lecture Notes in Computer Science, Vol. 963,
edited by D. Coppersmith (Springer-Verlag, Berlin, 1995) pp. 424–437.
[58] J. Proos and C. Zalka, Shor’s discrete logarithm quantum algorithm for elliptic curves, Quan-
tum Inf. Comput. 3, 317 (2003).
[59] S. Hallgren, Polynomial-time quantum algorithms for Pell’s equation and the principal ideal
problem, in Proc. 34th ACM Symposium on Theory of Computing (2002).
[60] J. Buchmann and H. Williams, A key-exchange system based on imaginary quadratic fields,
J. Cryptol. 1, 107 (1988).
[61] M. Mosca, Abelian hidden subgroup problem, in Encyclopedia of Algorithms, edited by M. Y.
Kao (Springer, Berlin, 2015) pp. 1–5.
[62] M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information: 10th
Anniversary Edition (Cambridge University Press, Cambridge, 2010).
[63] J. N. de Beaudrap, R. Cleve, and J. Watrous, Sharp quantum versus classical query com-
plexity separations, Algorithmica 34, 449 (2002).
 20

[64] G. Ivanyos, F. Magniez, and M. Santha, Efficient quantum algorithms for some instances
of the non-abelian hidden subgroup problem, in SPAA ’01: Proc. thirteenth Annual ACM
Symposium on Parallel Algorithms and Architectures (ACM, New York, 2001) pp. 263–270.
[65] M. Ettinger and P. Høyer, A quantum observable for the graph isomorphism problem (1999),
arXiv:quant-ph/9901029 [quant-ph].
[66] O. Regev, Quantum computation and lattice problems, in Proc. 3rd Symposium on Founda-
tions of Computer Science (2002) pp. 520–529.
[67] G. Kuperberg, A subexponential-time quantum algorithm for the dihedral hidden subgroup
problem, SIAM J. Comput. 35, 170 (2005).
[68] O. Regev, A subexponential time algorithm for the dihedral hidden subgroup problem with
polynomial space (2004), arXiv:quant-ph/0406151 [quant-ph].
[69] L. Grover, Quantum mechanics helps in searching for a needle in a haystack, Phys. Rev. Lett.
79, 325 (1997).
[70] M. Boyer, G. Brassard, P. Høyer, and A. Tapp, Tight bounds on quantum searching,
Fortschritte der Physik 46, 493 (1998).
[71] C. H. Bennett, E. Bernstein, G. Brassard, and U. Vazirani, Strengths and weaknesses of
quantum computing, SIAM J. Sci. Comput. 26, 1510 (1997).
[72] C. Zalka, Grover’s quantum searching algorithm is optimal, Phys. Rev. A 60, 2746 (1999).
[73] G. Brassard and P. Høyer, An exact quantum polynomial-time algorithm for simon’s problem,
in Proc. Fifth Israeli Symposium on Theory of Computing and Systems (IEEE Computer
Society Press, 1997) pp. 12–23.
[74] L. K. Grover, Quantum computers can search rapidly by using almost any transformation,
Phys. Rev. Lett. 80, 4329 (1998).
[75] G. Brassard, P. Høyer, M. Mosca, and A. Tapp, Quantum amplitude amplification and
estimation, in Quantum Computation and Quantum Information: A Millennium Volume,
AMS Contemporary Mathematics Series, Vol. 305, edited by S. J. Lomonaco Jr. and H. E.
Brandt (American Mathematical Society, 2002).
[76] A. Ambainis, Quantum search algorithms, SIGACT News 35, 22 (2004).
[77] D. Aharonov and A. Ta-Shma, Adiabatic quantum state generation and statistical zero
knowledge, in Proc. Thirty-Fifth Annual ACM Symposium on Theory of Computing , STOC
’03 (Association for Computing Machinery, New York, 2003) pp. 20–29.
 21

[78] R. P. Feynman, Simulating physics with computers, Int. J. Theor. Phys. 21, 467 (1982).
[79] I. Kassal, S. P. Jordan, P. J. Love, M. Mohseni, and A. Aspuru-Guzik,
Polynomial-time quantum algorithm for the simulation of chemical dynamics,
Proc. Natl. Acad. Sci. U.S.A. 105, 18681 (2008).
[80] A. M. Childs, Quantum information processing in continuous time, Ph.D. thesis, MIT (2004).
[81] D. W. Berry, G. Ahokas, R. Cleve, and B. C. Sanders, Efficient quantum algorithms for
simulating sparse Hamiltonians, Commun. Math. Phys 270, 359 (2007).
[82] D. W. Berry, G. Ahokas, R. Cleve, and B. C. Sanders, Quantum algorithms for Hamiltonian
simulation, in Mathematics of Quantum Computation and Quantum Technology, edited by
G. Chen, L. Kauffman, and S. J. Lomonaco (Taylor & Francis, Oxford UK, 2007) pp. 89–110.
[83] J. Kempe, A. Kitaev, and O. Regev, The complexity of the local Hamiltonian problem, in
Proc. 24th FSTTCS, LNCS 3328, Vol. 35 (Springer-Verlag, Berlin, 2004) pp. 372–383.
[84] B. Borchers and J. Furman, A two-phase exact algorithm for MAX-SAT and Weighted MAX-
SAT problems, J. Comb. Optim. 2, 299 (1998).
[85] A. W. Harrow, A. Hassidim, and S. Lloyd, Quantum algorithm for linear systems of equations,
Phys. Rev. Lett. 103, 150502 (2009).
[86] A. Alase, R. R. Nerem, M. Bagherimehrab, P. Høyer, and B. C. Sanders,
Tight bound for estimating expectation values from a system of linear equations,
Phys. Rev. Res. 4, 023237 (2022).
[87] D. A. Belsley, E. Kuh, and R. E. Welsch, Regression Diagnostics: Identifying Influential Data
and Sources of Collinearity (Wiley, New York, 2005) Chap. 3, pp. 100–105.
[88] I. Kerenidis and A. Prakash, Quantum recommendation system, in Innovations in Theoretical
Computer Science (ITCS 2017), LIPIcs, Vol. 67 (2017) pp. 1868–8969.
[89] L. Wossnig, Z. Zhao, and A. Prakash, Quantum linear system algorithm for dense matrices,
Phys. Rev. Lett. 120, 050502 (2018).
[90] S. Lloyd, M. Mohseni, and P. Rebentrost, Quantum principal component analysis,
Nat. Phys. 10, 631 (2014).
[91] E. Tang, A quantum-inspired classical algorithm for recommendation systems, in Proc. 51st
Annual ACM SIGACT Symposium on Theory of Computing (2019) pp. 217–228.
[92] E. Tang, Quantum principal component analysis only achieves an exponential speedup be-
cause of its state preparation assumptions, Phys. Rev. Lett. 127, 060503 (2021).
 22

[93] A. Gilyén, Y. Su, G. H. Low, and N. Wiebe, Quantum singular value transfor-
mation and beyond: exponential improvements for quantum matrix arithmetics, in
Proc. 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC 2019), pp. 193-204
(2019) pp. 193–204.
[94] S. Chakraborty, A. Gilyén, and S. Jeffery, The Power of Block-Encoded Matrix
Powers: Improved Regression Techniques via Faster Hamiltonian Simulation, in
46th International Colloquium on Automata, Languages, and Programming (ICALP 2019),
Leibniz International Proceedings in Informatics (LIPIcs), Vol. 132, edited by C. Baier,
I. Chatzigiannakis, P. Flocchini, and S. Leonardi (Schloss Dagstuhl – Leibniz-Zentrum für
Informatik, Dagstuhl, 2019) pp. 33:1–33:14.
[95] D. Jethwani, F. Le Gall, and S. K. Singh, Quantum-inspired classical algorithms for singular
value transformation, in Proc. 45th International Symposium on Mathematical Foundations
of Computer Science (MFCS 2020), 53:1-53:14 (2020).
[96] E. Farhi, J. Goldstone, and S. Gutmann, A quantum approximate optimization algorithm
(2014), arXiv:1411.4028 [quant-ph].
[97] E. Farhi, J. Goldstone, S. Gutmann, and L. Zhou, The Quantum Approximate Optimization
Algorithm and the Sherrington-Kirkpatrick Model at Infinite Size, Quantum 6, 759 (2022).
[98] E. Farhi, J. Goldstone, and S. Gutmann, A quantum approximate optimization algorithm
applied to a bounded occurrence constraint problem (2015), arXiv:1412.6062 [quant-ph].
[99] B. Barak, A. Moitra, R. O’Donnell, P. Raghavendra, O. Regev, D. Steurer,
L. Trevisan, A. Vijayaraghavan, D. Witmer, and J. Wright, Beating the ran-
dom assignment on constraint satisfaction problems of bounded degree, in
Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/R
Leibniz International Proceedings in Informatics (LIPIcs), Vol. 40, edited by N. Garg,
K. Jansen, A. Rao, and J. D. P. Rolim (Schloss Dagstuhl – Leibniz-Zentrum für Informatik,
Dagstuhl, 2015) pp. 110–123.
[100] R. Raussendorf and H. J. Briegel, A one-way quantum computer,
Phys. Rev. Lett. 86, 5188 (2001).
[101] A. M. Childs, D. Gosset, and Z. Webb, Universal computation by multiparticle quantum
walk, Science 339, 791 (2013).
[102] A. Kitaev, Fault-tolerant quantum computation by anyons, Ann. Phys. (N.Y.) 303, 2 (2003).
 23

[103] E. Farhi, J. Goldstone, S. Gutmann, and M. Sipser, Quantum computation by adiabatic

evolution (2000), arXiv:quant-ph/0001106 [quant-ph].
[104] E. Farhi, J. Goldstone, S. Gutmann, J. Lapan, A. Lundgren, and D. Preda, A quantum
adiabatic evolution algorithm applied to random instances of an NP-complete problem,
Science 292, 472 (2001).
[105] K.-P. Marzlin and B. C. Sanders, Inconsistency in the application of the adiabatic theorem,
Phys. Rev. Lett. 93, 160408 (2004).
[106] S. Jansen, M.-B. Ruskai, and R. Seiler, Bounds for the adiabatic approximation with appli-
cations to quantum computation, J. Math. Phys. 48, 102111 (2007).
[107] A. Elgart and G. A. Hagedorn, A note on the switching adiabatic theorem,
J. Math. Phys. 53, 102202 (2012).
[108] S. Bravyi, D. P. DiVincenzo, R. I. Oliveira, and B. M. Terhal, The complexity of stoquastic
local Hamiltonian problems, Quant. Inf. Comp. 8, 0361 (2008).
[109] D. Aharonov, W. van Dam, J. Kempe, Z. Landau, S. Lloyd, and O. Regev, Adiabatic quantum
computation is equivalent to standard quantum computation, SIAM J. Comput. 37, 166
(2007).
[110] M. B. Hastings, The power of adiabatic quantum computation with no sign problem,
Quantum 5, 597 (2021).
[111] B. C. Sanders, How to Build a Quantum Computer , 2399-2891 (IOP Publishing, 2017).
[112] J. Preskill, Quantum computing in the NISQ era and beyond, Quantum 2, 79 (2018).
[113] K. Bharti, A. Cervera-Lierta, T. H. Kyaw, T. Haug, S. Alperin-Lea, A. Anand, M. Degroote,
H. Heimonen, J. S. Kottmann, T. Menke, W.-K. Mok, S. Sim, L.-C. Kwek, and A. Aspuru-
Guzik, Noisy intermediate-scale quantum algorithms, Rev. Mod. Phys. 94, 015004 (2022).