Devops Crossplane Compositions

Devops Automation Of Software Deployment Pipelin · ML Project

Python · Data Preprocessing · Model Development · Evaluation

Project focus: anomaly detection / classification using IoT sensor streams and timestamped device measurements.

Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization

Yuval R. Sanders,1, 2 Dominic W. Berry,1, ∗ Pedro C. S. Costa,1 Louis W. Tessler,1

Nathan Wiebe,3, 4, 5 Craig Gidney,5 Hartmut Neven,5 and Ryan Babbush5, †

Department of Physics and Astronomy, Macquarie University, Sydney, NSW 2109, Australia

ARC Centre of Excellence in Engineered Quantum System, Macquarie University, Sydney, NSW 2109, Australia

Department of Physics, University of Washington, Seattle, WA 18195, United States of America

Pacific Northwest National Laboratory, Richland, WA 99354, United States of America

Google Research, Venice, CA 90291, United States of America

Here we explore which heuristic quantum algorithms for combinatorial optimization might be most

practical to try out on a small fault-tolerant quantum computer. We compile circuits for several variants of quantum accelerated simulated annealing including those using qubitization or Szegedy

walks to quantize classical Markov chains and those simulating spectral gap amplified Hamiltoni- ans encoding a Gibbs state. We also optimize fault-tolerant realizations of the adiabatic algorithm, quantum enhanced population transfer, the quantum approximate optimization algorithm, and other approaches. Many of these methods are bottlenecked by calls to the same subroutines; thus, opti- mized circuits for those primitives should be of interest regardless of which heuristic is most effective

in practice. We compile these bottlenecks for several families of optimization problems and report for how long and for what size systems one can perform these heuristics in the surface code given a range of resource budgets. Our results discourage the notion that any quantum optimization heuris- tic realizing only a quadratic speedup will achieve an advantage over classical algorithms on modest superconducting qubit surface code processors without significant improvements in the implementa-

tion of the surface code. For instance, under quantum-favorable assumptions (e.g., that the quantum algorithm requires exactly quadratically fewer steps), our analysis suggests that quantum acceler- ated simulated annealing would require roughly a day and a million physical qubits to optimize spin glasses that could be solved by classical simulated annealing in about four CPU-minutes.

List of Tables 2

I. Introduction 3

A. Overview of results 4

B. Organization of paper 5

II. Oracles and Circuit Primitives for Specific Cost Functions 6

A. Oracles for direct cost function evaluation 8

1. Direct energy oracle for L-term spin model and QUBO 9

2. Direct energy oracle for SK model 1

3. Direct energy oracle for LABS model 1

B. Energy difference oracles 1

C. Oracles for phasing by cost function 1

D. Oracles for linear combinations of unitaries 1

1. LCU oracles for L-term Hamiltonian 1

2. LCU oracles for QUBO and using dirty ancilla 1

3. LCU oracles for the SK model 2

4. LCU oracles for the LABS model 2

E. QROM-based function evaluation 2

III. Optimization Methods 2

A. Amplitude amplification 2

1. Combining amplitude amplification with quantum optimization heuristics 2

∗ corresponding author: [email protected] † corresponding author: [email protected]

2. Directly using amplitude amplification 2 B. The Quantum Approximate Optimization Algorithm 2 1. Amplitude estimation based direct phase oracle evaluation 3

2. Amplitude estimation based LCU evaluation 3 C. Adiabatic quantum optimization 3 1. Background on the adiabatic algorithm 3

2. Heuristic adiabatic optimization using quantum walks 3 3. Zeno projection of adiabatic path via phase randomization 3 D. Szegedy walk based quantum simulated annealing 3

E. LHPST qubitized walk based quantum simulated annealing 4 1. Rotation B 4 2. Equal superposition V 4

3. Controlled bit flip F 4 4. Reflection R 4 5. Total costs 4

F. Spectral gap amplification based quantum simulated annealing 4 1. The spectral gap amplification Hamiltonian 4 2. Implementing the Hamiltonian 5

IV. Error-Correction Analysis and Discussion 5

Acknowledgements 5

References 5

A. Addition for controlled rotations 5

B. Discretizing adiabatic state preparation with qubitization 6 1. Derivatives of matrix logarithms of unitary matrices 6

C. In-place binary to unary conversion 6

D. Cost of multiplication 6 1. Uses of multiplication in this paper 6 2. Methods for addition 6

3. Multiplying two integers 6 4. Multiplying an integer to a real number 7 5. Multiplying two different real numbers 7

6. Squaring a real number 7

E. Other approaches to Hamiltonian evolution based optimization 7 1. Heuristic variant of the shortest path algorithm 7 2. Quantum enhanced population transfer 7

LIST OF TABLES

I Summary of resource estimates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 II List of symbols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 III Oracle definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

IV Oracle complexities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 V QROAM complexities. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 VI Query complexity of algorithm primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

VII Resource estimates for optimization heuristic primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 VIII Resource estimates for the SK problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 IX Resource estimates for the LABS problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

I. INTRODUCTION

The prospect of quantum enhanced optimization has driven much interest in quantum technologies over the years. This is because discrete optimization problems are ubiquitous across many industries and faster solutions could poten- tially revolutionize fields as broad as logistics, finance, machine learning, and more. Since combinatorial optimization problems are often NP Hard, we do not expect that quantum computers can provide efficient solutions in the worst case. Rather, the hope is that there may exist ensembles of instances with structure that would enable a significant

quantum speedup on average, or for which a quantum computer can approximate better solutions. Among the most studied algorithms for quantum optimization are those that can function as heuristics. The objective of a heuristic algorithm is to produce a solution given a reasonable amount of computational resources that is “good enough” (or at least the best one can afford) for solving the problem at hand. While heuristics are often able to efficiently find the exact solution, sometimes they might fail to do so and instead only approximate the

exact solution (potentially in an uncontrolled fashion). But such techniques are still valuable because finding some usable result does not require a prohibitively long time. Accordingly, heuristics are often used without regard for rigorous bounds on their performance. Indeed, the NP Hardness of many combinatorial optimization problems makes heuristics the only viable option for many problems that need to be routinely solved in real-world applications. While some heuristic algorithms have a strong theoretical basis, many of the most effective heuristics are based

on intuitive principles and then honed empirically through data and experimentation. However, today, our ability to evaluate quantum heuristics through experimentation is limited since the only available quantum computers are small and noisy . We can perform numerics on small instances but extrapolation from those small system size numerics can be potentially misleading . Still, it is reasonable to ask the question: what would be some of the most compelling quantum heuristics for optimization that we would want to attempt on a small fault-tolerant quantum

computer, and how many resources would be required to implement their primitives?

There are many prominent approaches to combinatorial optimization on a quantum computer. These include

variants of Grover’s algorithm [3, 4], quantum annealing [5, 6], adiabatic quantum computing [7, 8], the shortest path algorithm , quantum enhanced population transfer [10, 11], the quantum approximate optimization algorithm , quantum versions of classical simulated annealing [13, 14], quantum versions of backtracking [15, 16] as well as branch and bound techniques , among many others. While often these works focus on the asymptotic scaling of exact quantum optimization, in many cases one can use these algorithms heuristically through trivial modifications

of the approach. For instance, the quantum adiabatic algorithm requires that one evolve the system for an amount of time scaling polynomially with the inverse of the minimum spectral gap of the adiabatic evolution. However, one can instead use this algorithm as a heuristic by choosing to evolve for a much shorter amount of time, and hoping for the best (this is similar to the strategy usually employed with quantum annealing). What essentially all forms of quantum optimization have in common is the requirement that the quantum algorithm

query some function of the cost function of interest. This is how the quantum computer accesses information about the energy landscape. For instance, if our cost function is H and H |xi = Ex |xi so that Ex is the value of the cost function for bit string |xi, then often we need to phase the computational basis by a function f (·) of Ex , e.g.,

X X

ax |xi 7→ e−if (Ex ) ax |xi . (1) x x

For example, f (Ex ) ∝ Ex is required to implement the quantum approximate optimization algorithm, quantum enhanced population transfer, digitized forms of quantum annealing and the shortest path algorithm. Alternatively, f (Ex ) ∝ arccos(Ex ) would describe something related to the quantum walk forms of those algorithms. If f (Ex ) ∝ (−1)(Ex ≤K) this primitive would be the bottleneck subroutine for amplitude amplification to boost our support on energies less than K. In most quantum approaches to optimization, a unitary like this is interleaved with a

much cheaper operation which does not commute with the operation in Eq. (1). Some algorithms instead call for simultaneously evolving under a function of the cost function together with a simple non-commuting Hamiltonian, but still the bottleneck is usually the complexity of the cost function Hamiltonian. The difference between many of these algorithms often comes down to the choice of f (·) and the choice of the much cheaper non-commuting unitary. The quantum algorithms for simulated annealing (e.g. ) work slightly differently as those algorithms are based

on making local updates to the wavefunction. For instance, the quantum version of a simulated annealing algorithm that updates with single bit flips requires

X X p p

ax |ki |xi |0i 7→ ax |ki 1 − f (Ex , Exk ) |xi |0i + f (Ex , Exk ) |xk i |1i (2) x x

where xk is defined as the bit string x with the k th bit flipped, i.e. |xk i = notk |xi, with k = 0 corresponding to no bit flip. But again, these approaches are still typically bottlenecked by our ability to compute these functions of the cost function f (·).

This paper will not address the important question of how well various heuristic quantum optimization approaches might perform in practice. Rather, our main motivation to is compile common bottleneck primitives for these ap- proaches to quantum circuits suitable for execution on a small fault-tolerant quantum computer. In doing this, we will see that most contemporary approaches to quantum optimization are actually bottlenecked by the same subroutines (e.g., those required for Eq. (1) and Eq. (2)), and thus improved strategies for realizing those subroutines are likely of

interest regardless of which paradigm of quantum optimization is ultimately found to be most effective in practice. In essentially all heuristic approaches to quantum optimization there is a primitive that is repeated many times in order to perform the optimization. Instead of investigating how many times those primitives must be repeated, we focus on the best strategies for realizing those primitives within a fault-tolerant cost model. For all algorithms we consider, we report the constant factors in the leading order scaling of the Toffoli and ancilla complexity of these primitives.

For some algorithms studied, such as for the quantum algorithms for simulated annealing, this work is the first to give concrete implementations which determine constant factors in the scaling. In other cases our contribution is to optimize the scaling for certain problem Hamiltonians or improve details of the implementation. We focus on Toffoli complexity since we imagine realizing these algorithms in the surface code [18, 19], where non-Clifford gates such as Toffoli or T gates require considerably more time (and physical qubits) to implement than Clifford gates.

A. Overview of results

The goal of this paper is to estimate the performance of an early universal quantum computer for key steps of combinatorial optimization. To achieve this goal, we consider prominent heuristic-based methods for combinatorial optimization on a quantum computer and how their key steps could be executed on early hardware. We consider the following heuristic-based methods: amplitude amplification as a heuristic for optimization and in combination with other approaches; quantum approximate optimization algorithms (QAOA) ; time-evolution approaches such

as adiabatic algorithms (including a variant incorporating a Zeno-like measurement ), quantum enhanced population transfer , and “shortest path” optimization ; and three quantum methods for simulated annealing (QSA), namely, a Szegedy walk-based implementation of Markov Chain Monte Carlo , a qubitized form of the Metropolis-Hastings approach , and simulation of a spectral gap amplified Hamiltonian . We review existing approaches in detail and develop several new methods or improvements. For each approach, we compile the primitive

operations into quantum circuits optimized for execution in the surface code . For concreteness, we focus our analysis on four families of combinatorial optimization problems: the L-term spin model, in which the Hamiltonian is specified as a real linear combination of L tensor products of Pauli-Z operators; Quadratic Unconstrained Binary Optimization (QUBO), which is an NP-hard special case of a 2-local L-term spin model; the Sherrington-Kirkpatrick (SK) model, which is a model of spin-glass physics and an instance of QUBO

that has been well-studied in the context of simulated annealing ; and the Low Autocorrelation Binary Sequences (LABS) problem, which is a problem with many terms but significant structure that is known to be extremely challenging in practice. For each of the above problems, we design several methods of calculating the cost function on a quantum computer depending on how a given algorithmic primitive is supposed to query and process the cost of a candidate solution. We present these methods in Section II.

Our analysis has produced several novel techniques that yield improvements over previous approaches. We recount the main ones here in order of appearance. In Section II A 2, we reduce by a logarithmic factor the cost of calculating the Hamming weight of a bit string using our method from . This new technique leads to improvements in several other parts of our paper. In Section II E, we introduce a new technique for evaluating costly arithmetic functions when computational cost matters more than accuracy. Our new technique is based on approximating the function using

linear interpolation between classically precomputed points that can be accessed using quantum read-only memory (QROM) , or a new variant of QROM designed for sampling at exponentially growing spacings. In Section III B, we introduce a method of cost function evaluation for QAOA based on amplitude estimation. This technique gives a quadratic improvement over the original approach. In Section III C, we introduce a heuristic method for adiabatic optimization that is likely to be computationally cheaper for some applications of early quantum

computers, although we do not expect an asymptotic advantage over other state-of-the-art approaches. The idea is to simulate the adiabatic path generated by the arccosine of the given Hamiltonian, not by the Hamiltonian directly, by “stroboscopically” simulating time evolution with short time steps produced by evolving under a qubitized walk. In Section III D we give a new method for constructing the Szegedy walk operator suggested in . Our key technique is a state preparation circuit that avoids expensive on-the-fly calculations by using the techniques introduced

in . In Section III E, we introduce an alternative method for executing the controlled qubit-rotation step in the qubitized Metropolis-Hastings approach introduced in . Our approach is preferable in cases where the Hamiltonian has a higher connectivity; i.e. when the probability of accepting a proposed transition depends on many bits in the candidate solution. In those cases the approach of would have exponential complexity. In Section III F, we give an

(Table VIII and Table IX) (Table VII)

Problem Algorithm Primitive

steps per day physical qubits Toffoli count Amplitude Amplification (§ III A) 4.8 × 1 8.1 × 1 2N 2 + N +O(log N )

QAOA / 1st order Trotter (§ III B) 4.7 × 1 8.6 × 1 2N 2 + 4N +O(1) SK Hamiltonian Walk (§ III C) 3.3 × 1 8.0 × 1 6N +O (log N )

QSA / Qubitized (§ III E) 3.3 × 1 8.4 × 1 5N +O(log N )

QSA / Gap Amplification (§ III F) 3.9 × 1 8.4 × 1 5N +O(log N ) 3 5 2 Amplitude Amplification (§ III A) 3.3 × 1 8.0 × 1 5N /2 + 7N/2 +O(log N )

QAOA / 1st order Trotter (§ III B) 3.4 × 1 8.4 × 1 5N 2 /2 +O(N ) LABS Hamiltonian Walk (§ III C) 4.9 × 1 8.0 × 1 4N +O(log N )

QSA / Qubitized (§ III E) 1.7 × 1 8.8 × 1 5N 2 +O(N )

QSA / Gap Amplification (§ III F) 1.7 × 1 8.8 × 1 5N 2 +O(N )

TABLE I. We compare the cost of implementing various types of heuristics optimization primitives in a fault-toleration cost

model. For concreteness, we give results for two problems: the Sherrington-Kirkpatrick model (SK) and Low Autocorrelation Binary Sequences problem (LABS). The numerical values from Table VIII and Table IX are based on a problem size of N = 256, a surface code cycle time of 1 µs, and a physical gate error rate of 10−3 (there are other assumptions as well, covered in more detail in Section IV). Note that depending how they would be used, it might be appropriate to scale the Hamiltonian walk

steps by a factor of λ which is roughly λSK ≈ N 2 /2 and λLABS ≈ N 3 /3. We simplify the complexity scaling estimates from

Table VII by treating as constant the bits of precision for numerical values.

explicit LCU-based oracle for the spectral gap amplified Hamiltonian introduced in . This explicit oracle enables a cost analysis of the approach, which we provide. Apart from assisting with our goal of estimating early quantum computer performance, many of these innovations produce asymptotic improvements to the approaches we consider. Having compiled the primitive operations of our chosen approaches and established how to query cost functions for our chosen problems, we are able to numerically estimate the computational resources needed to execute these

primitives on a quantum computer. Based on our assumption that the quantum computer will be built from super- conducting qubits and employ the surface code to protect the computation from errors, we focus on minimizing the number of ancilla qubits and non-Clifford gates that would be required. This approach is founded on the knowledge that non-Clifford operations are significantly harder than Clifford operations to perform in the surface code. We give an example of some of our ultimate findings in Table I. In the table we provide the leading order scaling

of the number of Toffoli gates needed to perform an update using five of the heuristics that we consider for two benchmark problems – LABS and SK. These scalings are reproduced from Table VII and presented in a simplified form where we assume that the working precision for various calculations is a constant. We also reproduce key figures from Table VIII and Table IX to show how we expect these estimated complexity scalings translate into the runtime of an early quantum computer. In Table I we show the estimated number of steps of the chosen algorithmic primitive

that could be executed in a single day on a quantum computer for a problem size of N = 256, a relatively small problem size that would be reasonable to execute with only a single Toffoli factory as we assume in Table VIII and

Table IX. We also present the estimated number of physical qubits needed.

We find that, despite great efforts made to optimize our compiled quantum circuits, the costs involved in imple- menting heuristics for combinatorial optimization will be taxing for early quantum computers. Not surprisingly, to implement problems between N = 6 and N = 10 we find that hundreds of thousands of physical qubits are required when physical gate error rates are on the order of 10−4 and sometimes over a million are required for physical gate error rates on the order of 10−3 . But even more concerning is that the number of updates that we can achieve in a

day (given realistic cycle times for the error correcting codes) is relatively low, on the order of about ten thousand updates for the smallest instances considered of the cheapest cost functions. With such overheads, these heuristics would need to yield dramatically better improvements in the objective function per step than classical optimization heuristics. From this we conclude that, barring significant advances in the implementation of the surface code (e.g., much faster state distillation), quantum optimization algorithms offering only a quadratic speedup are unlikely to

produce any quantum advantage on the first few generations of superconducting qubit surface code processors.

B. Organization of paper

Our paper is divided into essentially two parts. In the first part (Section II) we introduce and provide explicit compilations for a wide variety of subroutine or “oracle” circuits which perform operations related to specific problem

Hamiltonians. In the second part of our paper (Section III) we describe a variety of heuristic algorithms for quantum optimization and discuss how the oracle circuits of Section II can be called in order to implement these algorithms. We will see that the same “oracle” circuits are required by many algorithms. The results of Section III essentially provide query complexities to implement the primitives of common quantum optimization heuristics with respect to the oracles of Section II. Thus, while the results of Section II are adapted to particular problem Hamiltonians, the

results of Section III are fairly general. We now describe our results in slightly more detail.

Section II details strategies for realizing five straightforward oracle circuits which are detailed therein for each of four problem Hamiltonians in Table III. The specific problems we focus on are introduced at the beginning of Section II. These five oracles correspond to: (Section II A) the direct computation of a cost function into a quantum register, (Section II B) the computation of the difference between the cost of two computational basis states which differ by a specific single bit, (Section II C) an operation which phases the computational basis by an amount proportional to the

cost, (Section II D) the realization of a qubitized quantum walk which encodes eigenvalues of the cost function, and (Section II E) the computation of arithmetic functions of an input value using QROM . Our approach to computing arithmetic operations using QROM is likely useful in other contexts and is a new technique from this work. The culmination of Section II is Table IV which gives leading order constants in the scaling of Toffoli, T and ancilla complexities for all five of these oracles and for all four of the problems. Even though the first two cost functions we

introduce in Section II have fairly general specifications, they do not capture exploitable structure in all optimization problems of interest. Still, we imagine that the motifs developed in Section II will be helpful for any future work seeking to develop similar circuits for other cost functions. Section III describes how the oracle circuits of Section II are queried in order to realize the essential primitives of many fault-tolerant quantum heuristics for optimization. This section contains a mixture of new results and a

review of established methods. Section III A reviews how one can use amplitude amplification heuristically for optimization and also discusses how and why one might combine amplitude amplification with other algorithms in this section. Section III B discusses strategies for executing QAOA within fault-tolerant cost models. While most of this section is review, we also discuss the combination of QAOA with amplitude amplification based methods for more efficiently extracting the cost function value.

Section III C discusses several approaches to quantum optimization that are based on time evolution or quantum walks generated by a cost function and simple driver. First, we review the adiabatic algorithm and well known methods for how it might be digitized using product formula type circuits. We then introduce a method of simulating the adiabatic algorithm based on qubitized quantum walks. Next, we review how the adiabatic algorithm can be combined with a Zeno-like measurement approach which corresponds to evolution under static Hamiltonians for

random durations , and give some new results about how to optimally choose the distribution of those durations. The remainder of Section III focuses on three approaches to a quantum algorithm which accelerates classical simulated annealing. In terms of implementation, these are the most complex algorithms studied in the paper. For the three variants of the quantum simulated annealing algorithms, we provide the first complete compilation of circuits which execute the heuristic primitive. In Section III D we analyze and compile the original version of

these algorithms that is based on Szegedy quantum walks . As anticipated, this approach is the least efficient of the three studied. In Section III E we focus on what is essentially a qubitized version of the Szegedy quantum walk. The primary characteristics of this approach were independently described in (a paper that came out during the preparation of our own) but we go beyond that work to determine (and in some ways improve upon) constant factors in the scaling. Finally, in Section III F we compile the algorithm for quantum simulated annealing based on spectral

gap amplification , using an improvement based on qubitization. The results of Section III are summarized in

Table VI and Table VII, which give the query complexities with respect to the oracles of Section II and overall gate

and ancilla complexities of all algorithms of Section III for all of the cost functions of Section II. Finally, we conclude in Section IV with a discussion of these results. Our discussion includes an attempt to contextualize the ultimate cost of these heuristic primitives by giving the Toffoli count, ancilla count, and total number of physical qubits and wallclock time that would be required to realize these primitives given various resource budgets and assumptions in the surface code. These concrete resource estimates are given in Table VIII and Table IX.

We then finish with a discussion of how these results lead to a fairly pessimistic outlook on the viability of obtaining quantum advantage for optimization by using a small quantum computer unless one is able to obtain significantly better than a quadratic speedup over classical alternatives.

II. ORACLES AND CIRCUIT PRIMITIVES FOR SPECIFIC COST FUNCTIONS

While many paradigms of quantum optimization require the same bottleneck subroutines for their implementation, aspects of these subroutines will always be specific to the particular problem that one intends to optimize. Thus, in order to give concrete implementations and develop a sense of how many resources would be required for steps of

common quantum heuristics, aspects of our work are adapted to particular problem Hamiltonians (equivalently here, “cost functions”) of interest. There are four main types of Hamiltonians that we consider in this paper. The first two types of Hamiltonians we will study are of interest because they are programmable instances of optimization problems that one might encounter in practical situations. The second two types of problems we will study are of interest more to those who study statistical physics and for different reasons: because they define

ensembles of instances for which the average case has known and interesting properties. While solutions to specific instances of the latter two problems are probably not of much value, we anticipate they will be interesting problems on which to investigate the performance of a quantum computer. The four problems we study are described below.

1. L-term spin model: The most general Hamiltonian we will consider is the one we will refer to simply as the

“L-term spin model”. This Hamiltonian is a linear combination of L tensor products of Pauli-Z operators, L

X Y

HL = w` Zi , (3)

where w` are real scalars, Zi is the Pauli-Z operator on qubit i, N is the number of qubits in the cost function, and q` is a unique set of up to N integers which also take values between 1 and N (it is a set of integers corresponding to the indices of qubits on which term ` acts). One might anticipate that it would be helpful to also specify this Hamiltonian in terms of its many-body order k = max|{q` }|. However, perhaps surprisingly, none of the algorithms discussed in this paper have a Toffoli complexity that scales explicitly in k.

2. Quadratic Unconstrained Binary Optimization: We will also consider an NP-Hard example of HN 2 /2

known as Quadratic Unconstrained Binary Optimization (QUBO). The QUBO Hamiltonian is expressed as

X X X

HQUBO = wij = Jij Zi Zj + hi Zi + K (4)

2 2 i<j i i≤j

where K is a constant term that we will ignore from this point forward as this never needs to be explicitly simulated or computed for the purposes of optimizing the model, and the coefficients Jij and hi can be computed from the wij . This form of the model is also known as the Ising model but we refer to it here as QUBO since the Ising model can also mean a model with more limited connectivity and regular coefficients in some contexts.

3. Sherrington-Kirkpatrick: This problem corresponds to a widely studied model of spin glass physics .

The Sherrington-Kirkpatrick (SK) model is an example of the following QUBO Hamiltonian: X HSK = wij Zi Zj , wij ∈ {−1, 1} , kHSK k ≤ N 2 /2, (5) i<j

and the values of wij are usually chosen at random. The SK model is the focus of many studies on heuristic optimization, especially ones focusing on variants of simulated annealing. There is also a variant of the SK model which has the same statistical properties where the coefficients are Gaussian distributed real numbers.

4. Low Autocorrelation Binary Sequences: We think it would be interesting to use a quantum computer to

attempt to optimize problems that are very challenging on average. One problem is the Low Autocorrelation Binary Sequences (LABS) problem, also known as the Bernasconi model in physics : N

X −1 N

X −k

HLABS = Hk Hk = Zi Zi+k , kHLABS k ≈ N 3 /3, (6) k=0 i=1

which is an instance of HN 3 . This model is known to be extremely difficult; in fact the best classical algorithm has scaling like Θ(1.73N ) and has only been run for problem sizes up to N = 6 . However, we note that the model is not really a “problem” in the usual computer science sense because there is only one instance defined for each problem size. A variant of the LABS problem that we will consider is when the squared operators are instead replaced with absolute values, as one can verify that the ordering of the low energy solutions would be

unchanged by this modification, and it is sometimes less expensive to simulate with a quantum computer. The remainder of Section II discusses concrete circuit realizations for “oracles” which provide information about these cost functions of interest. Here we slightly abuse the term “oracle” to mean a circuit primitive which is repeatedly queried throughout an algorithm, usually revealing information about the problem we are solving. These oracles are

symbol meaning x bitstring corresponding to a candidate solution of the optimization problem

N number of bits needed to specify a candidate solution

Ex cost (a.k.a. energy) of candidate solution x as specified by a cost function

Hcf Hamiltonian operator corresponding to a cost function “cf”

b number of bits used to specify the precision of an oracle

L number of terms in a spin model (type of cost function)

λ the normalization parameter for LCU methods, related to the Hamiltonian 1-norm β inverse temperature in simulated annealing

C Toffoli or T cost of some oracle

A ancilla required to implement some oracle that must be kept

B temporary ancilla required to implement some oracle

TABLE II. A list of common symbols we use throughout this paper.

oracle oracle definition precision definition

Odirect Odirect Ex − Ẽx ≤ 2−bdir maxx |Ex |

P P

x ψx |xi |0i 7→ x ψx |xi |Ẽx i

Okdiff Okdiff

P ⊗bdif P f (k) i , f (k) −bdif

x ψx |xi |0i 7→ x ψx |xi |δE x |yi = Xk |xi δE x − Ex + Ey ≤ 2 maxx,y |Ex − Ey | −iγE f − γEx ≤ 2−bpha

Ophase (γ) Ophase (γ)

P P

x ψx |xi 7→ x ψ |xi xe γE g x x √ √ h0|⊗ log L OLCU |0i⊗ log L = H̃/λ,

PL PL

OLCU H̃ = `=1 w̃` U` , λ= `=1 |w` | w` − w̃` ≤ 2−bLCU

Oβfun Oβfun |zi |0i⊗bsm 7→ |xi |f˜(βz)i f (βz) − f˜(βz) ≤ 2−bfun

TABLE III. Quick definitions of the most important “oracle” circuits discussed in this work. Here, we slightly abuse the

term “oracle” to mean a circuit primitive which is repeatedly queried throughout an algorithm, usually revealing information about the problem we are solving. Throughout the paper we will use C to denote Toffoli (or occasionally T) complexity while A and B will denote persistent and temporary ancilla costs, respectively. For some of these oracles there are different Toffoli costs when performing them in the forward and reverse directions. We always pair a forward oracle with a reverse oracle, so

will give the average cost. In some cases the computation may introduce ancilla qubits not shown here, that are erased in the inverse computation. For the function evaluation oracle we incorporate multiplication by the inverse temperature β. The approximation f˜ is given to bsm bits, but for generality we allow an error 2−bfun which may be larger than 2−bsm .

used by multiple algorithms throughout our paper. In Section II A, we explain how to implement cost function oracles that are required to return the cost of a specific candidate solution x. We refer to such oracles as “direct energy oracles”. In Section II B, we explain how to implement cost function oracles that are required to return the difference in cost between two candidate solutions that differ by exactly one bit. In Section II C, we explain how to implement cost function oracles that are required to return the cost function as a phase, rather than as a value written to a

separate quantum register. In Section II D, we explain how to implement cost function oracles that are required to implement the cost function as a direct application of the Hamiltonian onto a target quantum register. Finally, in Section II E, we consider the cost of evaluating functions whose input is the difference in cost of candidate solutions as described in the other parts of this section. We summarize the content of this section using three tables. In Table II we give a list of the symbols we use for

reporting our computational complexity results. This table aids in the interpretation of the following two tables. In

Table III, we summarize the definitions of the various different kinds of oracles considered in this section. Finally, in

Table IV, we summarize the complexities of each of the sixteen cost function oracles (four types of oracles for each

of four types of cost functions) as well as the complexity of calculating functions of those oracle outputs. In these tables, and throughout the paper, we use log to indicate logarithms base 2.

A. Oracles for direct cost function evaluation

Many of the algorithms considered in this work are formulated in terms of a query to an oracle which computes the value of the cost function C (for instance, one of the Hamiltonians discussed above) in a binary register. For instance,

cost function oracle type Toffoli (*or T) gate count C persistent ancilla A temporary ancilla B L-term Spin Model direct energy L bdir (8) bdir (9) bdir − 1 (10) HL energy difference 2 L bdif + O(1) (8) bdif (9) bdif − 1 (10) direct phase* 1.15L(bpha + log L) + O(log L) (36) 0 (37) 1 (38)

Hamiltonian walk 3 L + 2 bLCU + O(log L) (56) 2 log L + 2 bLCU + O(1) (57) log L + O(1) (58) Quadratic direct energy N 2 bdir /2 + O(N bdir ) (11) bdir (12) bdir − 1 (13) Unconstrained energy difference N bdif (25) bdif (26) bdif − 1 (27) Binary Optimization direct phase* 0.5 N 2 (bpha + 2 log N ) + O(N 2 ) (39) 0 (40) 1 (41)

HQUBO Hamiltonian walk N (bLCU + 2 log N ) + O(N ) (73) 2bLCU + 4 log N + O(1) (75) 3 log N + O(log bLCU ) (76) Sherrington- direct energy N 2 (16) 2 log N (17) 4 log N (18) Kirkpatrick Model energy difference 2N (28) log N + 1 (29) 2 log N + O(1) (30) HSK direct phase 2N 2 + b2pha /2 + O(bpha log bpha ) (42) 2 log N + bpha + O(log bpha ) (43) 4 log N (44)

Hamiltonian walk 6 N + O(log N ) (82) 2 log N + O(1) (83) 3 log N + O(1) (84) Low direct energy 5N (N + 1)/4 (20) 2 log N + 1 (21) 3 log N + 3 (22) Autocorrelation energy difference 5N (N + 1)/2 (20) 2 log N + 1 (21) 3 log N + 3 (22)

N 2 + min 1 N b2pha , 1

N 2 + O(N bpha log bpha ) (49)

Binary Sequences direct phase 5

bpha + O(log bpha ) (46) 5 log N + O(log bpha ) (50) HLABS Hamiltonian walk 4 N + O(log N ) (87) 3 log N + O(1) (88) 2 log N + O(1) (89) function evaluation b2sm + bdif + O(bsm log bsm + 2bfun /2 ) (95) 2bsm + O(log bsm ) (97) bdif − 1 (98) arcsine evaluation (bsm + bfun )2 + bdif + O(bsm log bsm + 2bfun /2 ) (96) 2bsm + bfun + O(log bsm ) (99) bdif − 1 (100)

TABLE IV. Summary of complexities for realizing oracles used throughout this paper. Next to the complexity entry is a

number indicating the equation in the paper which gives the full expression in context. The energy difference for HL and LABS just has twice the Toffoli cost and the same ancilla cost as the direct energy oracle, because it is found by evaluating the energy twice. These oracles and the meaning of their precision parameters b are defined in Table III. The Toffoli count is reported except when the oracle type for that cost function is marked with (*), which indicates that T count is reported instead. Here

we include only the main terms in the order expressions. We use these costings to determine the complexities in Table VII.

X X

Odirect ψx |xi |0i 7→ ψx |xi |Ẽx i (7)

x x

where Ẽx is a binary approximation to Ex using bdir bits. We provide some strategies for how to realize this oracle for specific problems with low Toffoli complexity. We will refer to the Toffoli complexity of this oracle as C direct . However, first we will discuss an efficient method for performing reversible in-place addition of a constant. This routine will be critical to our implementation.

1. Direct energy oracle for L-term spin model and QUBO

We will now explain how to implement the direct energy oracle for the HL Hamiltonian with low Toffoli complexity. We will represent the energy Ẽx in the two’s complement binary representation, as this encoding enables efficient methods for addition . In two’s complement positive integers have a normal binary representation whereas negative integers are the complement of that representation minus one. For instance, in 4-bit two’s complement 3 = 001 whereas −3 = 110 + 1 = 110 . Zero still corresponds to all bits zero. The fact that we need to add one for

negative numbers complicates our approach but this representation is still preferable for our purposes. The main idea behind our approach will be toQadd or subtract the value of each term’s coefficient w` to a b-bit output register based on the parity of the string i∈q` Zi . To perform addition or subtraction controlled on a qubit, we use the fact that one can switch between addition and subtraction by applying not gates to the target register in two’s complement representation. That is, applying not gates to all qubits of a register will change |vi to |−v − 1i.

Adding w to this register will give |w − v − 1i, then applying not gates to all qubits again will yield |v − wi. To perform addition or subtraction controlled on a qubit, one can use the procedure shown in Figure 4(a) of (see

Appendix D 2). The complete procedure to compute the energy is then as given in Algorithm 1.

Algorithm 1 Energy evaluation for L-term spin model and QUBO

P Require: A quantum state x ax |xi, a vector of weights {w` } that specifies the L-term spin model or QUBO Hamiltonian. P Ensure: An output state of the form x ax |xi |Ẽx i, where H is the relevant Hamiltonian and Ẽx is the approximate eigenvalue of H corresponding to |xi. Q 1: Use Clifford gates (cnot gates) to compute the parity of the term i∈q Zi in-place in a single system qubit |π` i. Specifically, ` if xi is the ith bit of computational basis state x then we are using cnots to compute π` = ( i∈q` xi ) mod 2.

2: Controlled on |π` i, use more cnot gates to negate every bit of the output register. We will refer to this output register as |vi. Thus, after this step we will have the state |0i |vi if the first bit holds π` = 0 and we will have the state |1i |−v − 1i if the first bit holds π` = 1. 3: Using the strategy described in Appendix D 2 for the addition of a constant, add a bdir -bit binary approximation w̃` to the coefficient w` into the output register. This step has Toffoli complexity bdir − 2 where bdir is the size of the output register.

After performing this for L terms one can verify that this will produce the intended state |vi = |Ẽx i in the output register. Toffoli gates enter only through the adder in step 3. Thus, in total our approach has Toffoli complexity

CLdirect and ancilla requirements Adirect

CLdirect = L (bdir − 2) < L bdir , (8)

L = bdir , (9)

BL = bdir − 1 < bdir , (10)

where the ancilla refer to the carry bits for the adder in addition to the bdir bits required to output the energy. We note that for this oracle these costs have no dependence on the many-body order of the Hamiltonian HL since this only affects the number of cnot gates used to compute the parity of the terms. This exact same reasoning can be used to determine the complexity of computing the energies for the QUBO Hamiltonian. Due to the relative lack of structure in QUBO, there is no obvious way to improve over this general

complexity. There we have L = N (N + 1)/2 terms and so from Eq. (8), Eq. (9) and Eq. (10) we require a number of

Toffolis and ancillas equal to

directN 2 bdir N bdir N 2 bdir

CQUBO = + − N (N + 1) = + O(N bdir ), (11)

2 2 2 Adirect

QUBO = bdir , (12)

BQUBO = bdir − 1 < bdir . (13)

2. Direct energy oracle for SK model

Here we show that the energy for the SK model can be computed with only N 2 Toffolis and a logarithmic number of ancillas. The method we use is a sum of tree sums of bits. It is also possible to just use a tree sum with a Toffoli cost of about N 2 /4, but the drawback is that this method would need N 2 /2 ancilla qubits, which is prohibitive. For the SK model it is convenient to replace −1 with 0, so the sum takes values between 0 and L. That corresponds to dividing the Hamiltonian by 2 and shifting it, which does not change the optimization problem, but means we are

only summing bits. If we were to sum the bits in the obvious way, the Toffoli complexity would be approximately N 2 log N . However, we can take advantage of the fact we are summing bits to reduce the complexity to O N 2 .

Our methods are based on tree sums of bits. In it was shown that it is possible to sum L bits using L − 1 Toffoli gates and L − 1 ancilla qubits, and this sum can be uncomputed with no Toffoli cost. As discussed in , it is also possible to perform sums in approaches that reduce the number of ancilla at the price of increasing the number of Toffoli gates. In particular, we can subdivide the bits we are summing into about L/ log L groups of size log L, start by using the tree sum approach to sum each of the groups, add it into a running sum, and uncompute it. The number

of ancillas needed is reduced to approximately log L for each of the tree sums. There is also a cost of approximately L for adding the tree sums, giving a total complexity of approximately 2L. To be more specific, taking into account that L need not be a power of two, we can use M = dL/dlog Lee − 1 groups of size dlog Le, except for a remaining group of size J ≤ dlog Le such that M dlog Le + J = L. That is, there

are dL/dlog Lee groups, and J can be smaller than dlog Le. The Toffoli cost of computing each of these sums is

M dlog Le − M + J − 1 = L − M − 1 = L − dL/dlog Lee. (14)

The cost of the additions is

M X [dlog(J + jdlog Le + 1)e − 1] ≤ M (dlog(L + 1)e − 1) j=1

≤ M dlog Le < (L/dlog Le)dlog Le = L. (15)

We have assumed that L > 1 and hence log L > 0. The first line of Eq. (15) comes from starting with the sum over J bits and then adding each of the sums over dlog Le to it. After adding j of the sums over dlog Le bits, the maximum value of the sum is J + jdlog Le, so the number of bits needed to store the result is dlog(J + jdlog Le + 1)e, and the number of Toffolis needed for that sum is one less than that. The inequality in the first line comes from the fact that the total number is never less than L, so the cost of the additions is never greater than dlog(L + 1)e−1. The inequality

in the second line is because dlog(L + 1)e − 1 ≤ log L. The inequality in the third line is using M < L/dlog Le. Therefore, the total Toffoli cost is less than 2L. The ancilla cost of each tree sum is dlog Le−1, there are dlog(L + 1)e ancilla needed for the total, and dlog(L + 1)e − 1 temporary ancillas for the addition of the tree sum into the total. Since the ancillas in the tree sum are uncomputed, they contribute to an overall temporary ancilla cost, meaning the temporary ancilla cost is 2 log L + O(1) and the persistent ancilla cost (for the total) is log L + O(1).

Since L = N (N − 1)/2, if we were to use a tree sum the cost would be less than N 2 /2, but the ancilla cost would be approximately N 2 /2. The sum could be uncomputed without ancillas, giving an average (compute and uncompute) cost of N 2 /4. We expect that the tradeoff is not worth it in this case. However, by using the sum of tree sums, we get a Toffoli cost less than N 2 , and an ancilla cost that is logarithmic in N . That gives costs for the SK model of direct

CSK < N 2, (16)

SK ≤ 2 log N, (17)

BSK < 4 log N. (18)

3. Direct energy oracle for LABS model

Next we show that for the LABS problem it is possible to compute the energy with a Toffoli cost of 5N (N + 1)/4 for N ≥ 64, with a logarithmic number of ancilla qubits. We improve over the application of our general technique by specializing the implementation to the LABS problem. Since the LABS problem has L = O(N 3 ) with maximum integer energy values of O(N 3 ), we would expect a complexity of O(N 3 ). Instead, we show that it is possible to perform the direct energy evaluation at cost O(N 2 ). We focus on the form of the LABS Hamiltonian that is expressed

PN as k=1 |Hk | where Hk is as defined in Eq. (6) (as we mentioned, this form of the problem has the same ordering of the low energy landscape). In the following we use Ek to denote the eigenvalue of Hk . It will be most efficient to use the sum of tree sums approach described above. Here we need to find Ek by using +1 and −1 rather than +1 and 0, because we need to take the absolute value, so we need an extra bit for the sign. Therefore, after summing bits, we will need to multiply

by 2 (which has no Toffoli cost), followed by subtracting the number of bits. The overall approach is then as follows. We will sum k starting at k = N − 1 and go down to zero, so the number of bits at each step is minimized. For each value of k we will perform Algorithm 2.

Algorithm 2 Energy evaluation for LABS model

P Require: A quantum state x ax |xi,P the set of all terms in the LABS Hamiltonian {Hk }. Ensure: An output state of the form x ax |xi |Ex i. 1: Compute for computational basis vector |xi the value of Ek in a scratch register |ui that will require dlog(N − k + 1)e + 1 ancilla to store (with +1 for the sign). 2: Controlled by the highest bit of u (the sign bit in two’s complement), use cnot gates to negate the value of the output register |vi. At this point we have |ui |vi if u ≥ 0 or |ui |−v − 1i if u < 0.

3: Add the scratch register into the output register. 4: Use cnots to negate the output register controlled on the highest bit of the |ui register. 5: Uncompute |ui.

In Step 1, the Toffoli complexity computing each Ek is approximately 2(N − k) plus the cost of subtracting N − k. In two’s complement we can determine whether the number is negative or positive by looking at the highest bit; if the highest bit is 1 then we know the value is negative. This justifies the operations in Step 2. Since Step 2 requires no non-Clifford operations, it can be neglected in our cost analysis. In Step 3, the state is |ui |u + vi if u ≥ 0 or |ui |v − ui if u < 0; equivalently we now have the state |ui |v + |u|i. The output register will be of size

dlog[(N − k)(N − k + 1)/2 + 1]e + 1 so the Toffoli cost is dlog[(N − k)(N − k + 1)/2 + 1]e. The output register is significantly larger than the scratch register. However, with a slight modification of the procedure in Appendix D 2 we can allow this register to be smaller with no additional Toffoli cost. First, consider expanding the number of qubits |ui is encoded on. This is of course trivial for positive numbers. For negative u, for n bits it is encoded as 2n + u. Therefore, if we have a number that is negative and 0

we need to map it to a negative number on some larger number of bits n , then we need to map 2n + u to 2n + u, which means adding

0 Pn −1

2n − 2n = j=n 2j . This means that bits n + 1 to n of the negative number encoded on the n bits need to be ones. These can be set by using CNOTs controlled by bit n, which means no additional Toffoli cost is needed to encode the number into more qubits. A further simplification can be used to eliminate the need for those extra qubits. First, rearrange the addition circuit as in Figure 1 so that the qubits of |ui are only used as controls and not changed. Since all of the additional qubits for |ui contain the same value as the sign qubit of |ui, we may use that sign qubit

as the control instead of any of those additional qubits. Then the additional qubits are not used, and can be omitted. There is an improvement that we can make when we take into account that each computation needs to be paired with an uncomputation. This is because, in step 5, if we are computing an energy that we will later uncompute, then we can use the strategy of to erase |ui using X measurements and no Toffoli cost. A phase correction is required, but that can be done when we later uncompute the LABS energy. This means that in step 5 we have a cost of N − k

in uncomputing the LABS energy, but no Toffoli cost in computing the LABS energy. Because each computation is paired with an uncomputation, it is therefore convenient to give the average complexity of N − k. The largest temporary ancilla cost is when we need to uncompute the overall Hamiltonian, when it is 2 log(N − k) + O(1). That is still less than the temporary ancilla cost in step 3, so can be ignored. After repeating this for the N values of k one can verify that the output register will contain the energy of the

LABS Hamiltonian. Toffoli gates enter only through steps 1, 3 and 5. The primary contribution to the complexity is the computation of Ek in steps 1 and 5. Ignoring the complexity of subtracting N − k, the Toffoli complexity is N

X −1

3(N − k) = 3N (N + 1)/2. (19) k=0

The cost of the subtractions as well as the additions in step 3 will increase the cost, but also 2(N −k) is an overestimate of the cost of adding n − k bits. In particular, we can use tree sums of as many as approximately log N bits, rather than just log(N − k), with no penalty in terms of the temporary ancilla cost. The computed costs are shown in

Figure 1(a), and it is found for the range of N we are interested in (6 – 1024), the constant factor on N (N + 1) is

less than 1.2, rather than 1.5 (in fact, this bound is good for N ≥ 45). In particular, the constant factors for N = 64, 128, 2 and 10 are 1.16466, 1.12673, 1.13945, and 1.0901, respectively. To simplify the expressions we give the slightly looser bound in the table direct

CLABS < 5N (N + 1)/4, (20)

with the caveat that it is for N ≥ 45. The number of ancilla we will require is

Adirect LABS = dlog[N (N + 1)/2 + 1]e ≤ 2 log N + 1, (21) direct BLABS = dlog[N (N + 1)/2 + 1]e + dlog(N − k + 1)e + 2 ≤ 3 log N + 3. (22)

The persistent ancilla are for the output value. Approximately 2 log N of the temporary ancilla are for carry bits in the addition and log N are for the scratch register. We assume N > 1 for the inequalities which omits the trivial case. This example illustrates how taking advantage of problem structure can lead to advantages over the implementation of an oracle intended to handle a more general case.

B. Energy difference oracles

For some of the algorithms discussed in this work (specifically the quantum versions of simulated annealing) we often need the direct energy oracle only as means to compute a difference between the energies of two different states

Toffolis/(N(N+1)) (a) Toffolis/(N(N+1)) (b)

1.2 1.6

1.1 1.5

1.1 1.4

1.0 1.3

1.0 N 1.2 N 2 4 6 8 10 2 4 6 8 10

FIG. 1. The Toffoli costs for direct evaluation of the LABS Hamiltonian by computing Hk with a sum of tree sums. The average cost when computing and uncomputing the Hamiltonian is shown in (a). The cost of just computing and uncomputing Hk (omitting the cost of summing the absolute values), when we just compute the Hamiltonian, is given in (b).

which differ in only one bit. The ultimate objective in that context is a circuit that performs the mapping

X ⊗bdif

X (k)

Okdiff ψx |xi |0i 7→ ψx |xi |δE

f i, x δEx(k) = Ex − Ey , |yi = Xk |xi , (23) x x

(k) (k) where (as usual) Xk is the not operation on qubit k and δE f x is a binary approximation to δEx using bdif bits. Especially when the many-body order is 2-local, it is more efficient to consider a specialized implementation of Okdiff than to try to realize this operation using one call to Odirect and one call to Odirect Xk . (k) First, we will discuss the energy difference oracle for QUBOs. In this case, δEx is the eigenvalue of the operator X δH (k) = 2hk Zk + 2 Jik Zi Zk . (24)

We see that δH (k) is itself a simple cost function which is an example of HN (the L-term spin model with L = N ). Thus, to compute the eigenvalue of this operator (equivalent to implementing Okdiff ) we would require diff

CQUBO = N (bdif − 2) < N bdif , (25)

QUBO = bdif , (26)

BQUBO = bdif − 1. (27)

This scaling is much less than the N 2 bdif + O(N bdif ) Toffoli gates that would be required by making two queries to the direct energy oracle for QUBO. P For the SK model we can simplify the QUBO result. We would then have the difference operator 2 i6=k wik Zi Zk , so we just need to sum N − 1 bits, and can take bdif = dlog N e. We also need to subtract N − 1 from the bit sum to obtain the energy difference, but the cost of that subtraction plus the cost of the bit sum is still no more than the

upper bound of 2N we gave previously on the cost of the bit sum. Therefore the energy difference oracle has cost diff

CSK < 2N, (28)

SK = dlog N e ≤ log N + 1, (29)

BSK ≤ 2 log N + O(1). (30)

For higher many-body order Hamiltonians like LABS or the HL model of many-body order greater than two, the best strategy will probably involve two applications of the direct energy oracle Odirect . However, rather than actually use two registers to output the energy and then perform subtraction one can instead just compute the energy of x first and then in the same register compute the energy of y while subtracting all of the terms instead of adding them. There is a slightly greater Toffoli cost because the subtraction is on a slightly larger number of qubits, but that cost

is small enough to be ignored. This leads to Toffoli complexity of 2 C direct but requires no additional ancilla.

C. Oracles for phasing by cost function

In some contexts our goal will be to phase each computational state on which the wavefunction has support by an amount proportional to the energy of that computational basis state (this task is equivalent to performing evolution under a diagonal Hamiltonian for unit time). We will refer to circuits that achieve this task as a “phase” oracle and define them to act as

X X

Ophase (γ) ψx |xi 7→ e−iγEx ψx |xi gx − γEx ≤ 2−bpha . γE (31) g

To simplify the following discussion, we assume that Ex is shifted such that it is non-negative. Such a shift corresponds to an unobservable global phase. To realize this oracle, one strategy would be to first approximately compute Ex into a register using Odirect , then multiply by γ and perform further logic to phase the system by the amount in the register. For instance,

† X X

Odirect 1 ⊗ U phase (γ) O direct e−iγEx ψx |xi

ψx |xi 7→ (32) g

where the phasing operation needed is

2bX dir −1 phase 2πikγ̃

U (γ) = exp |kihk| . (33)

The value of 2πkγ̃/2bdir would correspond to the approximation of γEx , with k the integer approximating Ex (so k ≈ 2bdir Ex /Emax ) and γ̃ = γEmax /(2π) is a scaled form of γ. We will limit ourselves to simulations where the phase factor is no more than a factor of 2π, so γ̃ ≤ 1. Using the “phase gradient” trick of [32, 33], it is possible to apply a phase by adding into a reusable ancilla register initialized to the state

1 bgrad

|φi = √ e−2πi`/2 |`i . (34) 2bgrad `=0

Here we use bgrad rather than bdir in this state to allow for needing to use more bits to obtain the required precision in the phase. For details see Appendix A. In this case we need to multiply by the classically specified number γ̃ to obtain the required phase. This number can be given by log γ̃ + bpha + O(1) digits in order to obtain error < 2−bpha . There will be error due to the finite number of digits for Ex , the finite number of bits for γ̃, and the multiplication. Rather than performing the multiplication by γ̃, adding into the phase gradient state, then uncomputing the

multiplication, a more efficient method is to perform the multiplication by repeated addition into the phase gradient state. For each non-zero bit of γ̃, we can add a bit-shifted copy of k into the phase gradient state. Each addition into the phase gradient state has cost bgrad − 2, and on average approximately half the bits of γ̃ will be zero, giving cost roughly bgrad (log γ̃ + bpha )/2. To address cases where more bits of γ̃ are nonzero, we can write γ̃ as a sum of powers of 2 with plus and minus signs. In that case it is possible to use no more than (log γ̃ + bpha )/2 + O(1) additions,

giving cost bgrad (log γ̃ + bpha )/2 + O(bgrad ). The error due to omission of bits in the multiplication is no more than approximately 2−bgrad (log γ̃ + bpha )π, so to obtain error < 2−bpha one should take bgrad = bpha + O(log bpha ). That gives an overall cost for the multiplication

bpha (log γ̃ + bpha ) + O(bpha log bpha ). (35) For more details see Appendix A. Note finally that the state |φi can be initialized prior to simulation and reused throughout, with a negligible additive one time cost scaling as O(b2grad ). This one time cost comes from synthesizing bgrad arbitrary rotations. However, since this is additive to the overall cost (whereas all other oracle costs are multiplicative with the number of queries), we expect this will be negligible.

For the L-term spin Hamiltonians and QUBOs, the cost of the multiplication by γ can be eliminated by simply including it in the coefficients of the problem Hamiltonian. However for these cases an even more efficient approach is to simulate each term explicitly in a Trotter-like fashion and perform rotation synthesis to decompose each rotation into a sequence of T gates. In that case, one would require a number of T gates equal to the number of terms times the cost of rotation synthesis, which gives a complexity of O(L(bpha + log L)). Using the repeat until success circuits

of , this would give T gate and ancilla complexities of roughly

CLphase = 1.1 L(bpha + log L) + 10.9 L + O (1) = 1.1 L(bpha + log L) + O(L), (36) Aphase

L = 0, (37)

BL = 1. (38)

There is a single temporary ancilla

p qubit used by the repeat until success circuits. The measure of error in is the Frobenius distance d(U, V ) = 1 − |Tr(U V † )|/2. A phase error of 2−bpha gives |Tr(U V † )|/2 = |1 + exp 2−bpha i |/2 = √ cos 2−bpha /2 . Expanding in a series gives a Frobenius distance of 2−bpha / 8 + O(2−3bpha ). That means the cost √ becomes 1.1 bpha + log 8 + 9.2 = 1.1 bpha + 10.925, which is why the second term above is different than in . Because Toffoli gates require roughly twice the resources to distill as T gates , this approach is likely to be more

efficient in practice. This would give T and ancilla complexities for QUBO of C phase = 0.5 N (N +1)[bpha + log(N (N +1))] + 4.9 N (N +1) + O (1) = 0.5 N 2 (bpha + 2 log N ) + O(N 2 ), (39)

Aphase = 0, (40)

B = 1, (41)

assuming N > bpha . For the SK model it is better to compute the energy, add the energy into the phase gradient state, then uncompute the energy. That has Toffoli complexity 2N 2 , with 2 log N persistent ancillas and 4 log N temporary ancillas. The cost of the multiplication directly into the phase gradient state is b2pha /2 + O(bpha log bpha ) (with γ̄ ≤ 1), with bgrad permanent ancillas for the phase gradient state and bgrad − 1 temporary ancillas for the addition. That gives costs for

SK of

CSK = 2N 2 + b2pha /2 + O(bpha log bpha ), (42)

SK = 2 log N + bpha + O(log bpha ), (43)

BSK = max (4 log N, bpha + O(log bpha )) . (44)

For the parameters we consider for examples of gate counts, 4 log N ≥ bpha , so we give that in Table IV. For the LABS model we still need to explicitly compute the partial sum for Hk and then take the absolute value. Instead of adding the absolute value of that to an output register we can cnot the highest bit (indicating the sign of the partial sum u) into a single ancilla. Then, we can negate the whole partial sum controlled on this ancilla so that we have the state |ui |0i if u ≥ 0 or |−u − 1i |1i if u < 0. Then, we can add this ancilla to the partial sum register

giving us either |ui |0i if u ≥ 0 or |−ui |1i if u < 0. At this point we can multiply by γ and add the value of u to the |φi register and perform phase kickback in order to phase the system by the absolute value of the partial sum. Then, we need to invert adding the sign qubit register to the sum register and uncompute |ui and the ancilla. Using the sum of tree sums, we numerically find that the Toffoli cost to compute and uncompute the partial sums is no greater than 8N (N + 1)/5 for N in the range 6 to 10 that we consider. The numerically computed ratios are

shown in Figure 1(b), and for 64, 128, 2 and 10 we obtain 1.35962, 1.38507, 1.45027, and 1.43186. Multiplying by γ̄ directly into the phase gradient state has cost b2pha /2 + O(bpha log bpha ), giving a total cost phase CLABS ≤ 8N (N + 1)/5 + N b2pha /2 + O(N bpha log bpha ). (45) The number of ancillas needed is bgrad persistent ancillas for the phase gradient state, bgrad − 1 temporary ancillas for the addition, log N + O(1) for the temporary ancilla with the partial sum for Hk , and 2 log N + O(1) for the

temporary ancillas used for the sum of tree sums. The ancillas for the partial sum for Hk are needed at the same time as those for the addition into the phase gradient state, but the temporary ancillas for the sum of tree sums are not. The temporary ancillas for the sum of tree sums will be less than those for the addition into the phase gradient state, so can be ignored. That gives us a total of bgrad + dlog(N + 1)e + 1 temporary ancillas for a total

LABS = bgrad = bpha + O(log bpha ), (46)

phase BLABS = bgrad + dlog(N + 1)e + 1 = bpha + log N + O(log bpha ). (47)

For 9N/5 < b2pha , it is more efficient to just compute the entire energy, multiply by γ̄, then uncompute the energy, as explained above. Then we obtain complexity phase

CLABS ≤ 5N 2 /2 + O(N bpha log bpha ), (48)

|`i / = |`i / prepare prepare† R

W select

|ψi / |ψi / FIG. 2. A circuit realizing the qubitized quantum walk operator W controlled on an ancilla qubit [26, 28]. Here R is a reflection about the zero state for the entire |`i register, and therefore has Toffoli complexity log L + O(1) where dlog Le is the size of the |`i register. However, that overhead is negligible compared to the cost of the prepare and select operators in the constructions of this paper.

where the cost of multiplying by γ̄ is absorbed into the order term. Because this is smaller than that given above for 9N/5 < b2pha , we should give the cost as the minimum of the two complexities

phase ≤ 8N (N + 1)/5 + min N b2pha /2, 1 N 2 + O(N bpha log bpha ).

CLABS (49)

In that case we need 2 log N + O(1) temporary ancillas for the energy, and bgrad − 1 temporary ancillas for the addition into the phase gradient state at the same time. There are also 3 log N + O(1) temporary ancillas for computing the energy, which are not used at the same time as bgrad − 1 temporary ancillas. That gives a number of temporary ancillas increased to phase BLABS = max(bpha , 3 log N ) + 2 log N + O(log bpha ). (50)

We give this cost in Table IV to account for the possibility of using either method. In the table we assume 3 log N ≥ bpha , because that is true for most combinations of parameters we consider.

D. Oracles for linear combinations of unitaries

A number of approaches to quantum simulation are based on accessing the Hamiltonian as a linear combination of unitaries. This so-called “linear combination of unitaries” (LCU) query model has been used for Taylor series simulation , interaction picture simulation , and generalized to block encodings for “qubitization” . These approaches begin from the observation that any Hamiltonian can be decomposed as a linear combination of unitaries, L X

H= w` U` (51)

where w` are real scalars and U` are unitary operators. Here we consider an approach to forming quantum walks known as qubitization . The quantum walk involves LCU using queries to two oracles, followed by a reflection operation as shown in Figure 2. The first oracle circuit, the “preparation oracle”, acts on an empty ancilla register of dlog Le qubits and prepares a particular superposition state related to the notation of Eq. (51),

L r L

X w` X

prepare |0i 7→ |`i , λ≡ |w` | . (52) λ `=1 `=1

The quantity λ has significant ramifications for the overall algorithm complexity; specifically, the qubitization oracles will need to be repeated a number of times proportional to λ in order to realize the intended quantum walk. The second oracle circuit we require acts on the ancilla register |`i as well as the system register |ψi and directly applies one of the U` to the system, controlled on the ancilla register. For this reason, we refer to the ancilla register |`i as the “selection register” and name the second oracle the “Hamiltonian selection oracle”,

select |`i |ψi 7→ |`i U` |ψi . (53)

Using two queries to prepare and a single query to select we are able to implement a controlled quantum walk W which encodes the eigenvalues of H as a function of its own eigenvalues . Specifically, in a subspace this quantum walk has eigenvalues equal to the arccosine of the eigenvalues of the problem Hamiltonian divided by λ. We now discuss the realization of this quantum walk for the problems discussed in Section II.

1. LCU oracles for L-term Hamiltonian

Using the strategy for unary iteration introduced in we can implement select for HL with Toffoli complexity of exactly L − 2 and dlog Le − 1 extra ancilla qubits (or L − 1 and dlog Le if the operation needs to be controlled by another ancilla, as it is in ). The circuit given there has dlog Le ancilla. The other ancilla is just a control, it isn’t needed for the iteration. If we don’t want to make it controlled, then the number of ancilla needed is dlog Le − 1. Also, the Toffoli cost is only L − 2 if we don’t need to make it controlled. The operator we are to implement is

Y select |`i |ψi 7→ |`i Zi |ψi . (54) i∈q`

A simple way to understand the strategy would be to first map the binary representation of |`i to a one-hot unary register (a register that contains L qubits which are all off except for qubit ` which is on). Then, one could control the application of the Zi associated with i ∈ q` on this qubit with only Clifford gates. This strategy would have low Toffoli complexity but would require L ancilla. The basic insight of the unary iteration circuits in is that one can stream through bits of this unary register using just dlog Le − 1 extra ancilla. A circuit primitive is repeated L

times and at iteration j, a particular ancilla is equal to on if and only if ` = j. At that point in the circuit we can use Clifford gates to control the application of Hamiltonian terms like Zi Zj Zk . In a strategy referred to therein as “coherent alias sampling” is introduced and explicit circuits are provided which allow one to realize prepare for an arbitrary model with a Toffoli cost of L + bLCU + log L + O (1). We need approximately log L ancillas for the state being prepared, log L for the alternate index values, and log L for the

temporary ancillas in the QROM. There are bLCU ancillas for the keep probabilities in the coherent alias sampling and bLCU for the equal superposition state. Another temporary ancilla is used for the result of the inequality test. select uses L Toffolis and log L temporary ancilla, but these can be reused from the temporary ancilla used by prepare. Here, bLCU is a parameter that scales the precision of the cost function. In particular, this strategy will generate the state in Eq. (52) but with approximate coefficients w̃` in place of the exact coefficients w` such that

√ √ w` − w̃` ≤ 2−bLCU . (55)

Per the realization depicted in Figure 2, the quantum walk of interest is realized using two queries to prepare and one query to select. Thus, the strategy we have outlined requires Toffoli and ancilla counts of

CLLCU = 3 L + 2 bLCU + 2 log L + O (1) , (56)

ALCU

L = 2dlog Le + 2 bLCU + O(1), (57)

BL = dlog Le = log L + O(1). (58)

2. LCU oracles for QUBO and using dirty ancilla

In some cases, especially when there is some structure in the Hamiltonian terms and one is willing to reduce gate complexity at the cost of space complexity, another method of implementing prepare might be appropriate. In particular, we can combine the coherent alias sampling ideas of with the on-the-fly “dirty QROAM” of (which is a concrete realization of an idea in which builds on the QROM idea of and is named “QROAM” since it incorporates attributes of both QROM and QRAM). Using Theorem 1 of in conjunction with the coherent

alias sampling of with cost bLCU + O(log N ), we see that it is possible to implement prepare with 2L + 4 bLCU k + O (bLCU + k log L) (59) k Toffolis and (k − 1)bLCU dirty ancilla in addition to 2bLCU + log(L/k) + O(1) clean ancilla (not counting the selection register), where k ∈ [1, L] is a free parameter that must be a power of 2. This sort of QROAM can be uncomputed faster than it can be computed . Combining Theorem 3 in with coherent alias sampling leads us to the

result that the Toffoli cost of uncomputing prepare is less than the complexity quoted above by 4(bLCU − 1)k and can reuse the same ancilla. The number of dirty ancilla is reduced to k − 1, which means that the value of k can be taken to be larger, reducing the Toffoli complexity. See Table V for detailed costs of various types of QROAM. We will use this dirty QROAM strategy for the QUBO Hamiltonian. Our approach will involve indexing the terms and coefficients with two registers, each of size dlog N e so that |`i = |ii |ji. This makes applying select particularly

easy as we can use two applications of the unary iteration strategy that we discussed for implementing Eq. (54) to

type of ancilla type of computation Toffolis clean ancilla dirty ancilla clean forward dL/ke + M (k − 1) dlog(L/k)e + M (k − 1) 0 dirty forward 2dL/ke + 4M (k − 1) dlog(L/k)e M (k − 1) clean reverse dL/ke + k dlog(L/k)e + k 0 dirty reverse 2dL/ke + 4k dlog(L/k)e + 1 k−1

TABLE V. The QROAM complexities from , where L is the number of items, k is a power of 2, and M is the output size.

This table omits the log L ancilla from the selection register and the M -qubit output.

realize select with Toffoli complexity 2N − 4 and dlog N e − 1 ancilla (again, not counting those in the selection register). Because the QROAM strategy needs a single register that takes a contiguous set of values, we need to compute a new register for QUBO. For QUBO where i ≤ j one would calculate j(j − 1)/2 + i. (Note that this is with indexing starting from 1, which we have done to simplify the sums, but 1 would be represented in binary as 0 . . . 00, and so forth.) We apply the QROAM to this register, then uncompute it afterwards. The cost of computing and

uncomputing this register is O(log N ) due to the multiplications. Since L = N (N + 1)/2 for QUBO, the Toffoli cost of implementing select, in addition to implementing (and later uncomputing) prepare, will be

2 N

+ 4 bLCU k + 2 N + O bLCU + log N (60) k and will require kbLCU + O(1) dirty ancilla and 2bLCU + 2 log(N/k) + 2 log N + O(1) clean ancilla. For simplicity we are taking k to be the same for the computation and uncomputation here, though it is more efficient to take k larger for the uncomputation. Minimizing k by taking the derivative gives us p 4bLCU − 2N 2 /k 2 = 0, k = N/ 2bLCU , (61)

which leads to Toffoli complexity for the entire walk (including select) going like

4 N 2bLCU + 2 N + O bLCU + log N = 4N 2bLCU + O(N )

p p (62)

and ancilla complexity for the entire walk going like p p N bLCU /2 + 2 bLCU + 2 log bLCU + 2 log N + O(1) = N bLCU /2 + O(log(bLCU N )), (63)

where the first term in the ancilla scaling corresponds to the dirty ancilla, and thus can use the system qubits. For simplicity we have used the exact optimal value of k here; there√will a slight increase to the complexity because k needs to be a power of 2 so cannot be taken exactly equal to N/ 2bLCU . While this result optimizes the Toffoli complexity ofp our implementation it does so at a fairly high cost; we have increased the space complexity from N + O(bLCU ) to N bLCU /2 + O(bLCU ). In many cases this will not be a sensible

tradeoff and one should instead choose a smaller k so that the total number of qubits is not increased. For instance, k = N/bLCU will never increase the spatial complexity because we will always have N system qubits available in the system register that are not acted upon while we apply prepare. In some cases (for instance, the quantum simulated annealing algorithm realized by Szegedy quantum walks) we will actually have 2N qubits available for use during prepare and so we can safely take k = 2N/bLCU without increasing the spatial complexity.

Next we give a more detailed explanation of the costing. The QROAM costings are, for output size M , given in

Table V. The value of L is L = N (N + 1)/2 for QUBO. The output consists of bLCU qubits for the keep probability

in the state preparation, plus 2dlog N e qubits for the alternate values of i and j, so

M = bLCU + 2dlog N e. (64)

With clean ancilla qubits, the optimal value of k for preparation limited to powers of 2 is √ kc = 2round(log L/M ) , (65)

and for inverse preparation is √ kc = 2round(log L) , (66)

The other Toffoli costs in other parts of the LCU (beyond the QROAM) are as follows.

• There is O(log N ) cost to prepare the equal superposition states over i and j with i ≤ j. • There is 2(bLCU +2 log N )+O(1) Toffoli cost for the inequality test and controlled swaps for the state preparation and inverse preparation. • The cost of the arithmetic for producing the contiguous ancilla is O(log N ). • The select has a Toffoli cost of 2N − 4, or 2N − 2 if it needs to be made controlled.

Altogether these costs give a Toffoli cost with clean ancilla of

N (N + 1) N (N + 1)

+ M (kc − 1) + kc + 2bLCU + 2N + O log N , + (67) 2kc 2kc

with the values of M , kc , and kc in Eq. (64), Eq. (65), and Eq. (66). If we ignore the rounding in kc and kc , then the Toffoli cost is −1/2 p 2bLCU N + O N + bLCU + bLCU N log N . (68) √ √ The rounding in kc and kc can potentially increase the cost by a factor of 1/ 2 + 1/ 8, or about 6%. In costing the total number of ancillas for the state preparation, we also need to account for the following (in addition to those in Table V).

• There are 2dlog N e qubits needed for the prepared state. • There are bLCU qubits used for the register in equal superposition that we use to perform an inequality test with in the state preparation. • The M output qubits. • There are dlog Le temporary ancilla qubits used for the contiguous register. • There are bLCU − 1 temporary ancillas used in computing the inequality test for the state preparation. There are also log N temporary registers needed for the select step, but many of the qubits are only temporarily

used by the QROAM, and these can be reused, so we do not get an additional ancilla cost for select. The ancillas additional to those in Table V can therefore be given as 2M persistent ancillas and max(log L, bLCU )+O(1) temporary ancillas. The ancillas in Table V are temporary as well, and the bLCU qubits are not needed at the same time, giving a maximum of

log(L/kc ) + M (kc − 1) + log L + O(1), (69) p temporary ancillas. Ignoring the rounding in kc for simplicity gives the leading-order term as N M/2 temporary ancillas. Next we consider the cost with N dirty ancilla. The optimal value of k for the QROAM computation is

kd = 2blog(N/M +1)c . (70) p √ For the uncomputation cost it is optimal to take kd = L/2pwhich gives a cost of 4 2L, ignoring rounding of kd to a power of 2. With L = N (N + 1)/2, the optimal kd is N (N + 1)/4 < N , so there are enough dirty ancilla available. With rounding the value of kd for uncomputation would be √ kd = 2round(log N (N +1)/4) . (71)

Together with the additional Toffoli costs for the state preparation, the Toffoli cost for LCU is

N (N + 1) N (N + 1)

+ + 4M (kd − 1) + 4kd + 2bLCU + 2N + O(log N ). (72) kd kd

To simplify the expression, we will use N/M rather than N/M + 1 in the expression for kd , and not take into account rounding k to a power of 2. Then we get a computation Toffoli cost of LCU

CQUBO = N (bLCU + 2 log N ) + O(N ). (73)

For the ancilla cost, the persistent ancilla cost is again 2M , and the temporary ancilla cost loses the term M (k − 1) because dirty ancilla are used for that, so it does not increase the ancilla cost. The temporary ancilla cost is max(log(L/kd ) + log L, bLCU ) + O(1). (74) Using L = N (N +1)/2 and kd = N/M gives log(L/kd ) = log(N + 1)+log M −1. Then log(N + 1) = log N +O(1/N ).

Using M = bLCU + 2 log N + O(1) then gives

ALCU

QUBO = 2 bLCU + 4 log N + O(1), (75)

BQUBO = max(3 log N, bLCU ) + O(log bLCU ). (76)

In Table IV we just give 3 log N for the temporary ancilla cost, because it is true (or close to true) for the combinations of parameters we consider.

3. LCU oracles for the SK model

For the SK model we can considerably improve over the naive implementation. Because the SK model coefficients only need to give a sign, we just need to apply a sign to the terms in the superposition. That corresponds to the phase fixup used for the QROAM uncomputation, and the cost is the same. Another advantage of this approach is that we eliminate the 2(bLCU + 2 log N ) + O(1) cost for the inequality test and controlled swaps that would otherwise be needed for the coherent alias sampling. Therefore the Toffoli cost with clean ancilla is

N (N − 1)

+ kc + 2N + O log N . (77) 2kc

If we ignore the rounding in kc then we obtain the complexity

√ (2 + 2)N + O log N . (78) Beyond the ancillas needed for the QROAM, we just need the 4 log N + O(1) qubits for the i, j, and contiguous registers. Again select can use the same temporary ancillas as the QROAM and does not add to the ancilla cost.

Therefore the ancilla cost is

log(L/kc ) + kc + 4 log N + O(1). (79)

Ignoring the rounding in kc for simplicity gives

N/ 2 + O (log N ) . (80)

If we are using dirty ancilla, then the Toffoli cost becomes

N (N − 1)

+ 4kd + 2N + O log N . (81) kd

Ignoring the rounding in kd we obtain the complexity

CSK (82)

The persistent ancilla cost is only 2 log N for the i and j registers, and there is temporary ancilla cost of 2 log N for the contiguous register and log(L/kd ) ≈ log N from the QROAM. The total ancilla costs are therefore

ALCU

SK = 2 log N + O(1), (83)

BSK = 3 log N + O(1). (84)

4. LCU oracles for the LABS model

The LABS problem has L = O(N 3 ) terms in it, which would lead a high complexity quantum walk if our general strategy were applied. Fortunately, there is much structure in this problem. We start by rewriting Eq. (6) as N

X −1 N

X −k N

X −k

HLABS = Zi Zi+k Zj Zj+k . (85)

Instead of linearly indexing all O(N 3 ) terms, we will use three registers, each of size log N , which store the values of i, j and k. Thus, our select operation will act as select |ii |ji |ki |ψi 7→ |ii |ji |ki Zi Zi+k Zj Zj+k |ψi . (86) To accomplish this, we simply need 4 applications of the unary iteration primitive described in . Each of these primitives require N − 1 Toffoli gates. The only nuance is that we will need to compute the values i + k and j + k

before implementing the primitive to perform Zi+k and Zj+k . These additions can be performed in place (and then uncomputed) in the i and j registers and introduce a negligible additive 4 log N cost to the cost of unary iteration, where the cost of addition is dlog N e − 1 ≤ log N . Thus, the total Toffoli cost of our select implementation is 4N + 4 log N . We require approximately 3 log N persistent ancilla for the i, j and k registers, another log N temporary ancilla for computing the i + k and j + k (since they are computed

in place), and log N temporary ancilla for the addition. The unary iteration uses dlog N e − 2 < log N ancillas, which can be reused from the temporary ancillas for the addition so do not add to the cost. Because all terms have the same coefficient, prepare needs to initialize a superposition over a number of items that is not a power of 2. The Toffoli cost is O(log N ). The only unfortunate aspect is that for the LABS problem the corresponding normalization λ, is quite large and this will enter into the complexity of our quantum walks as the number of times the quantum walk

must be repeated to realize the intended unitary. In total then the cost to realize the quantum walk in Figure 2 is LCU

CLABS = 4 N + O(log N ), (87)

ALCU

LABS = 3 log N + O(1), (88)

BLABS = 2 log N + O(1), (89)

λLABS ≈ N 3 /3. (90)

E. QROM-based function evaluation

Now that we have explained how to implement oracles for various cost functions of interest, we turn to the question of how to calculate functions of the cost. This is important for several possible approaches to heuristic-based com- binatorial optimization. In simulated annealing, for instance, the probability of moving from one candidate solution to another is proportional to an exponential of the energy difference between the two solutions, multiplied by an inverse temperature β. We would thus require the quantum computer to calculate an exponential of the output of

the relevant energy difference oracle. Because we are implementing heuristic approaches to combinatorial optimization, we do not expect that the func- tions of the cost need to be calculated to a high degree of accuracy so long as the functions we compute are still monotonic in the cost (to make sure that the energy landscape is not inverted in any way). We instead want to minimize the computational complexity of evaluating these functions given rather weak requirements on the accuracy

of the output. Here we describe a general strategy for such cheap approximate function evaluation. Our overall strategy is to approximate a function f of a b-bit input z by a piecewise linear approximation, f˜. This approximation f˜ is calculated based on a choice of sample points z < z < . . . < zg , where z ≤ z < zg . These sample points separate the interval [z , zL ) into g different sub-intervals of the form [z` , z`+1 ) with ` = 0, 1, . . . , g − 1. The input z belongs to exactly one of these sub-intervals, and so we find an ` such that z` ≤ z < z`+1 . Having found `, we

use some data that can be looked up in order to calculate f˜(z) = αf (z` )+(1−α)f (z`+1 ) for α = (z`+1 −z)/(z`+1 −z` ). That is, the function f˜ is defined by interpolating between known values f (z` ) and f (z`+1 ) of the target function f . QROM can be used to obtain the region that z is in (i.e. the correct value of ` above), and for that region the QROM outputs a slope and intercept for the linear approximation. The Toffoli cost of looking up one of g different possible values in the scheme of is g − 2, or g − 1 if the output is controlled by a qubit. This Toffoli count relies on

a technique from in which certain naively expected Toffolis can be replaced with Clifford gates plus measurement. Also note that the Toffoli count of QROM-based lookup is independent of the number of bits of data output, meaning that we are free to choose any number of bits to represent the slope and intercept without introducing a Toffoli cost from the QROM. We choose the number of bits in order to obtain bsm bits for f˜. That is, f˜ may be a rough approximation of f , but we give f˜ to more bits than needed by that approximation so f˜ has smooth behaviour.

We will not use QROM precisely as specified in but rather a variant of it. To explain the distinction, we begin with some terminology. QROM is a method for executing a quantum circuit that operates on two registers, an input register and an output register. The input register has an initial value of ` encoded into it and the output register starts in the all-zero state. Each value of ` corresponds to some piece of data d` that has been specified classically before the quantum circuit was constructed. The effect of the QROM is

QROM : |`iinput |0ioutput 7→ |`iinput |d` ioutput . (91)

(a) • (b) • • • • • • •

• • • • • • • • • • • • • • • • • • •

• • • • • • • • • • • • • • • • • • • • • • • • • • • • • •

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? d d d d d4,5 d6,7 d8−1 d12−1 d d d2,3 d4−7 d8−1

FIG. 3. (a) This figure shows how to perform QROM with variable spacing for the example where there are 4 bits, and we aim to group the input numbers as 0, 1, 2, 3, {4, 5}, {6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15}. That is, we output the same data for inputs of 4 and 5, and so forth. The first four lines are the four input bits and the fifth is a control register. There are 6 Toffolis needed in this example for 8 data points, with one more Toffoli for a control. (b) This figure shows how to perform

QROM with variable spacing for the example where there are 4 bits, and we group the input numbers by powers of 2 as 0, 1, 2 − 3, 4 − 7, and 8 − 15. There are 3 Toffolis needed in this example for 5 data points, with one more Toffoli for a control.

Our variant of QROM is designed for the case in which there are data collisions. That is to say, we consider the case where d` = d`0 for several different pairs ` and `0 . In Figure 3(a) we explain how this QROM variant works for L = 1 in the case where d = d , d = d , d = d = d = d , and d = d = d = d . In this variant, we imagine that we have distinct parts of the iteration: iterate by ` 7→ ` + 1, iterate by ` 7→ ` + 2, iterate by ` 7→ ` + 4, and so on for each power of two. This variant of QROM is appropriate for our purposes because we want to improve

computational efficiency by spacing z` unevenly. This is equivalent to treating many pieced of data d` as being equal, as the data is simply the information needed to calculate a linear function. The total number of Toffoli gates is still g − 2 for g distinct regions, provided these regions correspond to ignoring bits of the input. For example, we can use a region such as {4, 5}, but not {3, 4}, because 4 ≡ 1 and 5 ≡ 101, so grouping 4 and 5 corresponds to ignoring the least significant bit, but the least significant bit changes between 3 and 4.

A further subtlety is that all regions need to be a size corresponding to a power of 2 for this cost. In some cases we may wish to have a final region that is larger than half, so it is not a size that is a power of 2. That will occur because we can have a large energy difference, but the exponential will give a transition probability that will just be approximated as zero for a wide range of energies. Then the cost can be larger. For example, if we are distinguishing 0 from 1 − 15, then it will take 3 Toffolis. The cost can be seen from the diagram where the size of the regions increases

in powers of 2, shown in Figure 3(b). There one can choose the numbers used for d4−7 and d8−1 to be equal, which gives a region for 4 − 15. This choice corresponds to a situation where the gap between neighboring interpolation points z` grows exponentially. For many of the piecewise approximations, we can obtain accurate approximations using just powers of 2, as in

Figure 3(b). Two main types of function that we aim to approximate are the exponential and the arcsine of the

exponential. For the exponential the piecewise approximation can use points at argument values of 0, 1/2, 1 and so on and achieve a piecewise linear approximation within about 0.03. The arcsine of the exponential is more difficult to approximate because the slope diverges at an argument of 0, but using piecewise linear approximation points starting at 1/2 and going up by powers of 2 gives similar precision as for the exponential. To estimate the number of interpolation points needed for higher precision, note that the error of interpolation of

function f (z) is approximately

(δz)2 0 f (z) , (92)

2-b/2 g 2-b/2 g 2.0 (a) 2.5 (b) e-z 2.0 1.5 arcsin(e-z/2 ) 1.5 1+e-z 1.0 e-z 1.0 1+e-z

0.5 e-z/2

0.5 1+e-z

2-b 2-b 10-6 10-5 10-4 0.0 0.0 0.1 1 10-6 10-5 10-4 0.0 0.0 0.1 1

FIG. 4. The numbers of intervals multiplied by 2−bfun /2 for the five functions we consider. In (a) we allow the intervals to have general endpoints, and in (b) we restrict the intervals to change by factors of 2, to be consistent with the QROM method we use. This demonstrates that the number of intervals scales as 2bfun /2 with a scaling constant around 1.

where δz is the width of the interval. To obtain error no greater than 2−bfun , we can therefore take √ 2−bfun /2 8 δz = p . (93) f 0 (z)

We can therefore estimate the number of intervals needed to approximate the function by

2bfun /2 ∞ p 0 Z √ dz f (z) . (94) 8 0

In the case where we are approximating arcsin(exp(−z/2)), then we would get g ≈ 1.311 × 2bfun /2 , and if we were approximating√ exp(−z), then √ we would have g √≈ 2(bfun −1)/2 . For the three functions used for spectral gap −z −z/2 −z amplification, 1/ 1 + e , e / 1 + e , and e −z / 1 + e−z we get 2−bfun /2 g of 0.346002, 0.566302, and 0.5170 −bfun /2 respectively. The variation of 2 g with bfun is shown in Figure 4(a). In practice, we need to limit the intervals to

sizes that increase by factors of two as described above. That increases the values of 2−bfun /2 g to around 1.0, 1.9, 0.5, 0.8, and 0.7 for the five cases, as can be seen in Figure 4(b), an increase of around 44%. Nevertheless, it is reasonable to give the scaling of g as O(2bfun /2 ), with the constant factor somewhere between 0.5 and 2. In the linear interpolation, the primary cost is that of multiplication of the argument times the slope. This cost will depend on how many digits are used for the slope and the argument. For simplicity, consider the case where

bits of the argument can be divided between those before the decimal point and those after the decimal point. The maximum value needed for the argument is O(bsm ), because beyond that the functions are within 1/2bsm +1 of their asymptotic values. That means only log bsm + O(1) bits would be needed before the decimal point. The number of digits after the decimal point would depend on the maximum value of the slope. In the case of the exponential the maximum slope is 1, so only bsm bits would be needed. Because the slope could be multiplied by an argument that

is O(bsm ), it could need bsm + log bsm + O(1) bits after the decimal point. Both numbers would need approximately bsm + log bsm + O(1) bits. This gives a cost of multiplication of b2sm + O(bsm log bsm ) Toffoli gates. The same result is obtained for all other functions we consider except the arcsine. The arcsine has a slope that goes to infinity, but the linear interpolation will onlyuse a finite slope. The minimum interpolation point needs to be O 2−2bfun , which gives maximum slope of O 2bfun , so the argument would require another bfun + O(1) bits after

the decimal point. The slope would need bfun + O(1) bits before the decimal point, and bsm + log bsm + O(1) bits after the decimal point to account for the maximum argument. Then both numbers would need bfun + bsm + log bsm + O(1) bits. We will take bfun similar to bsm , giving a multiplication cost of (bsm + bfun )2 + O(bsm log bsm ) Toffoli gates. To estimate the numbers of bits needed, we have performed simulation of the technique of Section III E with the SK Hamiltonian on 1 qubits, as shown in Figure 5. In that technique, we need an approximation of the arcsine of the

transition probability to control a qubit rotation, rather than the transition probability itself. Choosing interpolation points such that the error in the approximation of the rotation angle is no more than 0.01, the success probabilities are almost unchanged. So far we have assumed that the energy difference has been multiplied by the inverse temperature β before being input to the procedure. It is possible to bundle the multiplication by β into the oracle, and as shown in

Figure 5 that again has similar performance. There is also the question of how many bits are needed in the function

approximating the transition function. We again find that low-precision approximations have very little impact on the success probability.

Cost estimate

Failure probability

Rounded output

0.4 2 / 0.4 3 / 0.7 4 / 0.9 5 / 1.2

Number of annealing steps / Value of

FIG. 5. The effect of various methods of function approximation on optimization performance. We numerically simulate the quantum simulated annealing technique of Section III E using various methods of approximating the transition probability. We consider the performance when the rotation angle is calculated to machine precision (“exact”), with piecewise linear approxima- tion chosen to ensure the worst-case error does not exceed 0.0 (“interpolated”), incorporating the inverse temperature β into

the definition of the function so that we are interpolating f (z) = arcsin(exp(−βz/2)) rather than f (z) = arcsin(exp(−z/2)) to avoid a multiplication (“include β”), and when we round off the output of the function to 7 bits (“rounded output”). Each of these approximations builds upon the previous approximation, so we perform linear interpolation in all but the exact method. We simulate the performance averaging over 40 random SK instances on 1 qubits, with β linearly increasing over 5 steps

from 0 to 1.2. We report the average failure probability (bottom) as well as an estimate of the computational cost (top) in which we calculate the number of annealing steps divided by the probability of success. We observe that the differences in perfor- mance are not meaningfully affected by the method of function approximation, suggesting that we can pick the computationally cheapest option for our cost analysis.

The overall complexity of the interpolation excluding the QROM is therefore bsm + O(bsm log bsm ) or (bsm + bfun )2 + O(bsm log bsm ) when the arcsine is needed. To estimate the QROM complexity, we need to account for the final region not being a size which is a power of 2. In the worst case the additional cost can be no larger than bdif , which is the total size of the input register. We can therefore bound the QROM complexity as bdif + O(2bfun /2 ), giving total interpolation complexity of

C fun = b2sm + bdif + O(bsm log bsm + 2bfun /2 ), (95) or, for the case where the arcsine is needed, C fun = (bsm + bfun )2 + bdif + O(bsm log bsm + 2bfun /2 ). (96) For the number of ancilla qubits needed, except for the arcsine case there are 2bsm + O(log bsm ) needed for the slope and intercept, and 2bsm +O(log bsm ) used as temporary ancillas for the arithmetic. We need bdif −1 temporary ancillas for the QROM, which is more than the number used for the arithmetic. The output for the transition probability can

be added into the slope, so does not increase the ancilla cost. Therefore the ancilla costs are

Afun = 2bsm + O(log bsm ), (97)

B = bdif − 1. (98)

These considerations give the costs for function evaluation in Table IV. For the arcsine case we need 2bsm + bfun + O(log bsm ) ancillas for the slope and intercept, because we need another bfun ancillas for the slope. Again the temporary ancilla cost is primarily for the QROM, so the ancilla costs are

Afun = 2bsm + bfun + O(log bsm ), (99)

B = bdif − 1. (100)

III. OPTIMIZATION METHODS

In this section we review proposals for heuristic quantum optimization algorithms and explain how those algorithms can be implemented in terms of the oracles we describe in Section II. By this we include methods based on Hamiltonian walks, those based on time evolution, and methods related to simulated annealing. In most cases we will suggest improvements to these methods, but an important motivation for this section is to give a complete analysis of the complexity of these algorithms which includes constant factors so that we can estimate the resources required to

realize them in the surface code in Section IV. We describe the complexities of these methods in terms of the oracles from the previous section in Table VI, then give the complexity in terms of Toffoli or T gates in Table VII. As this section incorporates a wide variety of sophisticated techniques, we begin with a brief summary of the approaches we are considering. • Amplitude amplification (Section III A). We start by considering amplitude amplification, which can be used to directly amplify the amplitude of the solution. Unlike the other methods, it takes no advantage of the structure

of the solution, so is a useful reference point to compare to the other optimization approaches. Amplitude amplification can also be used in combination with the other optimization approaches, by performing amplitude amplification on the output of the optimization. • The Quantum Approximate Optimization Algorithm (Section III B). The steps of this approach (QAOA) are equivalent to Trotter steps, so the costing for QAOA and Trotter steps is given in the same lines in Table VI and

Table VII. Trotter steps can be used for adiabatic approaches, which are considered in the next subsection. But

here we also focusing on strategies for efficiently estimating the QAOA objective value that are more appropriate for a fault-tolerant cost model than standard approaches. • Adiabatic quantum optimization (Section III C). We review the quantum adiabatic algorithm and the most straightforward way of implementing that approach using a Trotter method that queries the phase oracles presented in Section II. We will then suggest a strategy for implementing the adiabatic algorithm using the

LCU oracles presented in Section II. The LCU oracles have a different costing to Trotter/QAOA, so are given in separate lines in Table VI and Table VII. Next, we will review a method for digitizing the adiabatic algorithm while suppressing certain types of errors that is based on inducing quantum Zeno-effect-like projection to the ground state by randomizing phases . We will suggest how this approach can be improved by using carefully chosen probability distributions to eliminate the errors that would manifest from incorrect measurements in the

Zeno approach. The time-evolution oracles used by these methods are also suitable for the quantum enhanced population transfer algorithm and the shortest path algorithm. Since we do not introduce new techniques for those algorithms, but rather review how our oracles can be queried within those frameworks, we discuss that content in Appendix E. • Szegedy walk based quantum simulated annealing (Section III D). Simulated annealing is a classical algorithm that mimics a physical cooling process via Markov chain Monte Carlo techniques. The quantum algorithm of

Somma et al. is to replace the Markov chain with a corresponding Szegedy walk. √ If the spectral gap of the Markov transition operator is ∆, the number of Szegedy walk steps grows as O(1/ ∆) in contrast with the best known bound on the worst case scaling of the number of Markov transitions needed in the classical approach, which goes like O(1/∆). Thus, the result appears to be a quadratic speedup over simulated annealing. We note that the O(1/∆) scaling of classical simulated annealing is known to be a very loose bound for a broad class

of problems. Typically, simulated annealing is used heuristically by lowering the temperature much faster than would be suggested by this bound. Our results constitute the first complete cost analysis for this algorithm that involves constant factors in the complexity. • LHPST qubitized walk based quantum simulated annealing (Section III E). Lemieux, Heim, Poulin, Svore, and

Troyer (LHPST) give a Metropolis-Hastings-like qubitized walk approach which is significantly more efficient

than the direct Szegedy approach. We will refer to this method by their initials, but we provide an improved technique that is efficient for more complicated problem Hamiltonians with high connectivity. LHPST consider a method that is efficient for simpler problem Hamiltonians with low connectivity, but would have exponential cost for the problem Hamiltonians considered here. • Spectral gap amplification based quantum simulated annealing (Section III F). In , the authors construct an

inverse-temperature-dependent Hamiltonian whose ground state in the zero-temperature limit is a superposition of solution configurations. By performing spectral gap amplification on their Hamiltonian, they obtain a gap that is similar to that for the quantum walk approach, indicating a similar speedup. Our main purpose is to outline these techniques and summarize the work needed to execute such algorithms in general and for specific

algorithm primitive Toffoli complexity ancilla complexity amplitude amplification step 2 C direct + N + O(bdir ) (108) Adirect + Bdirect + O(1) QAOA/Trotter step C phase + 4N + b2pha /2 + O(bpha log bpha ) (137) Aphase + max(Bphase , 3 log N ) + bpha + O(log bpha )

Hamiltonian walk step C LCU + O(1) ALCU + BLCU + O(1)

direct diff fun 2 Szegedy walk annealing step min(2(N + 1)C , 2N C ) + 2N C + 2N log N + 8N bsm + 18bsm + O(N ) (190) N A + N Afun + 5bsm + O(N ) (191) diff

LHPST walk annealing step 2C diff + 2C fun + N + 2bdif + 9 log N + O(1) (214) Adiff + Afun + Bdiff + log N + bsm + O(1) (215) gap amplified walk step 2C diff + 2C fun + 2bsm + N + 1 log N + O(brot ) (233) Adiff + Afun + Bdiff + 2 log N + bsm + O(1) (234)

TABLE VI. The Toffoli complexities and ancilla complexities needed to implement the basic primitives of various heuristic

algorithms, reported in terms of the oracle costs from Table III. For both the LHPST walk step and the gap amplified walk step the cost is reduced by 8 log N when N is a power of 2. By combining these scalings with the oracle costs given in Table IV, we arrive at the resource estimates in Table VII. For order ρ Suzuki (meaning that the error is O δtρ+1 ) we multiply the QAOA

cost by 2 × 5ρ/2−1 . For the QAOA/Trotter step, the bpha ancillas are for a phase gradient state, and may be saved if those are already accounted for in Aphase . The quantity is an allowable error in synthesizing a rotation in the state preparation.

problems of interest as outlined in the Introduction. We will also suggest a variant of this algorithm where one can use qubitized quantum walks rather than time evolution for the adiabatic evolution. In both cases, our

results provide the first constant factor bounds on the complexity of implementing these algorithms.

We summarize the outcomes of this section in Table VI. The entries of Table VI show how the Toffoli complexity and ancilla cost of each of the above named algorithm primitives depend on the relevant costs of oracles presented in

Table IV. We can then use Table VI together with Table IV to calculate the overall Toffoli complexity and ancilla cost

of each algorithm primitive for each type of cost function. The results of this analysis are summarized in Table VII. In giving the complexities in this table, we assume 2bfun /2 < bsm log bsm < brot to simplify the order terms, which is reasonable for the examples we consider in Section IV.

A. Amplitude amplification

1. Combining amplitude amplification with quantum optimization heuristics

All of the optimization heuristics discussed in this paper can be seen as methods of preparing a quantum state with overlap on a low energy subspace of interest. We will refer to the subspace of interest as S. Sometimes this subspace of interest is actually the lowest energy state (or states) and other times it is any state with energy less than a certain threshold. Furthermore, all algorithms discussed in this paper are heuristics that can be systematically refined. Let us refer to an algorithm for quantum optimization that is run for duration t as U(t). Let us assume that these algorithms

⊗N ⊗N

always begin in the state |+i and denote the output state of the algorithm by |ψ(t)i = U(t) |+i . Thus, after running our algorithm U(t) and sampling in the computational basis, the probability of measuring a state in the subspace of interest S is X p (t) = |hx|ψ(t)i| . (101) x∈S

When we say that these heuristics can be systematically refined what we mean is that we can (on average) increase p (t) by increasing t. This refinement will come at a cost C(t) > 0 which we define as the complexity of implementing ⊗N U(t). This complexity is greater than zero because preparing the initial state |+i requires nonzero time even if we do nothing further. We can also boost the probability of seeing a state in S by repeating U(t) more times and sampling. On average we will need to run our algorithm U(t) a number of times equal to 1/p (t) in order to see a

state in S. Thus, on average the cost to sample a state S is given by

C (t)

. (102) p (t)

There is a compromise to be reached between the duration t of the optimization heuristic U(t) and the success probability p (t); heuristics run for more time can reach a higher success probability and therefore be repeated fewer times, but increasing t beyond a certain point has a negligible impact on its success probability p (t). While past work has discussed this dichotomy in terms of a minimum time to solution metric which is parameterized in terms of a target success probability, here we focus on the mean cost to succeed because this seems more reasonable to consider

in a context where p (t) is unknown. Still, given knowledge of p (t) one could optimize this mean time by choosing t

cost function algorithm primitive Toffoli (* or T) count total ancilla qubits L-term amplitude amplification step 2 L bdir + N + O(bdir ) 2 bdir + O(1) Spin QAOA/Trotter step* 1.15L(bpha + log L) + O(N + log L + b2pha ) 3 log N + bpha + O(log bpha ) Model Hamiltonian walk step 3 L + 2bLCU + O(log L) 3 log L + 2 bLCU + O(1)

HL Szegedy walk annealing step 2(N + 1)Lbdir + 2N (b2sm + bdif + log N ) + O(N bsm log bsm ) N bdif + 2N bsm + O(N log bsm ) LHPST walk annealing step 4Lbdif + 2(bsm + bfun )2 + 2bdif + N + 9 log N + O(bsm log bsm ) 3bsm + 2bdif + bfun + log N + O(log bsm ) gap amplified walk step 4Lbdif + 2b2sm + 2bdif + N + 1 log N + O(brot ) 3bsm + 2bdif + 2 log N + O(log bsm )

Quadratic amplitude amplification N 2 bdir + O(N bdir ) 2 bdir + O(1)

Unconstrained QAOA/Trotter step* 0.5 N 2 (bpha + 2 log N ) + O(N 2 ) 3 log N + bpha + O(log bpha ) Binary Hamiltonian walk step N (bLCU + 2 log N ) + O(N ) 7 log N + 2 bLCU + O(log bLCU ) Optimization Szegedy walk annealing step 2N 2 bdif + 2N (b2sm + bdif + log N ) + O(N bsm log bsm ) N bdif + 2N bsm + O(N log bsm ) HQUBO LHPST walk annealing step 2N bdif + 2(bsm + bfun )2 + 2bdif + N + 9 log N + O(bsm log bsm ) 3bsm + 2bdif + bfun + log N + O(log bsm )

gap amplified walk step 2N bdif + 2b2sm + 2bdif + N + 1 log N + O(brot ) 3bsm + 2bdif + 2 log N + O(log bsm ) Sherrington– amplitude amplification step 2 N 2 + N + O(log N ) 6 log N + O(1) Kirkpatrick QAOA/Trotter step 2N 2 + 4N + b2pha + O(bpha log bpha ) 6 log N + bpha + O(log bpha ) Model Hamiltonian walk step 6 N + O(log N ) 5 log N + O(1)

HSK Szegedy walk annealing step 4N 2 + 2N (b2sm + 2 log N ) + 8N bsm + 18b2sm + O(N bsm log bsm ) N log N + 2N bsm + O(N log bsm ) LHPST walk annealing step 5N + 2(bsm + bfun )2 + 1 log N + O(bsm log bsm ) 4 log N + 3bsm + bfun + O(log bsm ) gap amplified walk step 5N + 2b2sm + 1 log N + O(brot ) 5 log N + 3bsm + O(log bsm ) Low amplitude amplification step 5 N (N + 1)/2 + N + O(log N ) 5 log N + O(1)

8N 2 /5 + min N b2pha /2, 9N 2 /1 + O(N bpha log bpha ) Autocorrelation QAOA/Trotter step 5 log N + bpha + O(log bpha ) Binary Hamiltonian walk step 4 N + O(log N ) 5 log N + O(1) Sequences Szegedy walk annealing step 5N (N + 1)2 /2 + 2N (b2sm + 3 log N ) + O(N bsm log bsm ) 2N log N + 2N bsm + O(N log bsm ) HLABS LHPST walk annealing step 5N 2 + 2(bsm + bfun )2 + 6N + 1 log N + O(bsm log bsm ) 6 log N + 3bsm + bfun + O(log bsm )

gap amplified walk step 5N 2 + 2b2sm + 6N + 1 log N + O(brot ) 7 log N + 3bsm + O(log bsm )

TABLE VII. Resource estimates for the various heuristic optimization primitives explored throughout this paper, applied to

our four problems of interest. For both the LHPST walk step and the gap amplified walk step the Toffoli count is reduced by

8 log N when N is a power of 2. In all cases, these algorithms are refined by applying the primitive more times. The parameters

used are as follows: N is the number of bits on which our cost function is defined; L is the numbers of terms in an L-term spin Hamiltonian; bpha is the number of bits we use to approximate phases in the implementation of our phase oracle; bdir is the number of bits we use to approximate the value of energies; bLCU is the number of bits used to approximate the square root of Hamiltonian coefficients in LCU methods, and brot is the number of bits of precision used in rotations. The Trotter step and

Hamiltonian walk steps can be used to realize the adiabatic algorithm, the Zeno phase randomization variant of the adiabatic algorithm, heuristic variants of the short path algorithm or quantum enhanced population transfer, and many other heuristics based on Hamiltonian time evolution. These scalings result from combining the query complexities in Table VI with the oracle costs in Table IV. When the algorithm type is decorated with (*) we report T complexity rather than Toffoli complexity. We

have only given the main terms in the order expressions to simplify them.

to minimize Eq. (102). But rather than simply repeating the state preparation 1/p (t) times, one could instead boost the success probability with amplitude amplification. Amplitude amplification is an idea which generalized Grover search and can be used to boost the probability of a marked state or subspace. For instance, we might define these marked states to be any state in S. In this context, amplitude amplification would allow us to perform a series of m reflections (involving two preparations of the state

|ψ(t)i) which boosts the probability of measuring the marked subspace to p pm (t) = sin (2m + 1) arcsin p (t) . (103)

For instance, if we hoped to boost the probability to 1 then by using repeated sampling we would need roughly

O(1/p (t)) repetitions. However, by using amplitude amplification we would need only

! π 1 m≈ p −1=O p (104)

4 arcsin p (t) p (t)

iterations if p (t) is small (this is akin the usual quadratic Grover speedup). For each round of amplitude amplification one needs to reflect about a qubit marking the subspace of interest S. In our context the idea would be to amplify either a target energy (if a target energy, e.g. the ground state energy, is known) or to amplify all states with energy less than a certain threshold. To do this, one will need to compute the energy value into a register and perform either an equality or inequality test to determine whether we have reached

a marked state. The energy can be computed simply by using the direct energy oracles introduced in Section II A. However, both that step and the cost of the equality or inequality evaluation will typically have a negligible additive cost to the cost C(t) of actually running the quantum algorithm U(t). Moreover, the ancilla used for storing the value of the energy can be borrowed from ancilla used in other parts of the algorithm. For amplitude amplification to be most effective one should have an estimate of the overlap p (t) in order to avoid

“overshooting” the peak of the function in Eq. (103). Unfortunately, a reliable estimate of p (t) will not be known in advance in general. In some rare cases one might instead have a somewhat tight estimate of a lower bound to p (t) and in those cases some advantages can be realized by using a variant of amplitude amplification known as fixed point amplitude amplification . However one can confirm that fixed point amplitude amplification will have no advantages in our context compared to the exponential search heuristic proposed in when the best lower bound

that is available is p (t) > 0. The idea behind the approach in is to run amplitude amplification for m = 2j iterations for j = 0, 1, 2, 3, ... and so on until we sample a marked state. The cost of each iteration of amplitude amplification is 2 C(t) and so if we need to repeat this procedure until m = 2k it will have a total cost that goes like k X 2j = 2 C (t) 2k − 1 .

2 C (t) (105)

Therefore, since the probability of failure in a single run with m = 2j iterations is 1 − p2j (t), we see that the overall mean cost of the procedure is ∞ k−1 !

X Y C (t)

2 C (t) (1 − p2j−1 (t)) = O p . (106)

Though the left side of this expression cannot be simplified analytically, it converges quickly and can be easily numerically computed for any p (t) > 0. Comparing Eq. (102) to Eq. (106) we can see that there is a clear asymptotic advantage to using amplitude amplification over classical sampling and expect this advantage will be realizable in practice in many contexts of interest for us. Like with Eq. (102), if one has knowledge of p (t) then one can minimize Eq. (106) with respect to t to make

the optimal tradeoff between running the algorithm U(t) for longer and using more rounds of amplitude amplification. In some cases it might actually be the case that the optimal choice is t = 0, which would correspond to using amplitude amplification directly as a heuristic for optimization. The only downside to using amplitude amplification in conjunction with other heuristic quantum algorithms for optimization is that we have traded incoherent repetitions of the primitive of U(t) for coherent repetitions of the primitive of U(t). In some cases this will mean that we need to

target a higher error rate to make the calculation fault-tolerant by using an error-correcting code.

2. Directly using amplitude amplification

In the prior section we described how amplitude amplification can be combined with any of the other optimization heuristics in this paper in order to boost overlap on a target low energy subspace of interest. However, one can also use amplitude amplification by itself as a heuristic for optimization. This heuristic provides an interesting point of comparison to other algorithms because it offers a quadratic advantage over classical brute force search without leveraging any structure that might be available in a particular optimization problem. Thus, it is asymptotically

the optimal strategy for solving totally unstructured problems like those described by the typical Grover oracle (all computational basis states have energy zero except for a solution with energy −1) or the random energy model (all computational basis states have a unique, Gaussian distributed energy). To use amplitude amplification on its own all one needs to do is to regard the algorithm U(t) as the preparation ⊗N of the symmetric superposition state |+i , which requires only Clifford gates. In the analysis of Section III A 1

we assumed that the cost of directly computing the energy and then performing the comparison operation would be negligible compared to the cost of applying U(t) but that is not the case when we aim to directly apply amplitude amplification. Here, the main cost of a step will be the cost to compute (and then later uncompute) the energy. Following Eq. (106), in this context we would find that the mean cost of applying amplitude amplification directly will then scale like ∞ k−1

2 j

1 direct √ 2C + N + O (bdir ) 2 −1 1−sin 2 +1 arcsin = O C + N + O (b dir ) 2N j=1 2N k=1 (107)

where we have used p (t) = 1/2N . The cost 2 C direct + N + O (bdir ) comes from cost C direct to directly compute the energy, cost O (bdir ) to apply the inequality operator to determine whether the energy is below the target threshold, cost C direct to uncompute the energy, and cost N − 2 to reflect about the equal superposition state. Note that this procedure is exactly the heuristic approach introduced in . When the subspace S contains only a single state this algorithm reduces exactly to standard Grover search . For later comparisons in this paper we will refer to the cost

of a single step of amplitude amplification as having

2 C direct + N + O (bdir ) (108)

Toffoli complexity and requiring Adirect + B direct + O(1) ancilla.

B. The Quantum Approximate Optimization Algorithm

The quantum approximate optimization algorithm (QAOA) is another popular approach to quantum optimization, introduced in . The QAOA initially attracted significant interest after it was shown to produce a better approxi- mation ratio for a specific combinatorial optimization problem of bounded occurrence, Max E3LIN2, than any known efficient classical method . While a more efficient classical algorithm was presented shortly afterwards , interest in QAOA has only increased since then. While bounds on the performance of QAOA are sometimes available, in most

contexts it is studied as a heuristic in the sense that the intention is to use the algorithm without knowing how well it will perform in practice. Part of the appeal of QAOA has been that it is an easy-to-implement algorithm that can be tested on noisy intermediate scale quantum (NISQ) devices even before fault-tolerance is available . Nonetheless, QAOA would still be an interesting algorithm to perform within error-correction. The QAOA is more straightforward than other algorithms discussed in this work. The QAOA consists of two

components that are repeatedly applied. The first component is parameterized evolution under the diagonal problem Hamiltonian C,

UC (γ) = e−iγC = Ophase (γ) , (109)

where in the last equality we emphasize that UC (γ) is equivalent to the phase oracle Ophase (γ) that we introduce and provide explicit circuit constructions for in Section II C. The second component is parameterized evolution under a local transverse field driver Hamiltonian B, N X

UB (β) = e−iβB B= Xj . (110)

The QAOA is a variational algorithm that uses repeated application of these unitaries to prepare a parameterized state that is then optimized. The depth of the variational algorithm is usually denoted as “p” in the QAOA literature. Specifically, for depth p we prepare a state parameterized by γ = (γ , . . . , γp ) and β = (β , . . . , βp ), ⊗N |γ, βi = UB (βp ) UC (γp ) . . . UB (β ) UC (γ ) |+i (111) ⊗N where |+i is the symmetric superposition of all 2N computational basis states.

For a given p, we attempt to find parameters that minimize the expectation value of the cost

hCi = hγ, β| C |γ, βi . (112)

The QAOA proposes to use the quantum computer to estimate this expectation value and then to use a classical processor to perform a classical optimization, in a fashion similar to other variational algorithms [44, 45]. In general finding the globally optimal values of γ and β could prove to be very challenging. However, QAOA is a heuristic algorithm and the idea is that even locally optimal parameter settings might provide good approximations. The original implementation of QAOA suggested that one directly sample the cost function C to estimate hCi.

Using this method, if one wishes to converge an unbiased estimator hCi e so that | hCi e − hCi | ≤ ∆C then the state |γ, βi must be prepared and sampled a number of times equal to σ 2 /∆2C where σ 2 = hC 2 i − hCi . (113)

While one will not know σ 2 in advance, one can obtain a reasonable estimate of σ 2 after only handful of measurements and use that to determine how many more measurements are required.

The cost of QAOA is always dominated by the number of times that one must repeat the unitary UC (γ); the cost to implement UB (β) is essentially free in comparison. Thus, if J is the number of outer-loop optimization iterations which each require a query of the energy accurate to within ∆C then in total we will require Toffoli complexity p J C phase σ 2 . (114) ∆2C It is difficult to say what an appropriate choice of the quantities J and ∆C should be as this depends on the problem, the

choice of optimizer one is using, and how aggressively one is attempting to optimize. However, in many circumstances one might not need to perform the outer-loop optimization at all and can thus take J = 1. This is the case when optimal (or “good enough”) parameters can be inferred before running the algorithm. Such a situation often arises when running large instances of optimization problems that are characteristic of a well defined ensemble (for example, if one is running instances of the Sherrington-Kirkpatrick model). This is due to the observation that normalized

energy landscapes (proportional to hCi as a function of γ and β) concentrate to instance and size independent average values for large N [46, 47]. Thus, surprisingly, it is possible to find the optimal values of γ and β by optimizing much smaller (presumably classically tractable) instances of these problems. Another possibility is that one simply use γ and β parameters that would be obtained from a Trotterization of the quantum adiabatic algorithm; in fact, there is evidence that these parameters become optimal as one increases p . Thus, for problems where it is appropriate

to forgo the outer-loop optimization step of QAOA, we can approximate the Toffoli complexity as p M C phase where M is the number of samples we desire. The number of logical qubits required for its implementation will be N (not counting any extra ancilla used for the phase oracle). Within the context of NISQ computations it makes sense to use this method of sampling to estimate the cost function expectation value and then to perform the optimization on a classical computer. The reason is because

both strategies minimize the size of each quantum circuit that must be executed, although potentially at a cost of needing a larger number of repetitions compared to other strategies. However, within cost models appropriate for fault-tolerance the primary resource to consider is the total number of gates required by the computation and no particular distinction is made whether those gates are involved in repeated applications of short quantum circuits or a single application of a longer quantum circuit. Thus, on a fault-tolerant quantum computer it may make sense

to consider more elaborate versions of QAOA in which the expectation value estimation and potentially even the optimization is also performed on a quantum computer. For instance, perhaps the variational parameters γ and β can be stored in a quantum register on which the QAOA unitary is controlled. Such a scheme is considered in where it shown that such a method can enable quadratically faster resolution of the gradient than would be otherwise required, however with significant constant overhead. Similarly, by using the amplitude amplification based Monte

Carlo techniques discussed in (see Theorem 5 therein) one can reduce the number of state preparations needed for an estimate of the cost function to O((σ/∆C ) log3/2 (σ/∆C ) log log(σ/∆C )), an almost quadratic improvement over the naive sampling strategy. However, as that method requires a number of copies of the system register scaling as O(log(σ/∆C ) log log(σ/∆C )), it might prove to be prohibitively expensive for realization on small fault-tolerant quantum computers. We now consider two alternative ways to measure the energy in QAOA which might prove more

practical for small fault-tolerant quantum computers.

1. Amplitude estimation based direct phase oracle evaluation

Apart from sampling, the next most natural algorithm for estimating the energy is using amplitude estimation to compute the expectation value of each term in the cost function in sequence. Let us assume that the cost function PL takes the form, C = `=1 w` U` , where U` is a unitary

P operator (and will typically be a sum of diagonal Pauli

operators), as in Eq. (51). Further we will take λ = ` |w` |. The algorithm that we employ is simple, for each ` from

1 to L wePcompute the quantity hψ| U` |ψi within error ∆C /(L|w` |). An unbiased estimate of the cost function is then

given by ` w` hψ| U` |ψi and from the triangle inequality the error is at most ∆C . An estimate of hψ| U` |ψi can be obtained by performing the Hadamard test (as shown in Figure 6). Specifically, the probability of measuring the ancillary qubit to be zero is (1 + Re(hψ| U` |ψi))/2. If Amplitude Amplification is used to mark the zero state for this circuit then the eigenphases of the resultant walk operator (within the two dimensional space spanned by the initial state and the marked state) is

r ! p 1 + Re (hψ| U` |ψi) φ = ±2 arcsin P = ±2 arcsin . (115)

We then have that

2 sin (φ/2) − 1 = Re(hψ| U` |ψi). (116)

|0iA H • H |0i Uψ U`

FIG. 6. Hadamard test circuit for computing the expectation value of one of the terms in the cost-function. Here Uψ is a unitary operation that prepares the ansatz state: Uψ |0i = |ψi.

From calculus we then see that

∂φ (2 sin (φ/2)) = 2 sin(φ/2) cos(φ/2) ≤ φ. (117)

Thus from Taylor’s remainder theorem we have that for any δ ≥ 0

|2 sin (φ/2) − 2 sin ((φ + δ)/2)| ≤ δ (118)

and if φ → φ + δ for some error δ we have that the uncertainty that propagates to the expectation value is at most

|Re(hψ| U` |ψi) − Re(hψ| U` |ψi)est | ≤ δ. (119)

Therefore if we wish to estimate the energy of a configuration within error it suffices to use phase estimation with an error of on the Grover operator. Finally, as discussed above we take = ∆C /(L|w` |) to ensure that the error sums up to ∆C as required. Using the QFT-based phase estimation algorithm in we find that, if we neglect the cost of the Quantum Fourier

Transform and any additional costs due to additional

precision required in the QROM then the number of queries to the Grover oracle needed is (for ≤ π) 2m ≤ 2 π ≤ 2π . Here the factor of 2 comes from the fact that the need to round to a power of 2 leads to, in the worst case scenario, a factor of 2 in the number of iterations required. Next the Grover oracle requires two reflection operators, one that reflects about the state yielded by the Hadamard test circuit and another that reflects about the target space which is marked by the top qubit in Figure 6 being zero

(i.e. R = 1 − 2 |0ih0| ⊗ 11). The Grover walk operator is a product of these two operators W = −R R and as a result, if we neglect the cost of the additional Hadamard and Toffoli gates needed to implement the conditional phase flip, the costs of this process are entirely due to the reflection about the initial state which requires two applications of the preparation of the initial state. We further will follow the assumption in the previous section that the cost of state preparation dwarfs the cost of applying prepare or select. Thus under these assumptions, and taking the uncertainty

in the objective function to be ∆C the Toffoli complexity for the entire simulation is approximately

X 4pJπ|w` |LC phase 4pJπλLC phase

= . (120)

∆C ∆C

Thus, under these assumptions, direct energy evaluation yields an advantage over sampling if

σ 2 ≥ 4πλ∆C L. (121)

We expect this to occur when the error tolerance is small and the number of terms is relatively modest. On the other hand if the variance is small, target uncertainty is large, or L is large then sampling will be preferable to the direct phase oracle evaluation process.

2. Amplitude estimation based LCU evaluation

One inexpensive approach that can be used to estimate the expectation value comes from combining the Hadamard test circuit and amplitude estimation . Here we used a slightly generalized form of a generalized Hadamard test circuit shown in Figure 7. The expectation value of the first qubit for the above circuit is 1/2 + Re(hψ| C |ψi)/2. In

|0iA H • H |0iA prepare prepare† |0iA select |0i Uψ

FIG. 7. Generalized form of a Hadamard test that we will use for our QAOA implementation using LCU oracles. Here Uψ is a unitary operation that prepares the ansatz state: Uψ |0i = |ψi.

order to see this, consider the following,

r ! r !

X w` |0i + |1i X w`

|0i |0i |ψi 7→ |0i |`i |ψi 7→ √ |`i |ψi λ 2 λ ` ` r ! r ! |0i X w` |1i X w` 7→ √ |`i |ψi + √ |`i U` |ψi 2 λ 2 λ ` ` r ! r ! |0i X w` |1i X w`

7 → (prepare |0i) |ψi + |`i U` |ψi + (prepare |0i) |ψi − |`i U` |ψi 2 λ 2 λ ` ` r ! |0i †

X w` |1i

7→ |0i |ψi + prepare |`i U` |ψi + (|0i |ψi − |junki) . (122) 2 λ 2 `

Therefore, the probability of measuring 0 in the top-most qubit in Figure 7 is

!∗ ! hψ|C|ψi

1 X

r w` X r w` 1 + Re λ 2 + h0| hψ| prepare† |`i U` |ψi + h0| hψ| prepare† |`i U` |ψi = . (123) 4 λ λ 2 ` `

If amplitude estimation is used, the number of invocations of prepare and select needed to estimate this probability within error is O(λ/), which is a quadratic improvement over the sampling bound in Eq. (113). Following the same reasoning used to derive Eq. (119) we find that the over all Toffoli count is then, under the assumptions that the Toffoli count is dominated by applications of the prepare, select and phase circuit operations and further that the cost of adding an additional control to select is negligible, given by

4πpJλ(Cphase + CSel + 2CPrep ) . (124) ∆C

Here CSel and CPrep are the Toffoli counts for select and prepare respectively. Equation Eq. (124) shows that the favorable scalings of the sampling approach and the direct phase evaluation methods can be combined together in a single method. However, this advantage comes potentially at the price of a worse prefactor owing to the additional complexity of the prepare and select circuits. In particular, we find that this approach will be preferable to sampling and direct phase estimation, respectively, when

Cphase + CSel + 2CPrep

σ ≥ 4πλ∆C , (125) Cphase

Cphase + CSel + 2CPrep

L≥ . (126)

In general, we suspect that in fault-tolerant settings this this approach will be preferable to direct phase oracle evaluation because the costs of the prepare and select circuits will often be comparable, or less than, that of Uψ as we will see in the following section where we provide explicit constructions for the prepare and select oracles.

C. Adiabatic quantum optimization

1. Background on the adiabatic algorithm

The adiabatic algorithm works by initializing a system as an easy-to-prepare ground state of a known Hamil- tonian, and then slowly (adiabatically) deforming that system Hamiltonian into the Hamiltonian whose ground state we wish to prepare. For instance, we might use a Hamiltonian parameterized by s ∈ [0, 1],

H(s) = (1 − s)H + sH , (127)

where H is a Hamiltonian with an easy-to-prepare ground state and H is a Hamiltonian whose ground state we wish to prepare. We start the system in the ground state of H(0) = H and then slowly deform the Hamiltonian by increasing s from 0 to 1 until H(1) = H . If this is performed slowly enough, then the system will be in the ground state of H at the end of the evolution. The main challenge with the adiabatic algorithm is that we may need to turn s on extremely slowly in order for the

procedure to succeed. The rate at which we can turn on s will depend on features of the spectrum of H(s), including its derivatives and the minimum gap ∆ between the ground state eigenvalue and first excited state eigenvalue. It is often empirically observed that the total time of the evolution T should scale as O(1/∆2 ). Indeed, this result has been proven using the so-called boundary adiabatic theorem. This result analyzes the adiabatic algorithm in terms of phase randomization between the different paths that describe quantum dynamics for a slowly varying time-

dependent Hamiltonian. This randomization causes paths that lead different excitations to destructively interfere, which effects a mapping from the eigenvectors of an initial Hamiltonian to the corresponding eigenvectors of the target Hamiltonian in the limit of slow evolution relative to a relevant gap in the instantaneous eigenvalues of the time-dependent Hamiltonian. The boundary adiabatic theorem holds that if we let |ψk (s)i be the k th instantaneous eigenvector of any Gevrey-class time-dependent H(s) then we have that

R 1

Te |ψk (0)i − |ψk (1)i ∈ O

e , (128)

∆2 T

where ∆ is the minimum eigenvalue gap between the state |ψk (s)i and the remainder of the spectrum. It then follows if we pick an appropriate value for T ∈ O 1/∆2 then we can make the error less than for an arbitrary gapped adiabatic path. Alternatively, if very high precision is required then the time required for adiabatic state preparation can also be improved for analytic Hamiltonians to O(poly(k e Ḣk, kḦk, . . .)(1/∆2 + log(1/)/∆)) by adaptively choosing

the adiabatic path to have obey k∂sq H(0)k = k∂sq H(1)k = 0 for all positive integers less than Q() ∈ O(log(1/)); however, this approach requires small error tolerance on the order of ∈ O(∆) in order to see the benefits of these improved adiabatic paths [53–55]. Note that the boundary adiabatic theorem only tells us about the state at the end of the evolution, and does not actually tell us anything the state we would be in at the middle of the evolution. For that there are “instantaneous”

adiabatic theorems which bound the probability of being in the ground state throughout the entire evolution. For instance, one such way to show this is based on the Zeno stabilized adiabatic evolutions described in Section III C 3 . These instantaneous adiabatic theorems have complexity O L /(∆) , where

Z 1

L= kψ̇(s)kds (129)

is the path length. In the case of simulated annealing, one can show that the path length is independent of ∆, whereas in general the worst-case bound is L ≤ kḢk/∆, which yields O kḢk /∆3 complexity . It is not completely clear which style of adiabatic evolution will give the best results when using the approach as a heuristic, and so we discuss both here. With either approach we typically take H to be the cost function of interest and take H to be a simple- to-implement Hamiltonian that does not commute, with an easy-to-prepare ground state. For instance, a common

PN ⊗N

choice is to take H = i=1 Xi where Xi is the Pauli-X operator, so that the initial state is |+i . Other H Hamiltonians (or more complicated adiabatic paths) are also possible. The simplest way to use the adiabatic algorithm as a heuristic is to discretize the evolution using product formulas. For instance, if we assume the adiabatic schedule in Eq. (127) then we could attempt to prepare the ground state as M

M −k

Y k

exp −i H T exp −i H T |ψ (0)i , (130)

M M

where M is the number of first order Trotter steps used to discretize the adiabatic evolution. The idea of the heuristic is to choose M based on available resources. T will also need to be chosen heuristically rather than based on knowledge of the gap, which we do not expect to have in general. For fixed M , smaller T will enable more precise approximation of the continuous-time algorithm, but smaller T also means the system is less likely to stay adiabatic. Of course, one can also easily extend this strategy to using higher-order product formulas, or to using either different

adiabatic interpolations or adiabatic paths. For example, if we define k−1 k M − k − 1/2 M − k − 1/2 k + 1/2 U , = exp −i H 0 T exp −i H 1 T exp −i H 0 T ,

M M 2M 2 M 2M 2

R (131)

QM k−1 k

T 3 2

then we have that k=1 U M , M − T exp −i 0 H(t)dt ∈ O(T /M ). Higher-order versions of such integra- tors of order can be formed via Suzuki’s recursive construction (for any s ∈ [0, 1]): Uρ (s, s + δ) := Uρ−2 (s + [1 − γρ ]δ, s + δ)Uρ−2 (s + [1 − 2γρ ]δ, s + [1 − γρ ]δ) × Uρ−2 (s + 2γρ δ, s + [1 − 2γρ ]δ)Uρ−2 (s + γρ δ, s + 2γρ δ)Uρ−2 (s, s + γρ δ). (132)

Here γρ = (4 − 41/(ρ−1) )−1 which approaches 1/3 as the order of the formula, ρ, goes to infinity. Furthermore we have that the error in the Trotter-Suzuki algorithm scales as as

M Z T !

Y

Uρ , − T exp −i H(t)dt (133)

M M 0

which results in near linear scaling with T in the limit as T approaches infinity. In practice, however, since the number of exponentials in the Trotter-Suzuki formula grows exponentially with the order there is in practice an optimal tradeoff in gate complexity that is satisfied by a finite order formula for a fixed and T . For simplicity, we will assume that the time evolution under H will be much cheaper to implement than the time evolution under H . As H can be implemented using the phase oracles Ophase discussed in Section II, the

total cost of the procedure will be approximately M C phase . This implies that, for a finite value of M , the cost of performing the heuristic optimization using the above adiabatic sequence is approximately

Cadiabatic = 2M 5ρ/2−1 C phase . (134)

Again, assuming that our target error in the adiabatic sweep is and ∆2 ∈ O() then it suffices to take T ∈ O(1/∆2 ) and further after optimizing the cost by setting M equal to 2ρ/2−1 we find that M ∈ (T 1+o(1) /o(1) ). Therefore the total cost obeys Cphase

Cadiabatic ∈ . (135)

(∆2 )1+o(1) Similarly, if we are interested in the limit where ∆2 ∈ ω(), then boundary cancellation methods [53, 54] can be used to improve the number of gates needed to reach the global optimum to

Cphase log1+o(1) (1/)

Cadiabatic ∈ . (136)

∆(∆)o(1) These results show that, provided the eigenvalue gap is polynomial, we can use a simulation routine for e−iH (t) and e−iH (t) to find the local optimum in polynomial time. However, in practice we will likely want to use such an algorithm in a heuristic fashion wherein the timesteps do not precisely conform to the adiabatic schedule. To give the cost for a single step a little more precisely, we can also include the cost of implementing a transverse driving field. Since that involves applying a phase to bpha bits to each of N qubits, using repeat-until-success circuits,

this has cost 1.15N bpha + O(N ) in terms of T gates, with a single ancilla qubit. It is also possible to sum the bits with Toffoli cost N , then phase by the sum with cost b2pha /2 + O(bpha log bpha ) (accounting for multiplying the phase by a constant factor), though that has large ancilla cost. Using the sum of tree sums approach would give complexity 4N + b2pha /2 + O(bpha log bpha ), with 3 log L + O(1) temporary ancillas. There will be bgrad = bpha + O(log bpha ) persistent ancillas needed for a phase gradient state as well, but in many cases that state will be the same as in other

steps of the procedure, so does not increase the ancilla cost. Using this approach, and omitting the factor of 2 × 5ρ/2−1 for order ρ Suzuki, gives Toffoli cost

C phase + 4N + b2pha /2 + O(bpha log bpha ) (137)

2. Heuristic adiabatic optimization using quantum walks

While the procedure we described for heuristically using the adiabatic algorithm with Trotter based methods is well known, it is less clear how one might heuristically use LCU methods with the adiabatic algorithm. One reason we might try doing this is because the qubitized quantum walks that we discuss in Section II are sometimes cheaper to implement than Trotter steps for some problems. One approach to using LCU methods for adiabatic state preparation might be to directly attempt to simulate the time-dependent Hamiltonian evolution using a Dyson series

approach, as was recently suggested for the purpose of adiabatic state preparation in . However, this would require fairly complicated circuits due to the many time registers that one must keep to index the time-ordered exponential operator. In principle, we could always use quantum signal processing (or more generally quantum singular value transformations) to convert the walk operator at time t into the form e−iH(t)δ for some timestep δ. Instead, here we will suggest a strategy which is something of a combination between using qubitized quantum walks

and using a product formula approximation. Our method is unlikely to be asymptotically optimal for this purpose but it is simple to implement and we suspect it would be cheaper than either a Dyson series approach or a Trotter approach for some applications on a small error-corrected quantum computer. The idea is to stroboscopically simulate time evolution as a short-time evolved “qubitized” walk. The result will be that we actually simulate the adiabatic path generated by the arccosine of the normalized Hamiltonian H(s) rather than the adiabatic path generated directly

by H(s), but we expect that the relevant part of the eigenspectrum will be in the linear part of the arccosine, which means there will be not much effect on the dynamics. The main challenge in this approach will be to artificially shrink the effective duration of these quantum walk steps so that the method can be refined. In the following we will assume that select = 1 which is to say that every Hamiltonian in the decomposition is self-adjoint (consistent with the problem Hamiltonians we consider). For every eigenvector |ψk (t)i of H(t) with

H |ψk (t)i = Ek (t), if we define |Li = prepare |0i then we can write

W = (I − 2I ⊗ |LihL|)select. (138)

The walk operator can be seen as a direct sum of two different walk operators, W = WH ⊕ W⊥ , where WH is the portion of the walk operator that acts non-trivially on |ψk (t), Li = |ψk (t)i ⊗ |Li and W⊥ is the operator that acts on the remaining states. Next, if for each k and t we define |ψk⊥ (t)i such that

W − Eλ(t)

k (t) |ψk (t), Li WH − Eλ(t) k (t) |ψk (t), Li |ψk⊥ (t)i = q = q , (139)

E 2 (t) E 2 (t)

1 − λ2k(t) 1 − λ2k(t)

then we can express ! !

X Ek (t)

WH (t) = exp −i i |ψk⊥ (t)ihψk (t), L| − i |ψk (t), Lihψk⊥ (t)| arccos . (140) λ(t) k

It may be unclear how to implement a time-step for W (t) since the operation is only capable of applying unit-time evolutions. Fortunately, we can address this by taking for any r ≥ 1

X X (r − 1)λ(t)

H(t) = λk (t)Uk 7→ λk (t)Uk + (I − I) . (141)

In this case we can block encode the Hamiltonian using a unary encoding of the extra two operators via s r

X λk (t) r−1

|L(t, r)i = |ki |00i + |0i (|10i + |11i) . (142) λ(t)r 2r k

The select oracles for this Hamiltonian require one additional control for each of the original terms in the Hamiltonian and the additional terms only need a single Pauli-Z gate to implement. We will define this operator to be select . With these two oracles defined, we can then describe the walk operator Wr (t) for any fixed value of t to be

Wr (t) = (I − 2I ⊗ |L(t, r)ihL(t, r)|)select . (143)

This new Hamiltonian has exactly the same eigenvectors, however its value of λ is greater by a factor of r. In particular, we can express the walk operator (restricted to the eigenspace supported by the instantaneous eigenvectors of H(t))

is ! ! !

X Ek (t) 1

WH,r (t) = exp −i i |ψk⊥ (t)ihψk (t), L(t, r)| − i |ψk (t), L(t, r)ihψk⊥ (t)| r arccos . (144) rλ(t) r k

Using the fact that arccos(x) = π/2 − arcsin(x) we have that, up to an irrelevant global phase this operator can be written as ! ! ! X ⊥ ⊥ Ek (t) 1 VH,r (t) = exp i i |ψk (t)ihψk (t), L(t, r)| − i |ψk (t), L(t, r)ihψk (t)| r arcsin . (145) rλ(t) r k

Thus the operator VH,r (t) can be seen to generate a short time-step of duration 1/r for an effective Hamiltonian ! X ⊥ ⊥ Ek (t) Hr (t) := i |ψk (t)ihψk (t), L(t, r)| − i |ψk (t), L(t, r)ihψk (t)| r arcsin . (146) rλ(t) k

Note that as r → ∞ the eigenvalues of this Hamiltonian approach ±Ek (t)/λ(t) and more generally

r sin−1 (Ek (t)/(rλ(t))) − Ek (t)/λ(t) ∈ O(1/r ).

For any fixed value of r we can choose an adiabatic path between an initial Hamiltonian and a final Hamiltonian. The accuracy of the adiabatic approximation depends strongly on how quickly we traverse this path so it is customary to introduce a dimensionless time s = t/T which allows us to easily change the speed without altering the shape of the adiabatic path. In Appendix B we are able to show that the adiabatic theorem then implies that the number of steps of the quantum walk required to achieve error in an adiabatic state preparation for a maximum rank Hamiltonian

with gap ∆ is in  v 3  u u max kḦk + |λ̈| max |λ̇| + kḢk λ maxs |λ̇| + kḢk  e 1  t s s

O 2

+ . (147)  3/2 min(∆, mink |Ek |) min(∆, mink |Ek |)4 

The reason why this result depends on the minimum value of Ek is an artifact of the fact that several of the eigenvalues of the walk operator can be mapped to 1 under repeated application of Wr . This potentially can alter the eigenvalue gaps for eigenvalues near zero which impacts the result. The key point behind this scaling is that it shows that as the number of time slices increases this heuristic converges to the true adiabatic path. Just as the intuition behind Trotterized adiabatic state preparation hinged on this fact,

here this result shows that we can similarly use a programmable sequence of parameterizable walk operators to implement the dynamics. The main advantage relative to Trotter methods is that the price that we have to pay using this technique does not depend strongly on the number of terms in the Hamiltonian which can lead to advantages in cases where the problem or driver Hamiltonians are complex. This scaling can be improved by using higher-order splitting formulas for the time evolution and by using

boundary cancellation methods to improve the scaling of the error in adiabatic state preparation. In general, if we assume that ∆ ∈ O(1) for the problem at hand then it is straightforward to see that we can improve the scaling from O(1/3/2 ) to 1/o(1) [53–55]. It is also worth noting that the bounds given above for the scaling with respect to the derivatives of the Hamiltonian and the coefficients of the Hamiltonian is expected to be quite loose owing to the many simplifying bounds used to make the expression easy to use. On the other hand, the scaling with the gap and error

3. Zeno projection of adiabatic path via phase randomization

The principle of the Zeno approach is to increment the parameter for the Hamiltonian s or β by some small amount such that the overlap of the ground state of the new Hamiltonian with that of the previous Hamiltonian is small. One can then perform phase estimation to ensure that the system is still in the ground state. This approach was used in [23, 58], and combined with a rewind procedure to give a significant reduction in gate complexity compared to other approaches. An alternative approach was proposed in [21, 59], where the measurement was replaced with

phase randomization. Here we summarize this method and show how to further optimize it.

When using phase estimation, if it verifies that the system is still in the ground state, one continues with incrementing the parameter. If the ground state is not obtained from the phase estimation, one could abort, in which case no output is given and one needs to restart. Because the probability of failure is low, one could just continue regardless, and check at the end. That means that the result of the phase estimation is discarded. The phase estimation is performed with control qubits controlling the time of the evolution, then an inverse quantum

Fourier transform on the control qubits to give the phase. But, if the result of the measurement is ignored, then one can simply ignore the inverse quantum Fourier transform, and regard the control qubits as being measured in the computational basis and the result discarded. That is equivalent to randomly selecting values for these control qubits in the computational basis at the beginning. But, if these qubits take random values in the computational basis, one can instead just classically randomly generate a time, and perform the evolution for that time.

In performing a phase measurement using control qubits, one uses a superposition state on those control qubits, and the error in the phase measurement corresponds to the Fourier transform of those amplitudes. That is, with b control qubits, we have a state of the form b

2X −1

|χφ i = eizφ χz |zi , (148) z=0

where φ is a phase that would correspond to −Eδt, the energy eigenvalue of the Hamiltonian times the shortest evolution time. Then the phase measurement using the quantum inverse Fourier transform corresponds to the POVM |φ̂ihφ̂|, with

1 X izφ̂

|φ̂i = √ e |zi . (149) 2π z=0

The probability distribution for the error δφ = φ̂ − φ is then given by b 2 2 −1

1 X izδφ

Pr(δφ) = hφ̂|χφ i = e χz . (150)

These measurements are equivalent to the theory of window functions in spectral analysis. A particularly useful window to choose is the Kaiser window, because it has exponential suppression of errors . In the case where the evolution time is chosen classically, it can be given by a real number, and we do not need any bound on the evolution time. Then the the expected cost is the expectation value of |t| Z h|t|i = dt |t|ptime (t). (151)

Because there is no upper bound on t, we can obtain a probability distribution for the error that drops strictly to zero outside the given interval, rather than being exponentially suppressed. Still considering a coherent superposition for the moment, the state is given by Z |ψE i = dt e−iEt χt |ti , (152)

The probability distribution for the error in the measurement of E is

Pr(δE) = dt eitδE χt . (154)

An alternative description is to describe the system as being in state

X |ψi = hψj |ψi |ψj i , (155) j

where Z p̃time (Ej − Ek ) = dt ptime (t)e−i(Ej −Ek )t . (157)

If the width of the Fourier transform of the probability distribution ptime is less than the spectral gap ∆, then the state is X |hψj |ψi|2 |ψj ihψj | . (158) j

In comparison, if Pr(δE) is equal to zero for |δE| ≤ Emax , then the same result will be obtained for 2Emax = ∆. This is what would be expected, because if ptime (t) = χ2t , then the Fourier transform of ptime is the autocorrelation of the Fourier transform of χt , and therefore has twice the width. Next we consider appropriate probability distributions. A probability distribution for t that was suggested in was 8π sinc (t∆/4) ptime (t) = . (159)

3∆ That gives h|t|i = 1 ln 2/(π∆), so h|t|i∆ ≈ 2.648. There Pr(δE) is equivalent to the square of a triangle window, but greater performance can be obtained by using the triangle window (1 − |2δE/∆|).

Pr(δE) = (160)

Then the corresponding ψt is obtained from the Fourier transform of Pr(δE) as

p p sin(∆t/2)C( ∆t/π) − cos(∆t/2)S( ∆t/π) χt = , (161) (∆t/2)3/2 where C and S are Fresnel integral functions. That gives h|t|i = 7/(3∆), so h|t|i∆ ≈ 2.333.

To find the optimal window, we can take

Z X

√ dt eitx χt = (1 − x ) a` x2` , (162) 2π `

for x the difference in energy divided by Emax . We use only even orders, so it is symmetric, and the factor of (1 − x ) ensures that it goes to zero at ±1. Then

Z 1

1 X

χt = √ a` dx cos(xt)(1 − x )x2` . (163) 2π ` −1

Then the expectation of the absolute value of the time is

1 X

Z dt |t| |χt | = ak a` Ak` , (164) 2π k,`

Z Z 1 Z 1

Ak` = dt |t| dx cos(xt)(1 − x )x2k dz cos(zt)(1 − z 2 )z 2` . (165) −1 −1

We also need, for normalization,

X Z 1 X

1= ak a` dx (1 − x )2 x2(k+`) = ak a` Bk` , (166) k,` −1 k,`

Bk` = . (167)

[2(k + `) + 1][2(k + `) + 3][2(k + `) + 5]

Then defining ~b = B 1/2~a, the normalisation corresponds to k~bk = 1. Then the minimum h|t|i corresponds to minimizing ~aT A~a/π, which is equivalent to minimizing ~aT B −1/2 AB −1/2~a/π, so we need to find the minimum eigenvalue of B −1/2 AB −1/2 . That gives h|t|iEmax ≈ 1.15 with terms up to a (a 46th order polynomial). This explanation is for the case where there is Hamiltonian evolution for a time t which can take any real value. In the case of steps of a quantum walk with eigenvalues e±i arccos(H/λ) , the number of steps would take an integer value.

For the Hamiltonian evolution it could be implemented by steps of a quantum walk as well but it is more efficient to simply use the steps of that quantum walk directly without signal processing. To obtain the corresponding probability distribution for a discrete number of steps, we simply take the probability distribution for t at points separated by 1/λ. That will yield a probability distribution for the error that is the same as for the continuous distribution, except with a periodicity of λ. That periodicity has no effect on the error, because it is beyond the range of possible values

for the energy. The reason for this correspondence is that taking the probability distribution at a series of discrete points is like multiplying by a comb function, equivalent to convolving the error distribution with a comb function.

D. Szegedy walk based quantum simulated annealing

In the remainder of Section III we consider quantum simulated annealing, where the goal is to prepare a coherent equivalent of a Gibbs state and cool to a low temperature. More specifically, the coherent Gibbs state is Xq |ψβ i := πβ (x) |xi , πβ (x) ∝ exp(−βEx ), (168) x∈Σ

where β is the inverse temperature. For annealing, we have transition probabilities of obtaining y from x denoted

Pr(y|x), which must satisfy the detailed balance condition

Pr(y|x)πβ (x) = Pr(x|y)πβ (y). (169)

The detailed balance condition ensures that πβ is the equilibrium distribution with these transition probabilities. For the costings in this work we take for y differing from x by a single bit flip,

Pr(y|x) := min {1, exp (β (Ex − Ey ))} /N, (170)

then the detailed balance condition ensures that the ground state is |ψβ i with eigenvalue zero. One can then apply an adiabatic evolution under this Hamiltonian to gradually reduce the temperature (increase β). In the approach of , the method used is to instead construct a quantum walk where the quantum Gibbs state is an eigenstate. One could change the value of β between each step of the quantum walk similarly to the adiabatic algorithm for the Hamiltonian. Alternatively, for each value of β one can apply a measurement of the walk operator

to project the state to |ψβ i via the quantum Zeno effect. Reference also proposes using a random number of steps of the walk operator to achieve the √ same effect as the measurement. The advantage of using the quantum walk is that the complexity scales as O(1/ δ), where δ is the spectral gap of Hβ , rather than O(1/δ), which is the best rigorous bound for the scaling of (classical) simulated annealing. The quantum walk used in is based on a Szegedy walk, which involves a controlled state preparation, a swap

between the system and the ancilla, and inversion of the controlled state preparation. Then a reflection on the ancilla is required. The sequence of operations is as shown in Figure 8. The dimension of the ancilla needed is the same as the dimension as the system. The reflection and swap have low cost, so the Toffoli cost is dominated by the cost of the controlled state preparation. The Szegedy approach builds a quantum walk in a similar way as the LCU approach in Figure 2, where there is a

block encoded operation followed by a reflection . That is, preparation of the ancilla in the state |0i, followed by unitary operations U and projection onto |0i on the ancilla would yields the block encoded operator A = h0| U |0i.

Instead of performing a measurement on the ancilla, the reflection about |0i results in a joint operation that has eigenvalues related to the eigenvalues of A as e±i arccos a , where a is an eigenvalue of A.

Here the controlled state preparation is of the form

Xp cprep |xi |0i = Pr(y|x) |xi |yi ≡ |αx i , (172) y

where the sum is taken over all y that differ from x by at most one bit. As a result, the block-encoded operation is Xp h0| cprep† swap cprep |0i = Pr(x|y) Pr(y|x) |yihx| . (173) x,y p Thus the block-encoded operation has a matrix representation of the form Pr(x|y) Pr(y|x), which is equivalent to 1 − Hβ . Therefore the quantum Gibbs state |ψβ i is an eigenstate of this operation with eigenvalue 1. Combining this operation with the reflection gives a step of a quantum walk with eigenvalues corresponding to the arccosine of the

block-encoded operator [61, 62]. It is this arccosine that causes a square root improvement in the scaling with the spectral gap. This is because if the block-encoded operation √ has gap δE from the eigenvalue of 1 for the target state, taking the arccosine yields a gap of approximately 2δE for the quantum walk. This gap governs the complexity of the algorithm based on the quantum walk. In implementing the step of the walk, the state preparation requires calculation of each of the Pr(y|x) for a given x.

In turn these require computing the energy difference

P under a bit flip, and the exponential. The probability Pr(x|x)

is computed from the formula Pr(x|x) ≡ 1 − y6=x Pr(y|x) required for normalization of the probabilities. To prepare the state one can first prepare a state of the form Xp |ψx i = Pr(xk |x) |xi |ki , (174) k

where xk indicates that bit k of x has been flipped with k = 0 indicating no bit flip, and |ki is encoded in one-hot unary. The state |αx i can then be prepared by applying cnots between the respective bits of the two registers. In order to prepare the state |ψx i in unary, an obvious method is to perform a sequence of controlled rotations depending on the transition probabilities. However, that tends to be expensive because our method of performing rotations involves multiplications, and high precision is required because the error in each rotation accumulates. A

better method can be obtained by noting that the amplitudes for k > 0 are limited. We can then perform the state preparation by the following method.

1. Compute N Pr(xk |x) for all N bit flips, and subtract those values from N to obtain N Pr(x|x). Note that

N Pr(xk |x) ≤ 1, and we compute this value to bsm bits. The value of N Pr(x|x) will need dlog N e + bsm bits, but only the leading bsm bits can be regarded as reliable. The complexity of the subtractions is N (dlog N e + bsm ).

2. We have N qubits in the target system we need to prepare the state and five ancillas,

|0iA |0iK |0iZ |0iZZ |0iB |0iC , (175)

where K is the target system, A, B, and C are single-qubit ancillas, and Z and ZZ are s-qubit ancillas. Apply Hadamards to the ancillas to give equal superpositions on all except ZZ and B. s

2X −1

|+iA |0iK |ziZ |0iZZ |0iB |+iC . (176) 2s/2 z=0

3. Controlled on ancilla A, prepare an equal superposition state on dlog N e qubits of K. If N is a power of 2, then

it can be performed with log N controlled Hadamards, each of which can be performed with two T gates. It is also possible to prepare an equal superposition for N not a power of 2 with complexity O(log N ). For more details see Section III E 2.

4. We can map the binary to unary in place, with cost no more than N − log N (see Appendix C), to give

1 1 X X

√ |0iA |0iK + √ |1iA |kiK |ziZ |0iZZ |0iB |+iC , (177) 2s/2 2 N k=1 z=0

where |kiK is a value in one-hot unary.

5. Compute the approximate square of z, denoted z̃ 2 , placing the result in register ZZ, to give

1 1 X X

√ |0iA |0iK + √ |1iA |kiK |ziZ |z̃ 2 iZZ |0iB |+iC . (178) 2s/2 2 N k=1 z=0

The complexity is no greater than s /2, as discussed in Appendix D 6. To obtain bsm bits of precision in the square, we need to take s = bsm + O(log bsm ), giving complexity b2sm /2 + O(bsm log bsm ).

6. For each k = 1, . . . , N , perform an inequality test between N Pr(xk |x) and z 2 in the ZZ register, controlled by

qubit k in K, placing the result in B. This has cost N bsm Toffolis.

7. Controlled on ancilla A being zero, perform an inequality test between N Pr(x|x) and N z 2 , with the output

in B. The inequality test has complexity bsm . In the case where N is not a power of 2, multiplying by N has complexity approximately b2sm + O(bsm log bsm ) to obtain bsm bits, and we incur this cost twice, once for computation and once for uncomputation. If N is a power of 2 the multiplication by N has no cost. We obtain the state  √ 2s Pr(x|x)−1 f s

2X −1

1 X

√ |0iA |0iK |ziZ |z̃ iZZ |0iB + |0iA |0iK |ziZ |z 2 iZZ |1iB (179)  2s/2 2 z=0 √ z=2s Pr(x|x) f

s √ 

N 2 f k |x)−1

N Pr(x N s

2X −1

1 X X 1 X

+ √ |1iA |kiK |ziZ |z̃ 2 iZZ |0iB + √ |1iA |kiK |ziZ |z̃ 2 iZZ |1iB  |+iC , (180) 

N k=1 z=0

N k=1

N Pr(x

where Pr f indicates an approximation of the probability, with the imprecision primarily due to imprecise squaring of z.

8. Uncompute z 2 in register ZZ with complexity no more than s /2.

9. Use a sequence of CNOTs with the N qubits of K as controls and ancilla A as target. This will reset A to zero.

10. Perform Hadamards on the qubits of K, giving a state of the form

1 1 X

q q |0i Pr(x|x) f |0iK + √ f k |x) |ki |0i |0i |0i |0i + |ψ ⊥ i ,

Pr(x (181)

2 A N k=1

K Z ZZ B C

where |ψ ⊥ i is the component of the state perpendicular to zero states on Z, B, and C.

11. Now conditioned on |0iZ |0iB |0iC , we have the correct state with amplitude approximately 1/2. We simply need

to perform one round of amplitude amplification. We reflect about |0iZ |0iB |0iC , invert steps 1 to 2, reflect about zero, then perform steps 2 to 1 again. In the limit of large s we then have the correct state. As well as incurring three times the cost of steps 2 to 10, we have a cost of N + O(bsm ) for the reflection.

The overall Toffoli complexity of this procedure, excluding the computation of Pr(xk |x), is

N (dlog N e + bsm ) + N + 3 N + b2sm + 2b2sm + (N + 1)bsm + O(log N + bsm log bsm ). (182)

Here is first term is for the subtractions in step 1, the second term N is for the reflection, then the terms inside the square brackets are from steps 2 to 10. In the square brackets N is for the binary to unary conversion, b2sm is for computation and inverse computation of z 2 , 2b2sm is for multiplication by N (computation and uncomputation), which is only needed for N not a power of two, and (N + 1)bsm is for the N + 1 inequality tests. The cost log N in the order term is for the controlled preparation of an equal superposition state, and bsm log bsm is the order term for the

squaring and multiplication. Note that the preparation will not be performed perfectly, because the initial amplitude is not exactly 1/2. We will use a flag qubit to indicate success, which will control the swap. To see the effect of this procedure, suppose the system is in basis state x. Then the state that is prepared is Xp cprep |0i |xi |0i = µx |1i |xi Pr(y|x) |yi + νx |0i |xi |φx i (183) y

where the first qubit flags success, µy is an amplitude for success, νx is an amplitude for failure, and φx is some state that is prepared in the case of failure and can depend on x. Here we have ignored the imperfect approximation of Pr(y|x), and are focusing just on the imperfect success probability. Then the swap is only performed in the case of success, which gives Xp swap cprep |0i |xi |0i = µx |1i Pr(y|x) |yi |xi + νx |0i |xi |φx i . (184) y

Then we can write

Xp h0| hy| h0| cprep† = µy |1i Pr(x|y) hy| hx| + νy h0| hy| hφy | , (185) x

h0| hy| h0| cprep† swap cprep |0i |xi |0i = µx µy Pr(y|x) Pr(x|y) + δx,y νx p q = Pr (y|x)Pr (x|y), (186)

where we define ( 0 µ2y Pr(x|y), x 6= y

Pr (x|y) = 2

P (187)

That is, the effect of the imperfect preparation is that the qubitized step corresponds to a slightly lower probability of transitions, which should have only a minor effect on the optimization. The cost of the quantum walk in this approach is primarily in computing all transition probabilities N Pr(xk |x). If we were only concerned with the inequality tests for k > 0, then we could incur that cost only once with a simple modification of the above scheme. The problem is that we also need N Pr(x|x), which requires computing all

N Pr(xk |x). The steps of computing each N Pr(xk |x) are as follows.

1. Query the energy difference oracle to find the energy difference δE of a proposed transition to bdif bits,

2. Calculate exp(−βδE) to bsm bits using the QROM/interpolation method from Section II E.

The costs for the energy difference oracles were discussed in Section II A, and are as in Table IV. In this table, the costs for the energy difference oracles for the L-term spin model and LABS problem are obtained by evaluating the energy twice. Computing N values of the energy difference would suggest we multiply this cost by N , but we can save computation cost by just calculating the energy for x once, and computing the energy for each of the xk . That means the cost for these problem Hamiltonians can be given as the cost for a single energy evaluation multiplied by N + 1.

For QUBO and the SK model it is considerably more efficient to compute the energy difference than the energy, so in these cases we simply compute the energy difference N times. The number of output registers is increased by a factor of N in all cases. For the cases where we compute the starting energy and the N energies under bit flips, we can compute the starting energy first, copy it into the N outputs, and subtract the energy under the bit flip from each of the output registers. In summary, the complexity can be given as the minimum of N + 1 times the cost of the

energy oracle, and N times the cost of energy difference oracle. To perform the state preparation, we need to compute the energy differences, use those to compute the transition probabilities, prepare the state, then uncompute the transition probabilities and energy differences. In each step of the Szegedy walk as shown in Figure 8, we need to do the controlled preparation and inverse preparation, which means that the energy differences and need to be computed four times for each step. That would give a cost of

min(4(N + 1)C direct , 4N C diff ) + 4N C fun . (188)

However, we can save a factor of two by taking the controlled preparation and moving it to the end of the step, as shown in Figure 9. The reason why we can save a factor of two is that then, in between the controlled inverse preparation and preparation, there is a reflection on the target, but the control is not changed. That means we can keep the values of the energy differences and transition probabilities computed in the controlled inverse preparation without uncomputing them, then only uncompute them after the controlled preparation.

This approach does not change the effect of a sequence of steps if β is kept constant. However, if β is changed between steps, then the procedure as shown in Figure 8 will be different to that taking the controlled preparation and

/ = / prepare × prepare† R W |ψi / |ψi / • × • FIG. 8. The qubitized quantum walk operator W using the Szegedy approach.

/ = / × prepare† R prepare W |ψi / |ψi /× • • FIG. 9. The quantum walk operator using the Szegedy approach, where we have moved the controlled preparation to the end.

moving it to the end of the state. That is, the value of β is changed at the swap operation, rather than the reflection. Because there is only a factor of 2 rather than 4, the resulting cost is

min 2(N + 1)C direct , 2N C diff + 2N C fun . (189)

Now adding twice the complexity of the state preparation from Eq. (182) gives complexity

min 2(N + 1)C direct , 2N C diff + 2N C fun + 2N log N + 8N bsm + 18b2sm + O(N ). (190)

Here we have omitted bsm log bsm in the order term because it is smaller than N for the parameter ranges we are interested in. The term 9b2sm includes 3b2sm from squaring and 6b2sm from multiplication. In the case where N is a power of 2 the cost of 6b2sm can be omitted. To evaluate the numbers of ancillas needed, we need to distinguish between the persistent ancillas and temporary ancillas in Table IV. This is because the persistent ancillas need to be multiplied by N , whereas the temporary

ancillas are reused, so we only need to take the maximum. Considering the persistent ancillas first, the ancilla costs are as follows.

1. The N qubits for the Szegedy walk for the copy of the system.

2. N times the ancilla cost for the energy evaluation.

3. N times the ancilla cost for the function evaluation.

4. The ancillas Z, A, B, C in the state preparation use bsm + O(log bsm ) qubits.

For the temporary ancillas, we have contributions from the energy difference evaluation, the function evaluation, and the state preparation. Since these operations are not done concurrently, we can take the maximum of the costs. The most significant will be that for the state preparation. In the state preparation we have costs

1. Ancilla ZZ has bsm + O(log bsm ) qubits, and it is temporary because it is uncomputed.

2. If N is not a power of 2 then we need another bsm + O(log bsm ) qubits for an ancilla with N z 2 .

3. We use bsm + O(log bsm ) qubits for squaring, or 2bsm + O(log bsm ) qubits if we are performing the multiplication

by N . As a result, the temporary ancilla cost is 2bsm + O(log bsm ) qubits if N is a power of 2, or 4bsm + O(log bsm ) otherwise. Considering the worst-case that N is not a power of 2, this temporary ancilla cost is larger than that for the difference function evaluation, giving a total ancilla cost

N Adiff + N Afun + 5bsm + O(log bsm ). (191)

E. LHPST qubitized walk based quantum simulated annealing

The same quantum walk approach to quantum simulated annealing can be achieved using an improved form of quantum walk given by Lemieux, Heim, Poulin, Svore, and Troyer (LHPST) that requires only computation of a

single transition probability for each step. Here we provide an improved implementation of that quantum walk that can be efficiently achieved for more general types of cost Hamiltonians than considered in . The operations used to achieve the step of the walk are

ŨW = RV † B † F BV (192)

1 X

V : |0iM → √ |jiM , (193)

N j

p √ B : |xiS |jiM |0iC → |xiS |jiM 1 − px,xj |0iC + px,xj |1iC , (194) |xiS |jiM |0iC → |xiS |jiM |0iC ,

F : (195)

|xiS |jiM |1iC → |xj iS |jiM |1iC , |0iM |0iC → − |0iM |0iC ,

R: (196)

|jiM |ciC → |jiM |ciC for (j, c) 6= (0, 0).

Here px,y = N Pr(y|x) in the notation used above, and we have specialized to an equal superposition over j and only single bit flips. This walk is equivalent to the Szegedy approachp of because it yields the same block-encoded operation. That is, h0| V † B † F BV |0i has matrix representation Pr(x|y) Pr(y|x). To show this fact, the sequence of operations gives

1 X

V |0iM |0iC = √ |jiM |0iC , (197)

N j=1

1 XX p √

BV |0iM |0iC = √ |xihx| ⊗ |ji 1 − px,xj |0iC + px,xj |1iC , (198)

N x j=1

N N

1 XX p 1 XX √

F BV |0iM |0iC = √ |xihx| ⊗ |ji 1 − px,xj |0iC + √ |xj ihx| ⊗ |ji px,xj |1iC

N x j=1 N x j=1

N N

1 XX p 1 XX √

=√ |xihx| ⊗ |ji 1 − px,xj |0iC + √ |xihxj | ⊗ |ji pxj ,x |1iC ,

N x j=1 N x j=1

N N

† 1 XX 1 XX √

M h0|C h0| V B † F BV |0iM |0iC = |xihx| (1 − px,xj ) + |xihxj | px,xj pxj ,x

N x j=1 N x j=1

N N

X 1 X 1 XX √

= |xihx| 1 −  px,xj +  |xj ihx| px,xj pxj ,x x

N j=1

N x j=1

X p

= |yihx| Pr(y|x) Pr(x|y) . (200) x,y

Just as with the Szegedy approach, most operations are trivial to perform, and the key difficulty is in the operation B which depends on the transition probability. However, B only depends on one transition probability, whereas the Szegedy approach requires computing all the transition probabilities for a state preparation. Lemieux et al. propose a method for the B operation that is not useful for the cost Hamiltonians considered here, but is useful for Hamiltonians with low connectivity. Instead of computing the energy difference then the exponential, they consider

an approach where the required angle of rotation is found from a database. That is, one considers the qubits that the transition probability for the move (here a bit flip) depends on, and classically precomputes the rotation angle for each basis state on those qubits. For each value of j, one sequentially performs a multiply-controlled Toffoli for each computational basis state for these qubits, and performs the required rotation on the ancilla qubit C. The complexity that is given by is O(2|Nj | |Nj | log(1/)), where |Nj | is the

number of qubits that the transition probability for move j depends on. That complexity is a slight overestimate, because each multiply controlled Toffoli has a cost of |Nj |, then the cost of the rotation synthesis is O(log(1/)). It

should also be noted that this is the cost for each value of j, and there are N values of j, giving an overall cost O(N 2|Nj | [|Nj | + log(1/)]). To improve the complexity, one can divide this procedure into two parts, where first a QROM is used to output the desired rotation in an ancilla, and then those qubits are used to control a rotation. Using the QROM procedure of to output the required rotation, the cost in terms of Toffoli gates is O(N 2|Nj | ). Then one can apply rotations using

the phase gradient state, which was discussed above in Section II C. Addition of the register containing the rotation to an ancilla with state |φi from Eq. (34) results in a phase rotation. To rotate the qubit, simply make the addition controlled by this qubit, and use Clifford gates before and after so that the rotation is in the y-direction. The cost of this rotation is O(log(1/)) Toffolis; for more details see Appendix A. With that improvement the complexity is reduced to O(N 2|Nj | + log(1/)).

Even with that improvement, any procedure of that type is exponential in the number of qubits that the energy difference depends on, |Nj |. That is acceptable for the types of Hamiltonians considered in , but here we consider Hamiltonians typical of real world problems where the energy difference will depend on most of the system qubits, because the Hamiltonians have high connectivity. We thus propose alternative procedures to achieve the rotation B.

1. Rotation B

We propose a completely different method to perform the rotation B than that of LHPST . We can first compute √ the energy difference Ex − Exj , then the rotation arcsin px,xj with the result put in an ancilla register. The rotation √ of the qubit ancilla C is controlled on the value of this ancilla as explained above, then the value of arcsin px,xj is √ uncomputed. There are many possible approaches to the computation of arcsin px,xj , for example that of . For the purposes of quantum optimization, we expect that we will not need to compute this function to high precision as

long as the function we compute is still monotonic in the actual energy, so there is the opportunity to use methods that are very efficient for low precision but would not be suitable for high precision. We propose a method based on using a piecewise linear approximation, with the coefficients output by a QROM, as described in Section II E. One could then apply the controlled rotation with cost bsm Toffolis using the phase gradient state in Eq. (34), as described in detail in Appendix A. Then after uncomputing the rotation angle we would have implemented B. That

√ approach would then mean that a single step of the walk has four times the cost of computing arcsin px,xj , because it needs to be computed and uncomputed for B, and the operation B is applied twice in each step. It is possible to halve that cost by only computing and uncomputing once in a step, and retaining the value of √ arcsin px,xj during the F operation. Because F is a controlled flip of bit j of x, it would reverse the role of x and xj , and the sign of Ex − Exj would be flipped. In more detail, the procedure is as follows.

1. Compute the energy difference between x and xj , Ex − Exj .

2. Compute arcsin px,xj based on |Ex − Exj |.

3. If Exj < Ex then perform an X operation on the qubit C. That can be achieved with a cnot (Clifford)

controlled by the sign bit of Ex − Exj .

4. The remaining rotations for the case of Exj > Ex need to be controlled on −1 for the sign bit.

5. When we apply F , as well as applying the Toffolis to change x to xj , we need to flip the sign bit on Ex − Exj

controlled on qubit C. This is another cnot, with no non-Clifford cost. √

6. Then at the end we uncompute arcsin px,xj and Ex − Exj .

This procedure assumes that Ex − Exj is represented as a signed integer. The computation of Ex − Exj uses two’s complement, so there will be an additional cost of bdif to switch to a signed integer. Because there is only a factor of two instead of four, the overall cost will then be 2C diff + 2C fun + 2bdif + O(1). Next we consider the other (simpler) operations used in the step of the quantum walk.

2. Equal superposition V

The operation V generates the equal superposition starting from a zero state

1 X

V : |0iM → √ |jiM . (201)

N j

In the case where N is a power of 2, then we can create the equal superposition over binary by using Hadamards (and no Toffolis). More generally, if we wish to create an equal superposition where the number of items is not a power of 2, we can rotate an ancilla qubit such that the net amplitude is 1/2 for |1i |1i on the result of the inequality test and the ancilla qubit. We can then perform a single step of amplitude amplification to obtain the superposition state. Our procedure is explained below and gives a complexity of 4 log N + O(1) Toffolis.

Our method for V is also very different that of LHPST . There they proposed encoding the M register in unary, whereas here we use binary which greatly reduces the ancilla cost (which is sublinear in N ). Moreover, LHPST did not consider using equal superpositions in cases where N is not a power of 2, and instead just allowed for a constant factor overhead in the complexity. Our procedure to create an equal superposition over N < 2k items is as follows. With Hadamards we prepare

1 X

√ |ji . (202) 2k j=0

Then we have an inequality test between j and N to give

k k 2 −1 2 −1

1 X 1 X

√ |ji |1i + √ |ji |0i . (203) 2k j=0 2k j=N

This is an inequality test on k bits, and since it is an inequality test with a constant we savep a Toffoli gate. The cost is therefore k − 2 Toffolis as per the explanation in . We would have an amplitude of N/2k for success, and p k would aim to multiply it by another amplitude of approximately 2 2 /N so the amplitude is 1/2 and we can use a single step of amplitude amplification. For an amplitude of 1 2k /N , we can rotate another register according to the p

procedure in Appendix A to give

cos θ |0i + sin θ |1i . (204)

We can then perform a single step of amplitude amplification for |1i on both this qubit and the result of the inequality test. The steps needed in the amplitude amplification and their costs are as follows. If we use the procedure for the rotation with s bits, it would take s − 3 Toffolis because the angle of rotation is given classically.

1. A first inequality test (k − 2 Toffolis) and a rotation on a qubit (cost s − 3).

2. A first reflection on the rotated qubit and the result of the inequality test. This just needs a controlled phase

3. Inverting the rotation and inequality test has cost k + s − 5.

4. Hadamards then reflection of the k qubits and the single qubit ancilla about zero (k − 1 Toffolis).

5. Applying the inequality test (k − 2 Toffolis).

The total cost is 4k + 2s − 1 Toffolis.

Conditioned on success of the inequality test, the state is

N −1

4N sin θ

1 X

√ |ji 1 − |0i + 2 sin θ(sin θ |0i + cos θ |1i) |1i . (205) 2k j=0 2k

The probability for success is then given by the normalization

" 2 #

N 4N sin θ 2 2 2

1− + 2 sin θ + 4 sin θ cos θ . (206) 2k 2k

It is found that highly accurate results are obtained for s = 7, as shown in Fig. 10. This procedure enables construction of equal superposition states flagged by an ancilla qubit for N not a power of 2. If we take s = 7, then the cost is 4k + 1.

0.99 n 1 2 3 4 5 6

FIG. 10. The probability for success using a rotation of the form 2π/2s with s = 7.

3. Controlled bit flip F

We also need to modify the operation F compared to that in LHPST to account for the M register being encoded in binary. This operation flips bit j on x for the control qubit C being in the state |1i,

|xiS |jiM |0iC → |xiS |jiM |0iC ,

F : (207)

|xiS |jiM |1iC → |xj iS |jiM |1iC .

This operation can be achieved using the iteration procedure of with Toffoli complexity N , which allows us to perform the operation with register M encoded in binary. A complication is that, in the case where N is not a power of 2, there is a nonzero cost of the state preparation in V failing. We should only perform the operation F in the case where we have success of the state preparation. We include another two Toffolis to create and erase a register that gives a control qubit that flags whether the C register

is in the state |1i and there is success of the state preparation. Because the other operations are inverted, in the case that the state preparation does not work the net operation performed is the identity.

To be more specific, V prepares a state of the form

V |0i = |1i |ψ i + |0i |ψ i , (208)

with the first register flagging success. Since we only perform F for the flag qubit in the state |1i, we obtain

B † F BV |0i = B † F B |1i |ψ i + 1 |0i |ψ i . (209)

To determine the block encoded operation

h0| V † B † F BV |0i , (210)

h0| V † = h1| hψ | + h0| hψ | , (211)

h0| V † B † F BV |0i = hψ | B † F B |ψ i + 1 hψ |ψ i , (212)

where 1 indicates the identity on the target system. The first term is the desired operation we would obtain if the equal superposition state was obtained exactly (with a multiplying factor corresponding to the probability of success), and the second term is proportional to the identity. This small offset by the identity just gives a trivial shift to the eigenvalues.

4. Reflection R

This operation applies a phase flip for zero on the ancillas as

R : |0iM |0iC → − |0iM |0iC , |jiM |ciC → |jiM |ciC for (j, c) 6= (0, 0). (213)

As well as the ancillas M and C, this reflection also needs to be on any ancilla qubits used to encode the ancilla for the preparation of the equal superposition state, and the flag qubit. There are dlog N e qubits used to encode j, one qubit for C, and one ancilla used for the rotation, for a total of dlog N e + 2 qubits. Therefore the number of Toffolis needed for reflection about zero is dlog N e.

5. Total costs

The total Toffoli costs of implementing ŨW = RV † B † F BV are as follows.

1. The cost of V and V † is 8 log N + O(1).

2. The cost of F is N Toffolis.

3. The cost of R is dlog N e.

4. The cost of two applications of B is 2C diff + 2C fun + 2bdif + O(1).

The total cost of a step is then

2C diff + 2C fun + N + 2bdif + 9 log N + O(1). (214)

Note that 8 log N of this cost is for preparing equal superposition states, and can be omitted if N is a power of 2. The ancilla qubits needed are as follows.

1. The ancilla registers M and C need dlog N e + 1 qubits.

2. The resource state used to implement the controlled rotations needs bsm qubits.

3. The ancilla requirements of the energy difference and function evaluation oracles.

For the temporary ancilla cost, we need to take the maximum of that for the energy difference and function evaluation, giving the total ancilla cost of

Adiff + Afun + max(B diff , B fun ) + log N + bsm + O(1). (215)

F. Spectral gap amplification based quantum simulated annealing

An alternative, and potentially simpler, approach to preparing a low-temperature thermal state is given by . The idea behind this approach is to construct a Hamiltonian whose ground state is a purification of the Gibbs state. Similarly to the case with the quantum walk, one can start with an equal superposition state corresponding to infinite temperature, and simulate the Hamiltonian evolution starting from β = 0 and gradually increase β. This approach can correspond to using an adibatic approach on this Hamiltonian, or one can also apply a quantum Zeno approach

by phase measurements on the Hamiltonian evolution, or apply Hamiltonian evolutions for randomly chosen times. A simple choice of Hamiltonian is similar to the block-encoded operation for the quantum walks, so has a small spectral gap. In order to obtain a speedup, one needs to construct a new Hamiltonian with the square root of the spectral gap of the original Hamiltonian, thus yielding the same speedup as the quantum walks. That procedure, from , is called spectral gap amplification. Simulating the time-dependent Hamiltonian, for example using a Dyson

series, has significant complexity. To avoid that complexity, here we suggest that one instead construct a step of a quantum walk using a linear combination of unitaries. Such a quantum walk could be used to simulate the Hamiltonian evolution, but as discussed in [61, 62] one can instead just perform steps of the quantum walk which has eigenvalues that are the exponential of the arccosine of those for the Hamiltonian. By applying the steps of the quantum walk we can obtain the advantage

of the spectral gap amplification, without the difficulty of needing to simulate a time-dependent Hamiltonian. Unlike the quantum walks in the previous subsections, the arccosine does not yield a further square-root amplification of the spectral gap, because the relevant eigenvalue for the amplified Hamiltonian is not at 1. However, it potentially gives other scaling advantages (for instance, in avoiding the need for quantum signal processing when using certain oracles) compared to other proposals in the literature for realizing quantum simulated annealing via spectral gap

1. The spectral gap amplification Hamiltonian

Here we summarise the method of spectral gap amplification from , but specialise to the case where only single bit flips are allowed to make the method clearer. As discussed above, one can use a Hamiltonian simulation approach with Hamiltonian Hβ given in Eq. (171) with ground state corresponding to the quantum Gibbs state |ψβ i. Because the complexity depends on the spectral gap, it is advantageous to increase the spectral gap as much as possible, which was done via a quantum walk in the previous subsections. The proposal in is to construct a different

Hamiltonian whose spectral gap has been amplified relative to Hβ . To define this new Hamiltonian, they introduce states equivalent to

1 X

Hβ = (px,y + py,x ) |λx,y ihλx,y | . (217)

In this work we consider only transitions with single bit flips, so the coefficient (px,y + py,x ) is non-zero only if x and y differ by exactly one bit. We have included a factor of 1/2 to account for the symmetry between x and y. We can use this condition to express Hβ as a sum of 2-sparse matrices. To do so, recall that each x is an N -bit string. Then for each k = 1, . . . , n we define

1 X

Hβ,k := (px,xk + pxk ,x ) |λx,xk ihλx,xk | , (218)

where xk = notk (x), the result of flipping the k th bit of x. Then Hβ = k Hβ,k . The operators Hβ,k here are P equivalent to Oβ,k in , except we have specialized to the case where only transitions with single bit flips are allowed.

One can then define a new Hamiltonian (Eq. (25) in )

X p

Aβ := Hβ,k ⊗ (|kih0| + |0ihk|). (219)

The projector structure of the Hamiltonian allows the square root to be easily implemented via p 1 Xp

Hβ,k = √ px,xk + pxk ,x |λx,xk ihλx,xk | . (220)

2 N x

Here the 1/2 is still included to account for the symmetry between i and i(k) . Following Eq. (32) in , a coherent

Gibbs distribution can be seen to be the ground state of the following Hamiltonian

H̃β := Aβ + ∆β (1 − |0ih0|), (221)

where ∆β is a lower bound for the spectral gap of Hβ . This means that by preparing the minimum energy configuration of this Hamiltonian one, in effect, is capable of drawing a sample from the distribution that would be seen by running a simulated annealing procedure for sufficient time.

2. Implementing the Hamiltonian

2 N x

This is a 2-sparse Hamiltonian, then summing overpk to obtain Aβ gives a 2N -sparse Hamiltonian. To express Aβ as a linear combination of unitaries, we can express Hβ,k as

p 1 X 1 X

Hβ,k = √ qxk |xihx| − √ rxk (|xihxk | + |xk ihx|)

N x 2 2N x

1 X 1 1 X 1

Z Z

N x 0 2 2N x 0

where pxk ,x qxk = √ , (224) px,xk + pxk ,x s 2pxk ,x px,xk rxk = , (225) px,xk + pxk ,x

and we are taking the inequality test to yield a numerical value of 0 for false and 1 for true. Note that with these definitions, qxk and rxk can take values in the range [0, 1]. We use the procedure from (Lemma 4.3) to obtain a linear combination of unitaries. The operator is then approximated as a sum s s

2X −1 X 2X −1 X

1 z/2s−1 >1+qxk 1 s−1

The operator Aβ is then approximated by

N 2s −1

1 X 1 XX s−1

Aβ ≈ √ s

N k=1 2 z=0 x

2X −1 X

1 z/2s−1 >1+rxk

− √ (−1) (|xihxk | + |xk ihx|) ⊗ (|kih0| + |0ihk|) . (227) 2s+1 2 z=0 x

For the part ∆β (1 − |0ih0|), we can write it as

p 2N ∆β p 1 1 ∆β (1 − |0ih0|) = √ √ 1− √ (N − 1)(1 − |0ih0|)

(N − 1)( 2 − 1) N 2

N X

δβ X 1 =√ 1− √ |`ih`|

N k=1 2 `>0,`6=k

2s −1 N X 1 1 X z/2s−1 >1+δβ

X 1

=√ (−1) 1 − √ |`ih`| (228)

N 2s z=0 k=1

where p 2N ∆β δβ := √ . (229)

(N − 1)( 2 − 1)

Therefore the complete approximation of the Hamiltonian with spectral gap amplification is

s  

N 2X −1  X

1 X s−1 s−1

 (−1)z/2 >1+qxk |xihx| ⊗ (|kih0| + |0ihk|) + (−1)z/2 >1+δβ 1 ⊗ X

H̃β ≈ √ |`ih`|

2 N k=1 z=0  x `>0,`6=k

  1 1 X s−1 s−1 X  −√  (−1)z/2 >1+rxk (|xihxk | + |xk ihx|) ⊗ (|kih0| + |0ihk|) + (−1)z/2 >1+δβ 1 ⊗ |`ih`| . 2 2 x `>0,`6=k  (230)

Here we have grouped the terms such that the operations in square brackets are unitaries. Summing the coefficients in the sums gives a λ-value of

1 √ λ= 1+ √ N. (231) To implement the operator by a linear combination of unitaries, we need two single qubit ancillas, a register with z and a register with k. The prepare operation is trivial, and just needs to prepare the state s

N 2X−1

1 X 1

√ |ki |zi |0iF + 1/4 |1iF . (232) λ2s k=1 z=0

The roles of these registers are as follows.

1. The register with k selects terms in the sum over k in Eq. (230).

2. The register with z selects terms in the sum over z in Eq. (230).

3. The F register selects between the terms in square brackets in the first and second lines of Eq. (230).

There are registers containing k for both this prepared control state and the target state. We will call these the control and target K registers. In the prepare operation, creating the superposition over z can be trivially achieved with Hadamards. The superposition over N can be achieved similarly if N is a power of 2, but otherwise the procedure outlined in Section III E 2 can be used with cost 4 log N + O(1). The rotation on qubit F can be achieved with precision using 1.15brot + O(1) T operations, where brot = log(1/).

The select procedure for the linear combinations of unitaries may be performed as follows.

1. Perform a test of whether the target system K-register is in the space {|0i , |ki}, placing the result in an ancilla

2. Controlled on E being |1i and F , compute qxk or rxk .

3. Controlled on E being |0i, place the value δβ into the output register also used for qxk or rxk .

4. Perform the inequality test between z/2s−1 and 1 + qxk , 1 + rxk , or 1 + δβ .

5. Apply a Z gate to the output of the inequality test.

6. Controlled on the E register being |1i and the register F being |1i, apply X to qubit k of the target system.

7. Apply a not between |0i and |ki for the target system. That gives |kih0| + |0ihk|.

8. Invert the inequality test from step 4.

9. Invert step 3.

10. Invert step 2 uncomputing qxk or rxk .

11. Invert step 1.

12. Apply a Z gate to F to introduce the −1 sign.

Here we call the register that would carry |ki for the target system the K-register. The cost of these steps may be quantified as follows, ignoring O(1) costs. Steps 1 and 11. We need an equality test between the K-register for the ancilla and the K-register for the system, with cost log N + O(1). We also test if the system has 0 in its K-register, with cost log N + O(1), and perform an OR on the results of the two comparisons with cost 1. Since the comparisons needs to be computed and uncomputed,

there is cost 4 log N + O(1) for the two steps. Steps 2 and 10. Computing qxk and rxk may be performed by first computing the energy difference, then using a QROM to output coefficients for linear interpolation. The cost estimation is as given in Section II E, and we pay the QROM lookup cost twice for qxk and rxk , but we pay the multiplication cost only once. Since that is the dominant cost, the cost may be regarded as that of a single function oracle. The computation and uncomputation in the two

steps means we pay twice the cost of the energy difference and function oracles. Note that qxk and rxk are unchanged under the bit flip in step 6 (since there is no bit flip for qxk and rxk is symmetric under the bit flip). There is O(1) cost to making the computation controlled on the ancilla in E. Steps 3 and 9. Outputting δβ controlled on a single ancilla may be performed with CNOTs (no Toffoli cost) because δβ is classically computed. Steps 4 and 8. The inequality test is simply performed in the form z < 2s−1 (1 + qxk ) and similarly for r. There are

no multiplications involved, because qxk and rxk are output as integer approximations. The inequality test has cost s Toffolis, so computation and uncomputation for the two steps has cost 2s. Step 5. This is just a Z gate with no Toffoli cost. Step 6. The cost is two Toffolis to prepare a control qubit that flags whether the conditions required are satisfied. Then this qubit is used as a control register for the QROM on the value of k to apply a X operation to the target system. That QROM has complexity N .

Step 7. Controlled on the system K-register being equal to k, we subtract k from it, and controlled on the system K-register being 0 we add k to it. We then swap the registers with the results of these two equality tests. Since we still have the qubits with the results of the equality tests from step 1, we have no additional cost for that here. The cost of the two additions is 2 log N + O(1).

The Toffoli cost of the steps is therefore 2s + N + 6 log N + O(1), plus two times the cost of the function evaluation and energy difference oracles. Note that we pay four times the cost of the QROM lookup within the function evaluation oracle, but we are regarding the cost as two function oracles because the QROM lookup cost is a smaller cost given in an order term. The cost of the preparation and inverse preparation is 8 log N + O(1) Toffolis and 2.3brot + O(1) T gates, or just 2.3brot + O(1) T gates if N is a power of 2. Taking s = bsm + O(1), that gives total cost

2C diff + 2C fun + 2bsm + N + 1 log N + O(brot ), (233) where we have put the T cost in the order term. The ancilla cost is as follows.

1. Two qubits for the E and F ancillae.

2. Two qubits from the results of the two equality tests for the system K-register.

3. The register with k for the control ancilla and that with k for the system each need dlog N e qubits.

4. The register with z for the control ancilla needs s qubits.

5. The ancillas for the energy difference oracle.

6. The ancillas for the function evaluation oracle.

The number of qubits s used for z can be taken to be within O(1) of the number of qubits c used for qxk or rxk . We need temporary qubits for working, but the same working qubits as for the oracles can be used, so we will not count these ancilla costs again. The function evaluation oracle may use more or less temporary ancilla than the energy difference, so we need to take the maximum of these two costs. That gives an ancilla cost of 2 log N + bsm + O(1) plus the ancilla costs of the two oracles, or

Adiff + Afun + max(B diff , B fun ) + 2 log N + bsm + O(1). (234)

IV. ERROR-CORRECTION ANALYSIS AND DISCUSSION

Previous sections of this paper have discussed and optimized the compilation of various heuristic approaches to quantum optimization into cost models appropriate for quantum error-correction. Specifically, we focused on reducing

one hour runtime one day runtime algorithm applied to problem logical Toffolis maximum physical maximum physical

Sherrington-Kirkpatrick model size, N qubits per step steps qubits steps qubits

6 1 6.3×1 3.3×1 3.1×1 (1.8×1 ) 7.9×1 3.7×1 (2.0×1 ) 1 1 2.6×1 7.9×1 4.2×1 (2.1×1 ) 1.9×1 5.2×1 (2.3×1 ) amplitude amplification 2 3 1.0×1 2.0×1 7.2×1 (3.0×1 ) 4.8×1 8.1×1 (3.0×1 ) 5 5 4.6×1 4.5×1 1.2×1 (4.3×1 ) 1.1×1 1.4×1 (4.3×1 ) 10 10 1.8×1 1.1×1 2.2×1 (7.0×1 ) 2.7×1 2.9×1 (8.8×1 ) 6 1 6.8×1 3.1×1 3.4×1 (1.9×1 ) 7.3×1 4.1×1 (2.1×1 ) QAOA / 1st order Trotter 1 1 2.7×1 7.7×1 5.0×1 (2.4×1 ) 1.9×1 5.6×1 (2.4×1 )

e.g., for population transfer 2 3 1.1×1 2.0×1 7.6×1 (3.1×1 ) 4.7×1 8.6×1 (3.1×1 ) or adiabatic algorithm 5 5 4.6×1 4.5×1 1.2×1 (4.5×1 ) 1.1×1 1.4×1 (4.5×1 ) 10 11 1.8×1 1.1×1 2.2×1 (7.1×1 ) 2.7×1 2.9×1 (8.9×1 ) 6 9 3.8×1 5.4×1 3.0×1 (1.8×1 ) 1.3×1 3.5×1 (2.0×1 )

Hamiltonian walk 1 1 7.7×1 2.7×1 4.1×1 (2.1×1 ) 6.5×1 5.0×1 (2.3×1 )

e.g., for population transfer 2 2 1.5×1 1.4×1 7.0×1 (3.0×1 ) 3.3×1 8.0×1 (3.0×1 ) or adiabatic algorithm 5 5 3.1×1 6.8×1 1.2×1 (4.3×1 ) 1.6×1 1.4×1 (4.3×1 ) 10 10 6.1×1 3.4×1 2.2×1 (6.9×1 ) 8.1×1 2.9×1 (8.7×1 ) 6 1 6.7×1 3.1×1 3.3×1 (1.9×1 ) 7.5×1 4.0×1 (2.1×1 )

LHPST walk 1 1 9.0×1 2.3×1 4.4×1 (2.2×1 ) 5.6×1 5.5×1 (2.4×1 )

quantum simulated annealing 2 3 1.5×1 1.4×1 7.4×1 (3.1×1 ) 3.3×1 8.4×1 (3.1×1 ) 5 5 2.6×1 8.1×1 1.2×1 (4.4×1 ) 2.0×1 1.4×1 (4.4×1 ) 10 10 4.8×1 4.4×1 2.2×1 (7.0×1 ) 1.0×1 2.9×1 (8.9×1 ) 6 1 4.0×1 5.2×1 3.3×1 (1.9×1 ) 1.2×1 4.0×1 (2.1×1 ) spectral gap amplified 1 1 6.4×1 3.3×1 4.4×1 (2.2×1 ) 7.8×1 5.5×1 (2.4×1 ) walk based quantum 2 3 1.3×1 1.6×1 7.4×1 (3.1×1 ) 3.9×1 8.4×1 (3.1×1 )

simulated annealing 5 5 2.3×1 9.0×1 1.2×1 (4.4×1 ) 2.2×1 1.4×1 (4.4×1 ) 10 10 4.5×1 4.6×1 2.2×1 (7.0×1 ) 1.1×1 2.9×1 (8.9×1 )

TABLE VIII. Estimates of resources required to implement steps of various heuristic algorithms for the Sherrington-Kirkpatrick

(SK) model within the surface code. All error-correction overheads are reported assuming a single Toffoli factory using state distillation constructions from . Surface code overheads in parenthesis assume a physical error rate of 10−4 whereas the overheads not in parenthesis assume a physical error rate of 10−3 . The target success probability is 0.9. These estimates are based on Table VII where we somewhat arbitrarily choose to set all values of the parameter quantifying the number of bits of

precision (b) that appear in the table to 2 except for bfun and bsm which can be smaller so we take bfun = bsm = 7.

the Toffoli (and in some cases T) complexity of these algorithms while also keeping the number of ancilla qubits reasonable. This cost model is motivated by our desire to assess the viability of these heuristics within the surface code (the most practical error-correcting code suitable for a 2D array of physical qubits) [19, 65–67]. T gates and Toffoli gates cannot be implemented transversely within practical implementations of the surface code. Instead, one must implement these gates by first distilling resource states. In particular, to implement a T gate one requires a T

state (|Ti = T |+i) and to implement a Toffoli gate one requires a CCZ state (|CCZi = CCZ |+ + +i); in both cases these states are consumed during the implementation of the associated gates. Distilling T or CCZ states requires a substantial amount of both time and hardware. Here, we will analyze the cost to implement our various heuristic optimization primitives using the constructions of which are based on applying the lattice surgery constructions of to the fault-tolerant Toffoli protocols

of [69, 70]. We will further assume a correlated-error minimum weight perfect matching decoder capable of keeping pace with 1 µs rounds of surface code error detection , and capable of performing feedforward in about 1 µs. We will assume that our physical hardware gates have error rates of either 10−3 or 10−4 , the former consistent with the best error rates demonstrated in state-of-the-art intermediate scale superconducting qubit platforms and the latter consistent with improvements in the technology that we hope would be feasible in the next decade. Under

these assumptions the spacetime volume required to implement one Toffoli gate or two T gates with two levels of state distillation and code distance d = 3 (which is safely sufficient for the computations we analyze here) is equal to roughly 2 qubitseconds . For instance, to distill one CCZ state using the approach in requires 5.5d + O(1)

cycles using a factory with a data qubit footprint of about 12d × 6d (the total qubit count includes measurement qubits, and so is roughly double this figure). Specifically, in our estimates we will assume that executing a Toffoli gate requires about 1 microseconds and 150,0 physical qubits (see the resource estimation spreadsheet included in the supplementary materials of for more detailed assumptions). Due to this large overhead we will focus on estimates assuming that we distill CCZ states in series, which is likely how we would operate the first generation of

fault-tolerant surface code computers. In Table VIII and Table IX we estimate the resources that would be required to implement various heuristic optimization primitives within the surface code (given the assumptions of the the prior paragraphs) for the Sherrington-

Kirkpatrick and Low Autocorrelation Binary Sequences problems, respectively. We perform this analysis for the

primitives of amplitude amplification, a first order Trotter step (which can be used for QAOA, population transfer, the adiabatic algorithm, etc.), a qubitized Hamiltonian walk realized from the linear combinations of unitaries query model (which can be used for measuring energies in QAOA, performing population transfer, the adiabatic algorithm, etc.), the qubitized quantum walk approach to quantum simulated annealing (“LHPST walk”) and the spectral gap amplified approach to quantum simulated annealing. The only primitive discussed in this paper omitted from these

tables is the Szegedy walk approach to quantum simulated annealing. This is because we can see from Table VII that the Szegedy walk approach is strictly less efficient than the qubitized variant, and would require so many ancilla that analyzing it under the assumption of serial state distillation seems unreasonable. Because we do not know how many times one would need to repeat these primitives to solve the various optimization problems, in Table VIII and Table IX we report how many times one would be able to implement these primitives for various system sizes,

assuming maximum run times of one hour or one day (2 hours). We also report how many physical qubits would be required to realize these computations assuming physical gate error rates of 10−3 or (10−4 ). We focus on the SK and LABS cost functions primarily for concreteness. As seen in Table IV and Table VII, the choice to focus on these specific problems rather than QUBO or the HL model means that we do not need to choose a precision parameter in some cases. For example, with amplitude amplification we know how many bits of

precision we should compute the energy to since SK and LABS both have integer valued energies in a well defined range. However, in order to produce specific numerical estimates for other primitives it is necessary to assume values for the precision parameters b appearing Table IV (defined in Table III); e.g., for the Trotter steps one must realize time evolutions of non-integer duration so that the phase is accurate to within some precision bpha which we must choose independently of the particular problem. Thus, in order to produce actual numerical estimates, in Table VIII

and Table IX we choose to set many variants of the free precision parameter b to 20; thus, b = 2 bits of precision. However, as discussed in previous sections, the parameters bfun and bsm can generally be chosen to be smaller than the other values of b without compromising precision; here we take bfun = bsm = 7. It is tempting to directly compare the costs of the various primitives shown in Table VIII and Table IX. While comparisons of the same primitives between the two problem types are straightforward (e.g., SK is more efficient

than LABS in most, but not all, cases), comparisons between the different primitive types are challenging. Quantum simulated annealing, amplitude amplification, QAOA, population transfer, and the adiabatic algorithm are simply different algorithms so it is difficult to compare the relative values of a step of these algorithms. It seems more reasonable to compare the Trotter steps to the qubitized Hamiltonian walk steps since these primitives can be used for the same ends (e.g., population transfer or the adiabatic algorithm). But first, the choice of b = 2

means something different for these two algorithms. And second, while the Hamiltonian walks are capable of more precise evolutions (scaling as O(log 1/) in terms of precision compared to the O(poly(1/)) scaling of fixed order Trotter based methods), for heuristic optimization the evolution does not necessarily need to be precise, so the Trotter approach may be more efficient by using large steps. The Trotter steps can be made arbitrarily large without increasing gate count (although at a cost of less precision), whereas the Hamiltonian walk effectively simulates time of

at most 1/λ where λSK ≈ N 2 /2 and λLABS ≈ N 3 /3 (but it does so quite precisely). Thus, although the Hamiltonian walk steps require the fewest Toffolis in Table IX, they may still be less efficient than other approaches. For the various forms of quantum simulated annealing, the number of steps needed is governed by the spectral gap. The qubitized annealing (LHPST) and Szegedy approaches are directly comparable because they have the same gap, which means the same number of steps should be sufficient. This means that the smaller step cost of LHPST

means that it is more efficient. The spectral gap amplified approach has a similar gap as the LHPST and Szegedy approaches, because √ it provides a similar square-root improvement. The problem is that the Hamiltonian has a λ-value proportional √ to N , as shown in Eq. (231). This increases the cost √ of implementing the Hamiltonian by a factor of N , so the cost given for a single step should be multiplied by N for a fair comparison with the other simulated annealing approaches. When that is taken into account, the spectral gap amplified approach is less efficient.

With these caveats and context, we believe that Table VIII and Table IX give a rough sense for the feasibility of implementing these various heuristic optimization primitives on a small fault-tolerant surface code quantum processor. In most cases one can attempt these algorithms up to roughly a thousand bits with around a million physical qubits or less (especially given 10−4 error rates). However, we can see that the significant overheads of state distillation make

one hour runtime one day runtime algorithm applied to problem logical Toffolis maximum physical maximum physical

LABS problem size, N qubits per step steps qubits steps qubits

6 9 9.8×1 2.1×1 3.0×1 (1.8×1 ) 5.1×1 3.6×1 (2.0×1 ) 1 1 3.7×1 5.6×1 4.1×1 (2.1×1 ) 1.3×1 5.1×1 (2.3×1 ) amplitude amplification 2 3 1.5×1 1.4×1 7.1×1 (3.0×1 ) 3.3×1 8.0×1 (3.0×1 ) 5 5 6.1×1 3.4×1 1.2×1 (4.3×1 ) 8.2×1 1.4×1 (4.3×1 ) 10 10 2.3×1 9.0×1 2.2×1 (6.9×1 ) 2.2×1 2.9×1 (8.8×1 ) 6 1 1.0×1 2.1×1 3.3×1 (1.9×1 ) 5.0×1 4.0×1 (2.1×1 ) QAOA / 1st order Trotter 1 1 3.8×1 5.5×1 4.4×1 (2.1×1 ) 1.3×1 5.5×1 (2.4×1 )

e.g., for population transfer 2 3 1.5×1 1.4×1 7.4×1 (3.1×1 ) 3.4×1 8.4×1 (3.1×1 ) or adiabatic algorithm 5 5 5.0×1 4.2×1 1.2×1 (4.4×1 ) 1.0×1 1.4×1 (4.4×1 ) 10 10 1.7×1 1.2×1 2.2×1 (7.0×1 ) 2.9×1 2.9×1 (8.9×1 ) 6 9 2.6×1 8.1×1 3.0×1 (1.8×1 ) 2.0×1 3.5×1 (2.0×1 )

Hamiltonian walk 1 1 5.1×1 4.1×1 4.1×1 (2.1×1 ) 9.8×1 5.0×1 (2.3×1 )

e.g., for population transfer 2 2 1.0×1 2.0×1 7.0×1 (3.0×1 ) 4.9×1 8.0×1 (3.0×1 ) or adiabatic algorithm 5 5 2.0×1 1.0×1 1.2×1 (4.3×1 ) 2.4×1 1.4×1 (4.3×1 ) 10 10 4.1×1 5.1×1 2.2×1 (6.9×1 ) 1.2×1 2.9×1 (8.7×1 ) 6 1 2.0×1 1.0×1 3.6×1 (2.0×1 ) 2.5×1 4.4×1 (2.1×1 )

LHPST walk 1 2 7.5×1 2.8×1 5.3×1 (2.5×1 ) 6.7×1 5.9×1 (2.5×1 )

quantum simulated annealing 2 3 3.0×1 6.9×1 7.8×1 (3.2×1 ) 1.7×1 8.8×1 (3.2×1 ) 5 5 1.2×1 1.7×1 1.3×1 (4.5×1 ) 4.1×1 1.5×1 (4.5×1 ) 10 11 4.6×1 5.0×1 2.2×1 (7.1×1 ) 1.1×1 3.0×1 (9.0×1 ) 6 1 2.0×1 1.1×1 3.6×1 (2.0×1 ) 2.5×1 4.3×1 (2.1×1 ) spectral gap amplified 1 2 7.5×1 2.8×1 5.3×1 (2.5×1 ) 6.7×1 5.9×1 (2.5×1 ) walk based quantum 2 3 3.0×1 6.9×1 7.8×1 (3.2×1 ) 1.7×1 8.8×1 (3.2×1 )

simulated annealing 5 6 1.2×1 1.7×1 1.3×1 (4.5×1 ) 4.1×1 1.5×1 (4.5×1 ) 10 11 4.6×1 5.0×1 2.2×1 (7.2×1 ) 1.1×1 3.0×1 (9.0×1 )

TABLE IX. Estimates of resources required to implement steps of various heuristic algorithms for the Low Autocorrelation

Binary Sequence (LABS) problem within the surface code. All overheads are reported assuming a single Toffoli factory using state distillation constructions from . Surface code overheads in parenthesis assume a physical error rate of 10−4 whereas the overheads not in parenthesis assume a physical error rate of 10−3 . Target success probability is 0.9. These estimates are based on Table VII where we somewhat arbitrarily choose to set all values of the parameter quantifying the number of bits of

precision (b) that appear in the table to 2 except for bfun and bsm which can be smaller, so we take bfun = bsm = 7.

the execution of these algorithms painfully slow. The quantum simulated annealing steps are often more efficient to implement than most other steps. The one exception is the Hamiltonian walk steps, which are highly efficient. But again, there it is likely that the large value of λ means that many more Hamiltonian walk steps would be required. We see that for SK model problem sizes between N = 6 and N = 10 one can perform between about 4×1 and 3×1 quantum simulated annealing updates per hour. As a comparison, the work of discusses the implementation

of a very performant classical simulated annealing code for optimizing sparse spin glasses. This same code deployed to an N = 5 spin instance of SK is capable of performing a simulated annealing update step in an average of 7

CPU-nanoseconds (this average accounts for the fact that most updates for the Sherrington-Kirkpatrick model

are rejected). This works out to about 6×10 attempted updates per core-hour, or about one-hundred million times more steps than the quantum computer can implement in that same amount of time for an N = 5 spin SK model. The state produced after the 2×1 quantum simulated annealing steps that our quantum computer can make in one day for the N = 5 spin SK model could be produced by a single classical core in about four CPU-minutes, assuming that the classical algorithm would require exactly quadratically more (4×10 ) steps. The comparison is even less

favorable for quantum computing if we consider larger problem sizes. Furthermore, given the high costs of quantum computing, it is unclear why we should restrict the classical competition to one core rather than to millions of cores. The quantum computer must give a speedup for a sufficiently difficult problem if we assume a quadratic speedup in the number of annealing steps required. For the N = 5 spin SK model, by comparing the number of steps that the classical algorithm from can make in one hour (5×10 ) to the number of steps that the quantum algorithm

can make in one hour (8×1 ), we can estimate a crossover point. In particular, solving M/(8×1 ) = M 2 /(5×10 ) yields M ≈ 7×1 as the minimum number of steps that would be required for the quantum algorithm to give an advantage. Unfortunately, this would mean the quantum computer would need to run for a number of hours that is 7 × 1 /(8 × 1 ), which works out to about one year. Moreover, this analysis is very favorable to the quantum computer in that (1) it does not adjust the surface code distance (and thus, resource overheads) for runtimes longer

than an hour, (2) it compares to a single classical core and (3) it assumes that N = 5 is a large enough instance to warrant this many steps in some cases. Of course, most N = 5 instances of the SK model can be solved with much less than a CPU year of simulated annealing run time, thus precluding the possibility of a quantum speedup for most instances at that size under the assumptions of our analysis.

Comparisons for amplitude amplification are similarly discouraging. For these two problems one can perform

between about ten and three thousand steps of amplitude amplification using between about one-hundred thousand and one-million qubithours of state distillation. In the same amount of time one could conservatively check hundreds of billions of solutions on even a single core of a classical computer. Assuming the quantum computer would require quadratically fewer steps of amplitude amplification (still at least a hundred thousand steps) compared to random classical energy queries, we would still need roughly billions of qubithours of state distillation in order to compete

with what a single core of a classical computer can do in one hour. Once again, if we instead make our comparisons to a classical supercomputing cluster rather than to a single classical core, the overheads appear even more daunting. The LABS problem is an example where the scaling of the best known classical algorithm is worse than O(2N/2 ) and thus, an approach based on amplitude amplification would have better scaling. In particular, the best scaling method in the literature goes as Θ(1.73N ) . That scaling is obtained for a branch-and-bound type method that queries

the effect of local spin flips (and thus, not the entire objective function). Each of these queries is slightly faster than requiring 7 CPU-microseconds with an optimized classical implementation for N = 6 (about 5×1 steps per hour). If we were to compete with this approach using amplitude amplification on a quantum computer (where we can perform about 2×1 steps per hour at N = 64) then we can approximate the crossover point as 2M/2 /(2×1 ) = 1.73M /(5×1 ) so long as we remember that these numbers are only valid in the vicinity of M ≈ N = 64. Coincidentally, that is

the case as we find that M = 62, which corresponds to about 2 × 1 queries, which would take about 1 years. Once again, here we are being generous to the quantum computer by making comparisons to a single core and not adjusting the code distance for long runtimes. Still, we again see that a small error-corrected quantum computer cannot compete with classical methods under such a modest scaling advantage. The heuristics based on Trotter steps or qubitized walk LCU queries are more difficult to compare to classical

competition since algorithms such as QAOA, the adiabatic algorithm, or population transfer lack a clear classical analog. In that sense, it is not straightforward to predict what being able to perform a few hundred Trotter steps or a few thousand qubitized walk steps in an hour might buy us, but it is clear that these would be able to perform only very short quantum walks or time evolutions, or very inaccurate time evolutions. Eventually, it will at least be possible to find out by using our constructions to realize these algorithms on a small fault-tolerant quantum computer

and experimentally discovering what happens. We note that for these algorithms the number of steps should be interpreted as the product of the number of repetitions of the primitive and the total number of times the algorithm is repeated. For instance, we see that for either the SK model or LABS at N = 256, slightly more than 1 Trotter steps can be implemented in an hour. In the context of QAOA, this could mean that we run QAOA at p = 1 and draw one sample, or we run QAOA at p = 1 and draw ten samples or we run QAOA at p = 1 and draw one-hundred

samples, etc. However, as we have explained in Section III A and Section III B one is probably better off using coherent repetitions in the context of an amplitude-amplification like scheme rather than making classical repetitions. Although we have tried to optimize the realization of these heuristic primitives for the cost functions considered in this paper, clever improvements to our approaches might further reduce the resources required. However, we would expect the complexity of these primitives to be no better than N . In particular, LCU-based methods require

a minimum of N − 1 Toffolis just to access N qubits in a controlled way. For Trotter step methods, evolution under the problem Hamiltonian could be below N for a particularly simple problem Hamiltonian, but then the evolution under the transverse field driver Hamiltonian would be the dominant cost and require O(N ) non-Clifford gates. For amplitude amplification, one could again have a small cost for a particularly simple problem Hamiltonian, but amplitude amplification requires a reflection on at least N qubits, with cost at least N − 2 Toffolis.

We are already at about 5N for the LHPST walk with SK, so we would not expect more than about a factor of 5 improvement even for the easiest problem. If we were to use the sum of bits directly as in , then the complexity would be about 2N , but another N ancilla qubits would be needed. One could also propose to use a larger fault- tolerant quantum computer and distill more Toffoli states in parallel. But even if this strategy is pursued to the fullest extent possible (requiring tens or hundreds of millions of physical qubits) and parallelized near-optimally, the surface

code will then be bottlenecked by Clifford gates (or the overhead of routing) which are, at best, only about a hundred to a thousand times faster to implement. In conclusion, we have optimized and compiled the basic primitives required for many popular heuristic algorithms

for quantum optimization to a cost model appropriate for practical quantum error-correction schemes. This allowed us to assess and compare the cost of several quantum algorithms that have not previously been compiled in such detail. We focused on doing this for only a subset of the possible cost function structures that one might hope to algorithmically exploit for more efficient implementations, but our constructions led to the development of various methodologies which we expect will be useful in a more general context. For instance, we expect that work outside

the context of quantum optimization might benefit from our strategy of interpolating arithmetic functions using an adaptive QROM. However, despite our attempts at optimization, the concrete resource estimates from Table VIII and Table IX are predictably discouraging. The essential reason for this is the substantial constant factor slowdown between error-corrected quantum computation and classical computation. Based on these numbers we strongly suspect that in order for early fault-tolerant quantum computers to have a meaningful impact on combinatorial optimization,

we will either need quantum optimization algorithms that afford speedups which are much better than quadratic, or we will need significant improvements in the way that we realize error-correction.

ACKNOWLEDGEMENTS

The authors thank Sergio Boixo, Austin Fowler, Sergei Isakov, Kostyantyn Kechedzhi, Mária Kieferová, Jessica

Lemieux, Jarrod McClean, John Platt, and Vadim Smelyanskiy for helpful discussions. Y.R.S., D.W.B., P.C.S.C, and N.W. acknowledge funding for this work from a grant from Google Quantum. D.W.B. is also funded by an Australian Research Council Discovery Project DP190102633.

F. Arute, K. Arya, R. Babbush, D. Bacon, J. C. Bardin, R. Barends, R. Biswas, S. Boixo, F. G. S. L. Brandao, D. A. Buell, B. Burkett, Y. Chen, Z. Chen, B. Chiaro, R. Collins, W. Courtney, A. Dunsworth, E. Farhi, B. Foxen, A. Fowler, C. Gidney, M. Giustina, R. Graff, K. Guerin, S. Habegger, M. P. Harrigan, M. J. Hartmann, A. Ho, M. Hoffmann, T. Huang, T. S. Humble, S. V. Isakov, E. Jeffrey, Z. Jiang, D. Kafri, K. Kechedzhi, J. Kelly, P. V. Klimov, S. Knysh, A. Korotkov, F. Kostritsa, D. Landhuis, M. Lindmark, E. Lucero, D. Lyakh, S. Mandrà, J. R. McClean, M. McEwen, A. Megrant,

X. Mi, K. Michielsen, M. Mohseni, J. Mutus, O. Naaman, M. Neeley, C. Neill, M. Y. Niu, E. Ostby, A. Petukhov, J. C. Platt, C. Quintana, E. G. Rieffel, P. Roushan, N. C. Rubin, D. Sank, K. J. Satzinger, V. Smelyanskiy, K. J. Sung, M. D. Trevithick, A. Vainsencher, B. Villalonga, T. White, Z. J. Yao, P. Yeh, A. Zalcman, H. Neven, and J. M. Martinis, Nature 574, 5 (2019). E. Farhi, J. Goldstone, S. Gutmann, J. Lapan, A. Lundgren, and D. Preda, Science 292, 4 (2001). L. K. Grover, in Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing, STOC 9 (Associ-

ation for Computing Machinery, New York, NY, USA, 1996) p. 212219. C. Durr and P. Hoyer, “A quantum algorithm for finding the minimum,” (1996), arXiv:quant-ph/9607014. P. Ray, B. K. Chakrabarti, and A. Chakrabarti, Physical Review B 39, 118 (1989). T. Kadowaki and H. Nishimori, Physical Review E 58, 53 (1998). E. Farhi, J. Goldstone, S. Gutmann, and M. Sipser, “Quantum computation by adiabatic evolution,” (2000), arXiv:quant- ph/0001106. D. Aharonov, W. van Dam, J. Kempe, Z. Landau, S. Lloyd, and O. Regev, SIAM Journal on Computing 37, 1 (2007).

M. B. Hastings, Quantum 2, 7 (2018). K. Kechedzhi, V. Smelyanskiy, J. R. McClean, V. S. Denchev, M. Mohseni, S. Isakov, S. Boixo, B. Altshuler, and H. Neven, in 13th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2018),

Leibniz International Proceedings in Informatics (LIPIcs), Vol. 111, edited by S. Jeffery (Schloss Dagstuhl–Leibniz-Zentrum

fuer Informatik, Dagstuhl, Germany, 2018) pp. 9:1–9:16. V. N. Smelyanskiy, K. Kechedzhi, S. Boixo, S. V. Isakov, H. Neven, and B. Altshuler, Physical Review X 10, 0110 (2020). E. Farhi, J. Goldstone, and S. Gutmann, “A quantum approximate optimization algorithm,” (2014), arXiv:1411.4028. R. D. Somma, S. Boixo, H. Barnum, and E. Knill, Physical Review Letters 101, 1305 (2008). S. Boixo, G. Ortiz, and R. Somma, The European Physical Journal Special Topics 224, 3 (2015). A. Montanaro, “Quantum walk speedup of backtracking algorithms,” (2015), arXiv:1509.02374.

E. Campbell, A. Khurana, and A. Montanaro, Quantum 3, 1 (2019). A. Montanaro, Physical Review Research 2, 0130 (2020). A. Kitaev, Annals of Physics 303, 2 (2003). A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Physical Review A 86, 0323 (2012). G. Brassard, P. Høyer, M. Mosca, and A. Tapp, in Quantum Computation and Information, edited by Vitaly I Voloshin, Samuel J. Lomonaco, and Howard E. Brandt (American Mathematical Society, Washington D.C., 2002) Chap. 3, pp.

S. Boixo, E. Knill, and R. Somma, Quantum Information & Computation 9, 08 (2009). M. Szegedy, in 45th Annual IEEE Symposium on Foundations of Computer Science (2004) pp. 32–41. J. Lemieux, B. Heim, D. Poulin, K. Svore, and M. Troyer, Quantum 4, 2 (2020). S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi, Science 220, 6 (1983). I. D. Kivlichan, C. Gidney, D. W. Berry, N. Wiebe, J. McClean, W. Sun, Z. Jiang, N. Rubin, A. Fowler, A. Aspuru-Guzik, H. Neven, and R. Babbush, Quantum 4, 2 (2020).

R. Babbush, C. Gidney, D. W. Berry, N. Wiebe, J. McClean, A. Paler, A. Fowler, and H. Neven, Physical Review X 8, 0410 (2018). Y. R. Sanders, G. H. Low, A. Scherer, and D. W. Berry, Physical Review Letters 122, 0205 (2019). G. H. Low and I. L. Chuang, Quantum 3, 1 (2019). S. Boixo, T. F. Ronnow, S. V. Isakov, Z. Wang, D. Wecker, D. A. Lidar, J. M. Martinis, and M. Troyer, Nature Physics 10, 2 (2014). J. Bernasconi, Journal de Physique 48, 5 (1987). T. Packebusch and S. Mertens, Journal of Physics A: Mathematical and Theoretical 49, 1650 (2016).

C. Gidney, Quantum 2, 7 (2018). A. Y. Kitaev, A. H. Shen, and M. N. Vyalyi, Graduate Studies in Mathematics, Vol. 4 (American Mathematical Society, Providence, Rhode Island, 2002). A. Bocharov, M. Roetteler, and K. M. Svore, Physical Review Letters 114, 0805 (2015). C. Gidney and A. G. Fowler, Quantum 3, 1 (2019). A. M. Childs and N. Wiebe, Quantum Information & Computation 12, 9 (2012). D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, and R. D. Somma, Physical Review Letters 114, 0905 (2015).

G. H. Low and N. Wiebe, “Hamiltonian simulation in the interaction picture,” (2018), 1805.00675. D. W. Berry, C. Gidney, M. Motta, J. R. McClean, and R. Babbush, Quantum 3, 2 (2019). G. H. Low, V. Kliuchnikov, and L. Schaeffer, “Trading T-gates for dirty qubits in state preparation and unitary synthesis,” (2018), arXiv:1812.00954. T. J. Yoder, G. H. Low, and I. L. Chuang, Physical Review Letters 113, 2105 (2014). B. Barak, A. Moitra, R. O’Donnell, P. Raghavendra, O. Regev, D. Steurer, L. Trevisan, A. Vijayaraghavan, D. Wit-

mer, and J. Wright, in Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM 2015, August 24-26, 2015, Princeton, NJ, USA, LIPIcs, Vol. 40, edited by N. Garg, K. Jansen, A. Rao, and J. D. P. Rolim (Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2015) pp. 110–123. F. Arute, K. Arya, R. Babbush, D. Bacon, J. C. Bardin, R. Barends, S. Boixo, M. Broughton, B. B. Buckley, D. A. Buell, B. Burkett, N. Bushnell, Y. Chen, Z. Chen, B. Chiaro, R. Collins, W. Courtney, S. Demura, A. Dunsworth, E. Farhi,

A. Fowler, B. Foxen, C. Gidney, M. Giustina, R. Graff, S. Habegger, M. P. Harrigan, A. Ho, S. Hong, T. Huang, L. B. Ioffe, S. V. Isakov, E. Jeffrey, Z. Jiang, C. Jones, D. Kafri, K. Kechedzhi, J. Kelly, S. Kim, P. V. Klimov, A. N. Korotkov, F. Kostritsa, D. Landhuis, P. Laptev, M. Lindmark, M. Leib, E. Lucero, O. Martin, J. M. Martinis, J. R. McClean, M. McEwen, A. Megrant, X. Mi, M. Mohseni, W. Mruczkiewicz, J. Mutus, O. Naaman, M. Neeley, C. Neill, F. Neukart, H. Neven, M. Y. Niu, T. E. O’Brien, B. O’Gorman, E. Ostby, A. Petukhov, H. Putterman, C. Quintana, P. Roushan, N. C.

Rubin, D. Sank, K. J. Satzinger, A. Skolik, V. Smelyanskiy, D. Strain, M. Streif, K. J. Sung, M. Szalay, A. Vainsencher, T. White, Z. J. Yao, P. Yeh, A. Zalcman, and L. Zhou, “Quantum approximate optimization of non-planar graph problems on a planar superconducting processor,” (2020), arXiv:2004.04197. A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, and J. L. O’Brien, Nature Communications 5, 42 (2014). J. R. McClean, J. Romero, R. Babbush, and A. Aspuru-Guzik, New Journal of Physics 18, 0230 (2016).

F. G. S. L. Brandao, M. Broughton, E. Farhi, S. Gutmann, and H. Neven, “For fixed control parameters the quantum ap- proximate optimization algorithm’s objective function value concentrates for typical instances,” (2018), arXiv:1812.04170. E. Farhi, J. Goldstone, S. Gutmann, and L. Zhou, “The quantum approximate optimization algorithm and the Sherrington- Kirkpatrick model at infinite size,” (2019), arXiv:1910.08187. L. Zhou, S.-T. Wang, S. Choi, H. Pichler, and M. D. Lukin, Physical Review X 10, 0210 (2020).

A. Gilyén, S. Arunachalam, and N. Wiebe, in Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms (Society for Industrial and Applied Mathematics, 2019) pp. 1425–1444. A. Montanaro, Proceedings of the Royal Society A 471, 201503 (2015). E. Farhi, J. Goldstone, and S. Gutmann, “A numerical study of the performance of a quantum adiabatic evolution algorithm for satisfiability,” (2000), arXiv:quant-ph/0007071. A. Elgart and G. A. Hagedorn, Journal of Mathematical Physics 53, 1022 (2012).

D. A. Lidar, A. T. Rezakhani, and A. Hamma, Journal of Mathematical Physics 50, 1021 (2009). N. Wiebe and N. S. Babcock, New Journal of Physics 14, 0130 (2012). M. Kieferová and N. Wiebe, New Journal of Physics 16, 1230 (2014). K. Wan and I. Kim, “Fast digital methods for adiabatic state preparation,” (2020), arXiv:2004.04164. N. Wiebe, D. Berry, P. Høyer, and B. C. Sanders, Journal of Physics A: Mathematical and Theoretical 43, 0652 (2010). J. Lemieux, G. Duclos-Cianci, D. Sénéchal, and D. Poulin, arXiv:2006.046 (2020).

H.-T. Chiang, G. Xu, and R. D. Somma, Physical Review A 89, 0123 (2014). J. Kaiser and R. Schafer, IEEE Transactions on Acoustics, Speech, and Signal Processing 28, 1 (1980). D. W. Berry, M. Kieferová, A. Scherer, Y. R. Sanders, G. H. Low, N. Wiebe, C. Gidney, and R. Babbush, npj Quantum Information 4, 2 (2018).

D. Poulin, A. Kitaev, D. S. Steiger, M. B. Hastings, and M. Troyer, Physical Review Letters 121, 0105 (2018). T. Häner, M. Roetteler, and K. M. Svore, “Optimizing quantum circuits for arithmetic,” (2018), arXiv:1805.12445. D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, and R. D. Somma, in Proceedings of the 46th Annual ACM Symposium on Theory of Computing, STOC ’1 (ACM, New York, NY, USA, 2014) pp. 283–292. S. B. Bravyi and A. Y. Kitaev, “Quantum codes on a lattice with boundary,” (1998), arXiv:quant-ph/9811052.

E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, Journal of Mathematical Physics 43, 44 (2002). R. Raussendorf and J. Harrington, Physical Review Letters 98, 1905 (2007). A. G. Fowler and C. Gidney, “Low overhead quantum computation using lattice surgery,” (2018), arXiv:1808.06709. N. C. Jones, J. D. Whitfield, P. L. McMahon, M.-H. Yung, R. V. Meter, A. Aspuru-Guzik, and Y. Yamamoto, New Journal of Physics 14, 1150 (2012). B. Eastin, Physical Review A 87, 0323 (2013). A. G. Fowler, “Optimal complexity correction of correlated errors in the surface code,” (2013), arXiv:1310.0863.

S. V. Isakov, I. Zintchenko, T. Rønnow, and M. Troyer, Computer Physics Communications 192, 2 (2015). S. V. Isakov, personal communication about simulated annealing code in . (2020). A. Wouk, Journal of Mathematical Analysis and Applications 11, 1 (1965). M. B. Hastings, “Weaker assumptions for the short path optimization algorithm,” (2018), arXiv:1807.03758.

Appendix A: Addition for controlled rotations

Here we give more details on how to perform phase rotations using the method from [32, 33]. Prior to the simulation the following state is prepared 2bgrad X−1

1 bgrad

|φi = √ e−2πik/2 |ki . (A1) 2bgrad k=0

This state is a tensor product of the form

1 O j

|φi = √ |0i + e−2πi/2 |1i . (A2) 2bgrad j=1

It can be prepared using standard techniques for performing rotations on qubits. To obtain overall error , each rotation should be performed with error /bgrad , which has complexity O(log(bgrad /)) , giving overall complexity O(bgrad log(bgrad /)) to prepare this state. Because this state only need be prepared once, this complexity is negligible compared to the complexities in other parts of the algorithm.

Adding a value ` into this register gives

X−1 2bgrad

X−1 1 −2πik/2bgrad 1 bgrad bgrad √ e |k + `i = √ e−2πi(k−`)/2 |ki = e2πi`/2 |φi . (A3) 2bgrad k=0 2bgrad k=0

This is why the addition yields a phase factor. Moreover, the value of ` can be stored in a quantum register, in order to make this a controlled phase. In order to make a controlled rotation on a qubit, we can perform the addition controlled by this qubit. Then one would obtain bgrad (µ |0i + ν |1i) |`i |φi 7→ (µ |0i + e2πi`/2 ν |1i) |`i |φi . (A4)

This approach is somewhat inefficient, because controlled addition has twice the complexity of addition. Instead we can use the trick described in Section II A 1, which enables a qubit to control whether addition or subtraction is performed with only Clifford gates. The qubit simply needs to control cnots on the target system before and after the addition. Then we would obtain bgrad bgrad (e−2πi`/2 µ |0i + e2πi`/2 ν |1i) |`i |φi . (A5)

bgrad This procedure therefore enables us to perform the rotation e−2πi`Z/2 with bgrad − 2 Toffolis. This approach is far more efficient than techniques based on rotation synthesis with T gates when the rotation angle is given in a quantum register, because those techniques would need a separate rotation controlled on each bit. When the rotation angle is given classically, this technique is slightly less efficient than rotation synthesis with T gates as in , because Toffolis

have a cost equivalent to two T gates in magic state distillation . On the other hand, rotation angles that are integer multiples of 2π/2bgrad can be performed exactly, up to the accuracy of synthesizing the resource state |φi.

To obtain a rotation that performs the mapping

|0i 7→ cos 2π`/2bgrad |0i + sin 2π`/2bgrad |1i ,

(A6)

bgrad one can simply perform the operations SHe−2πi`Z/2 H. Here the Hadamard H and S gates are Clifford gates, so this gives the state preparation with the only Toffoli cost in synthesizing the Z-rotation. The complexity of performing the addition is only bgrad − 2 rather than bgrad − 1, as would normally be the case for addition of bgrad -bit numbers (modulo 2bgrad ). The reason is that the most significant qubit of |φi is in a |+i state, so not gates on this qubit can be replaced with phase gates, and this qubit can be discarded. Doing that yields the

circuit shown in Figure 11. The Toffoli is not immediately saved, but the cnots and Z gate on the final carry qubit can be replaced with two Z gates as shown in Figure 12. Then the Toffoli used on the final carry qubit can simply be replaced with a controlled phase, as shown in Figure 13. The resulting complexity is bgrad − 2 Toffolis. If the angle to be rotated by is given as a classical variable, then the cost is further reduced to bgrad − 3 Toffolis, because addition of a classical number takes one fewer Toffoli. This means that bgrad = 4, which would give a T gate, takes one Toffoli.

Next we consider the case that we need to multiply an integer k with b bits by a constant γ̃ to give the phase. Given that γ̃ is represented on n bits, we can write γ̃ as a sum of no more than d(n + 1)/2e powers of two, with positive and negative signs. This formula is checked in Figure 14. To prove the formula, assume that it is true for numbers with ≤ n bits, and consider a number m with n = n + 2 bits (so the most significant bit must be a 1). There are then three cases to consider.

1. For m < (3/4)2n , we find that m − 2n−1 < 2n−2 , so m − 2n−1 has no more than n − 2 = n bits, and so can

be written as a sum of at most d(n + 1)/2e powers of two. That means m can be written as a sum of at most d(n + 1)/2e + 1 = d(n + 1)/2e powers of two.

2. For m > (3/4)2n , we have 2n − m < 2n−2 , so 2n − m has no more than n − 2 = n bits, and can be written as a

sum of ≤ d(n + 1)/2e powers of two. Since m can be written as 2n minus 2n − m, it can be written as at most d(n + 1)/2e + 1 = d(n + 1)/2e powers of two.

3. The last case is that where m = (3/4)2n , so m = 2n−1 + 2n−2 . Since n = n + 2 ≥ 2, d(n + 1)/2e ≥ 2, so again

m is written as a sum of at most d(n + 1)/2e powers of two. Since we have checked that the formula is true for small numbers of bits in Figure 14, the formula is true for all n by induction. To perform the multiplication, we will take each term in the sum for γ̃, and add or subtract a bit-shifted copy of k to the phase gradient state. We have no more than (n + 2)/2 additions/subtractions, each of which is into the phase gradient state with bgrad bits, which gives cost no more than (bgrad − 2)(n + 2)/2.

The error due to omitted bits in the multiplication (those omitted in bit-shifting k) can be bounded as follows. First, note that the error for the additions is entirely in underestimating the product, since we are omitting digits. For the subtractions the error is in overestimating the product. Therefore, to obtain the maximum error we need to consider the case with entirely additions, since the subtractions would cancel the error. For each addition the error is upper bounded by 2π/2bgrad , because we omit adding bits that would correspond to phase shifts of 2π/2bgrad +1 ,

2π/2bgrad +2 , and so forth. That means the upper bound on the error from (n + 2)/2 additions is (n + 2)π/2bgrad . To make the error in the multiplication no larger than we should take bgrad = dlog[(n + 2)π/]e = log(n/) + O(1). (A7)

Appendix B: Discretizing adiabatic state preparation with qubitization

Here we place bounds on the error for the method of adiabatic evolution from Section III C 2. For any fixed value of r we can choose an adiabatic path between an initial Hamiltonian and a final Hamiltonian. The accuracy of the adiabatic approximation depends strongly on how quickly we traverse this path, so it is customary to introduce a dimensionless time s = t/T which allows us to easily change the speed without altering the shape of the path.

Using Trotter-Suzuki formulas for time-ordered operator exponentials we have that

maxs k∂s Heff (s)kT + maxs k∂s Heff (s)kkHeff (s)kT 2 −iT ss+1/r Heff (s)ds R −iHeff (s+1/2r)T /r

Te −e ∈O . (B1)

r However, the Hamiltonian Heff for the time evolution operator in this case is not known except in terms of its action on the space containing the instantaneous eigenvectors of H. In order to use this result, we need to bound the derivatives acting on the entire space. In order to find an asymptotic bound on these derivatives we define, ir ir 4 Heff (s) = ln Wr (s) = ln ((I − 2I ⊗ |L(r, s)ihL(r, s)|) select) . (B2)

i • • • i t • • (t + i)0 • • • • • i • • • i t • • (t + i)1

• • • • • i • • • i t • • (t + i)2 • • • • • i • • • i t • • (t + i)3

Z i Z i |+i (t + i)4

FIG. 11. A circuit to perform addition on 5 qubits modulo 2 when the most significant target qubit is in a |+i state.

i • • • i t • • (t + i)0 • • • • • i • • • i t • • (t + i)1

• • • • • i • • • i t • • (t + i)2

• • Z •

i • • • i t • • (t + i)3 Z i Z i

FIG. 12. A simplification of Figure 1 to eliminate the cnots on the last carry qubit. The |+i state is omitted here because it is not acted upon.

i • • • i t • • (t + i)0 • • • • • i • • • i t • • (t + i)1

• • • • • i • • • i t • • (t + i)2

• • Z •

i • • i t Z (t + i)3 i Z i

FIG. 13. A simplification of Figure 1 where the last carry qubit is eliminated entirely and the Toffoli is replaced with a controlled phase.

n 2 4 6 8 10

FIG. 14. In orange is the number of powers of 2 needed to give integer m, when we allow additions and subtractions. The formula d(n + 1)/2e is shown in orange, where the number of bits required to represent m is n = dlog(m + 1)e.

It is then clear from the unitarity of Wr (s) that for any |s| ∈ O(1), if we choose the principal logarithm for Heff then kHeff (s)k ∈ O(1). The derivatives of the Hamiltonian are more involved to estimate.

1. Derivatives of matrix logarithms of unitary matrices

In order to compute the derivatives of the effective Hamiltonian, we will need to compute the derivatives of the logarithm function. Such an analysis is usually based on differentiating the Mercator series for the matrix logarithm; however, the Mercator series of log(A) does not converge for kAk ≥ 1. For greater generality we will use an integral representation for the matrix logarithm log(A) from ,

Z 1

log(A) = dt (A − 11)[t(A − 11) + 11]−1 . (B3)

This representation converges unless there is a real non-positive eigenvalue. For the case where A is unitary, this requirement prohibits matrices that have any eigenvalues equal to precisely −1. Next, defining V := [t(A − 11) + 11]−1 , and in turn (A − 11) = t−1 (V −1 − 11) this expression simplifies to

Z 1

= dt (1 − V ) . (B4)

0 t

Next, note that for any invertible matrix-valued function A(s) we have from the product rule that

∂s (A(s)A−1 (s)) = 0 ⇒ ∂s (A−1 (s)) = −A−1 (s)Ȧ(s)A−1 (s). (B5)

Using ∂s V = −tV ȦV we get

Z 1

∂s log(A(s)) = dt V ȦV. (B6)

Taking the derivative of (B6) gives

Z 1

∂s log(A(s)) = dt V̇ ȦV + V ÄV + V ȦV̇

Z 1

= dt −tV ȦV ȦV + V ÄV − tV ȦV ȦV

Z 1

= dt V Ä − 2tȦV Ȧ V. (B7)

We can use the fact that A is unitary to see that

−1 kV k = (t(A − 11) + 11)(t(A† − 11) + 11) −1 = (t + (t − 1)2 )1 + (A + A† ) t − t . (B8) In the case where A is close to the identity, if the absolute values of the phases of the eigenvalues are no greater than

Γ, then

Γ k∂s log(A(s))k ≤ kȦk , (B9) sin Γ

Γ 1

+ 4 |L(s, r)ihL(s, r)| select |L(s, r)ihL(s, r)| select . (B11) Using s r

X λk (s) r−1

|L(s, r)i = |ki |00i + |0i (|10i + |11i) , (B12) λ(s)r 2r k

we have H(s) hL(s, r)| select |L(s, r)i = . (B13) λ(s)r

Then squaring again gives

H(s) H(s)

+ 4 |L(s, r)i hL(s, r)| select + 4 select |L(s, r)i hL(s, r)| λ(s)r λ(s)r 2

H(s) 0 H(s)

− 8 |L(s, r)i hL(s, r)| select − 8 |L(s, r)i hL(s, r)| λ(s)r λ(s)r 2

H(s) H(s)

− 8 select |L(s, r)i hL(s, r)| select − 8 |L(s, r)i hL(s, r)| select λ(s)r λ(s)r 3 2

H(s) 0 H(s)

H(s) H(s)

− 4 |L(s, r)i hL(s, r)| select + 4 select |L(s, r)i hL(s, r)| λ(s)r λ(s)r

H(s) 1

= 1 + 4 select , |L(s, r)i hL(s, r)| + O 2 . (B14) λ(s)r r This means that kWr (s) − 11k ≤ 8/r + 16/r + 16/r , so for r & 5.7, Wr does not have negative real eigenvalues, and our expression for the matrix logarithm holds. This also implies that

Z 1

dt k(A − 11)V k ≤ 8/r + O 1/r . k log Wr (s) k ≤ (B15)

Next, under these assumptions we can use (B9) and (B14) to show that (neglecting terms of O r−2 which are negligible for large r and using kHk/λ ≤ 1)

k∂s log Wr (s) k ∈ O k∂s Wr (s)k

H(s) ∂ H(s)

⊆ O |L̇(s, r)i + λ(s)r ∂s λ(s)r   |L̇(s, r)i | λ̇| + k Ḣk

⊆ O + . (B16)

We observe from (142) and the definition of the Euclidean norm it follows that if the Hamiltonian is chosen to be independent of r then v  u r 2 u X ∂ λk  √ k |L̇i k ∈ O t  ⊆ O 1/ r . (B17)  ∂s λr k

Thus neglecting terms of order O r−3/2 we find from substituting this expression into (B16) that

! |λ̇| + kḢk k∂s log Wr (s) k ∈ O

. (B18)

It further follows from (B10) and (B14) that the second derivative of the matrix logarithm obeys (neglecting terms order O r−3/2 and higher)

k∂s log Wr (s) k ∈ O k∂s Wr (s))k + k∂s Wr (s))k

= O k∂s Wr (s))k ! k |L̈(s, r)i k ∂2 H ∂ H ⊆O + + k |L̇i k r ∂s λr ∂s λr ! k |L̈(s, r)i k ∂2 H 1

⊆O + + 3/2

r ∂s λr r kḦk + (kḢk + |λ̇|) |λ̇|    k |L̈(s, r)i k λ + |λ̈|

⊆ O +  . (B19)

Note that in the above derivation terms of the form k |L̇(s, r)i kk∂s H/(λr)k are dropped because they are O r−3/2 .

Again, if the Hamiltonian is chosen to be independent of r, then

v  u r 2 uX ∂ λk  1 k |L̈(s, r)i k ∈ O t ⊆ O √ , (B20)  ∂s λr r  k

which implies that, neglecting terms of O r−3/2 and higher

|λ̇|   kḦk + (kḢk + |λ̇|) λ + |λ̈| k∂s log Wr (s) k ∈ O 

. (B21)

Next in we bound the error that arises from approximating the time-ordered operator exponential by the exponential of the effective Hamiltonian evaluated at the midpoint. From the analysis of the midpoint rule for integration, we intuitively expect that the error should scale as O(1/r ); however, such analysis cannot be directly applied here because of the fact that the derivatives of the Hamiltonian need not commute with the Hamiltonian. It can be seen

by performing a Taylor series expansion of the effective Hamiltonian to second order and substituting the result into the Dyson series that

k∂s Heff (s)kT k∂s Heff (s)kkHeff (s)kT 2 −iT ss+4/r Heff (s )ds −i 4T R

Heff (s+2/r)

Te −e r ∈ O max + max . (B22)

s r s r

We then can bound the scaling of the error in the midpointapproximation by substituting (B18) and (B21) into (B22) and noting from (B15) that kHeff (s)k = (r/4)k log Wr (s) k ∈ O(1) to find 0 0

R s+4/r 4T

T e−iT s Heff (s )ds

− e−i r Heff (s+2/r) 2 4 k∂s Wr (s)kT + k∂s Wr (s)kT 2 =O r  maxs kḦk + (kḢk + |λ̇|) |λλ̇| + |λ̈| T + maxs |λ̇| + kḢk T 2 

= O . (B23) λr

Since errors are sub-additive the error in performing a simulation from s = 0 to s = 1 is at most O(r) times the error given above. This results in the following bound on the scaling of the value of r that suffices to guarantee simulation error at most v  u u max kḦk + (kḢk + |λ̇|) |λ̇| + |λ̈| T + max |λ̇| + kḢk T 2 t s λ s  r ∈ O . (B24)

 λ 

The adiabatic theorem then implies that, under reasonable assumptions about the derivatives of the Hamiltonian (specifically that the Hamiltonian is Gevrey class Gα for α ≥ 1), the value of T needed to achieve error , given that the minimum eigenvalue gap for the effective Hamiltonian is ∆eff , scales at most as   max kḢ(s)k + |λ̇| ! e maxs kḢeff (s)k ⊆ O s

T ∈O 2

e . (B25) ∆eff λ∆2eff

This implies that if λ ∈ Ω(1) and ∆eff ∈ o(1)

 v 3  u max kḦk + (kḢk + |λ̇|) |λ̇| + |λ̈| max |λ̇| + kḢk u maxs |λ̇| + kḢk  e 1  t s λ s r∈O +   3/2 ∆2eff λ ∆4eff λ 

 v 3  u u max kḦk + |λ̈| max |λ̇| + kḢk maxs |λ̇| + kḢk  e 1  t s s ⊆O + . (B26)  3/2 ∆2eff λ ∆4eff λ 

If the Hamiltonian H is maximum rank then the spectral gap of the effective Hamiltonian is on the order of ∆eff ∈ Ω(min(∆, mink |Ek |)/λ) where ∆ is the minimum spectral gap of the Hamiltonian H. The minimum over energy comes from the fact that the eigenvalues of Wr in the set {±1, ±i} are mapped to 1, which can lead to degeneracies in the effective Hamiltonian that were absent in the original Hamiltonian. Thus the final scaling that we obtain is  v 3 

u u max kḦk + |λ̈| max |λ̇| + kḢk λ maxs |λ̇| + kḢk  e 1  t s s r∈O + . (B27)  3/2 min(∆, mink |Ek |)2 min(∆, mink |Ek |)4 

This confirms that by taking the number of steps sufficiently large that we can force the diabatic error to become arbitrarily small. Thus we can use the walk operator in place of a Trotterized sequence for adiabatic state preparation and in turn as a heuristic that will converge to the global optima given a large enough r. It should be noted, however, that the bounds used in this analysis are extremely loose and if a quantitatively correct estimate of the scaling is

(a) k × (b) k k ×× • × × k1,...,n−2 / × n−2 k ×× • • × B2UN/2 × • × kn−1 × × × • • • • / × N/2−n × • × • • • • × •

× • / × • n−2 × >0 • / × •

N/2−n >0

FIG. 15. A depiction of the binary-to-unary circuit mapping an n-bit binary number to an N -bit (N = 2n ) unary encoding of the input. In (a) we have the specific example where N = 8 (i.e. B2U ). In (b) we have the circuit (B2UN ) defined recursively (in terms of B2UN/2 ), In (b) the controlled-swap symbols are used to represent many controlled-swaps, one for each qubit in the relevant registers. The symbol “> 0” signifies that the multi-cnot is activated on any state other than the state of all

zeros, which can be implemented with a cascade of cnots because the input is promised to have at most one non-zero qubit. The labelled rails in both circuit diagrams refer to the bits of the binary-encoded input k, and the unlabelled inputs are fresh ancillae.

desired then many of the simplifications used above can be eschewed at the price of increasing the complexity of the expression. Note that in practice, the adiabatic paths can be chosen such that the second derivative of the Hamiltonian is zero and similarly we can choose paths such that λ is constant by absorbing it into the definition of the evolution time for each infinitesimal step. However, we give the above expression for generality. Higher order versions of this can also

be derived using time-dependent Trotter-Suzuki formulas .

Appendix C: In-place binary to unary conversion

Here we present a quantum circuit (B2UN ) for converting a binary-encoded integer k (0 ≤ k < N ) into one-hot ⊗(k−1) ⊗(N −k) unary on N bits. Recall that the one-hot unary encoding should have k encoded as |0i |1i |0i . An

overview of the circuit is depicted in Figure 1 in the special case that N is a power of two. First we sketch a proof

that the circuit is correct. Then we explain how to generalize the circuit to the case where N is not a power of two. Finally, we count the non-Clifford gates needed to perform our binary-to-unary conversion circuit. We give a sketch of a proof that the circuit is correct for N a power of two. Our proof works by induction and we begin by explaining the trivial case N = 1. In this case, the output can only be the 1-bit, one-hot unary encoding of

0 and hence the output should be a single qubit, |1i. The only input to the circuit is an ancilla initialized to |0i and

so we can perform B2U with a single not gate. Now that we have explained the trivial case, we next explain our recursion and why it works (see Figure 15(b)). The idea is as follows. First, we apply B2UN/2 to k 0 := k − 2n−1 kn−1 , where kn−1 is the most significant bit of k. This input is simply the last n − 1 bits of k and the output of B2UN/2 is N/2 qubits. Then, controlled on kn−1 , we swap bits 1 through N/2 − 1 (counting from zero) of the output of B2UN/2 with N/2 − 1 ancilla qubits initialized

to 0. Note that this step does not execute a controlled-swap on position 0 of the one-hot unary encoding of k 0 . Having performed these controlled-swaps, we next wish to erase qubit N/2 if k > N/2. We do this by performing N/2 − 1 cnot gates targeted on the qubit at position N/2 and controlled by each of the qubits at positions above N/2. Finally, we have to resolve the special cases where k is N/2 or 0. We do this with one more cnot, with qubit N/2 as the control and qubit 0 as the target.

Having given an explanation of our recursive construction, we next explain how to prove that the recursion works. We consider three distinct cases.

1. If k < N/2, we have kn−1 = 0 and hence none of the controlled-swaps or cnots will do anything. This is

correct behaviour because the one-hot unary encoding of k will be the one-hot unary encoding of k 0 with N/2 ancilla qubits appended to it.

2. If k = N/2, the controlled-swaps will again do nothing but this is now because they are swapping pairs of

identical qubits in the |0i state. The cnots targeted on the qubit at position N/2 will also do nothing because the control qubits are 0. The final cnot will then erase the 1 encoded in position 0 of the output of B2UN/2 , which is there because the input was k 0 = 0.

3. If k > N/2, the controlled-swaps will swap the one-hot unary encoding of k 0 into the final N/2 qubits of the

output register. The cnots targeted on qubit N/2 then erase that qubit, leaving the correct unary encoding of k. The final cnot does nothing, as the control qubit was erased. The proof sketch demonstrates that our recursive binary-to-unary circuit works when N is a power of two. Next we explain how to modify the circuit when N is not a power of two. If N is not a power of two, define n := dlog N e and N 0 = 2n . Apply B2UN /2 to the least significant n − 1 bits of k. Then perform the controlled-swaps and cnots

involving the remaining N − N 0 /2 ancilla qubits, removing any operations that would involve deleted qubits. For N = 7, for example, we would delete the bottom rail from Figure 15(a) as well as the controlled-swap and the cnot involving that final rail. To see that this works, observe that the circuit would also work if we performed B2UN and then remove the final N 0 −N qubits, which are guaranteed to be zero. Our construction simply eliminates unnecessary gates from B2UN . Our final task is to count the number of non-Clifford gates needed by our B2UN circuit. The only non-Clifford

gates are the controlled-swap operations, which can be executed with a single Toffoli gate and two cnots. We prove that the number of controlled-swap gates is

CN := N − dlog N e − 1. (C1)

First, it is clear that C = 0 as required. Next, it is clear from Figure 15(b) that CN 0 = N 0 /2 − 1 + CN 0 /2 . Based on our analysis above, CN = CN 0 − (N 0 − N ) and hence

CN = N − N 0 /2 − 1 + CN 0 /2 . (C2)

Next assume Eq. (C1) is true for some particular value N 0 /2. Then by substitution in Eq. (C2),

CN = N − N 0 /2 − 1 + N 0 /2 − dlog N 0 /2e − 1 = N − n − 1 = N − dlog N e − 1 (C3)

thus satisfying Eq. (C1) for N as required. Therefore by induction Eq. (C1) is correct for all N .

Appendix D: Cost of multiplication

As the multiplication operation is a major contributor to the overall complexity of our algorithms, we need to be quite careful in our analysis of the operation. We also frequently require only low-precision arithmetic, meaning that we can make our multiplications less accurate and therefore computationally cheaper. This Appendix presents our algorithms for performing four variations of the multiplication task, with modifications to be used when one of the inputs is given classically rather than quantumly.

Our strategy isPto use schoolbook multiplication. In schoolbook multiplication,Pthe product γ := κ × λ is calculated ` ` by writing κ = ` 2 κ` with κ` ∈ {0, 1} and then calculating the sum γ = ` 2 κ` λ. This reduces the task of multiplication to two very simple multiplications and the task of adding a list of numbers. The two multiplications are simple because multiplication by a power of two can be accomplished by an appropriate bit-shift operation, and

multiplying by a single bit can be accomplished by using that bit as a control for the addition operation. That is, we perform that part of the addition if and only if the control bit is one. We begin in Appendix D 1 by reviewing the parts of the main text where we need to multiply two numbers together. In Appendix D 2 we explain how to add a constant value to a quantum register, which is used separately in Algorithm 1 but is also used through the rest of this appendix in order to multiply a quantum variable to a classical constant. We

then explain the simplest variant of multiplication in Appendix D 3, where we must multiply two integers together. We then explain the remaining variants by modifying the integer-integer multiplication algorithm as appropriate. In Appendix D 4, we explain the case where we multiply an integer to a real number. In Appendix D 5, we explain the case where we multiply a real number to another real number. Finally, in Appendix D 6, we explain the case where we calculate the square of a given real number. In all cases we indicate how the algorithm is to be modified when one

of the inputs is classically specified.

1. Uses of multiplication in this paper

In Section II C we need to multiply a quantum register by a classical constant γ̃ or γ to obtain the phase to apply. The multiplication is performed directly into the phase gradient state, so we cannot use the savings where

i • • • i t • • (t + i)0 • • • • • i • • • i t • • (t + i)1

• • • • • i • • • i t • • (t + i)2 • • • • • i • • • i t • • (t + i)3

• i • i t (t + i)4

FIG. 16. A circuit to perform addition on 5 qubits modulo 2 from .

(a) • • (b) • • i • i • • t • t •

FIG. 17. (a) The component of the adder circuit where the qubit containing classical data is the target of a cnot. (b) The circuit may be rewritten so the value on the second qubit is never changed.

the multiplication result is placed in an initially zero register. The fastest method seems to be to write the classical constant as a sum of powers of 2 with plus and minus signs. In Section II E we consider QROM for interpolation of functions, and we need to multiply the input register by the slope. In that case, both registers are quantum. The input register is given to bdif bits, and the goal is to give the approximation to the function to bsm bits. This may require giving the slope to bsm + O(log bsm ) bits, or

bsm + bfun + O(log bsm ) bits in the case of the arcsine. For Szegedy walks, we need to take the square of a quantum register, and need to multiply a quantum register by a constant.

2. Methods for addition

When adding a classically given constant to a quantum register, it is possible to save the qubits that would be used to store this classical constant. Consider the quantum circuit for addition following , as shown in Figure 1 where i is the classically given integer and t is the quantum register. For this diagram we use the convention of where a Toffoli with a target known to be initially zeroed is shown with a x for the target. That is the first operation on the left in Figure 16. The Toffolis with targets that are known to be zero afterwards are shown with y for the target.

These may be performed with measurements and Cliffords so do not add to the non-Clifford cost. The circuit for the adder contains a subsection where a cnot gate is performed on a qubit of i, say i , as shown in Figure 17(a). The state after the cnot can alternatively be obtained on the control by switching the control and target for the cnot. Then for the following Toffoli where i would be the control, we switch the control to the carry register at the top. After that the carry register needs to be used as a control where it should take its original value,

so we need another cnot to undo the first. The resulting section of the circuit is as shown in Figure 17(b). Replacing all these sections of the circuit in this way, we obtain an addition circuit as shown in Figure 18. This adder only uses the ij registers as controls. Since these registers have classically known values, all controls by these qubits may be replaced with classical controls, and these qubits need not be used. This also reduces the Toffoli cost by 1, because the first Toffoli is replaced with a cnot. The Toffoli cost is therefore the number of bits minus 2. The number of

ancillas needed is the number of bits minus 1.

i • •• i t • • (t + i)0 • • • • • i • • • • • i

t • • (t + i)1 • • • • • i • • • • • i t • • (t + i)2 • • • • •

i • • • • • i t

FAQ

Typical stacks include Git, a CI engine (Jenkins/GitHub Actions/GitLab CI), Docker, Kubernetes or a cloud PaaS, infrastructure-as-code (Terraform/Ansible), and monitoring (Prometheus/Grafana). Exact tools for Devops Crossplane Compositions depend on the chosen cloud and delivery model.

It can be delivered as a fully documented simulation on local/kind clusters or as a guided deployment on a cloud free tier. Both approaches are acceptable for academic evaluation when metrics, logs and diagrams are captured.

Pipeline screenshots, successful/failed run history, deployment frequency charts, rollback demos, monitoring dashboards, IaC plans/applies, and a short viva demo script are commonly included.

Devops Crossplane Compositions