A Derivation of Eq. (18)

# Superposition of Macroscopically Distinct States in Adiabatic Quantum Computation

## Abstract

What are the conditions for adiabatic quantum computation (AQC) to outperform classical computation? Although there exist several quantum adiabatic algorithms achieving the strong quantum speedup, the essential keys to their speedups are still unclear. Here, we investigate the connection between superpositions of macroscopically distinct states and known examples of the speedup in AQC. To formalize this notion we consider an index that quantifies a superposition of macroscopically distinct states from the asymptotic behaviors of fluctuations of additive observables. We determine this index for five examples of adiabatic algorithms exhibiting various degrees of the speedup. The results suggest that the superposition of macroscopically distinct states is an appropriate indicator of entanglement crucial to the strong quantum speedup in AQC.

## I Introduction

Adiabatic quantum computation (AQC) can outperform classical computation. But why and in what conditions does it achieve the quantum speedup? This fundamental question is yet to be answered although, since the proposal of AQC Farhi et al. (2000, 2001) and quantum annealing Apolloni et al. (1989); Somorjai (1991); Amara et al. (1993); Finnila et al. (1994); Kadowaki and Nishimori (1998), intensive studies have been carried out Santoro and Tosatti (2006); Das and Chakrabarti (2008); Morita and Nishimori (2008); Bapst et al. (2013); Suzuki and Das (2015); Albash and Lidar (2016).

The basic procedure of AQC for optimization problems is as follows. First, we encode the cost function of a problem instance into a “problem Hamiltonian” such that its ground state minimizes the cost function. Here, is the problem size and is a symbolic label of instances. Second, we prepare a system (a quantum device) in the ground state of another Hamiltonian , called “driver Hamiltonian.” should not commute with , and ’s ground state should be easily prepared. Third, we let the system evolve according to the Shrödinger equation with the following time-dependent Hamiltonian:

 ^H(s;n,ν)=s^Hp(n,ν)+(1−s)^Hd(n). (1)

Here, we vary the “annealing parameter” in time from to . If the rate of change is sufficiently small to satisfy the adiabatic condition Kato (1950); Messiah (1961) (see also Sec. II of Ref. Albash and Lidar (2016)), then the state stays close to the instantaneous ground state of at any time. And, at the end () of the time evolution, we obtain the ground state of , the solution of the instance. From the adiabatic theorem, the computational time depends on a polynomial of the inverse of the energy gap between the ground and first excited states of .

There are quantum adiabatic algorithms which do outperform classical computation in the sense of the strong quantum speedup Papageorgiou and Traub (2013); Rønnow et al. (2014) (the scaling advantage compared with the best classical algorithms). One of them is the adiabatic algorithm for Grover’s search problem Roland and Cerf (2002). It was shown that its computational time is the same order as that of the original Grover algorithm Grover (1997). And several other algorithms were found Somma et al. (2012); Hen (2014a, b, 2016); Albash and Lidar (2016). However, in general and in many problems, it is unclear whether AQC achieves the quantum speedup or not. In addition, even if restricted to the algorithms known to outperform, it is unclear what features of quantum physics are essential to their quantum speedups. For example, although quantum tunneling is often expected to be a key to the speedup of AQC, there are counterexamples to this expectation Muthukrishnan et al. (2016).

Clarifying the mechanism and conditions of quantum speedup is crucial for developing AQC. They will enable us to judge whether a given algorithm of AQC achieves quantum speedup. They will be also useful for real quantum devices, such as D-wave machines Johnson et al. (2011); Lanting et al. (2014); Rønnow et al. (2014); Boixo et al. (2014); Katzgraber et al. (2015); Denchev et al. (2016), which implement algorithms of quantum annealing and AQC: we can judge quantum speedup of algorithms on devices by investigating whether they satisfy the conditions, instead of by direct comparison with classical ones.

As a quantum effect possibly connected to the quantum speedup, the many-body localization may be considered. This phenomenon induces an exponentially small energy gap and is thus considered as a bottleneck for AQC Altshuler et al. (2010); Bapst et al. (2013). And methods of circumventing this phenomenon have been argued Farhi et al. (2011); Choi (2010); Dickson and Amin (2011); Dickson (2011). But its relation to the strong quantum speedup is not clear because some algorithms achieve the speedup even with exponentially small gaps.

As another quantum effect, we here consider quantum entanglement. In circuit-based quantum computation, many studies assert the necessity of entanglement for the quantum speedup Jozsa and Linden (2003); Vidal (2003); Parker and Plenio (2002); Shimoni et al. (2004, 2005); Orús and Latorre (2004); Ukena and Shimizu (2004); Shimizu et al. (2013). In AQC, by contrast, the necessity of entanglement is less clear although there are several theoretical studies Orús and Latorre (2004); Latorre and Orús (2004); Rezakhani et al. (2009); Bauer et al. (2015); Hauke et al. (2015); Batle et al. (2016) and although entanglement is experimentally detected in the D-wave machine Lanting et al. (2014) (see also Ref. Albash et al. (2015)).

Orús and Latorre studied the entanglement entropy in AQC Orús and Latorre (2004); Latorre and Orús (2004): in the exact cover problem a simulation with up to 20 qubits showed that the entanglement entropy increases proportionally to the system size, whereas in the adiabatic Grover algorithm an analytical calculation showed that the entanglement entropy is bounded (approaches a constant value as the size increases). Rezakhani et al. showed that entanglement (negativity) in the optimal AQC algorithm for Grover’s search problem is smaller than that in a non-optimal case Rezakhani et al. (2009). Relation between entanglement and the success probability of finding the solution was argued in simulations of AQC Bauer et al. (2015); Hauke et al. (2015). In Ref. Bauer et al. (2015), it was reported that, in an AQC algorithm for Ising spin glass problems, the success probability increases as the limit of entanglement allowed in the simulation is increased. In Ref. Hauke et al. (2015), by contrast, it was reported that, in an AQC algorithm for the Coulomb-glass problem, the entanglement entropy of the intermediate states has little significance for the success probability although that of the final state provides an upper bound on the probability. Reference Batle et al. (2016) investigated multipartite entanglement in AQC algorithms for the factoring problem and the Deutsch–Jozsa problem. It reported that no significantly large entanglement appears during computation.

In the present paper, we propose a necessary condition for the strong quantum speedup in AQC. We conjecture that a superposition of macroscopically distinct states appears during AQC, if it achieves the speedup. This conjecture is an extension of that proposed in a context of circuit-based quantum computation Ukena and Shimizu (2004); Shimizu et al. (2013). We investigate whether our conjecture is correct in five AQC algorithms: four of them are known to achieve the quantum speedup and the rest one is known not to achieve. As summarized in Table 1, all of the results support our conjecture.

The structure of the present paper is as follows. In Sec. II, we review a superposition of macroscopically distinct states. We mention the conjecture in Sec. III and show its plausibility by testing it in several algorithms in Sec. IV. In Sec. V, we make concluding remarks. We describe some technical details in Appendices.

## Ii Superposition of macroscopically distinct states

In this section, we briefly review a superposition of macroscopically distinct states and its quantification. Suppose a quantum system composed of local sites. We assume that the dimension of the Hilbert space of each site is finite and any local operators on are bounded. Here, we consider only pure states because we discuss AQC that uses only pure states in this study. For more details, see Ref. Shimizu et al. (2013).

### ii.1 Macroscopically distinct states and their superposition

We first define “macroscopically distinct states.” Two or more states are macroscopically distinct if there is at least one macroscopic quantity whose values are different among them in macroscopic accuracy. There are many macroscopic quantities—total energy, magnetization, temperature, entropy, and so on. Among them we take “mechanical additive observables” (such as total energy and magnetization). They are expressed as sums of local operators. In this choice, the macroscopic accuracy means resolution of .

Therefore, we can say that two pure states, and , are macroscopically distinct if for an additive operator . An additive operator is defined as , where is a local operator at the th site and runs over all the sites in the system. We assume that as usual so that , where the operator norm is defined appropriately.

We next explain a superposition of macroscopically distinct states. To this end we first consider a superposition of macroscopically identical (non-distinct) states. Let be any additive operator, and let be an eigenstate of with an eigenvalue . From the above argument, any superposition of macroscopically identical states contains almost only ’s that satisfy with an -independent value . In other words, the probability to find ’s with is vanishingly small. Then, we can show that has normal fluctuations for any additive observables: , where . That is, the relative fluctuations vanish in the macroscopic limit: .

Then, taking the contrapositive of the above statement, we obtain a sufficient condition for a superposition of macroscopically distinct states: a pure state is a superposition of macroscopically distinct states if for an additive operator . In other words, a superposition of macroscopically distinct states has anomalous or macroscopic fluctuation for at least one additive observable.

### ii.2 Index p: an indicator of superposition of macroscopically distinct states

From the argument in the previous subsection, we can judge whether a given state is a superposition of macroscopically distinct states from the asymptotic behaviors of the fluctuations of additive observables. To investigate the asymptotic behaviors, we must assign states for each at a certain criterion. We use a label to distinguish the assigned states for each . In AQC, for example, represents a problem instance of size . We collect all the assigned states to have a family .

Then, we investigate asymptotic properties of the family. We define the index for the family by

 max^A(n)⟨Δ^A†(n)Δ^A(n)⟩n,ν=¯¯¯¯Θ(np), (2)

where , and the maximum is taken over the additive operators in the system of size . The asymptotic notation is defined as follows Shimizu et al. (2013). Suppose a family of positive numbers that are generated by positive-valued functions . We say that if and only if for almost every in the family, i.e., except for a vanishingly small fraction of ’s (for large ). The big Theta notation is defined according to the convention in computer science Knuth (1976); Cormen et al. (2009); Nielsen and Chuang (2000): if and only if holds with positive constants and for .

We can show that if exists for Shimizu et al. (2013). It is clear that if for a family , almost every state in is superpositions of macroscopically distinct states. In this sense, the index is an indicator of superpositions of macroscopically distinct states.

We note that the index quantifies quantum entanglement because superpositions of macroscopically distinct states are entangled states. Furthermore it is known that is not correlated with bipartite entanglement (such as the entanglement entropy): some states with have small bipartite entanglement, and some states with have large bipartite entanglement Morimae et al. (2005); Sugita and Shimizu (2005). Thus captures an aspect of entanglement that cannot be well quantified by bipartite entanglement. See Refs. Fröwis and Dür (2012); Yadin and Vedral (2015); Tichy et al. (2016); Abad and Karimipour (2016); Park et al. (2016); Kuwahara et al. (2017); Tatsuta and Shimizu (2017) for recent applications of the index and its relation to other quantities.

### ii.3 Practical method of evaluating the index p

From the definition of the index , Eq. (2), it seems hard to calculate in general. However, there is a method of efficiently evaluating Shimizu et al. (2013); Morimae et al. (2005); Sugita and Shimizu (2005); Morimae and Shimizu (2006).

To explain the method, we consider a complete orthonormal set of local operators on at site —we write them as . Here, and (identity operator on ). In a system composed of qubits, for example, , and we may take ’s () as the components of the Pauli matrices at site .

In this method we evaluate the maximum eigenvalue of the variance-covariance matrix (VCM). The VCM is defined by the following matrix elements:

 Vlα,l′α′(n,ν)≡⟨Δ^b†α(l)Δ^bα′(l′)⟩n,ν,

where . Here, and run over all the sites, and ( and are not included), so that the VCM is an Hermitian matrix. From the asymptotic behavior of the maximum eigenvalue of the VCM, we define another index :

 emax(n,ν)=¯¯¯¯Θ(npe−1).

Then we can show that if and only if Shimizu et al. (2013). Therefore, we can judge by investigating whether is asymptotically proportional to .

Moreover, if , this method tells us which is the additive observable that macroscopically fluctuates Shimizu et al. (2013). We can construct it from the eigenvector corresponding to as .

## Iii Conjecture on a necessary condition for quantum speedup in adiabatic quantum computation

In this section, we propose a conjecture on a necessary condition for the quantum speedup in AQC. In Refs. Ukena and Shimizu (2004); Shimizu et al. (2013), a conjecture was proposed for circuit-based quantum computation. It states that a state with is necessary for the quantum speedup. Our expectation here is that both adiabatic and circuit-based quantum computation should use the same features of quantum physics to achieve the quantum speedup, although their operation principles are different.

Among several kinds of quantum speedup Rønnow et al. (2014), we here consider the strong quantum speedup Papageorgiou and Traub (2013). Our conjecture reads:

###### Conjecture

Let QAA be a quantum adiabatic algorithm that solves a problem. If QAA achieves the strong quantum speedup, then there exists a set of infinitely many instances such that a state with appears during the computation of almost every instance in .

Furthermore, if an algorithm uses only the ground states of , i.e., if the adiabatic approximation works well, our conjecture yields a stronger form:

###### Corollary of Conjecture

Let QAA be a quantum adiabatic algorithm that solves a problem by using only the ground states of . If QAA achieves the strong quantum speedup, then there exists a set of infinitely many instances such that at some has for almost every in .

Here we make a few remarks.

In Ref. Shimizu et al. (2013), problems are restricted to those not in class BPP (bounded-error probabilistic polynomial time). In our conjecture, we remove this restriction because at present there is no evidence for it. In fact, for the Bernstein–Vazirani problem, which is in class BPP, we obtain a result that supports our conjecture (Sec. IV.3).

One might think that our conjecture is a trivial extension of that in circuit-based quantum computation since AQC is equivalent to circuit-based quantum computation up to polynomial overhead Aharonov et al. (2007); Kempe et al. (2006); Mizel et al. (2007); Gosset et al. (2015). However, this is not the case for the following reasons. (i) In the proofs of the equivalence, mainly shown is the equivalence of the measurement output from the final states, and the equivalence of (intermediate) states is not necessarily required. Therefore, even if a state with appears in a circuit-based quantum algorithm, it is not clear whether the same or similar state with appears in its equivalent algorithm of AQC. (ii) If the quantum speedup is polynomial, the polynomial overhead can invalidate the speedup. Therefore, even if a circuit-based quantum algorithm achieves the polynomial quantum speedup, its equivalent algorithm of AQC does not necessarily achieve the speedup. (iii) Some of the algorithms of AQC that achieve the quantum speedup were formulated without relying on the equivalence. For such algorithms, validity of our conjecture is not trivial. The algorithms investigated in Sec. IV are examples of such ones.

As mentioned in Sec. II.2, is defined for a family of states. For the case of Corollary of Conjecture, we should take the family as

 Missing or unrecognized delimiter for \big

where may or may not depend on . In practice, is useful.

It was pointed out Van den Nest (2013) that the quantum speedup can be achieved with vanishingly small entanglement. If a problem can be solved by using an -qubit AQC with states , the problem can be solved also by an -qubit AQC with states where . In the latter AQC, any family of states has even if it achieves the quantum speedup. However, because the parts essentially contributed to the computation are , we circumvent this drawback by extracting the essential parts. As one of the ways, we allow a state connected by a local operation when we evaluate the index . That is, we extend the definition (2) of to

 max^ℓαmax^A(n)⟨ψn,ν|^ℓ†αΔ^A†(n)Δ^A(n)^ℓα|ψn,ν⟩⟨ψn,ν|^ℓ†α^ℓα|ψn,ν⟩=¯¯¯¯Θ(np), (3)

where , and is a Kraus operator on sites (qubits), which represents a local operation. The leftmost maximum in Eq. (3) is taken over all the local operations that satisfy . In the next section, however, we use the original definition (2) because we can evaluate by Eq. (2) for the states there.

## Iv Tests for conjecture

Our conjecture for AQC as well as the conjecture for circuit-based quantum computation Shimizu et al. (2013) have not been proved for general problems at present. In this section, we investigate its correctness in specific problems as the first tests for our conjecture. We have five examples of AQC algorithms: quantum adiabatic versions of the algorithms of Grover, Deutsch–Jozsa, Bernstein–Vazirani, and Simon and an algorithm for the glued-trees problem. All of these algorithms are known to achieve the strong quantum speedup or not. We show the summary of the results in Table 1. All the results are consistent with and thus support our conjecture.

Throughout this section, we assume systems of qubits. We use the following notation. The Pauli matrices at site are . The eigenstate of corresponding to the eigenvalue of is , and that of is . The eigenstates of corresponding to the eigenvalues of are . The computational basis in the -qubit system is composed of with . Here, is the th-bit value of , and .

The Grover algorithm is a quantum algorithm of searching solutions in unstructured databases of entries. It was originally formulated in a circuit-based quantum computation Grover (1997) and was proved to achieve the quadratic quantum speedup Grover (1997); Bennett et al. (1997); Nielsen and Chuang (2000); Mermin (2007).

An AQC version of the Grover algorithm was proposed in Ref Farhi et al. (2000). It was improved in Ref Roland and Cerf (2002) to achieve the quadratic quantum speedup Roland and Cerf (2002); Jansen et al. (2007); Albash and Lidar (2016).

Here, we show that our conjecture is correct for the adiabatic Grover algorithm of Ref Roland and Cerf (2002). For simplicity we assume single-solution cases.

The input of Grover’s search problem is a function of -bit strings, , which satisfies only for the solution and for except for . The task is to find the solution . An instance for fixed is identified with —we therefore use instead of .

For the adiabatic Grover algorithm Roland and Cerf (2002), the problem Hamiltonian is given by , where is one of the computational basis states corresponding to the solution . And the driver Hamiltonian is given by

 ^Hd(n) =1−|φ⟩⟨φ|, (4)

where is the uniform superposition of the computational basis, which is equivalent to the product state of ’s:

 |φ⟩≡1√NN−1∑w=0|w⟩=n⨂l=1|+⟩l. (5)

In this algorithm, is tuned to satisfy a time-local adiabatic condition Roland and Cerf (2002), so that the system is in the ground state of at each . We can show that the ground state lies in the subspace spanned by and Roland and Cerf (2002); Albash and Lidar (2016). We thus easily obtain as

 |ψ0n,w∗(s)⟩ =as|w∗⟩+bs|φ⟩, (6)

where

 as=sinθs2−cosθs2tanθ02,   bs=cosθs2/cosθ02, sinθs=2(1−s)√N−1ΔE(s)N, cosθs=−1ΔE(s)[1−2(1−s)N−1N], ΔE(s)=√1−4s(1−s)N−1N.

We note that is the energy gap between the ground and first-excited states and that the gap closes at in the infinite-size limit.

Now we show that our conjecture is correct for the adiabatic Grover algorithm. Because the algorithm uses only the ground states, we investigate Corollary of Conjecture. We choose the set in our conjecture as the collection of all the instances: . Then we take the family of states as the ground states at fixed :

 Missing or unrecognized delimiter for \bigr

To , it is sufficient to find one additive observable whose fluctuation is macroscopically large. We here choose as the additive observable (this choice is the same as that in Ref. Shimizu et al. (2013) for the circuit-based Grover algorithm).

By using Eqs. (6) and (5), we can calculate the expectation values of and for as

 ⟨ψ0n,w∗(s)|^Mx|ψ0n,w∗(s)⟩ =b2sn+2asbsn√N, ⟨ψ0n,w∗(s)|^M2x|ψ0n,w∗(s)⟩ =b2sn2+a2sn+2asbsn2√N.

We thus obtain the fluctuation as

 ⟨ψ0n,w∗(s)|Δ^M2x|ψ0n,w∗(s)⟩ (7) =b2s(1−b2s)n2+a2sn+2asbs(1−2b2s)n2√N−4a2sb2sn2N.

It is possible only for the first term to be . We can evaluate the prefactor of this term as

 b2s(1−b2s)={1/4+O(N−1)s=1/2O(N−1)s≠1/2. (8)

Equations (7) and (8) lead to the result that for the family at the gap closing point for every instance. We thus conclude that Corollary of Conjecture is correct for the adiabatic Grover algorithm.

We may understand this result as follows. As shown in Eq. (6), the ground state can be expressed as a superposition of the two states, and . These two states are macroscopically distinct because and . For large , the amplitudes, and , in Eq. (6) are approximated within errors of as

 as≃⎧⎪⎨⎪⎩0s<1/21/√2s=1/21s>1/2

and . This indicates that a transition between the macroscopically distinct states (from the initial state to the final state ) occurs at the gap closing point () and that the superposition of these states appears at the transition point.

The Deutsch–Jozsa algorithm is a quantum algorithm to solve the following problem Nielsen and Chuang (2000); Mermin (2007); Deutsch and Jozsa (1992). The input of the problem is a function of -bit strings, . The function is promised to be either constant or balanced: is constant if for any or if for any , whereas is balanced if for in a half of and for in the other half. The problem is to judge which type a given function is. An instance of the problem for fixed is identified with —we therefore use instead of .

The original Deutsch–Jozsa algorithm was proposed in the circuit-based quantum computation Deutsch and Jozsa (1992). It was shown that the quantum algorithm solves the problem in a single query of , i.e., its computational time is Cleve et al. (1998). Note that, however, a classical bounded-error probabilistic algorithm can also solve the problem in -independent times of -queries (although classical deterministic algorithms requires computational time). Hence, the Deutsch–Jozsa algorithm does not achieve the quantum speedup.

AQC versions of the algorithm were proposed in Refs. Sarandy and Lidar (2005); Wei and Ying (2006). In these algorithms the energy gap is between the ground and first-excited states of . From this, it follows that they require computational time to satisfy the adiabatic condition. This also implies that they use only the ground states.

We investigate whether Corollary of Conjecture is correct in this problem. We here focus on the algorithm proposed in Ref. Wei and Ying (2006). As we show below, only states with appear in this algorithm. This implies that the contrapositive of our conjecture is correct for this algorithm: if states with never appear during the computation, the algorithm will not achieve the quantum speedup.

For the adiabatic Deutsch–Jozsa algorithm in Ref. Wei and Ying (2006), the driver Hamiltonian is the same as that of the adiabatic Grover algorithm, Eq. (4) with in Eq. (5). The problem Hamiltonian is , where the final state is chosen as

 |βf⟩ =μf√N/2N/2−1∑w′=0|2w′⟩+1−μf√N/2N/2−1∑w′=0|2w′+1⟩, (9) μf Unknown environment '%

with . The above equation means that is the uniform superposition of all the even (odd) index states in the computational basis if is constant (balanced)—hence we can get an answer by measuring the final state in the computational basis. We note that only a particular single qubit, say the first qubit (), has the information on whether a state in the computational basis is an even index state or odd one. Hence we can rewrite Eq. (9) as

 |βf⟩ =[μf|0⟩1+(1−μf)|1⟩1]⊗1√N/2N/2−1∑w′=0|w′⟩ =[μf|0⟩1+(1−μf)|1⟩1]n⨂l=2|+⟩l. (10)

We can easily show that the ground state of lies in the subspace spanned by and . We thus obtain the ground state as

 |ψ0n,f(s)⟩=sinθs2|βf⟩+cosθs2|β⊥f⟩, (11)

where

 |β⊥f⟩=√2|φ⟩−|βf⟩. (12)

The concrete form of is not important here. By substituting Eqs. (12), (10), and (5) into Eq. (11), we obtain

 |ψ0n,f(s)⟩=[c0,f(s)|0⟩1+c1,f(s)|1⟩1]n⨂l=2|+⟩l, (13)

where , and . Therefore the ground state at any is a product state for every instance.

This result means that for the family of the ground states at any and for any set of instances, since (any families of) product states have Shimizu et al. (2013). We therefore conclude that the contrapositive of our conjecture is correct for the adiabatic Deutsch–Jozsa algorithm.

The Bernstein–Vazirani algorithm is a quantum algorithm to solve the following problem Bernstein and Vazirani (1997); Mermin (2007). The input of the problem is a function of -bit strings, , which is given by the bitwise inner product with a hidden -bit string modulo 2:

 fa(w)=(n∑l=1alwl)  mod 2,

where () is the th-bit value of (). The task is to find the value of . An instance of the problem for fixed is identified with —we therefore use instead of .

The original Bernstein–Vazirani algorithm was proposed in a context of quantum Turing machine Bernstein and Vazirani (1997). It was shown that the quantum algorithm solves the problem in queries of while classical algorithms require queries—hence the polynomial quantum speedup is achieved.

An AQC version of the algorithm was proposed in Ref Hen (2014b). It was shown that this algorithm requires computational time, so that it also achieves the polynomial quantum speedup.

Before investigating our conjecture, we briefly review this adiabatic algorithm. This algorithm uses a system of qubits for instances of size . The problem Hamiltonian is given by

 ^Hp(n,a)=12N−1∑w=0|w⟩⟨w|⊗[^1+(−1)fa(w)^σz(n+1)],

where . And the driver Hamiltonian is given by

 ^Hd(n) Missing or unrecognized delimiter for \bigl

Obviously, the ground states are -fold degenerate for both and . We choose the initial state as the following one of the degenerate ground states of :

 |ψ0n,a(0)⟩=n+1⨂l=1|+⟩l. (14)

Then, after we slowly vary from to in of Eq. (1), we can adiabatically connect this initial state to the following one of the ground states of :

 |ψ0n,a(1)⟩=1√NN−1∑w=0|w⟩⊗|fa(w)⟩n+1. (15)

The time needed for this adiabatic evolution is because the energy gap between the ground states and the first excited states is independent of Hen (2014b). We then measure on . We obtain the outcome of with probability to have a post-measurement state,

 |ψ−n,a⟩=n⨂l=1(|0⟩l+(−1)al|1⟩l)⊗|−⟩n+1. (16)

Since this state corresponds to the configuration of in the basis, we obtain the solution by performing a measurement of on this state. In -independent runs of this procedure, we can make exponentially small the probability to fail to obtain in the measurement of . Therefore the computational time of this adiabatic algorithm is .

Now we show that our conjecture is correct for this algorithm. We take the set as the collection of all the instances: . Then we find that for the family of the states at the end of the adiabatic evolution:

 FH={|ψ0n,a(1)⟩}(n,a)∈H, (17)

where is given by Eq. (15). In the following, we show this result by using the method of the VCM (described in Sec. II.3).

To this end, we first note the following exact equality for the maximum eigenvalue of the VCM for :

 emax(n,a)=⎧⎨⎩2a=01+n∑l=1al1≤a≤N−1. (18)

See Appendix A for the derivation of this equality. Next, suppose that is randomly chosen from according to the uniform distribution. Then, Eq. (18) implies that follows the binomial distribution . For large , because is well approximated by the normal distribution , holds for almost every instance. This leads to for the states in of Eq. (17) (for rigorous estimation, see Appendix C). We thus show that and for . Therefore, we conclude that Corollary of Conjecture is correct for the adiabatic Bernstein–Vazirani algorithm.

We may understand this result as follows. As shown in Appendix A, we can rewrite as

 |ψ0n,a(1)⟩=1√2(|ψ0n,a(0)⟩+|ψ−n,a⟩), (19)

where is the initial state [Eq. (14)] and is the configuration of the solution [Eq. (16)]. We note that both and are eigenstates of an additive operator and the difference of their eigenvalues is . Since as argued above, These two states are macroscopically distinct for almost every . Equation (19) indicates that is a superposition of these two states.

The Simon algorithm is a quantum algorithm of solving the following problem Simon (1997); Mermin (2007). The input of the problem is a function of -bit strings, , which is characterized by a hidden -bit string . The function is promised to satisfy if and only if (except for the trivial case of ), where the symbol is the bitwise-xor operation. The task is to find the value of . An instance of the problem for fixed is identified with —we therefore use instead of .

The original Simon algorithm was proposed in Ref. Simon (1997). It was shown that the quantum algorithm solve the problem in queries of while classical algorithms require exponentially many queries—hence the exponential quantum speedup is achieved.

An AQC version of the algorithm was proposed in Ref. Hen (2014b). It was shown that this algorithm also achieves the exponential quantum speedup.

Before investigating our conjecture, we briefly review this adiabatic algorithm. This algorithm uses a composite system of two subsystems—for instances of size , the first subsystem consists of qubits and the second consists of qubits. The problem Hamiltonian is given by

 ^Hp(n,a)=12N−1∑w=0|w⟩⟨w|⊗n−1∑l2=1[^1+(−1)gl2(w)^σz(l2)],

where , and is the th-bit value of . The driver Hamiltonian is given by

 ^Hd(n) =12⎛⎝n⨂l1=1^1⎞⎠⊗n−1∑l2=1[^1−^σx(l2)].

The ground states are -fold degenerate for both and . Similarly to the case of the adiabatic Bernstein–Vazirani algorithm, we choose the initial state as the following one of the degenerate ground states of : . Then, by slowly varying from to in of Eq. (1), we can adiabatically connect this initial state to the following one of the ground states of : . The time needed for this adiabatic evolution is because the energy gap between the ground states and the first excited states is independent of Hen (2014b). After the adiabatic evolution, we perform the computational-basis measurement of the second subsystem. We obtain an outcome to have a post-measurement state,

 |ψn,a,w∗⟩=1√2(|w∗⟩+|w∗⊕a⟩)⊗|g(w∗)⟩. (20)

We subsequently perform the -basis measurement of the first subsystem to obtain an outcome , which is orthogonal to in the bitwise inner product modulo 2.

In the algorithm we perform runs of the above procedure (initial-state preparation, adiabatic evolution, and two measurements). Then, almost certainly we will obtain sufficient information to determine the value of . Because the computational time in a single run is , overall time of the algorithm is —thus it achieves the exponential quantum speedup.

Now we show that our conjecture is correct for this algorithm. We investigate Conjecture since it uses not only the ground states but also the post-measurement states. We take the set as the collection of all the instances: . Then we find that for the family of the post-measurement states:

 FH={|ψn,a,w∗⟩}(n,a)∈H, (21)

where is given by Eq. (20), and (determined by a random outcome) is arbitrary in . In the following, we show this result by using the method of the VCM (described in Sec. II.3).

To this end, we note the following exact equality for the maximum eigenvalue of the VCM for :

 emax(n,a)=⎧⎪⎨⎪⎩2a=2l−1 (l=1,2,...,n)n∑l=1alotherwise. (22)

This holds independently of . (Note that the case of is not included in Simon’s problem.) See Appendix B for the derivation of Eq. (22). Hence, in the same way as in Sec. IV.3, we can show that follows the binomial distribution and that for large , holds for almost every instance. This leads to for the states in of Eq. (21) (for rigorous estimation, see Appendix C). We thus show that and for . Therefore, we conclude that our conjecture is correct for the adiabatic Simon algorithm.

We may understand this result as follows. Equation (20) indicates that is a superposition of and . These two states are eigenstates of an additive operator , and the difference of their eigenvalues is . Since as argued above, and are macroscopically distinct for almost every . Therefore, is a superposition of these two macroscopically distinct states.

### iv.5 Glued-trees problem

The glued-trees problem is as follows Somma et al. (2012); Childs et al. (2003). We consider two perfect binary trees of height , as shown in Fig. 1. The total number of the vertices is . Each vertex has a unique name randomly chosen from -bit strings—this implies that the number of possible names is and is much larger than . The trees are randomly glued: the leaves are connected by a random cycle that alternates between the leaves of the two trees. We are given an oracle that outputs the names of the adjacent vertices on any input vertex name. Then the problem is, given the name of the left root, to find the name of the right root. An instance (denoted by ) for fixed is identified with a random cycle and a list of random names.

This problem was proposed in Ref. Childs et al. (2003) in a context of quantum walk. It was shown that a quantum-walk algorithm solves it in polynomial computational time, while classical algorithms require at least subexponential number of oracle calls. Hence the quantum algorithm achieves the exponential quantum speedup.

An AQC version of the algorithm was proposed in Ref. Somma et al. (2012). It was shown that this adiabatic algorithm also achieves the exponential quantum speedup.

Before investigating our conjecture in this algorithm, we briefly review it. This algorithm uses a system of qubits for instances of problem size to express vertex names of -bit strings. The total Hamiltonian is different from that in Eq. (1). It is composed of three Hamiltonians:

 ^H(s;n,ν)=(1−s)α^Hini+sα^Hfin−s(1−s)^Hora, (23)

where the parameter is a constant satisfying . In the below, we define individual Hamiltonians.

Let be the name of a vertex . We define the initial and final Hamiltonians respectively as and . Here, and represent the left and right roots, respectively. To define the oracle Hamiltonian , we consider the following orthonormal states: