-
Improved Techniques for Preparing Eigenstates of Fermionic
Hamiltonians
Dominic W. Berry,1 Mária Kieferová,1, 2 Artur Scherer,1 Yuval
R. Sanders,1
Guang Hao Low,3 Nathan Wiebe,3 Craig Gidney,4 and Ryan Babbush5,
∗
1Department of Physics and Astronomy, Macquarie University,
Sydney, NSW 2109, Australia2Institute for Quantum Computing and
Department of Physics and Astronomy,
University of Waterloo, Waterloo, ON N2L 3G1, Canada3Microsoft
Research, Redmond, WA 98052, United States of America
4Google Inc., Santa Barbara, CA 93117, United States of
America5Google Inc., Venice, CA 90291, United States of America
(Dated: March 26, 2018)
Modeling low energy eigenstates of fermionic systems can provide
insight into chemical reactionsand material properties and is one
of the most anticipated applications of quantum computing.
Wepresent three techniques for reducing the cost of preparing
fermionic Hamiltonian eigenstates usingphase estimation. First, we
report a polylogarithmic-depth quantum algorithm for
antisymmetrizingthe initial states required for simulation of
fermions in first quantization. This is an exponentialimprovement
over the previous state-of-the-art. Next, we show how to reduce the
overhead due torepeated state preparation in phase estimation when
the goal is to prepare the ground state to highprecision and one
has knowledge of an upper bound on the ground state energy that is
less thanthe excited state energy (often the case in quantum
chemistry). Finally, we explain how one canperform the time
evolution necessary for the phase estimation based preparation of
Hamiltonianeigenstates with exactly zero error by using the
recently introduced qubitization procedure.
I. INTRODUCTION
One of the most important applications of quantumsimulation (and
of quantum computing in general) isthe Hamiltonian simulation based
solution of the elec-tronic structure problem. The ability to
accurately modelground states of fermionic systems would have
significantimplications for many areas of chemistry and
materialsscience and could enable the in silico design of new
so-lar cells, batteries, catalysts, pharmaceuticals, etc. [1,
2].The most rigorous approaches to solving this probleminvolve
using the quantum phase estimation algorithm[3] to project to
molecular ground states starting froma classically guessed state
[4]. Beyond applications inchemistry, one might want to prepare
fermionic eigen-states in order to simulate quantum materials [5]
includ-ing models of high-temperature superconductivity [6].
In the procedure introduced by Abrams and Lloyd [7],one first
initializes the system in some efficient-to-prepareinitial state
|ϕ〉 which has appreciable support on the de-sired eigenstate |k〉 of
Hamiltonian H. One then usesquantum simulation to construct a
unitary operator thatapproximates time evolution under H. With
these in-gredients, standard phase estimation techniques
invokecontrolled application of powers of U(τ) = e−iHτ .
Withprobability αk = |〈ϕ|k〉|2, the output is then an estimateof the
corresponding eigenvalue Ek with standard devia-tion σEk =
O((τM)
−1), where M is the total number ofapplications of U(τ). The
synthesis of e−iHτ is typicallyperformed using digital quantum
simulation algorithms,such as by Lie-Trotter product formulas [8],
truncatedTaylor series [9], or quantum signal processing [10].
∗ Corresponding author: [email protected]
Since the proposal by Abrams and Lloyd [7], al-gorithms for
time-evolving fermionic systems have im-proved substantially
[11–18]. Innovations that are partic-ularly relevant to this paper
include the use of first quan-tization to reduce spatial overhead
[19–24] from O(N) toO(η logN) where η is number of particles and N
� ηis number of single-particle basis functions (e.g. molecu-lar
orbitals or plane waves), and the use of post-Trottermethods to
reduce the scaling with time-evolution errorfrom O(poly(1/�)) to
O(polylog(1/�)) [24–26]. The al-gorithm of [24] makes use of both
of these techniques toenable the most efficient first quantized
quantum simu-lation of electronic structure in the literature.
Unlike second quantized simulations which necessar-ily scale
polynomially in N , first quantized simulationoffers the
possibility of achieving total gate complexityO(poly(η) polylog(N,
1/�)). This is important becausethe convergence of basis set
discretization error is lim-ited by resolution of the
electron-electron cusp [27], whichcannot be resolved faster than
O(1/N) using any single-particle basis expansion. Thus, whereas the
cost of re-fining second quantized simulations to within δ of
thecontinuum basis limit is necessarily O(poly(1/δ)),
firstquantization offers the possibility of suppressing basis
seterrors as O(polylog(1/δ)), providing essentially arbitrar-ily
precise representations.
In second quantized simulations of fermions the wave-function
encodes an antisymmetric fermionic system, butthe qubit
representation of that wavefunction is not nec-essarily
antisymmetric. Thus, in second quantization itis necessary that
operators act on the encoded wavefunc-tion in a way that enforces
the proper exchange statis-tics. This is the purpose of second
quantized fermionmappings such as those explored in [28–34]. By
contrast,the distinguishing feature of first quantized
simulations
arX
iv:1
711.
1046
0v3
[qu
ant-
ph]
23
Mar
201
8
mailto:[email protected]
-
2
is that the antisymmetry of the encoded system must beenforced
directly in the qubit representation of the wave-function. This
often simplifies the task of Hamiltoniansimulation but complicates
the initial state preparation.
In first quantization there are typically η different reg-isters
of size logN (where η is the number of particlesand N is number of
spin-orbitals) encoding integers in-dicating the indices of
occupied orbitals. As only η ofthe N orbitals are occupied, with η
logN qubits one canspecify an arbitrary configuration. To perform
simula-tions in first quantization, one typically requires that
theinitial state |ϕ〉 is antisymmetric under the exchange ofany two
of the η registers. Prior work presented a proce-dure for preparing
such antisymmetric states with gate
complexity scaling as Õ(η2) [35, 36].In Section II we provide a
general approach for
antisymmetrizing states via sorting networks. Thecircuit size is
O(η logc η logN) and the depth isO(logc η log logN), where the
value of c ≥ 1 depends onthe choice of sorting network (it can be
1, albeit with alarge multiplying factor). In terms of the circuit
depth,these results improve exponentially over prior
implemen-tations [35, 36]. They also improve polynomially onthe
total number of gates needed. We also discuss analternative
approach, a quantum variant of the Fisher-Yates shuffle, which
avoids sorting, and achieves a size-complexity of O(η2 logN) with
lower spatial overheadthan the sort-based methods.
Once the initial state |ϕ〉 has been prepared, it typ-ically will
not be exactly the ground state desired. Inthe usual approach, one
would perform phase estimationrepeatedly until the ground state is
obtained, giving anoverhead scaling inversely with the initial
state overlap.In Section III we propose a strategy for reducing
this cost,by initially performing the estimation with only
enoughprecision to eliminate excited states.
In Section IV we explain how qubitization [37] pro-vides a
unitary sufficient for phase estimation purposeswith exactly zero
error (provided a gate set consisting ofan entangling gate and
arbitrary single-qubit rotations).This improves over proposals to
perform the time evolu-tion unitary with post-Trotter methods at
cost scaling asO(polylog(1/�)). We expect that a combination of
thesestrategies will enable quantum simulations of fermionssimilar
to the proposal of [24] with substantially fewer Tgates than any
method suggested in prior literature.
II. EXPONENTIALLY FASTERANTISYMMETRIZATION
Here we present our algorithm for imposing fermionicexchange
symmetry on a sorted, repetition-free quantumarray target.
Specifically, the result of this procedure isto perform the
transformation
|r1 · · · rη〉 7→∑
σ∈Sη(−1)π(σ) |σ (r1, · · · , rη)〉 (1)
where π(σ) is the parity of the permutation σ, and werequire for
the initial state that rp < rp+1 (necessary forthis procedure to
be unitary). Although we describe theprocedure for a single input
|r1 · · · rη〉, our algorithm maybe applied to any superposition of
such states.
Our approach is a modification of that proposed inRefs. [35,
36]; namely, to apply the reverse of a sort to asorted quantum
array. Whereas Refs. [35, 36] provide agate count of O(η2(logN)2),
we can report a gate countof O(η log η logN) and a runtime of O(log
η log logN).
This section proceeds as follows. We begin with a sum-mary of
our algorithm. We then explain the reasoningunderlying the key step
(Step 4) of our algorithm, whichis to reverse a sorting operation
on target. Next we dis-cuss the choice of sorting algorithm, which
we require tobe a sorting network. Then, we assess the cost of our
al-gorithm in terms of gate complexity and runtime and wecompare
this to previous work in Refs. [35, 36]. Finally,we discuss the
possibility of antisymmetrizing withoutsorting and propose an
alternative, though more costly,algorithm based on the Fisher-Yates
shuffle. Our algo-rithm consists of the following four steps:
1. Prepare seed. Let f be a function chosen so thatf(η) ≥ η2 for
all η. We prepare an ancillary registercalled seed in an even
superposition of all possiblelength-η strings of the numbers 0, 1,
. . . , f(η) − 1.If f(η) is a power of two, preparing seed is
easy:simply apply a Hadamard gate to each qubit.
2. Sort seed. Apply a reversible sorting network toseed. Any
sorting network can be made reversibleby storing the outcome of
each comparator in asecond ancillary register called record. There
areseveral known sorting networks with polylogarith-mic runtime, as
we discuss below.
3. Delete collisions from seed. As seed was pre-pared in a
superposition of all length-η strings, itincludes strings with
repeated entries. As we areimposing fermionic exchange symmetry,
these rep-etitions must be deleted. We therefore measureseed to
determine whether a repetition is present,and we accept the result
if it is repetition-free. Weprove in Appendix A that choosing f(η)
≥ η2 en-sures that the probability of success is greater than1/2.
We further prove that the resulting state ofseed is disentangled
from record, meaning seedcan be discarded after this step.
4. Apply the reverse of the sort to target. Usingthe comparator
values stored in record, we applyeach step of the sorting network
in reverse orderto the sorted array target. The resulting stateof
target is an evenly weighted superposition ofeach possible
permutation of the original values.To ensure the correct phase, we
apply a controlled-phase gate after each swap.
-
3
Step 4 is the key step. Having prepared (in Step 1-Step 3) a
record of the in-place swaps needed to sort asymmetrized,
collision-free array, we undo each of theseswaps in turn on the
sorted target. We employ a sort-ing network, a restricted type of
sorting algorithm, be-cause sorting networks have comparisons and
swaps at afixed sequence of locations. By contrast, many
commonclassical sorting algorithms (like heapsort) choose
loca-tions depending on the values in the list. This resultsin
accessing registers in a superposition of locations inthe
corresponding quantum algorithm, incurring a lin-ear overhead. As a
result, a quantum heapsort requires
Õ(η2)
operations, not Õ(η). By contrast, no overhead isrequired for
using a fixed sequence of locations. The im-plementation of sorting
networks in quantum algorithmshas previously been considered in
Refs. [38, 39].
Sorting networks are logical circuits that consist ofwires
carrying values and comparator modules appliedto pairs of wires,
that compare values and swap themif they are not in the correct
order. Wires repre-sent bit strings (integers are stored in binary)
in clas-sical sorting networks and qubit strings in their quan-tum
analogues. A classical comparator is a sort ontwo numbers, which
gives the transformation (A,B) 7→(min(A,B),max(A,B)). A quantum
comparator is itsreversible version where we record whether the
itemswere already sorted (ancilla state |0〉) or the
comparatorneeded to apply a swap (ancilla state |1〉); see Figure
1.
The positions of comparators are set as a predeter-mined fixed
sequence in advance and therefore cannotdepend on the inputs. This
makes sorting networks vi-able candidates for quantum computing.
Many of thesorting networks are also highly parallelizable, thus
al-lowing low-depth, often polylogarithmic, performance.
Our algorithm allows for any choice of sorting net-work. Several
common sort algorithms such as the in-sert and bubble sorts can be
represented as sorting net-works. However, these algorithms have
poor time com-plexity even after parallelization. More efficient
run-time can be achieved, for example, using the bitonic sort[40,
41], which is illustrated for 8 inputs in Figure 2. Thebitonic sort
uses O(η log2 η) comparators and O(log2 η)depth, thus achieving an
exponential improvement in
A • A / • × min(A,B)B • = B / • × max(A,B)
|0〉 A > B •
FIG. 1. The standard notation for a comparator is indicatedon
the left. Its implementation as a quantum circuit is shownon the
right. In the first step, we compare two inputs withvalues A and B
and save the outcome (1 if A > B is trueand 0 otherwise) in a
single-qubit ancilla. In the second step,conditioned on the value
of the ancilla qubit, the values Aand B in the two wires are
swapped.
• • • • • •• • • • • •• • • • • •• • • • • •• • • • • •• • • • •
•• • • • • •• • • • • •
FIG. 2. Example of a bitonic sort on 8 inputs. The
ancillaenecessary to record the results as part of implementing
each ofthe comparators are omitted for clarity. Comparators in
eachdashed box can be applied in parallel for depth reduction.
depth compared to common sorting techniques.Slightly better
performance can be obtained using an
odd-even mergesort [40]. The asymptotically best sortingnetworks
have depth O(log η) and complexity O(η log η),though there is a
large constant which means they areless efficient for realistic η
[42, 43]. There is also a sortingnetwork with O(η log η) complexity
with a better multi-plicative constant [44], though its depth is
O(η log η) (soit is not logarithmic).
Assuming we use an asymptotically optimal sort-ing network, the
circuit depth for our algorithmis O(log η log logN) and the gate
complexity isO(η log η logN). The dominant cost of the
algorithmcomes from Step 2 and Step 4, each of which haveO(η log η)
comparators that can be parallelized to ensurethe sorting network
executes only O(log η) comparatorrounds. Each comparator for Step 4
has a complexityof O(logN) and a depth of O(log logN), as we show
inAppendix B. The comparators for Step 2 have complex-ity O(log η)
and depth O(log log η), which is less becauseη < N . Thus Step 2
and Step 4 each have gate complex-ity O(η log η logN) and runtime
O(log η log logN).
The other two steps in our algorithm have smaller cost.Step 1
has constant depth and O(η log η) complexity.Step 3 requires O(η)
comparisons because only nearest-neighbor comparisons need be
carried out on seed af-ter sorting. These comparisons can be
parallelized overtwo rounds, with complexity O(η log η) and circuit
depthO(log log η). Then the result for any of the registers be-ing
equal is computed in a single qubit, which has com-plexity O(η) and
depth O(log η). Thus the complexity ofStep 3 is O(η log η) and the
total circuit depth is O(log η).We give further details in Appendix
B. Thus, our al-gorithm has an exponential runtime improvement
overthe proposal in Refs. [35, 36]. We also have a quadratic
improvement in gate complexity, which is Õ(η) for our
algorithm but Õ(η2) for Refs. [35, 36].Our runtime is likely
optimal for symmetrization, at
least in terms of the η scaling. Symmetrization takes asingle
computational basis state and generates a superpo-sition of η!
computational basis states. Each single-qubitoperation can increase
the number of states in the super-position by at most a factor of
two, and two-qubit opera-
-
4
tions can increase the number of states in the superposi-tion by
at most a factor of four. Thus, the number of one-and two-qubit
operations is at least log2(η!) = O(η log η).In our algorithm we
need this number of operations be-tween the registers. If that is
true in general, then η op-erations can be parallelized, resulting
in minimum depthO(log η). It is more easily seen that the total
numberof registers used is optimal. There are O(η log η)
ancillaqubits due to the number of steps in the sort, but thenumber
of qubits for the system state we wish to sym-metrize is O(η logN),
which is asymptotically larger.
Our quoted asymptotic runtime and gate complex-ity scalings
assume the use of sorting networks thatare asymptotically optimal.
However, these algorithmshave a large constant overhead making it
more prac-tical to use an odd-even mergesort, leading to
depthO(log2 η log logN). Note that is possible to obtain
com-plexity O(η log η logN) and number of ancilla qubitsO(η log η)
with a better scaling constant using the sortingnetwork of Ref.
[44].
Given that the cost of our algorithm is dictated bythe cost of
sorting algorithms, it is natural to ask if itis possible to
antisymmetrize without sorting. Thoughthe complexity and runtime
both turn out to be sig-nificantly worse than our sort-based
approach, we sug-gest an alternative antisymmetrization algorithm
basedon the Fisher-Yates shuffle. The Fisher-Yates shuffle isa
method for applying to a length-η target array a per-mutation
chosen uniformly at random using a numberof operations scaling as
O(η). Our algorithm indexesthe positions to be swapped, thereby
increasing the com-
plexity to Õ(η2). Briefly put, our algorithm generates
asuperposition of states as in Step II of Ref. [36], then usesthese
as control registers to apply the Fisher-Yates shuffleto the
orbital numbers. The complexity is O(η2 logN),with a factor of logN
due to the size of the registers. Wereset the control registers,
thereby disentangling them,using O(η log η) ancillae. We provide
more details of thisapproach in Appendix C.
To conclude this section, we have presented an al-gorithm for
antisymmetrizing a sorted, repetition-freequantum register. The
dominant cost of our algorithmderives from the choice of sorting
network, whose asymp-totically optimal gate count complexity and
runtime are,respectively, O(η log η logN) andO(log η log logN).
Thisconstitutes a polynomial improvement in the first caseand
exponential in the second case over previous workin Refs. [35, 36].
As in Ref. [36], our antisymmetrizationalgorithm constitutes a key
step for preparing fermionicwavefunctions in first
quantization.
III. FEWER PHASE ESTIMATIONREPETITIONS BY PARTIAL EIGENSTATE
PROJECTION REJECTION
Once the initial state |ϕ〉 has been prepared, it typi-cally will
not be exactly the ground state (or other eigen-
state) desired. In the usual approach, one would performphase
estimation repeatedly, in order to obtain the de-sired eigenstate
|k〉. The number of repetitions neededscales inversely in αk =
|〈ϕ|k〉|2, increasing the complex-ity. We propose a practical
strategy for reducing thiscost which is particularly relevant for
quantum chem-istry. Our approach applies if one seeks to prepare
theground state with knowledge of an upper bound on theground state
energy Ẽ0, together with the promise thatE0 ≤ Ẽ0 < E1. With
such bounds available, one can re-duce costs by restarting the
phase estimation procedureas soon as the energy is estimated to be
above Ẽ0 withhigh probability. That is, one can perform a phase
es-timation procedure that gradually provides estimates ofthe phase
to greater and greater accuracy, for exampleas in Ref. [45]. If at
any stage the phase is estimated to
be above Ẽ0 with high probability, then the initial statecan be
discarded and re-prepared.
Performing phase estimation within error � typicallyrequires
evolution time for the Hamiltonian of 1/�, lead-ing to complexity
scaling as 1/�. This means that, if thestate is the first excited
state, then an estimation errorless than E1− Ẽ0 will be sufficient
to show that the stateis not the ground state. The complexity
needed wouldthen scale as 1/(E1 − Ẽ0). In many cases, the final
errorrequired, �f , will be considerably less than E1 − Ẽ0, sothe
majority of the contribution to the complexity comesfrom measuring
the phase with full precision, rather thanjust rejecting the state
as not the ground state.
Given the initial state |ϕ〉 which has initial overlap ofα0 with
the ground state, if we restart every time theenergy is found to be
above Ẽ0, then the contribution tothe complexity is 1/[α0(E1 −
Ẽ0)]. There will be an ad-ditional contribution to the complexity
of 1/�f to obtainthe estimate of the ground state energy with the
desiredaccuracy, giving an overall scaling of the complexity of
O
(1
α0(E1 − Ẽ0)+
1
�f
). (2)
In contrast, if one were to perform the phase estimationwith
full accuracy every time, then the scaling of the com-plexity would
be O(1/(α0�f )). Provided α0(E1 − Ẽ0) >�f , the method we
propose would essentially eliminatethe overhead from α0.
In cases where α0 is very small, it would be helpfulto apply
amplitude amplification. A complication withamplitude amplification
is that we would need to choose aparticular initial accuracy to
perform the estimation. If alower bound on the excitation energy,
Ẽ1, is known, thenwe can choose the initial accuracy to be Ẽ1 −
Ẽ0. Thesuccess case would then correspond to not finding thatthe
energy is above Ẽ0 after performing phase estimationwith that
precision. Then amplitude amplification canbe performed in the
usual way, and the overhead for thecomplexity is 1/
√α0 instead of 1/α0.
All of this discussion is predicated on the assumptionthat there
are cases where α0 is small enough to war-rant using phase
estimation as part of the state prepa-
-
5
ration process and where a bound meeting the promisesof Ẽ0 is
readily available. We now discuss why theseconditions are
anticipated for many problems in quan-tum chemistry. Most chemistry
is understood in termsof mean-field models (e.g. molecular orbital
theory, lig-and field theory, the periodic table, etc.). Thus, the
usualassumption (empirically confirmed for many smaller sys-tems)
is that the ground state has reasonable support onthe Hartree-Fock
state (the typical choice for |ϕ〉) [46–49]. However, this overlap
will decrease as a function ofboth basis size and system size. As a
simple example,consider a large system composed of n copies of
non-interacting subsystems. If the Hartree-Fock solution forthe
subsystem has overlap α0, then the Hartree-Fock so-lution for the
larger system has overlap of exactly αn0 ,which is exponentially
small in n.
It is literally plain-to-see that the electronic groundstate of
molecules is often protected by a large gap. Thecolor of many
molecules and materials is the signatureof an electronic excitation
from the ground state to firstexcited state upon absorption of a
photon in the visiblerange (around 0.7 Hartree); many clear
organics haveeven larger gaps in the UV spectrum. Visible
spectrumE1−E0 gaps are roughly a hundred times larger than
thetypical target accuracy of �f = 0.0016 Hartree
(“chemicalaccuracy”)1. Furthermore, in many cases the first
excitedstate is perfectly orthogonal to the Hartree-Fock state
forsymmetry reasons (e.g. due to the ground state being aspin
singlet and the excited state being a spin triplet).Thus, the gap
of interest is really E∗ − E0 where E∗ =mink>0Ek subject to
|〈ϕ|k〉|2 > 0. Often the E∗ − E0gap is much larger than the E1 −
E0 gap.
For most problems in quantum chemistry a variety ofscalable
classical methods are accurate enough to com-pute upper bounds on
the ground state energy Ẽ0 suchthat E0 ≤ Ẽ0 < E∗, but not
accurate enough to ob-tain chemical accuracy (which would require
quantumcomputers). Classical methods usually produce upperbounds
when based on the variational principle. Ex-amples include
mean-field and Configuration InteractionSingles and Doubles (CISD)
methods [50].
As a concrete example, consider a calculation on thewater
molecule in its equilibrium geometry (bond an-gle of 104.5◦, bond
length of 0.9584 Å) in the minimal(STO-3G) basis set performed
using OpenFermion [51]and Psi4 [52]. For this system, E0 = −75.0104
Hartreeand E1 = −74.6836 Hartree. However, 〈ϕ|1〉 = 0 andE∗ =
−74.3688 Hartree. The classical mean-field en-ergy provides an
upper bound on the ground state en-ergy of Ẽ0 = −74.9579 Hartree.
Therefore E∗−Ẽ0 ≈ 0.6
1 The rates of chemical reactions are proportional to
e−β∆A/βwhere β is inverse temperature and ∆A is a difference in
freeenergy between reactants and the transition state separating
re-actants and products. Chemical accuracy is defined as the
max-imum error allowable in ∆A such that errors in the rate
aresmaller than a factor of ten at room temperature [4].
Hartree, which is about 370 times �f . Thus, using ourstrategy,
for α0 > 0.003 there is very little overhead dueto the initial
state |ϕ〉 not being the exact ground state.In the most extreme case
for this example, that representsa speedup by a factor of more than
two orders of mag-nitude. However, in some cases the ground state
overlapmight be high enough that this technique provides only
amodest advantage. While the Hartree-Fock state overlapin this
small basis example is α0 = 0.972, as the sys-tem size and basis
size grow we expect this overlap willdecrease (as argued
earlier).
Another way to cause the overlap to decrease is todeviate from
equilibrium geometries [46, 47]. For exam-ple, we consider this
same system (water in the minimalbasis) when we stretch the bond
lengths to 2.25× theirnormal lengths. In this case, E0 = −74.7505
Hartree,E∗ = −74.6394 Hartree, and α0 = 0.107. The CISD so-lution
provides an upper bound Ẽ0 = −74.7248. In thiscase, E∗ − Ẽ0 ≈
0.085 Hartree, about 50 times �f . Sinceα0 > 0.02, here we speed
up state preparation by roughlya factor of α−10 (more than an order
of magnitude).
IV. PHASE ESTIMATION UNITARIESWITHOUT APPROXIMATION
Normally, the phase estimation would be performed byHamiltonian
simulation. That introduces two difficulties:first, there is error
introduced by the Hamiltonian simu-lation that needs to be taken
into account in boundingthe overall error, and second, there can be
ambiguitiesin the phase that require simulation of the
Hamiltonianover very short times to eliminate.
These problems can be eliminated if one were touse Hamiltonian
simulation via a quantum walk, as inRefs. [53, 54]. There, steps of
a quantum walk can beperformed exactly, which have eigenvalues
related to theeigenvalues of the Hamiltonian. Specifically, the
eigen-values are of the form ±e±i arcsin(Ek/λ). Instead of
usingHamiltonian simulation, it is possible to simply performphase
estimation on the steps of that quantum walk, andinvert the
function to find the eigenvalues of the Hamil-tonian. That
eliminates any error due to Hamiltoniansimulation. Moreover, the
possible range of eigenvaluesof the Hamiltonian is automatically
limited, which elim-inates the problem with ambiguities.
The quantum walk of Ref. [54] does not appear to beappropriate
for quantum chemistry, because it requiresan efficient method of
calculating matrix entries of theHamiltonian. That is not available
for the Hamiltoniansof quantum chemistry, but they can be expressed
as sumsof unitaries, as for example discussed in Ref. [25]. It
turnsout that the method called qubitization [37] allows oneto take
a Hamiltonian given by a sum of unitaries, andconstruct a new
operation with exactly the same func-tional dependence on the
eigenvalues of the Hamiltonianas for the quantum walk in Refs. [53,
54].
Next, we summarize how qubitization works [37]. One
-
6
assumes black-box access to a signal oracle V that en-codes H in
the form:
(|0〉〈0|a ⊗ 11s)V (|0〉〈0|a ⊗ 11s) = |0〉〈0|a ⊗H/λ (3)
where |0〉a is in general a multi-qubit ancilla state in
thecomputational basis, 11s is the identity gate on the
systemregister and λ ≥ ‖H‖ is a normalization constant.
ForHamiltonians given by a sum of unitaries,
H =
d−1∑
j=0
ajUj aj > 0, (4)
one constructs
U = (A† ⊗ 11) SELECT-U(A⊗ 11), (5)
where A is an operator for state preparation acting as
A |0〉 =d−1∑
j=0
√aj/λ |j〉 (6)
with λ =∑d−1j=0 aj , and
SELECT-U =
d−1∑
j=0
|j〉〈j| ⊗ Uj . (7)
For U that is Hermitian, we can simply take V = U .This is the
case for any local Hamiltonian that can bewritten as a weighted sum
of tensor products of Paulioperators, since tensor products of
Pauli operators areboth unitary and Hermitian. More general
strategies forrepresenting Hamiltonians as linear combinations of
uni-taries, as in Eq. (4), are discussed in [55], related to
thesparse decompositions first described in [56]. If U is
notHermitian, then we may construct a Hermitian V as
V = |+〉〈−| ⊗ U + |−〉〈+| ⊗ U† (8)
where |±〉 = 1√2(|0〉 ± |1〉). The multiqubit ancilla la-
belled “a” would then include this additional qubit, aswell as
the ancilla used for the control for SELECT-U.In either case we can
then construct a unitary operatorcalled the qubiterate as
follows:
W = i(2 |0〉〈0|a ⊗ 11s − 11)V. (9)
The qubiterate transforms each eigenstate |k〉 of H as
W |0〉a |k〉s = iEkλ|0〉a |k〉s + i
√1−
∣∣∣∣Ekλ
∣∣∣∣2
|0k⊥〉as (10)
W |0k⊥〉as = iEkλ|0k⊥〉as − i
√1−
∣∣∣∣Ekλ
∣∣∣∣2
|0〉a |k〉s (11)
where |0k⊥〉as has no support on |0〉a. Thus, W per-forms rotation
between two orthogonal states |0〉a |k〉s
and |0k⊥〉as. Restricted to this subspace, the qubiteratemay be
diagonalized as
W |±k〉as = ∓e∓i arcsin(Ek/λ) |±k〉as (12)
|±k〉as =1√2
(|0〉a |k〉s ± |0k⊥〉as
). (13)
This spectrum is exact, and identical to that for the quan-tum
walk in Refs. [53, 54]. This procedure is also simple,requiring
only two queries to U and a number of gates toimplement the
controlled-Z operator (2 |0〉〈0|a ⊗ 11s − 11)scaling linearly in the
number of controls.
We may replace the time evolution operator withthe qubiterate W
in phase estimation, and phase es-timation will provide an estimate
of arcsin(Ek/λ) orπ − arcsin (Ek/λ). In either case taking the sine
givesan estimate of Ek/λ, so it is not necessary to distin-guish
the cases. Any problems with phase ambiguity areeliminated, because
performing the sine of the estimatedphase of W yields an
unambiguous estimate for Ek. Notealso that λ ≥ ‖H‖ implies that
|Ek/λ| ≤ 1.
More generally, any unitary operation eif(H) that haseigenvalues
related to those of the Hamiltonian wouldwork so long as the
function f(·) : R→ (−π, π) is knownin advance and invertible. One
may perform phase es-timation to obtain a classical estimate of
f(Ek), theninvert the function to estimate Ek. To first order,
theerror of the estimate would then propagate like
σEk =
∣∣∣∣∣
(df
dx
∣∣∣∣x=Ek
)∣∣∣∣∣
−1
σf(Ek). (14)
In our example, with standard deviation σphase in thephase
estimate of W , the error in the estimate is
σEk = σphase
√λ2 − E2k ≤ λσphase . (15)
Obtaining uncertainty � for the phase of W requires ap-plying W
a number of times scaling as 1/�. Hence,obtaining uncertainty � for
Ek requires applying W anumber of times scaling as λ/�. For
Hamiltonians givenby sums of unitaries, as in chemistry, each
applicationof W uses O(1) applications of state preparations
andSELECT-U operations. In terms of these operations,
thecomplexities of Section III have multiplying factors of λ.
V. CONCLUSION
We have described three techniques which we expectwill be
practical and useful for the quantum simulationof fermionic
systems. Our first technique provides an ex-ponentially faster
method for antisymmetrizing configu-ration states, a necessary step
for simulating fermions infirst quantization. We expect that in
virtually all cir-cumstances the gate complexity of this algorithm
willbe nearly trivial compared to the cost of the subsequentphase
estimation. Then, we showed that when one has
-
7
knowledge of an upper bound on the ground state energythat is
separated from the first excited state energy, onecan prepare
ground states using phase estimation withlower cost. We discussed
why this situation is anticipatedfor many problems in chemistry and
provided numericsfor a situation in which this trick reduced the
gate com-plexity of preparing the ground state of molecular waterby
more than an order of magnitude. Finally, we ex-plained how
qubitization [37] provides a unitary that canbe used for phase
estimation without introducing the ad-ditional error inherent in
Hamiltonian simulation.
We expect that these techniques will be useful in a va-riety of
contexts within quantum simulation. In particu-lar, we anticipate
that the combination of the three tech-niques will enable
exceptionally efficient quantum simu-lations of chemistry based on
methods similar to thoseproposed in [24]. While specific gate
counts will be thesubject of a future work, we conjecture that such
tech-niques will enable simulations of systems with roughly
ahundred electrons on a million point grid with fewer thana billion
T gates. With such low T counts, simulationssuch as the mechanism
of Nitrogen fixation by ferredoxin,explored for quantum simulation
in [57], should be practi-cal to implement within the surface code
in a reasonableamount of time with fewer than a few million
physicalqubits and error rates just beyond threshold. This
state-ment is based on the time and space complexity of magicstate
distillation (usually the bottleneck for the surfacecode) estimated
for superconducting qubit architecturesin [58], and in particular,
the assumption that with a bil-
lion T gates or fewer one can reasonably perform
statedistillation in series using only a single T factory.
ACKNOWLEDGEMENTS
The authors thank Matthias Troyer for relaying theidea of Alexei
Kitaev that phase estimation could beperformed without Hamiltonian
simulation. We thankJarrod McClean for discussions about molecular
excitedstate gaps. We note that arguments relating the colorsof
compounds to their molecular excited state gaps inthe context of
quantum computing have been popularfor many years, likely due to
comments of Alán Aspuru-Guzik. DWB is funded by an Australian
Research Coun-cil Discovery Project (Grant No. DP160102426).
AUTHOR CONTRIBUTIONS
DWB proposed the algorithms of Section II and thebasic idea
behind Section III as solutions to issues raisedby RB. MK, AS and
YRS worked out and wrote up thedetails of Section II and associated
appendices. RB con-nected developments to chemistry simulation,
conductednumerics, and wrote Section III with input from DWB.Based
on discussions with NW, GHL suggested the basicidea of Section IV.
CG helped to improve the gate com-plexity of our comparator
circuits. Remaining aspects ofthe paper were written by RB and DWB
with assistancefrom MK, AS and YRS.
[1] L. Mueck, Nature Chemistry 7, 361 (2015).[2] M. Mohseni, P.
Read, H. Neven, S. Boixo, V. Denchev,
R. Babbush, A. Fowler, V. Smelyanskiy, and J. Martinis,Nature
543, 171 (2017).
[3] A. Y. Kitaev, eprint arXiv: quant-ph/9511026 (1995).[4] A.
Aspuru-Guzik, A. D. Dutoi, P. J. Love, and M. Head-
Gordon, Science 309, 1704 (2005).[5] B. Bauer, D. Wecker, A. J.
Millis, M. B. Hastings, and
M. Troyer, e-print arXiv: 1510.03859 (2015).[6] Z. Jiang, K. J.
Sung, K. Kechedzhi, V. N. Smelyanskiy,
and S. Boixo, arXiv:1711.05395 (2017).[7] D. S. Abrams and S.
Lloyd, Physical Review Letters 83,
5162 (1999).[8] D. W. Berry, G. Ahokas, R. Cleve, and B. C.
Sanders,
Communications In Mathematical Physics 270, 359(2007).
[9] D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, andR. D.
Somma, Physical Review Letters 114, 090502(2015).
[10] G. H. Low and I. L. Chuang, Physical Review Letters118,
010501 (2017).
[11] G. Ortiz, J. Gubernatis, E. Knill, and R. Laflamme,Physical
Review A 64, 022319 (2001).
[12] J. D. Whitfield, J. Biamonte, and A. Aspuru-Guzik,
Mol.Phys. 109, 735 (2011).
[13] M. B. Hastings, D. Wecker, B. Bauer, and M. Troyer,Quantum
Information & Computation 15, 1 (2015).
[14] D. Poulin, M. B. Hastings, D. Wecker, N. Wiebe, A.
C.Doherty, and M. Troyer, Quantum Information & Com-putation
15, 361 (2015).
[15] K. Sugisaki, S. Yamamoto, S. Nakazawa, K. Toyota,K. Sato,
D. Shiomi, and T. Takui, The Journal of Phys-ical Chemistry A 120,
6459 (2016).
[16] F. Motzoi, M. Kaicher, and F. Wilhelm, e-print
arXiv:1705.10863 (2017).
[17] R. Babbush, N. Wiebe, J. McClean, J. McClain,H. Neven, and
G. K.-L. Chan, e-print arXiv: 1706.0023(2017).
[18] I. D. Kivlichan, J. McClean, N. Wiebe, C. Gidney,A.
Aspuru-Guzik, G. K.-L. Chan, and R. Babbush,Physical Review Letters
120, 110501 (2018).
[19] B. M. Boghosian and W. Taylor, Physica D-NonlinearPhenomena
120, 30 (1998).
[20] B. M. Boghosian and W. Taylor, Physical Review E 57,54
(1998).
[21] C. Zalka, Fortschritte der Physik 46, 877 (1998).[22] I.
Kassal, S. P. Jordan, P. J. Love, M. Mohseni, and
A. Aspuru-Guzik, Proceedings of the National Academyof Sciences
105, 18681 (2008).
http://dx.doi.org/10.1038/nchem.2248http://dx.doi.org/10.1038/543171ahttp://arxiv.org/abs/quant-ph/9511026http://dx.doi.org/10.1126/science.1113479http://arxiv.org/abs/1510.03859http://arxiv.org/abs/1711.05395http://dx.doi.org/10.1103/PhysRevLett.83.5162http://dx.doi.org/10.1103/PhysRevLett.83.5162http://www.springerlink.com/index/hk7484445j37r228.pdfhttp://www.springerlink.com/index/hk7484445j37r228.pdfhttp://dx.doi.org/
10.1103/PhysRevLett.114.090502http://dx.doi.org/
10.1103/PhysRevLett.114.090502http://dx.doi.org/10.1103/PhysRevLett.118.010501http://dx.doi.org/10.1103/PhysRevLett.118.010501http://dx.doi.org/
10.1103/PhysRevA.64.022319http://dx.doi.org/10.1080/00268976.2011.552441http://dx.doi.org/10.1080/00268976.2011.552441http://arxiv.org/abs/1403.1539http://arxiv.org/abs/1406.4920http://arxiv.org/abs/1406.4920http://dx.doi.org/10.1021/acs.jpca.6b04932http://dx.doi.org/10.1021/acs.jpca.6b04932http://arxiv.org/abs/1705.10863http://arxiv.org/abs/1705.10863http://arxiv.org/abs/1706.00023http://arxiv.org/abs/1706.00023http://dx.doi.org/
10.1103/PhysRevLett.120.110501http://dx.doi.org/10.1016/S0167-2789(98)00042-6http://dx.doi.org/10.1016/S0167-2789(98)00042-6http://dx.doi.org/10.1103/PhysRevE.57.54http://dx.doi.org/10.1103/PhysRevE.57.54http://dx.doi.org/
10.1002/(SICI)1521-3978(199811)46:6/83.0.CO;2-Ahttp://www.pnas.org/content/105/48/18681.abstracthttp://www.pnas.org/content/105/48/18681.abstract
-
8
[23] B. Toloui and P. J. Love, e-print arXiv:
1312.2579(2013).
[24] I. D. Kivlichan, N. Wiebe, R. Babbush, and A. Aspuru-Guzik,
Journal of Physics A: Mathematical and Theoret-ical 50, 305301
(2017).
[25] R. Babbush, D. W. Berry, I. D. Kivlichan, A. Y. Wei,P. J.
Love, and A. Aspuru-Guzik, New Journal of Physics18, 033032
(2016).
[26] R. Babbush, D. W. Berry, I. D. Kivlichan, A. Y.Wei, P. J.
Love, and A. Aspuru-Guzik, e-print arXiv:1506.01029 (2015).
[27] T. Kato, Communications on Pure and Applied Mathe-matics
10, 151 (1957).
[28] R. D. Somma, G. Ortiz, J. Gubernatis, E. Knill, andR.
Laflamme, Physical Review A 65, 17 (2002).
[29] J. T. Seeley, M. J. Richard, and P. J. Love, Journal
ofChemical Physics 137, 224109 (2012).
[30] A. Tranter, S. Sofia, J. Seeley, M. Kaicher, J. McClean,R.
Babbush, P. V. Coveney, F. Mintert, F. Wilhelm, andP. J. Love,
International Journal of Quantum Chemistry115, 1431 (2015).
[31] S. Bravyi, J. M. Gambetta, A. Mezzacapo, andK. Temme,
e-print arXiv: 1701.08213 (2017).
[32] V. Havlicek, M. Troyer, and J. D. Whitfield, PhysicalReview
A 95, 032332 (2017).
[33] K. Setia and J. D. Whitfield, arXiv:1712.00446 (2017).[34]
M. Steudtner and S. Wehner, arXiv:1712.07067 (2017).[35] D. S.
Abrams, Quantum Algorithms, Ph.D. thesis (1994).[36] D. S. Abrams
and S. Lloyd, Physical Review Letters 79,
4 (1997).[37] G. H. Low and I. L. Chuang, e-print arXiv:
1610.06546
(2016).[38] S.-T. Cheng and C.-Y. Wang, IEEE Transactions on
Cir-
cuits and Systems I: Regular Papers 53, 316 (2006).[39] R.
Beals, S. Brierley, O. Gray, A. W. Harrow, S. Kutin,
N. Linden, D. Shepherd, and M. Stather, Proceedings ofthe Royal
Society of London A: Mathematical, Physicaland Engineering Sciences
469 (2013).
[40] K. E. Batcher, Communications of the ACM 32, 307(1968).
[41] K. J. Liszka and K. E. Batcher, International Conferenceon
Parallel Processing 1, 105 (1993).
[42] M. Ajtai, J. Komlós, and E. Szemerédi, in Proceed-ings of
the Fifteenth Annual ACM Symposium on Theoryof Computing , STOC ’83
(ACM, New York, NY, USA,1983) pp. 1–9.
[43] M. S. Paterson, Algorithmica 5, 75 (1990).[44] M. T.
Goodrich, in Proceedings of the Forty-sixth Annual
ACM Symposium on Theory of Computing , STOC ’14(ACM, New York,
NY, USA, 2014) pp. 684–693.
[45] B. L. Higgins, D. W. Berry, S. D. Bartlett, H. M. Wise-man,
and G. J. Pryde, Nature 450, 393 (2007).
[46] H. Wang, S. Kais, A. Aspuru-Guzik, and M. R. Hoff-mann,
Physical Chemistry Chemical Physics 10, 5388(2008).
[47] L. Veis and J. Pittner, The Journal of Chemical Physics140,
1 (2014).
[48] J. R. McClean, R. Babbush, P. J. Love, and A. Aspuru-Guzik,
The Journal of Physical Chemistry Letters 5, 4368(2014).
[49] R. Babbush, J. McClean, D. Wecker, A. Aspuru-Guzik,and N.
Wiebe, Physical Review A 91, 022311 (2015).
[50] T. Helgaker, P. Jorgensen, and J. Olsen, Molecular
Elec-tronic Structure Theory (Wiley, 2002).
[51] J. R. McClean, I. D. Kivlichan, D. S. Steiger, Y. Cao,E. S.
Fried, C. Gidney, T. Häner, V. Havĺıček, Z. Jiang,M. Neeley, J.
Romero, N. Rubin, N. P. D. Sawaya, K. Se-tia, S. Sim, W. Sun, K.
Sung, and R. Babbush, e-printarXiv: 1710.07629 (2017).
[52] R. M. Parrish, L. A. Burns, D. G. A. Smith, A. C.
Sim-monett, A. E. DePrince, E. G. Hohenstein, U. Bozkaya,A. Y.
Sokolov, R. Di Remigio, R. M. Richard, J. F.Gonthier, A. M. James,
H. R. McAlexander, A. Kumar,M. Saitow, X. Wang, B. P. Pritchard, P.
Verma, H. F.Schaefer, K. Patkowski, R. A. King, E. F. Valeev, F.
A.Evangelista, J. M. Turney, T. D. Crawford, and C. D.Sherrill,
Journal of Chemical Theory and Computation13, 3185 (2017).
[53] A. M. Childs, Communications in Mathematical Physics294,
581 (2010).
[54] D. W. Berry and A. M. Childs, Quantum Information
&Computation 12, 29 (2012).
[55] D. W. Berry, A. M. Childs, R. Cleve, R. Kothari, andR. D.
Somma, in STOC ’14 Proceedings of the 46th An-nual ACM Symposium on
Theory of Computing (2014)pp. 283–292.
[56] D. Aharonov and A. Ta-Shma, in Proceedings of
thethirty-fifth ACM symposium on Theory of computing -STOC ’03 (ACM
Press, New York, New York, USA,2003) p. 20.
[57] M. Reiher, N. Wiebe, K. M. Svore, D. Wecker, andM. Troyer,
Proceedings of the National Academy of Sci-ences 114, 7555
(2017).
[58] A. G. Fowler, M. Mariantoni, J. M. Martinis, and A.
N.Cleland, Physical Review A 86, 32324 (2012).
[59] M. Bellare, J. Kilian, and P. Rogaway, Journal of Com-puter
and System Sciences 61, 362 (2000).
[60] D. E. Knuth, The art of computer programming, Vol.
3(Pearson Education, 1997).
[61] M. Codish, L. Cruz-Filipe, T. Ehlers,M. Mller, and P.
Schneider-Kamp, Journalof Computer and System Sciences
(2016),https://doi.org/10.1016/j.jcss.2016.04.004.
[62] C. Jones, Physical Review A 87, 022328 (2013).[63] C.
Gidney, e-print arXiv: 1709.06648 (2017).[64] R. Durstenfeld,
Communications of the ACM 7, 420
(1964).[65] M. A. Nielsen and I. L. Chuang, Quantum
Computing
and Quantum Information (Cambridge University Press,2000).
Appendix A: Analysis of ‘Delete Collisions’ Step
In this appendix, we explain the most difficult-to-understand
step of our algorithm: the step in which wedelete collisions from
seed. There are two importantpoints that require explanation.
First, we have to showthat the probability of failure is small.
Second, we haveto show that the resulting state of seed is
disentangledfrom record, as we wish to uncompute record duringthe
final step of our algorithm.
To explain these two points, we begin with an analysis
http://arxiv.org/abs/1312.2579http://arxiv.org/abs/1312.2579http://iopscience.iop.org/article/10.1088/1751-8121/aa77b8http://iopscience.iop.org/article/10.1088/1751-8121/aa77b8http://dx.doi.org/
10.1088/1367-2630/18/3/033032http://dx.doi.org/
10.1088/1367-2630/18/3/033032http://arxiv.org/abs/1506.01029http://arxiv.org/abs/1506.01029http://dx.doi.org/10.1002/cpa.3160100201http://dx.doi.org/10.1002/cpa.3160100201http://dx.doi.org/
10.1103/PhysRevA.65.042323http://dx.doi.org/10.1063/1.4768229http://dx.doi.org/10.1063/1.4768229http://dx.doi.org/10.1002/qua.24969http://dx.doi.org/10.1002/qua.24969http://arxiv.org/abs/1701.08213http://dx.doi.org/10.1103/PhysRevA.95.032332http://dx.doi.org/10.1103/PhysRevA.95.032332http://arxiv.org/abs/1712.00446https://arxiv.org/abs/1712.07067https://journals.aps.org/prl/pdf/10.1103/PhysRevLett.79.2586https://journals.aps.org/prl/pdf/10.1103/PhysRevLett.79.2586http://arxiv.org/abs/1610.06546http://arxiv.org/abs/1610.06546http://dx.doi.org/10.1109/TCSI.2005.856669http://dx.doi.org/10.1109/TCSI.2005.856669http://rspa.royalsocietypublishing.org/content/469/2153/20120686http://rspa.royalsocietypublishing.org/content/469/2153/20120686http://rspa.royalsocietypublishing.org/content/469/2153/20120686http://dx.doi.org/10.1145/1468075.1468121http://dx.doi.org/10.1145/1468075.1468121http://dx.doi.org/10.1109/ICPP.1993.23http://dx.doi.org/10.1109/ICPP.1993.23http://dx.doi.org/10.1145/800061.808726http://dx.doi.org/10.1145/800061.808726http://dx.doi.org/10.1145/800061.808726http://dx.doi.org/10.1007/BF01840378http://dx.doi.org/10.1145/2591796.2591830http://dx.doi.org/10.1145/2591796.2591830http://dx.doi.org/
10.1038/nature06257http://dx.doi.org/
10.1039/B804804Ehttp://dx.doi.org/
10.1039/B804804Ehttp://dx.doi.org/10.1063/1.4880755http://dx.doi.org/10.1063/1.4880755http://dx.doi.org/10.1021/jz501649mhttp://dx.doi.org/10.1021/jz501649mhttp://dx.doi.org/10.1103/PhysRevA.91.022311http://arxiv.org/abs/1710.07629http://arxiv.org/abs/1710.07629http://dx.doi.org/10.1021/acs.jctc.7b00174http://dx.doi.org/10.1021/acs.jctc.7b00174http://dx.doi.org/10.1007/s00220-009-0930-1http://dx.doi.org/10.1007/s00220-009-0930-1http://dl.acm.org/citation.cfm?id=2231036.2231040http://dl.acm.org/citation.cfm?id=2231036.2231040https://doi.org/10.1145/2591796.2591854https://doi.org/10.1145/2591796.2591854http://dx.doi.org/10.1145/780542.780546http://dx.doi.org/10.1145/780542.780546http://dx.doi.org/10.1145/780542.780546http://www.pnas.org/content/114/29/7555.abstracthttp://www.pnas.org/content/114/29/7555.abstracthttp://dx.doi.org/10.1103/PhysRevA.86.032324http://www.sciencedirect.com/science/article/pii/S002200009991694Xhttp://www.sciencedirect.com/science/article/pii/S002200009991694Xhttp://dx.doi.org/https://doi.org/10.1016/j.jcss.2016.04.004http://dx.doi.org/https://doi.org/10.1016/j.jcss.2016.04.004http://dx.doi.org/https://doi.org/10.1016/j.jcss.2016.04.004http://dx.doi.org/10.1103/PhysRevA.87.022328https://arxiv.org/abs/1709.06648https://doi.org/10.1145/364520.364540https://doi.org/10.1145/364520.364540
-
9
of the state of seed after Step 1. The state of seed is
1
f(η)η/2
f(η)−1∑
`0,...,`η−1=0
|`0, . . . , `η−1〉 . (A1)
We can decompose the state space of seed into two or-thogonal
subspaces: the ‘repetition-free’ subspace
span {|`0, . . . , `η−1〉 |∀i 6= j : `i 6= `j} (A2)
and its orthogonal complement. If we project the stateof seed
onto the repetition-free subspace, we obtain theunnormalized
vector
1
f(η)η/2
∑
0≤`0
-
10
construct a comparator. As explained above, the latterrequires
one query to a comparison oracle, whose cir-cuit implementation and
complexity are provided in Ap-pendix B 2, and a conditional swap
applied to the com-pared registers of size d controlled by the
single-qubitancilla holding the result of the comparison.
The construction of the comparison oracle as well asthe
implementation of the conditional swaps both yielda network
consisting predominantly of Toffoli, Not andCNot gates requiring
O(d) elementary gate operationsbut only O(log d) circuit depth.
Indeed, as shown in Ap-pendix B 2, the comparison oracle can be
implementedsuch that the operations can mostly be performed in
par-allel with only O(log d) circuit depth.
When implementing conditional swaps on two regis-ters of size d
as part of a comparator, all elementaryswaps between the
corresponding qubits of these regis-ters must be controlled by the
very same ancilla qubit,namely the one encoding the result of the
comparison or-acle. This suggests having to perform all the
controlledswaps in sequence, as they all are to be controlled bythe
same qubit, which would imply depth scaling O(d)rather than O(log
d). Yet the conditional swaps can alsobe parallelized. This can be
achieved by first copying thebit of the ancilla holding the result
of the comparison tod − 1 additional ancillae, all initialized in
|0〉. Such anexpansion of the result to d copies can be attained
with aparallelized arrangement of O(d) CNots but with circuitdepth
only O(log d). After copying, all the d controlledelementary swaps
can then be executed in parallel (by us-ing the additional
ancillae) with circuit depth only O(1).After executing the swaps,
the d − 1 additional ancillaeused for holding the copied result of
comparison are un-computed again, by reversing the copying process.
Whilethis procedure requires O(d) ancillary space overhead,
itoptimizes the depth. The overall space overhead of thequantum
comparator is also O(d).
Taking d = dlogNe (the largest registers usedin Step 4 of our
sort-based antisymmetrization algo-rithm), conducting the quantum
bitonic sort, for in-stance, thus requires O(η log2(η) logN)
elementary gatesbut only O(log2(η) log logN) circuit depth, while
theoverall worst-case ancillary space overhead amounts toO(η
log2(η) logN).
2. Comparison Oracle
Here we describe how to implement reversibly the com-parison of
the value held in one register with the valuecarried by a second
equally-sized register, and store theresult (larger or not) in a
single-qubit ancilla. We termthe corresponding unitary process a
‘comparison oracle’.We need to use it for implementing the
comparator mod-ules of quantum sorting networks as well as in our
anti-symmetrization approach based on the quantum Fisher-Yates
shuffle. We first explain a naive method for com-parison with depth
linear in the length of the involved
registers. In the second step we then convert this pro-totype
into an algorithm with depth logarithmic in theregister length
using a divide and conquer approach.
Let A and B denote the two equally sized registers tobe
compared, and A and B the values held by these tworegisters. To
determine whether A > B or A < B orA = B, we compare the
registers in a bit-by-bit fashion,starting with their most
significant bits and going downto their least significant bits. At
the very first occurrenceof an i such that A[i] 6= B[i], i.e.,
either A[i] = 1 andB[i] = 0 or A[i] = 0 and B[i] = 1, we know that
A > B inthe first case and A < B in the second case. If A[i]
= B[i]for all i, then A = B. We now show how to infer andrecord the
result in a reversible way.
To achieve a reversible comparison, we employ two an-cillary
registers, each consisting of d qubits, and each ini-
tialized to state |0〉⊗d, respectively. We denote them byA′ and
B′. They are introduced for the purpose of record-ing the result of
bitwise comparison as follows. A′[i] = 1implies that after i
bitwise comparisons we know withcertainty that A = max(A,B), while
B′[i] = 1 impliesB = max(A,B). These implications can be achieved
bythe following protocol, which is illustrated by a simpleexample
in Table I.
To start, at i = 0 we compare the most significant bitsA[0] and
B[0], and write 1 into ancilla A′[0] if A[0] > B[0],or write 1
into ancilla B′[0] if A[0] < B[0]. Otherwise theancillas remain
as 0. For each i > 0, if A′[i − 1] = 0and B′[i− 1] = 0 we
compare A[i] and B[i] and record theoutcome to A′[i] and B′[i] in
the same way as for i = 0.If however A′[i − 1] = 1 and B′[i − 1] =
0, we alreadyknow that A > B, so we set A′[i] = 1 and B′[i] =
0.Similarly, A′[i − 1] = 0 and B′[i − 1] = 1 implies A < B,so we
set A′[i] = 0 and B′[i] = 1. We continue doing sountil we reach the
least significant bits. This results inthe least significant bits
of the ancillary registers A′ andB′ holding information about
max(A,B). If these leastsignificant bits are both 0, then A = B. At
the end theleast significant bit of A′ has value 1 if A > B, and
0 ifA ≤ B. This bit can be copied to an output register,and the
initial sequence of operations reversed to erasethe other ancilla
qubits.
While this algorithm works, it has the drawback thatthe bitwise
comparison is conducted sequentially, whichresults in circuit-depth
scaling O(d). It also uses moreancilla qubits than necessary. We
can improve upon this.We can reduce the number of ancilla qubits by
reusingsome input bits as output bits, and we can achieve adepth
scaling of O(log d) by parallelizing the bitwise com-parison. To
introduce a parallelization, observe the fol-lowing. Let us split
the register A into two parts: A1consisting of the first
approximately d/2 bits and A2 con-sisting of the remaining
approximately d/2 bits. Splitregister B in the very same way into
subregisters B1and B2. We can then determine which number is
larger(or whether both are equal) for each pair (A1, B1) and(A2,
B2) separately in parallel (using the method de-scribed above) and
record the results of the two com-
-
11
Register i=0 i=1 i=2 i=3 i=4 i=5 i=6 i=7 i=8
A 0 0 0 0 1 0 1 0 1
B 0 0 0 0 0 1 1 1 0
A′ 0 0 0 0 1 1 1 1 1
B′ 0 0 0 0 0 0 0 0 0
TABLE I. Example illustrating the idea of reversible
bitwisecomparison. Here, d = 9, the value held in register A is 21
andthe value held in register B is 14. The index i labels the bits
ofthe registers, with i = 0 designating the most significant
bits,respectively. Observe that the first occurrence of A[i] 6=
B[i] isfor i = 4, at which stage the value of ancilla A′[4] is
switched to1, as A[4] > B[4]. This change causes all lesser
significant bitsof A′ also to be switched to 1, whereas all bits of
B′ remain 0.Thus, the least significant bits of A′ and B′ contain
informationabout which number is larger. Here, A′[8] = 1 implies A
> B.
parisons in ancilla registers (A′1, B′1), (A
′2, B′2). The least
significant bits of these four ancilla registers can then beused
to deduce whether A > B or A < B or A = B withjust a single
bitwise comparison. Thus, we effectivelyhalved the depth by
dividing the problem into smallerproblems and merging them
afterwards. We now explaina bottom-up implementation.
Instead of comparing the whole registers A and B,
ourparallelized algorithm slices A and B into pairs of bits –the
first slice contains A[0] and A[1], the second slice con-sists of
A[2] and A[3], etc., and in the very same way for B.The key step
takes the corresponding slices of A and B andoverwrites the second
bit of each slice with the outcome ofthe comparison. The first bit
of each slice is then ignored,so that the comparison results stored
in the second bitsbecome the next layer on which bitwise
comparisons areperformed. We denote the i’th bit forming the
registersof the jth layer by Aj [i] and Bj [i]. The original
registers Aand B correspond to j = 0: A0 ≡ A and B0 ≡ B. The partof
the circuit that implements a single bitwise compari-son is
depicted in Figure 3. We denote the correspondingtransformation by
‘Compare2’, i.e. (Aj+1[i], Bj+1[i]) =Compare2(Aj [2i], Bj [2i], Aj
[2i + 1], Bj [2i + 1]), mean-ing that it prepares the bits Aj+1[i],
Bj+1[i] storing thecomparison result.
At each step, comparisons of the pairs of the originalarrays can
be performed in parallel, and produce twonew arrays with
approximately half the size of the orig-inal ones to record the
results. Thus, at each step weapproximately halve the size of the
problem, while us-ing a constant depth for computing the results.
Thebasic idea is illustrated in Figure 4. This procedure isrepeated
for dlog de steps3 until registers Afin := Adlog deand Bfin :=
Bdlog de both of size 1 have been prepared.
This parallelized algorithm is perfectly suited for com-paring
arrays whose length d is a power of 2. If d is not
3 All logarithms are taken to the base 2.
x1 • • tempy1 • × tempx0 × x′y0 • × • y′|1〉 × temp
FIG. 3. A circuit that implements Compare2, taking apair of
2-bit integers and outputting a pair of single bitswhile preserving
inequalities. The input pair is (x, y) =(x0 +2x1, y0 +2y1). The
output pair is (x
′, y′) and will satisfysign(x′ − y′) = sign(x − y). Output
qubits marked “temp”store values that are not needed, and are kept
until a lateruncompute step where the inputs are restored. Each
Fredkingate within the circuit can be computed using 4 T gates
and(by storing an ancilla not shown) later uncomputed using 0T
gates [62, 63].
000
00
00 0 0
011 1
1 11
1 11 1
11 1
A0B0
01
00
00
0
01 1
001
01 0
1 10
10
01
01
A1B1
A2B2
A3B3
A4B4
11
FIG. 4. Parallelized bitwise comparison. Observe how eachstep
reduces the size of the problem by approximately onehalf, while
using a constant depth for computing the results.
a power of 2, we can either pad A and B with 0s prior totheir
most significant bits without altering the result, orintroduce
comparison of single bits (using only the firsttwo gates from the
circuit in Figure 3 with targets onAj+1 and Bj+1 registers
respectively).
Formally, we can express our comparison algorithm asfollows,
here assuming d to be a power of 2:
for j = 0, . . . , log d− 1 dofor i = 0, . . . , size(Aj)/2− 1
do(
Aj+1[i], Bj+1[i])
= Compare2(Aj [2i], Bj [2i],
Aj [2i+ 1], Bj [2i+ 1])end for
end forreturn (Alog d−1[0], Blog d−1[0])
The key feature of this algorithm is that all the op-erations of
the inner loop can be performed in paral-lel. Since one application
of Compare2 requires onlyconstant depth and constant number of
operations, ourcomparison algorithm requires only depth O(log
d).
-
12
x • xy • • x=y
|0〉 • xy
FIG. 5. A circuit that determines if two bits are equal,
as-cending, or descending. When the comparison is no longerneeded,
the results are uncomputed by applying the circuit inreverse
order.
Our comparison algorithm constructed above can in-deed be used
to output a result that distinguishes be-tween A > B, A < B
and A = B. Observe that itsreversible execution results in the
ancillary single-qubitregisters Afin and Bfin generated in the very
last step ofthe algorithm holding information about which number
islarger or whether they are equal. Indeed, Afin[0] =
Bfin[0]implies A = B, Afin[0] < Bfin[0] implies A < B,
andAfin[0] > Bfin[0] implies A > B. The three cases are
sepa-rated into three control qubits by using the circuit shownin
Figure 5. These individual control qubits can be usedto control
further conditional operations that depend onthe result of the
comparison.
For the purpose in our applications (comparator mod-ules of
quantum sorting networks or quantum Fisher-Yates shuffle), we only
need to condition on whetherA > B is true or false. Thus, we
only need the first op-eration from the circuit in Figure 5 which
takes a singlequbit initialized to |0〉 and transforms it into the
out-put of the comparison oracle. After the output bit hasbeen
produced, we must reverse the complete compari-son algorithm
(invert the corresponding unitary process),thereby uncomputing all
the ancillary registers that havebeen generated along this
reversible process and restoringthe input registers A and B.
The actual ‘comparison oracle’ thus takes as inputs twosize-d
registers A and B (holding values A and B) anda single-qubit
ancilla q initialized to |0〉. It reversiblycomputes whether A >
B is true or false by executingthe parallelized comparison process
presented above. Itcopies the result (which is stored in Afin) to
ancilla q. Itthen executes the inverse of the comparison process.
Itoutputs A and B unaltered and the ancilla q holding theresult of
the oracle: q = 1 if A > B and q = 0 if A ≤ B.As shown, this
oracle has circuit size O(d) but depth onlyO(log d) and a T-count
of 8d+O(1).
1 2 5 71 2 7 51 7 5 27 2 5 11 5 2 71 5 7 21 7 2 5
1 2 5 7
7 5 2 15 2 1 75 2 7 15 7 1 2
2 1 52 1 5 72 1 7 52 7 5 17 1 5 2
1 5 2 7
2 1 7
2 1 5 7
2 5 1 72 5 7 12 7 1 5
5 1 25 1 2 75 1 7 25 7 2 17 1 2 5
2 5 1
5 1 2 7
1 2 5 7
2 1 5 7
1 2 5 7
k=3k=2k=1
7
7
5
7
FIG. 6. A tree diagram for the Fisher-Yates shuffle appliedto an
example sorted array. Here the green boxes identifythe array entry
that has been swapped at each stage of theshuffle. Observe that the
green boxes also label the largestvalue in the array truncated to
position k.
Appendix C: Symmetrization Using The QuantumFisher-Yates
Shuffle
In this appendix we present an alternative approach
forantisymmetrization that is not based on sorting, yield-ing a
size- and depth-complexity O(η2 logN), but with alower spatial
overhead than the sort-based method. Ouralternative symmetrization
method uses a quantum vari-ant of the well-known Fisher-Yates
shuffle, which appliesa permutation chosen uniformly at random to
an inputarray input of length η. A standard form of the algo-rithm
is given in [64].
We consider the following variant of the
Fisher-Yatesshuffle:
for k = 1, . . . , (η − 1) doChoose ` uniformly at random from
{0, . . . , k}.Swap positions k and ` of input.
end for
The basic idea is illustrated in Figure 6 for η = 4.
There are two key steps that turn the Fisher-Yatesshuffle into a
quantum algorithm. First, our quantumimplementation of the shuffle
replaces the random selec-tion of swaps with a superposition of all
possible swaps.To achieve this superposition, the random variable
is re-
placed by an equal-weight superposition 1√k+1
∑k`=0 |`〉
in an ancillary register (called choice). At each stepof the
quantum Fisher-Yates shuffle, the choice registermust begin and end
in a fiducial initial state.
-
13
In order to reset the choice register, we introduce anadditional
index register, which initially contains the in-tegers 0, . . . , η
− 1. We shuffle both the length-η inputregister and the index
register, and the simple form ofindex enables us to easily reset
choice. The resultingstate of the joint input⊗index register is
still highly en-tangled; however, provided input was initially
sorted inascending order, we can disentangle index from input.
Our quantum Fisher-Yates shuffle consists of the fol-lowing
steps:
1. Initialization. Prepare the choice register in thestate |0〉.
Prepare the index register in the state|0, 1, . . . , η − 1〉. Also
set a classical variable k = 1.
2. Prepare choice. Transform the choice register
from |0〉 to 1√k+1
∑k`=0 |`〉.
3. Execute swap. Swap element k of input withthe element
specified by choice. If a non-trivialswap was executed (i.e. if
choice did not specifyk), apply a phase of −1 to the input
register. Alsoswap element k of index with the element specifiedby
choice.
4. Reset choice. For each ` = 1, . . . , k, subtract `from the
choice register if position ` in index isequal to k. The resulting
state of choice is |0〉.
5. Repeat. Increment k by one. If k < η, go toStep 2.
Otherwise, proceed to the next step.
6. Disentangle index from input. For each k 6=` = 0, 1, . . . ,
η − 1, subtract 1 from position ` ofindex if the element at
position k in input isgreater than the element at position ` in
input.The resulting state of index is |0, 0, . . . , 0〉, whichis
disentangled from input.
We present an overview of the algorithm in Figure 7.At the
highest level, depicted in Figure 7a, we applyan initialization
procedure to index, then η − 1 ‘Fisher-Yates’ blocks (FYk for k =
1, . . . , η−1), and finally a dis-entangling (‘Detangle’)
procedure on index and input.Following the Detangle procedure, the
ancillary regis-ters choice and index are reset to their initial
all-zerostates and the input register has been symmetrized. Ineach
Fisher-Yates block, depicted in Figure 7b, we applythe preparation
operator Πk to choice, apply selectedswaps on choice+index and
choice+input, then applya phase conditioned on choice to input, and
finally resetthe choice register. Preparing and resetting choice
aswell as executing swap are therefore part of each Fisher-Yates
block and are thus each applied a total of η − 1times (for each of
k = 1, . . . , η − 1). Their gate countsand circuits depths must
thus be multiplied by (η − 1).Disentangling index and input is the
most expensivestep, but it is executed only once, so it contributes
onlyan additive cost to the overall resource requirement.
|0〉⊗η
FY1
. . .
FYη−1
|0〉⊗η
|0〉⊗ηdlog ηe / Init . . .Detangle
|0〉⊗ηdlog ηe
input / . . . Symm(input)
(a)
|0〉⊗η / Prepare choice c c < kResetchoice
|0〉⊗η
index / Swap(c,k)
input / Swap(c,k) eiπ
(b)
FIG. 7. An overview of symmetrization by quantum Fisher-Yates
shuffle. (a) High-level view of the algorithm. The proce-dure acts
on registers labeled (top to bottom) choice, indexand input. (b)
Detail for the Fisher-Yates block FYk. Thefirst register (again
labeled choice) is used to select the tar-get of the two selected
swap steps. Then a phase eiπ = −1 isapplied to the input register
if a swap was performed, i.e. ifthe choice register encodes a value
less than k. Each blockFYk is completed by resetting the choice
register back to itsoriginal state |0〉⊗η.
In what follows, we explain each step of the algo-rithm and
justify their corresponding resource contribu-tions, which are
briefly summarized here: Step 1 requiresO(η log η) gates but has a
negligible depth O(1). Step 2requires O(η) gates and has the same
depth complex-ity. Step 3 requires O(η logN) gates and has also
depthO(η logN). Step 4 requires O(η log η) gates but has onlydepth
O(log η). As Step 2 to Step 4 are repeated η − 1times, the total
gate count before Step 6 is O(η2 logN).Finally, Step 6 requires
O(η2 logN) gates and has depthO(η2 [log logN + log η]
). Thus the total gate count of
the quantum Fisher-Yates shuffle is O(η2 logN). Becausemost of
the gates need to be performed sequentially, theoverall circuit
depth of the algorithm is also O(η2 logN).
Our complexity analysis is given in terms of elemen-tary gate
operations, a term we use loosely. Generallyspeaking, we treat all
single-qubit gates as elementaryand we allow up to two controls for
free on each single-qubit gate. This definition of elementary gates
includesseveral standard universal gate sets such as Clifford+Tand
Hadamard+Toffoli. A more restrictive choice of el-ementary gate set
only introduces somewhat larger con-stant factors in most of the
procedure. The exceptionis the application of Πk in the first step
of FYk, wherewe require the ability to perform controlled
single-qubit
rotations of angle arcsin(√
``+1
), where ` = 1, . . . , k.
The Solovay-Kitaev theorem implies a gate-count over-head that
grows polylogarithmically in the inverse of theerror tolerance. We
now proceed by analyzing each step
-
14
to the quantum Fisher-Yates shuffle.
1. Initialization
The first step is to initialize choice in the state |0〉⊗η.This
is assumed to have zero cost. The index register isset to the state
|0, 1, . . . , η − 1〉 that represents the posi-tions of the entries
of input in ascending order. Becauseeach of the η entries in index
must be capable of stor-ing any of the values 0, 1, . . . , η − 1,
the size of index isηdlog ηe qubits. This step requires O(η log η)
single-qubitgates that can be applied in parallel with circuit
depthO(1).
2. Fisher-Yates Blocks
Each Fisher-Yates block has three stages: preparechoice,
executed selected swaps, and reset choice. Theexact steps depend on
the encoding of the choice regis-ter; in particular, whether it is
binary or unary.
We elect the conceptually simplest encoding of choice,which is a
kind of unary encoding. We use η qubits (la-belled 0, 1, . . . ,
η), define
|null〉 = |0〉⊗η (C1)and encode
|`〉 = X` |null〉 , (C2)where X` is the Pauli X applied to the
qubit labelled `.
An advantage of our encoding for choice is that theselected
swaps require only single-qubit controls. An ob-vious disadvantage
is the unnecessary space overhead.Although one can save space with
a binary encoding, theresulting operations become somewhat more
complicatedand hence come at an increased time cost. Our choice
ofencoding is made for simplicity.
a. Prepare choice
Our preparation procedure has two stages. First, weprepare an
alternative unary encoding of the state
|Wk〉 :=1√k + 1
k∑
`=0
|`〉 , (C3)
which we name for its resemblance to the W-state1√3(|001〉 +
|010〉 + |100〉). Second, we translate the al-
ternative unary encoding to our desired encoding. For asummary
of the procedure, see Figure 8.
Next, we explain how to prepare |Wk〉 in the alterna-tive unary
encoding. The alternative encoding is
|`〉 =(∏̀
`′=0
X`′
)|null〉 . (C4)
0 X . . .
1 Rk • . . . •2 Rk−1 . . . •...
. . .. . .
k − 1 . . . •k . . . R1 •
FIG. 8. Circuit for preparing the choice register at the
be-ginning of block FYk. See Eq. (C5) for the definition of R`.
We can prepare |Wk〉 in this encoding with a cascade ofcontrolled
rotations of the form
R` :=1√`+ 1
(1 −
√`√
` 1
). (C5)
Explicitly:
Apply X to qubit 0.Apply Rk to qubit 1.for ` = 1, . . . , k − 1
do
Apply Rk−` controlled on qubit ` to qubit `+ 1.end for
This is a total of k + 1 gates, k = 1 of which are
appliedsequentially.
Next we explain how to translate to the desired encod-ing. This
is a simple procedure:
for ` = k, . . . , 1 doApply Not controlled on qubit ` to qubit
`− 1.
end for
The total number of CNot gates is k, and they mustbe applied in
sequence. Thus the total gate count (andtime-complexity) for
preparing choice is O(k) = O(η).
b. Selected Swap
We need to implement selected swaps of the form
SelSwapk :=
η−1∑
c=0
|c〉〈c|choice ⊗ Swap(c, k)target, (C6)
where the Swap(c, k) operator acts on either target =index or
target = input. Here the state of the choiceregister selects which
entry in the target array is to beswapped with entry k. Our unary
encoding of the choiceregister allows for a simple implementation
of SelSwap;see Figure 9.
Observe that only the first k + 1 subregisters are in-volved of
each choice, index and input, respectively.Also observe that, for
each i = 0, 1, . . . , k, index[i] is ofsize dlog ηe whereas
input[i] is of size dlogNe. Hence,the circuit actually consists of
kdlog ηe + kdlogNe or-dinary 3-qubit controlled-Swap gates that for
the mostpart must be executed sequentially. As η ≤ N , we reportO
(η logN) for both gate count and depth.
-
15
choice[0] • . . . • . . .choice[1] • . . . • . . .
.... . .
. . .choice[k − 1] . . . • . . . •
choice[k] . . . . . .
index[0] / × . . . . . .index[1] / × . . . . . .
.... . .
index[k − 1] / . . . × . . .index[k] / × × . . . × . . .
input[0] / . . . × . . .input[1] / . . . × . . .
.... . .
input[k − 1] / . . . . . . ×input[k] / . . . × × . . . ×
FIG. 9. Implementation of the two selected swaps SelSwapkas part
of FYk, with the unary-encoded choice as the controlregister and
index and input as target registers, respectively.As each wire of
the target registers stand for several qubits,each controlled-Swap
is to be interepreted as many bitwisecontrolled-Swaps.
c. Applying the controlled-phase
Applying the controlled-phase gate is straightforward.We select
a target qubit in the input register – it doesnot matter which.
Then, for each ` = 0, 1, . . . , k − 1, weapply a phase gate
controlled on position ` of choice tothe target qubit. The result
is that input has picked upa phase of (−1) if choice specified a
value strictly lessthan k. The total number of gates is k = O(η),
while thedepth can be made O(1).
d. Resetting choice register
The reason we execute swaps on both index and inputis to enable
reversible erasure of choice at the end ofeach Fisher-Yates block.
This is done by scanning indexto find out which value of k was
encoded into choice. Ingeneral, we know that step k sends the value
k to posi-tion ` of index, where ` is specified by the choice
regis-ter. We thus erase choice by applying a Not operationto
choice[`] if index[`] = k. This can be expressed asa
multi-controlled-Not, as illustrated by an example inFigure 10. The
control sequence of the multi-controlled-
Not is a binary encoding of the value k.
choice[`]
0
1 •2
index[`]
{3 •4...
...
dlog ηe − 1
FIG. 10. Circuit for resetting choice register as part of
it-eration block FYk. In this example k = 10. It consists of
aseries of multi-fold-controlled-Nots, employing the `-th wireof
choice and the `-th subregister index[`] of size dlog ηe, foreach `
= 0, . . . , k. Note that the multi-fold-controlled-Not isthe same
for all values of `. The control sequence is a binaryencoding of k
= 10. The Not erases choice[`] if index[`] = k.
For compiling multiple controls, see Figure 4.10 in[65]. Each
dlog ηe-fold-controlled-Not can be decom-posed into a network of
O(log η) gates (predominantlyToffolis) with depth O(log η). Because
the k + 1 multi-fold-controlled-Nots (for ` ≤ k ≤ η − 1) can all be
exe-cuted in parallel, resetting choice register thus requiresa
circuit with O(η log η) gates but only O(log η) depth.
3. Disentangling index from input
The last task is to clean up and disentangle indexfrom input by
resetting the former to the original state
|0〉⊗ηdlog ηe while leaving the latter in the desired
antisym-metrized superposition. This can be achieved as
follows.
We compare the value carried by each of the η subregis-ters
input[`] (labeled by position index ` = 0, 1, . . . , η−1)with the
value of each other subregister input[`′] (`′ 6= `),thus requiring
η(η − 1) comparisons in total. Note thatthese subregisters of input
have all size dlogNe. Eachtime the value held in input[`] is larger
than the valuecarried by any other of the remaining η − 1
subregistersinput[`′], we decrement the value of the corresponding
`th
subregister index[`] of index by 1. In cases in which thevalue
carried by input[`] is smaller than input[`′], we donot decrement
the value of index[`]. After accomplish-ing all the η(η−1)
comparisons within the input registerand controlled decrements, we
have reset the index reg-
ister state to |0〉⊗ηdlog ηe while leaving the input registerin
the antisymmetrized superposition state.
Each comparison between the values of two subregis-ters of input
(each of size dlogNe) can be performedusing the comparison oracle
introduced in Appendix B 2.
-
16
The oracle’s output is then used to control the ‘decrementby 1’
operation, after which the oracle is used again touncompute the
ancilla holding its result. The compari-son oracle has been shown
to require O(logN) gates butto have only circuit depth O(log
logN).
Decrementing the value of the dlog ηe-sized index sub-register
index[`] (for any ` = 0, 1, . . . , η−1) by the value1 can be
achieved by a circuit depicted in Figure 11.
(a) (b)0 0
1 1
2 = 2
3 3
4 4
5 5
|0〉 • • • |0〉|0〉 • • • |0〉|0〉 • |0〉
FIG. 11. Circuit implementing ‘decrement by 1’ operation,applied
to index[`] subregisters of size dlog ηe. (a) Examplefor η = 64.
(b) Decomposition into a network of O (log η)Toffoli gates using O
(log η) ancillae.
Each such operation involves a total of dlog ηe
multi-fold-controlled-Nots. More specifically, it involves
n-fold-controlled-Nots for each n = dlog ηe−1, . . . , 0. Notethat
each must also be controlled by the qubit holdingthe result of the
comparison oracle. When decompos-ing each of them into a network of
O(n) Toffoli gatesusing O(n) ancillae according to the method
providedin Figure 4.10 in [65], the majority of the involved
Tof-foli gates for different values of n effectively cancel
eachother out. The resulting cost is only O (log η) Toffolisrather
than O
(log2 η
), at the expense of an additional
space overhead of size O (log η). However, there is noneed to
employ new ancillae. We can simply reuse thosequbits that
previously composed the choice register forthis purpose, as the
latter is not being used otherwise atthis stage any more.
Putting everything together, the overall circuit size forthis
step amounts to O (η(η − 1) [logN + log η]) predom-inantly Toffoli
gates, which can then be further decom-posed into CNots and
single-qubit gates (including Tgates) in well-known ways. Because η
≤ N , we thus re-port O(η2 logN) for the overall gate count for
this step,while its circuit depth is O
(η2 [log logN + log η]
).
Improved Techniques for Preparing Eigenstates of Fermionic
HamiltoniansAbstractI IntroductionII Exponentially Faster
AntisymmetrizationIII Fewer Phase Estimation Repetitions by Partial
Eigenstate Projection RejectionIV Phase Estimation Unitaries
without ApproximationV Conclusion Acknowledgements Author
Contributions ReferencesA Analysis of `Delete Collisions' StepB
Quantum Sorting1 Resource Analysis of Quantum Sorting Networks2
Comparison Oracle
C Symmetrization Using The Quantum Fisher-Yates Shuffle1
Initialization2 Fisher-Yates Blocksa Prepare choiceb Selected Swapc
Applying the controlled-phased Resetting choice register
3 Disentangling index from input
