Period Finding with Adiabatic Quantum Computation*hen/Aspen_Mar14.pdf · Itay Hen Aspen Winter Conference: March 13, 2014 ... speedup over probabilistic classical algorithms

Itay Hen March 13, 2014 Aspen Winter Conference:

Itay Hen Information Sciences Institute, USC

Aspen Winter Conference: Advances in Quantum Algorithms and Computation

March 13, 2014

Period Finding with Adiabatic Quantum Computation*

arXiv preprint: 1307.6538, 1401.5172


polynomial equivalence [Aharonov et al., 2004/7, Mizel et al., 2005] is suboptimal and somewhat artificial.

Grover [Roland and Cerf, 2002] and extensions [IH, 2012] (although it is unclear how to construct the driver Hamiltonian of the Roland and Cerf algorithm).

any other algorithms?

Motivation

What can we do optimally with Adiabatic Quantum Computation?


controlled adiabatic evolution

the Bernstein-Vazirani problem in AQC

Simon’s period finding problem in AQC

conclusions and outlook

Outline


Controlled Adiabatic Evolution


𝐻𝐻� 𝑡𝑡 = 1 − 𝑠𝑠 𝑡𝑡 𝐻𝐻�(𝑏𝑏) + 𝑠𝑠(𝑡𝑡)𝐻𝐻�(𝑓𝑓)

𝐻𝐻�(𝑓𝑓) is the final “problem” Hamiltonian whose ground state encodes the

solution to a given problem

𝐻𝐻�(𝑏𝑏) is an easily solvable beginning Hamiltonian, which does not commute with 𝐻𝐻�(𝑓𝑓)

the Hamiltonian of the usual QAA scheme has the form:

The quantum adiabatic algorithm (QAA)

the parameter 𝑠𝑠 obeys 0 ≤ 𝑠𝑠 𝑡𝑡 ≤ 1, with 𝑠𝑠 0 = 0 and 𝑠𝑠 𝒯𝒯 = 1. also: 𝐻𝐻� 0 = 𝐻𝐻�(𝑏𝑏) and 𝐻𝐻� 𝒯𝒯 = 𝐻𝐻�(𝑓𝑓).

here, 𝑡𝑡 stands for time and 𝒯𝒯 is the running time, or complexity, of the algorithm.


the adiabatic theorem ensures that if the change in 𝑠𝑠 𝑡𝑡 is slow enough, the system will stay close to the ground state of the instantaneous Hamiltonian throughout the evolution.

a measurement at the end of the evolution, will give the solution of the original problem with high probability.

runtime should obey:

The quantum adiabatic algorithm (QAA)

𝐻𝐻� 𝑡𝑡 = 1 − 𝑠𝑠 𝑡𝑡 𝐻𝐻�(𝑏𝑏) + 𝑠𝑠(𝑡𝑡)𝐻𝐻�(𝑓𝑓)

the Hamiltonian of the usual QAA scheme has the form:

𝒯𝒯 ≫𝑚𝑚𝑚𝑚𝑚𝑚𝑠𝑠 0|𝑑𝑑𝐻𝐻�/𝑑𝑑𝑠𝑠|1

𝑚𝑚𝑚𝑚𝑚𝑚𝑠𝑠 𝑔𝑔𝑚𝑚𝑔𝑔2


consider several quantum adiabatic evolutions

running in parallel. described by the bipartite system:

Controlled adiabatic evolution

𝐻𝐻�𝑤𝑤 𝑡𝑡 = 1 − 𝑠𝑠 𝑡𝑡 𝐻𝐻�(𝑏𝑏) + 𝑠𝑠(𝑡𝑡)𝐻𝐻�𝑤𝑤(𝑓𝑓)

𝐻𝐻� 𝑡𝑡 = � 𝑤𝑤⟩⟨𝑤𝑤 ⨂𝐻𝐻�𝑤𝑤 𝑡𝑡𝑤𝑤

the set { 𝑤𝑤⟩⟨𝑤𝑤 } is a complete set of orthogonal 1D projection operators onto the |𝑤𝑤⟩ subspaces.

here, all beginning Hamiltonians are the same (𝐻𝐻�(𝑏𝑏)) but final Hamiltonians (𝐻𝐻�𝑤𝑤

(𝑓𝑓)) are in general different.

e.g., 𝐻𝐻�1 𝑡𝑡 0 0

0 𝐻𝐻�2 𝑡𝑡 00 0 𝐻𝐻�3 𝑡𝑡


total beginning Hamiltonian is:

Controlled adiabatic evolution

the state in the first subsystem determines which 𝐻𝐻�𝑤𝑤 𝑡𝑡 will act. in general:

𝐻𝐻� 𝑡𝑡 = 0 = � 𝑤𝑤⟩⟨𝑤𝑤 ⨂𝐻𝐻�𝑤𝑤 𝑡𝑡 = 0𝑤𝑤

= 1⨂𝐻𝐻�(𝑏𝑏)

so ground state of total beginning Hamiltonian is any:

|𝜓𝜓𝑏𝑏⟩ = �𝑐𝑐𝑤𝑤|𝑤𝑤⟩𝑤𝑤

⨂|𝑔𝑔𝑠𝑠𝑏𝑏⟩

|𝜓𝜓𝑓𝑓� = �𝑐𝑐𝑤𝑤|𝑤𝑤⟩𝑤𝑤

⨂|𝑔𝑔𝑠𝑠𝑤𝑤⟩

e.g., |𝑔𝑔𝑠𝑠𝑏𝑏⟩|𝑔𝑔𝑠𝑠𝑏𝑏⟩|𝑔𝑔𝑠𝑠𝑏𝑏⟩

e.g., |𝑔𝑔𝑠𝑠1⟩|𝑔𝑔𝑠𝑠2⟩|𝑔𝑔𝑠𝑠3⟩


The Bernstein-Vazirani problem in AQC


the BV problem was the first to show quantum (polynomial) speedup over probabilistic classical algorithms.

the problem is: given an oracle function of the integer 𝑤𝑤:

find the integer 𝑚𝑚.

here, 𝑚𝑚𝑘𝑘 and 𝑤𝑤𝑘𝑘 are the bits of the 𝑚𝑚-bit input 𝑤𝑤 and the 𝑚𝑚-bit unknown integer 𝑚𝑚.

The Bernstein-Vazirani problem

𝑓𝑓 𝑤𝑤 = 𝑚𝑚 ⋅ 𝑤𝑤 𝑚𝑚𝑚𝑚𝑑𝑑 2 = �𝑚𝑚𝑘𝑘𝑤𝑤𝑘𝑘 𝑚𝑚𝑚𝑚𝑑𝑑 2𝑛𝑛−1

𝑘𝑘=0


given the oracle function:

how can we find 𝑚𝑚?

classically: it takes 𝑂𝑂(𝑚𝑚) queries. e.g., call 𝑓𝑓(∙) with 𝑤𝑤 = 2𝑗𝑗 for 𝑗𝑗 = 0. .𝑚𝑚 − 1.

quantum gate (circuit) model requires 𝑂𝑂(1) calls. how about AQC?


𝑓𝑓 2𝑗𝑗 = 𝑚𝑚𝑗𝑗

𝑓𝑓 𝑤𝑤 = 𝑚𝑚 ⋅ 𝑤𝑤 𝑚𝑚𝑚𝑚𝑑𝑑 2 = �𝑚𝑚𝑘𝑘𝑤𝑤𝑘𝑘 𝑚𝑚𝑚𝑚𝑑𝑑 2𝑛𝑛−1

𝑘𝑘=0


to solve with AQC, we first need to set up a quantum oracle.

in gate model, oracle is unitary. in AQC it is hermitian:

this is an (𝑚𝑚 + 1)-bit hermitian operator. first subsystem contains 𝑚𝑚 bits. second subsystem has 1 bit.

acting with 𝐻𝐻�(𝑓𝑓) on a classical state |𝑤𝑤⟩⨂|0⟩, we get energy 0 if indeed 𝑓𝑓(𝑤𝑤) = 0 and energy 1 otherwise.

the ground states are therefore |𝑤𝑤⟩⨂|𝑓𝑓(𝑤𝑤)⟩ with energy 0 (half of the states are ground states).


𝐻𝐻�(𝑓𝑓) =12 � 𝑤𝑤⟩⟨𝑤𝑤 ⨂ 1 − (−1)𝑓𝑓(𝑤𝑤)𝜎𝜎𝑧𝑧𝑤𝑤∈ 0,1 𝑛𝑛


to solve with AQC, we first need to set up a quantum oracle.

in gate model, oracle is unitary. in AQC it is hermitian:

this is an (𝑚𝑚 + 1)-bit hermitian operator. first subsystem contains 𝑚𝑚 bits. second subspace has 1 bit.

act with 𝐻𝐻�(𝑝𝑝) on a classical state |𝑤𝑤⟩⨂|0⟩, you get energy 0 if indeed 𝑓𝑓(𝑤𝑤) = 0 and energy 1 otherwise.

the ground states are therefore |𝑤𝑤⟩⨂|𝑓𝑓(𝑤𝑤)⟩ with energy 0 (half of the states are ground states).


𝐻𝐻�(𝑓𝑓) =12 � 𝑤𝑤⟩⟨𝑤𝑤 ⨂ 1 − (−1)𝑓𝑓(𝑤𝑤)𝜎𝜎𝑧𝑧𝑤𝑤∈ 0,1 𝑛𝑛

1 00 0 0 0

0 ⋱ 00 0 0 0

0 1

if f w = 0 then 0 00 1 with g.s. |0⟩

if f w = 1 then 1 00 0 with g.s. |1⟩


for the beginning Hamiltonian, we choose the simple:

clearly the beginning Hamiltonian has a degenerate ground state. we will choose the initial state to be the easily-preparable:

here, | +⟩ = 12

|0⟩ + |1⟩ ⨂ is the state in which all spins in the subsystem are pointing in the positive 𝑚𝑚�-direction.


|𝜓𝜓𝑏𝑏⟩ =12𝑛𝑛

� |𝑤𝑤⟩⨂| +⟩𝑤𝑤∈ 0,1 𝑛𝑛

= | +⟩⨂| +⟩

𝐻𝐻�(𝑏𝑏) = −1�⨂𝜎𝜎𝑥𝑥 = − ∑ 𝑤𝑤⟩⟨𝑤𝑤 ⨂𝜎𝜎𝑥𝑥𝑤𝑤∈ 0,1 𝑛𝑛


for the beginning Hamiltonian, we choose the simple:

clearly the beginning Hamiltonian has a degenerate ground state. we will choose the initial state to be the easily-preparable

here, | +⟩ = 12

|0⟩ + |1⟩ ⨂ is the state in which all spins in the subsystem are pointing in the positive 𝑚𝑚�-direction.


𝐻𝐻�(𝑏𝑏) = −1�⨂𝜎𝜎𝑥𝑥 = − ∑ 𝑤𝑤⟩⟨𝑤𝑤 ⨂𝜎𝜎𝑥𝑥𝑤𝑤∈ 0,1 𝑛𝑛


� |𝑤𝑤⟩⨂| +⟩𝑤𝑤∈ 0,1 𝑛𝑛

= | +⟩⨂| +⟩ −

0 11 0 0 0

0 ⋱ 00 0 0 1

1 0


the total Hamiltonian becomes:

the trick is that for each |𝑤𝑤⟩ in the 1st subsystem, states in the 2nd subsystem tunnel adiabatically in a trivial manner from the initial | +⟩ to the ground state, be it |0⟩ or |1⟩.

most importantly, to reach the ground state, the runtime does not depend on the number of qubits 𝑚𝑚. it is 𝑂𝑂(1).

the end state is:


𝐻𝐻� = � 𝑤𝑤⟩⟨𝑤𝑤 ⨂ − 1 − 𝑠𝑠 𝜎𝜎𝑥𝑥 +𝑠𝑠2

(1 − (−1)𝑓𝑓(𝑤𝑤)𝜎𝜎𝑧𝑧)𝑤𝑤∈ 0,1 𝑛𝑛

|𝜓𝜓𝑓𝑓� =12𝑛𝑛

� |𝑤𝑤⟩⨂|𝑓𝑓(𝑤𝑤)⟩𝑤𝑤∈ 0,1 𝑛𝑛


the total Hamiltonian becomes:

the trick is that for each |𝑤𝑤⟩ in the 1st subsystem, states in the 2nd subsystem tunnel adiabatically in a trivial manner from the initial | +⟩ to the ground state, be it |0⟩ or |1⟩.

most importantly, to reach the ground state, the runtime does not depend on the number of qubits 𝑚𝑚. it is 𝑂𝑂(1).

the end state is:


𝐻𝐻� = � 𝑤𝑤⟩⟨𝑤𝑤 ⨂ − 1 − 𝑠𝑠 𝜎𝜎𝑥𝑥 +𝑠𝑠2

(1 − (−1)𝑓𝑓(𝑤𝑤)𝜎𝜎𝑧𝑧)𝑤𝑤∈ 0,1 𝑛𝑛

if 𝑓𝑓 w = 0 then |+⟩ → |0⟩ if 𝑓𝑓 w = 1 then |+⟩ → |1⟩ important to note: no relative phase between |0⟩’s and |1⟩’s.




noting that:


|𝑓𝑓(𝑤𝑤)⟩ =12

| +⟩+(−1)𝑓𝑓(𝑤𝑤)| −�

where |±⟩ = 12

|0⟩ ± |1⟩ are the 𝑚𝑚-basis up and down states,

the final state may be rewritten as:

|𝜓𝜓𝑓𝑓� =12

12𝑛𝑛

�|𝑤𝑤⟩⨂| +⟩𝑤𝑤

+

12𝑛𝑛

�(−1)𝑓𝑓(𝑤𝑤)|𝑤𝑤⟩⨂| −⟩𝑤𝑤

the initial state |𝜓𝜓𝑏𝑏⟩

something we can use!


an 𝑚𝑚-basis measurement of the 2nd subsystem qubit, would yield with 50% probability, the 1st subsystem in the state:

this state can be easily rewritten as:

i.e., an 𝑚𝑚-basis measurement of the 1st subsystem, would reveal, bit by bit the values of 𝑚𝑚𝑘𝑘.

with 50% probability, we end up with our initial state, and therefore must rerun algorithm. 𝑃𝑃𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓 = 2−(#𝑡𝑡𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑓𝑠𝑠).



�(−1)𝑓𝑓(𝑤𝑤)|𝑤𝑤⟩𝑤𝑤

|𝜓𝜓𝑓𝑓� =⊗𝑘𝑘=0𝑛𝑛−1 1

2|0⟩+(−1)𝑓𝑓𝑘𝑘|1⟩


(*) the end state of the Bernstein-Vazirani algorithm prior to the measurement is:




one of exponentially many ground states.

obtained via the use of parallel coherent evolutions, taking advantage of symmetry.

bears similarity to adiabatic Grover is that respect.

while certainly adiabatic, this is not traditional AQC.

is it still AQC?


Simon’s period finding problem in AQC


Simon’s problem is trickier to solve, but profit is gaining an exponential speedup over classical algorithms. also more important as it serves as the basis for Shor’s algorithm.

here, the oracle is a function from 𝑚𝑚 bits to (𝑚𝑚 − 1) bits:

here too 𝑚𝑚 ≠ 0 is again an unknown 𝑚𝑚-bit integer.

as with BV: goal is to find the “period” 𝑚𝑚.

Simon’s period-finding problem

𝑔𝑔: 0,1 𝑛𝑛 → 0,1 𝑛𝑛−1 𝑔𝑔(𝑚𝑚) = 𝑔𝑔(𝑦𝑦) iff y = 𝑚𝑚 ⊕ 𝑚𝑚 with


reminder of what ⨁ (XOR) is:

classically, to find the “XOR-mask” 𝑚𝑚, we need an exponential number of queries.

we must call the oracle until we get two inputs with same output. this is very unlikely (birthday paradox). problem is exponentially hard 𝑂𝑂(2𝑛𝑛/2) queries.

gate model requires 𝑂𝑂(𝑚𝑚) queries. exponential speedup.

Simon’s period-finding problem 𝑚𝑚 𝑚𝑚 𝑦𝑦

⊕ =


how about AQC?

same tricks as with BV problem. this time, the second subsystem has (𝑚𝑚 − 1) bits and the adiabatic oracle is:

here, the function 𝑑𝑑(∙,∙) computes the Hamming distance between 𝑦𝑦 and 𝑔𝑔(𝑤𝑤).

now the Hilbert space is that of 𝑚𝑚 bits (first subsystem) plus (𝑚𝑚 − 1) bits (second subsystem).

the ground states are |𝑤𝑤⟩⨂|𝑔𝑔(𝑤𝑤)⟩ with energy 0.


𝐻𝐻�(𝑓𝑓) = � � 𝑑𝑑(𝑦𝑦,𝑔𝑔 𝑤𝑤 ) 𝑤𝑤⟩⟨𝑤𝑤 ⨂ 𝑦𝑦⟩⟨𝑦𝑦𝑦𝑦∈ 0,1 𝑛𝑛−1𝑤𝑤∈ 0,1 𝑛𝑛


how about AQC?

same tricks as with BV problem. this time, the second subsystem has (𝑚𝑚 − 1) bits and the adiabatic oracle is:

here, the function 𝑑𝑑(∙,∙) computes the Hamming distance between 𝑦𝑦 and 𝑔𝑔(𝑤𝑤).

now the Hilbert space is that of 𝑚𝑚 bits (first subsystem) plus (𝑚𝑚 − 1) bits (second subsystem).

the ground states are |𝑤𝑤⟩⨂|𝑔𝑔(𝑤𝑤)⟩ with energy 0.


𝐻𝐻�(𝑓𝑓) = � � 𝑑𝑑(𝑦𝑦,𝑔𝑔 𝑤𝑤 ) 𝑤𝑤⟩⟨𝑤𝑤 ⨂ 𝑦𝑦⟩⟨𝑦𝑦𝑦𝑦∈ 0,1 𝑛𝑛−1𝑤𝑤∈ 0,1 𝑛𝑛

4 0 00 ⋱ 00 0 0

0 0

0 ⋱ 0

0 00 0 00 ⋱ 00 0 1


for the driver, we choose the simple Hamiltonian:


𝐻𝐻�(𝑏𝑏) = −1�⨂�𝜎𝜎𝑥𝑥𝑘𝑘𝑛𝑛−1

𝑘𝑘=1

= − � 𝑤𝑤⟩⟨𝑤𝑤 ⨂�𝜎𝜎𝑥𝑥𝑘𝑘𝑛𝑛−1

𝑘𝑘=1𝑤𝑤∈ 0,1 𝑛𝑛

clearly the driver is degenerate. we will choose the initial state to be the easily-preparable:

as before, here, | +⟩ is the state where all spins in the subsystem are pointing in the positive 𝑚𝑚-direction.


� |𝑤𝑤⟩⨂| +⟩𝑤𝑤∈ 0,1 𝑛𝑛

= | +⟩⨂| +⟩


(after some algebra) the total Hamiltonian becomes:

as with BV, for each |𝑤𝑤⟩ in the 1st subsystem, states in the 2nd subsystem tunnel adiabatically in a trivial manner from the initial | +⟩ to the ground states |0⟩ or |1⟩.

most importantly, to reach the ground state, the runtime does not depend on the number of qubits 𝑚𝑚, it is 𝑂𝑂(1).

the end state is:


𝐻𝐻� = � 𝑤𝑤⟩⟨𝑤𝑤 ⨂ � − 1 − 𝑠𝑠 𝜎𝜎𝑥𝑥𝑘𝑘 +

𝑠𝑠2

(1 − (−1)𝑔𝑔𝑘𝑘𝜎𝜎𝑧𝑧𝑘𝑘)𝑛𝑛−1

𝑘𝑘=1𝑤𝑤∈ 0,1 𝑛𝑛


� |𝑤𝑤⟩⨂|𝑔𝑔(𝑤𝑤)⟩𝑤𝑤∈ 0,1 𝑛𝑛


noting that:

a measurement of the second subsystem will pick out one |𝑔𝑔(𝑤𝑤∗)⟩ at random, leaving us with the state:


|𝜓𝜓𝑓𝑓�~∑ |𝑤𝑤⟩⨂|𝑔𝑔(𝑤𝑤)⟩𝑤𝑤∈ 0,1 𝑛𝑛 = =∑ |𝑤𝑤⟩ + |𝑤𝑤⨁𝑚𝑚⟩ ⨂|𝑔𝑔(𝑤𝑤)⟩𝑤𝑤∈ 0,1 𝑛𝑛/𝑔𝑔

|𝜓𝜓𝑤𝑤∗� =12

|𝑤𝑤∗⟩ + |𝑤𝑤∗ ⊕ 𝑚𝑚⟩ ⨂|𝑔𝑔(𝑤𝑤∗)⟩


rewriting the state of the 1st subsystem:

in the 𝑚𝑚-basis, we get (requires some algebra):

i.e., an equi-probable superposition of 𝑚𝑚-basis states, all of which are “orthogonal” to 𝑚𝑚.


|𝜓𝜓𝑤𝑤∗� =12

|𝑤𝑤∗⟩ + |𝑤𝑤∗ ⊕ 𝑚𝑚⟩

|𝜓𝜓𝑤𝑤∗� =1

2𝑛𝑛−1� −1 𝑤𝑤∗∙𝑥𝑥

𝑓𝑓∙𝑥𝑥=0

|𝑚𝑚⟩


a subsequent 𝑚𝑚-basis measurement of the first subsystem, will therefore give us a random state |𝑚𝑚⟩ such that:

repeating the algorithm ∼ 𝑚𝑚 times will generate a set of (𝑚𝑚 − 1) linearly-independent linear equations for 𝑚𝑚𝑘𝑘.

this set can be solved using Gaussian Elimination (𝑚𝑚𝑚𝑚𝑑𝑑 2).

the total (query) runtime of the algorithm (without taking into account solving the set of equations) is 𝑂𝑂(𝑚𝑚), as in the gate model.


∑ 𝑚𝑚𝑘𝑘𝑚𝑚𝑘𝑘 = 0 (𝑚𝑚𝑚𝑚𝑑𝑑 2)𝑛𝑛−1𝑘𝑘=0


Conclusions and outlook


adiabatic computations with no overhead are possible.

evidence in favor of AQC being as powerful as other quantum computing paradigms, specifically the gate model(?)

so far, we can show that several adiabatic/continuous-time algorithms can be “optimally” formulated:

• Grover, generalizations, quantum counting, deterministic Deutsch-Josza (not discussed).

• Bernstein-Vazirani and Simon’s period finding problems.

maybe even no-overhead adiabatic Shor’s algorithm?

can these algorithms be made fault-tolerant?

Conclusions and outlook


Itay Hen Information Sciences Institute, USC

Aspen Winter Conference: Advances in Quantum Algorithms and Computation

March 13, 2014

Period Finding with Adiabatic Quantum Computation*

arXiv preprint: 1307.6538, 1401.5172

Thank you!


Quantum Adiabatic Gates


can we utilize the above protocol?

consider the following simple case, where the initial state is:

a bipartite system consisting of two qubits.

the first is in an unknown state, written in some basis corresponding to 𝑚𝑚� where 𝑚𝑚� is a point on the Bloch sphere.

the second is an auxiliary qubit, initialized to the |0⟩ computational-basis state.

Quantum adiabatic gates

|𝜓𝜓𝑏𝑏⟩ = 𝛼𝛼|𝑚𝑚�⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩ ⨂|0⟩


under the Hamiltonian:

let us evolve the initial (ground) state:


|𝜓𝜓𝑏𝑏⟩ = 𝛼𝛼|𝑚𝑚�⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩ ⨂|0⟩

𝐻𝐻� 𝑡𝑡 = 𝑚𝑚�⟩⟨𝑚𝑚� ⨂ |0⟩ → |+⟩ + 𝑚𝑚�⊥⟩⟨𝑚𝑚�⊥ ⨂ |0⟩ → |+𝜑𝜑�

both adiabatic evolutions above are simple, independent and simultaneous.

each evolution has a constant gap. on surface of Bloch sphere.


under the Hamiltonian:

let us evolve the initial (ground) state:


|𝜓𝜓𝑏𝑏⟩ = 𝛼𝛼|𝑚𝑚�⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩ ⨂|0⟩

𝐻𝐻� 𝑡𝑡 = 𝑚𝑚�⟩⟨𝑚𝑚� ⨂ |0⟩ → |+⟩ + 𝑚𝑚�⊥⟩⟨𝑚𝑚�⊥ ⨂ |0⟩ → |+𝜑𝜑�

both adiabatic evolutions above are simple, independent and simultaneous.

each evolution has a constant gap. on surface of Bloch sphere.

−𝑐𝑐𝑚𝑚𝑠𝑠𝜃𝜃 𝑡𝑡 𝜎𝜎𝑧𝑧 − 𝑠𝑠𝑚𝑚𝑚𝑚𝜃𝜃 𝑡𝑡 𝜎𝜎𝑥𝑥 12

1 − 𝑚𝑚� ∙ 𝝈𝝈

12

1 + 𝑚𝑚� ∙ 𝝈𝝈

−𝑐𝑐𝑚𝑚𝑠𝑠𝜃𝜃 𝑡𝑡 𝜎𝜎𝑧𝑧 − 𝑠𝑠𝑚𝑚𝑚𝑚𝜃𝜃 𝑡𝑡 𝑐𝑐𝑚𝑚𝑠𝑠𝑐𝑐 𝜎𝜎𝑥𝑥 + 𝑠𝑠𝑚𝑚𝑚𝑚𝑐𝑐 𝜎𝜎𝑦𝑦


not hard to show that relative phase vanishes (crucially important).

could be inferred from symmetry considerations. both trajectories are equivalent.

also, we can look at the adiabatic phases:

same dynamic phase:

geometric phase vanishes on the surface of the Bloch sphere.


𝛾𝛾𝑑𝑑 = 𝑚𝑚 � 𝐸𝐸 𝑡𝑡 𝑑𝑑𝑡𝑡𝒯𝒯

0

𝛾𝛾𝑔𝑔 = � 𝜓𝜓 �̇�𝜓 𝑑𝑑𝑡𝑡𝒯𝒯

0= 0


becomes the final state:

where

initial state:

|𝜓𝜓𝑏𝑏⟩ = 𝛼𝛼|𝑚𝑚�⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩ ⨂|0⟩

|𝜓𝜓𝑓𝑓� = 𝛼𝛼|𝑚𝑚�⟩⨂|+⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩⨂|+𝜑𝜑�

|+⟩ =12

0⟩ + 1⟩

|+𝜑𝜑� =12

0⟩ + 𝑒𝑒𝑓𝑓𝜑𝜑 1⟩



may be rewritten as the sum:

final state:

|𝜓𝜓𝑓𝑓� = 𝛼𝛼|𝑚𝑚�⟩⨂|+⟩ + 𝛽𝛽|𝑚𝑚�⊥⟩⨂|+𝜑𝜑�

|𝜓𝜓𝑓𝑓� =12𝛼𝛼 𝑚𝑚�⟩ + 𝛽𝛽 𝑚𝑚�⊥⟩ ⨂|0⟩

+12𝛼𝛼 𝑚𝑚�⟩ + 𝛽𝛽𝑒𝑒𝑓𝑓𝜑𝜑 𝑚𝑚�⊥⟩ ⨂|1⟩

initial state |𝜓𝜓𝑏𝑏⟩

rotated state

measurement of the second auxiliary qubit in the computational basis yields with equal probability either the initial state or a rotated state.

rotation is general: of an angle 𝑐𝑐 around axis 𝑚𝑚�.



application of the single-qubit rotation gate:

process can be made automatic (feedback loop).

probability of failure (to rotate) after one trial is 50%.

probability of failure after 𝑘𝑘 trials is 2−𝑘𝑘 (i.e., exponentially small). average number of trials required is 2.


run aforementioned

controlled adiabatic evolution

measure auxiliary

qubit

first qubit is in rotated state. we’re done.

first qubit is back in initial state.


where the first qubit is a control qubit.

under the evolution:

we could do the same with the following initial state:

|𝜓𝜓𝑏𝑏⟩ = 𝛼𝛼 0,𝑚𝑚�⟩ + 𝛽𝛽 0,𝑚𝑚�⊥⟩ + 𝛾𝛾 1,𝑚𝑚�⟩ + 𝛿𝛿 1,𝑚𝑚�⊥⟩ ⨂|0⟩

we end up with:

where:

Controlled-rotation adiabatic gates

𝐻𝐻� 𝑡𝑡 = 1⟩⟨1 ⨂ 𝑚𝑚�⊥⟩⟨𝑚𝑚�⊥ ⨂ |0⟩ → |+𝜑𝜑� + 0⟩⟨0 ⨂1 + 1⟩⟨1 ⨂ 𝑚𝑚�⟩⟨𝑚𝑚� ⨂ |0⟩ → |+⟩

|𝜓𝜓𝑓𝑓� =12

|𝜓𝜓𝑏𝑏⟩⨂|0⟩ + |𝜓𝜓𝑐𝑐.𝑓𝑓𝑟𝑟𝑡𝑡⟩⨂|1⟩

|𝜓𝜓𝑐𝑐.𝑓𝑓𝑟𝑟𝑡𝑡⟩ = 𝛼𝛼 0,𝑚𝑚�⟩ + 𝛽𝛽 0,𝑚𝑚�⊥⟩ + 𝛾𝛾 1,𝑚𝑚�⟩ + 𝛿𝛿𝑒𝑒𝑓𝑓𝜑𝜑 1,𝑚𝑚�⊥⟩


for example, the NOT gate is a rotation of 𝜋𝜋 around the 𝑚𝑚�-axis:

easily generalized to CNOT.

the Hadamard is a 𝜋𝜋/2 rotation around the 𝑦𝑦�-axis:



comments:

final Hamiltonian of gate is not diagonal in computational basis, but measurement is.

ground state is doubly-degenerate (because two systems evolve independently in parallel).

gap is kept constant (=2) by staying on Bloch sphere.

Hamiltonians are two-local (three-local for controlled gates).

the relative phase between the two evolving systems vanishes. this issue becomes important when discussing dephasing and noise.



Quantum adiabatic circuits


we have a universal set of gates.

a sequence of such gates may be used to form an “adiabatic circuit”.

final state of one gate serves as the initial state of the next gate.

one auxiliary qubit can be used for all gates in circuit if gates do not act at the same time.

since gap for each gate is constant, runtime of circuit is 𝑂𝑂(𝑚𝑚𝑛𝑛𝑚𝑚𝑛𝑛𝑒𝑒𝑛𝑛 𝑚𝑚𝑓𝑓 𝑔𝑔𝑚𝑚𝑡𝑡𝑒𝑒𝑠𝑠).

computation is driven by adiabatic evolution as well as by single-qubit computational-basis measurements.

Quantum adiabatic circuits


Conclusions and further comments


we can construct arbitrary quantum (and classical) circuits based only on adiabatic evolution and computational-basis measurements. but is this still AQC?

no resource overhead and no runtime overhead, when compared with usual gate model.

Hamiltonians are two- or three-local at most. can we reduce three-local gates to two-local gates? using gadgets maybe?

easy to construct Shor’s algorithm for example.

how robust is it? can it be made fault-tolerant? protocol, while adiabatic, is not the traditional one.

can we push all measurements to the end of the circuit?



need to understand advantages and disadvantages of scheme over usual gates in more realistic settings.

what happens when interactions with environment are considered?

adiabatic gates are better than non-adiabatic gates?

…


Documents

Period Finding with Adiabatic Quantum Computation*hen/Aspen_Mar14.pdf · Itay Hen Aspen Winter Conference: March 13, 2014 ... speedup over probabilistic classical algorithms