Brought to you by:
Paper

Grover search with lackadaisical quantum walks

Published 7 October 2015 © 2015 IOP Publishing Ltd
, , Citation Thomas G Wong 2015 J. Phys. A: Math. Theor. 48 435304 DOI 10.1088/1751-8113/48/43/435304

This article is corrected by 2018 J. Phys. A: Math. Theor. 51 069501

1751-8121/48/43/435304

Abstract

The lazy random walk, where the walker has some probability of staying put, is a useful tool in classical algorithms. We propose a quantum analogue, the lackadaisical quantum walk, where each vertex is given l self-loops, and we investigate its effects on Grover's algorithm when formulated as search for a marked vertex on the complete graph of N vertices. For the discrete-time quantum walk using the phase flip coin, adding a self-loop to each vertex boosts the success probability from 1/2 to 1. Additional self-loops, however, decrease the success probability. Using instead the Shenvi, Kempe, and Whaley (2003) coin, adding self-loops simply slows down the search. These coins also differ in that the first is faster than classical when l scales less than N, while the second requires that l scale less than N2. Finally, continuous-time quantum walks differ from both of these discrete-time examples—the self-loops make no difference at all. These behaviors generalize to multiple marked vertices.

Export citation and abstract BibTeX RIS

1. Introduction

Random walks, or Markov chains, are the basis for a variety of classical algorithms [1]. One typically wants the random walker to move readily, but there are some scenarios when it is desirable for the walker to be lazy, meaning it has some probability of staying put. For example, if a normal (non-lazy) random walker starts in one of the two vertex sets of a bipartite graph, then at each time step, the walker will only be in one vertex set. By making the walk lazy, however, the walker can have probability of being in both vertex sets, improving its coverage of the graph. Such lazy random walks equate to adding self-loops to the vertices of the graph with appropriate weight, and they have been utilized in a variety of classical algorithms, including pagerank [2], graph covering [3], and image processing [4].

Given the success of lazy random walks in the classical regime, we propose in this paper a quantum analogue called lackadaisical quantum walks, defined to be a standard quantum walk [57] on a graph with the addition of l self-loops to each vertex of the graph. So the greater l is, the more the walker prefers to stay put. Note this differs from the 'lazy' quantum walk proposed by [8], hence our choice of a different name. It also generalizes three-state lazy quantum walks on the line [912], which only have one self-loop at each vertex. Since there exist both discrete- and continuous-time varieties of quantum walks [7], we will consider both in our investigation of lackadaisical quantum walks.

In particular, we explore the addition of self-loops to one of the best-known problems in computing: unstructured search, whose famous quantum solution is Grover's algorithm [13]. To review, given a 'database' with entries $1,2,...,N,$ and an oracle f(x) that outputs 1 for a particular 'marked' entry w and 0 otherwise, a classical computer expects to query the oracle N/2 = Θ(N) times before finding w, since it could be the first guess or the last. In the quantum setting, $| 1\rangle ,| 2\rangle ,...,| N\rangle $ are computational basis states, and the oracle ${R}_{w}={(-1)}^{f(x)}$ acts by flipping the phase of a marked basis state $| w\rangle $ while leaving the rest unchanged, i.e., ${R}_{w}| w\rangle =-| w\rangle $ and ${R}_{w}| x\rangle =| x\rangle ,$ $\forall x\ne w.$ This reflection through $| w\rangle $ can be written as ${R}_{w}=I-2| w\rangle \langle w| .$ Grover's algorithm [13] finds $| w\rangle $ in only ${\rm{\Theta }}(\sqrt{N})$ queries, which is a quadratic speedup over the classical Θ(N), and it does so by initializing the system in an equal superposition

over the basis states and repeatedly applying

Equation (1)

where ${R}_{{s}^{\perp }}=2| s\rangle \langle s| -I$ is a reflection through $| {s}^{\perp }\rangle .$ Applying these two reflections $\pi \sqrt{N}/4$ times, the state is rotated from $| s\rangle $ to $| w\rangle $ with probability near 1.

As a graph problem, we formulate this unstructured search problem as search on the complete graph of N vertices for a particular marked vertex, an example of which is shown in figure 1(a). Since each vertex is connected to every other, there is no structure demanding an order to which we visit the vertices. Thus a classical random walk that jumps from vertex to vertex, checking at each step if it has found w, expects to make Θ(N) such steps and checks to find the marked vertex. A quantum walk, on the other hand, searches in Grover's ${\rm{\Theta }}(\sqrt{N}),$ and we explicitly show this in the next two sections in both discrete and continuous time [14]. Then we add l self-loops to each vertex, as shown in figure 1(b), and show how the lackadaisical walk affects the search algorithms. For the discrete-time quantum walk, we get an improvement in the success probability of the algorithm with a particular 'coin' with l = 1. Additional self-loops, or search with a different coin, hurt the algorithm. The continuous-time algorithm, on the other hand, is not affected by the self-loops at all. Finally, we generalize the results to multiple marked vertices.

Figure 1.

Figure 1. (a) The complete graph with N = 6 vertices. A vertex is marked, as indicated by a double circle. Identically evolving vertices are identically colored and labeled, and the labels indicate the subspace basis vectors that the vertices belong to. (b) With l self-loops at each vertex.

Standard image High-resolution image

2. Grover's algorithm as a discrete-time quantum walk

We begin by analyzing quantum walk search on the complete graph with no self-loops, in discrete-time in this section and continuous-time in the next. For both discrete- and continuous-time quantum walks, the quantum walker jumps from vertex to vertex, and the vertices of the graph label computational basis states of an N-dimensional 'vertex' Hilbert space ${{\mathbb{C}}}^{N}.$ For discrete-time quantum walks, however, this is insufficient to define a local unitary operator [15, 16], so we necessarily include an additional d-dimensional 'coin' Hilbert space ${{\mathbb{C}}}^{d}$ supported by the directions/edges that the particle can jump along from each vertex. For the complete graph, each vertex is connected to the other N − 1 vertices, so d = N − 1. Let $| {s}_{v}\rangle $ and $| {s}_{c}\rangle $ be equal superpositions over each space:

Then the system $| \psi \rangle $ begins in the equal superposition over the entire ${{\mathbb{C}}}^{N}\otimes {{\mathbb{C}}}^{d}$ Hilbert space:

The quantum walk is defined by repeated applications of

where C0 is the 'Grover diffusion' coin [17]

and S is the 'flip-flop' shift [18] that causes a particle to hop and then turn around, e.g., a particle at vertex 1 that points towards vertex 2 will, after an application of S, be at vertex 2 and point towards vertex 1: $S(| 1\rangle \otimes | 1\to 2\rangle )=| 2\rangle \otimes | 2\to 1\rangle $. Note that $| {\psi }_{0}\rangle $ is the equilibrium distribution of this walk, so ${U}_{0}| {\psi }_{0}\rangle =| {\psi }_{0}\rangle $.

To turn this into a search algorithm, we apply a different coin C1 to the marked vertex and still use C0 on the unmarked vertices [17], so the search operator is

Equation (2)

Two choices for C1 are common [18]. The first is ${C}_{1}^{{\rm{flip}}}=-{C}_{0}$, which causes U to become

Equation (3)

Note Rw is the phase flip in Grover's algorithm, so this applies a phase flip to the marked vertex followed by a step of the quantum walk. The second common choice for ${C}_{1}\;\mathrm{is}\;{C}_{1}^{{\rm{SKW}}}=-{I}_{d}$, which was first introduced by Shenvi et al [17] to solve search on the hypercube, and later used by Ambainis et al [18] to solve search on arbitrary dimensional periodic square lattices.

With either of these coins, the system evolves such that there are only two types of vertices, as shown in figure 1(a). In particular, the marked red a vertex evolves differently from the identically evolving unmarked white b vertices. Since the a vertex can only point towards b vertices, and the b vertices can either point towards the a vertex or other b vertices, the system evolves in a 3D subspace, and we take equal superpositions of these vertices/directions as the basis vectors:

In this $\{| {ab}\rangle ,| {ba}\rangle ,| {bb}\rangle \}$ basis, the initial state is

In general, the search operator (2) is different for ${C}_{1}^{{\rm{flip}}}\;\mathrm{and}\;{C}_{1}^{{\rm{SKW}}}$. But for the complete graph, they are identical; with either coin, the search operator is

Equation (4)

where

Repeatedly applying this operator to the initial state, the success probability evolves as shown in figure 2 for N = 1024 and 2048 vertices. We see that the success probability reaches 1/2, and the runtime (i.e., number of applications of U to reach the maximum success probability) scales less than linear (i.e., classical) since doubling N results in a runtime that is less than double. In particular, we expect it to scale as ${\rm{\Theta }}(\sqrt{N})$ to be a formulation of Grover's algorithm.

Figure 2.

Figure 2. Success probability as a function of the number of discrete-time applications of U (with either the ${C}_{1}^{{\rm{flip}}}\;\mathrm{or}\;{C}_{1}^{{\rm{SKW}}}$ coins) for search on the complete graph with N = 1024 (solid black) and 2048 (dashed red) vertices.

Standard image High-resolution image

To prove this behavior and find the precise runtime, we first find the eigenvectors and eigenvalues of U. They are

where ϕ is defined such that

Now we express the initial state in terms of the eigenvectors of U. Consider

For large $N,\mathrm{sin}\theta \approx 2/\sqrt{N}$ implies that $\theta \approx 2/\sqrt{N}$, so the first two components of this are

which means the last term dominates for large N. That is

Since $| {\psi }_{0}\rangle \approx | {bb}\rangle $, the system after t applications of U is

When ϕt = π/2, i.e.

the state of the system is approximately

So the system roughly evolves from $| {bb}\rangle $ to being half in $| {ab}\rangle $ and half in $| {ba}\rangle $, which from the $| {ab}\rangle $ component gives a success probability of $1/2$. This agrees with figure 2; the success probability reaches $1/2\;\mathrm{after}\;\pi \sqrt{1024}/2\sqrt{2}\approx 36\;\mathrm{and}\;\pi \sqrt{2048}/2\sqrt{2}\approx $ 50 applications of U. Repeating the algorithm an expected constant number of times to boost the success probability near 1, the algorithm still finds the marked vertex in ${\rm{\Theta }}(\sqrt{N})$ applications of U, which is the same scaling as Grover's algorithm.

This explicit proof that the success probability reaches $1/2\;\mathrm{in}\;\pi \sqrt{N}/2\sqrt{2}$ applications of U seems original, even though it is well-known that the success probability reaches 1 in continuous-time [14] (which we review next), or in discrete-time with one self-loop per vertex [18] (which we review later). Note that the first discrete-time quantum walk search algorithm [17] was search on the hypercube, not the complete graph.

3. Grover's algorithm as a continuous-time quantum walk

In continuous-time, quantum walk search on the complete graph with no self-loops (l = 0) was previously investigated by [14], and we review the results here. Continuous-time quantum walks do not require the coin space, so they walk in the N-dimensional Hilbert space ${{\mathbb{C}}}^{N}$ supported by the vertices of the graph. The system begins in the equal superposition over the vertices:

and evolves by Schrödinger's equation

with Hamiltonian

where γ is the jumping rate (i.e., amplitude per time), A is the adjacency matrix of the graph (${A}_{{ij}}=1\;\mathrm{if}\;i\;\mathrm{and}\;j$ are adjacent and 0 otherwise), and $| w\rangle $ is the marked vertex we are looking for. The first term effects a quantum walk [14] while the second term acts as an oracle [19], with γ setting their relative strength.

As shown in figure 1(a), there are only two types of vertices: the marked vertex and the unmarked vertices. So we take equal superpositions of them to be basis vectors of a 2D subspace:

In this $\{| a\rangle ,| b\rangle \}$ basis, the initial state is

and the Hamiltonian is

Equation (5)

When γ takes its critical value of $1/N$ [14, 20, 21], evolving by Schrödinger's equation with this Hamiltonian yields the success probability shown in figure 3. We see that it reaches a maximum value of 1, and the runtime (which should be Grover's ${\rm{\Theta }}(\sqrt{N})$) scales better than linear (classical) since doubling N less than doubles the runtime.

Figure 3.

Figure 3. Success probability as a function of time for continuous-time search on the complete graph with N = 1024 (solid black) and 2048 (dashed red) vertices, at the critical $\gamma =1/N$.

Standard image High-resolution image

To show this analytically, note that the eigenvectors of the Hamiltonian with $\gamma =1/N\;\mathrm{are}\;\left|{\psi }_{\pm }\right\rangle \propto | {s}_{v}\rangle \mp | a\rangle $ with corresponding eigenvalues ${E}_{\pm }=-1\pm 1/\sqrt{N}+1/N$. Then the initial state is $| \psi (0)\rangle =\left(\left|{\psi }_{+}\right\rangle +\left|{\psi }_{-}\right\rangle \right)/\sqrt{2}$, and the marked vertex is $| a\rangle =\left(-\left|{\psi }_{+}\right\rangle +\left|{\psi }_{-}\right\rangle \right)/\sqrt{2}$. Since the Hamiltonian is time-independent, solving Schrödinger's equation yields

where ${\rm{\Delta }}E={E}_{+}-{E}_{-}$. When ${\rm{\Delta }}E\;t=\pi $, i.e.

this becomes

Thus the system evolves to the marked vertex with probability 1 in time $\pi \sqrt{N}/2$, which agrees with figure 3 with ${\text{}}N=1024\;\mathrm{and}\;2048$; as expected, the success probability reaches 1 at time $\pi \sqrt{1024}/2\approx 50.265\;\mathrm{and}\;\pi \sqrt{2048}/2\;\approx $ 71.086.

4. Discrete-time quantum walk with self-loops

Now we include $l\gt 0$ self-loops at each vertex, as shown in figure 1(b). As before, there are only two types of vertices, $a\;\mathrm{and}\;b$. But now the a vertex can also point towards itself, so the system evolves in a 4D subspace spanned by equal superpositions of the vertices/directions:

In this $\{| {aa}\rangle ,| {ab}\rangle ,| {ba}\rangle ,| {bb}\rangle \}$ basis, the initial state is

With self-loops, the ${C}_{1}^{{\rm{flip}}}=-{C}_{0}\;\mathrm{and}\;{C}_{1}^{{\rm{SKW}}}=-{I}_{d}$ coins now result in different search operators (2) and evolutions, which we analyze separately.

With ${C}_{1}^{{\rm{flip}}}=-{C}_{0}$, [18] showed that with this coin and l = 1 self-loop at each vertex, two applications of the search operator (3) corresponds exactly to Grover's iterate (1) on the vertex space. Reproducing their argument, the vertex and coin spaces have equal dimension N in this case. Then ${C}_{0}={R}_{{s}^{\perp }}=2| s\rangle \langle s| -{I}_{N}$ is the reflection about the equal superposition $| s\rangle $ over the $N$-dimensional computational basis in Grover's algorithm. With this substitution, the search operator (3) becomes U $=\;S\cdot ({I}_{N}\otimes {R}_{{s}^{\perp }})\cdot ({R}_{w}\otimes {I}_{N})$. Acting by this on the initial equal superposition state $| {\psi }_{0}\rangle =| s\rangle \otimes | s\rangle $, we get U $| {\psi }_{0}\rangle \;=S({R}_{w}| s\rangle \otimes {R}_{{s}^{\perp }}| s\rangle )={R}_{{s}^{\perp }}| s\rangle \otimes {R}_{w}| s\rangle $. Acting a second time, ${U}^{2}| {\psi }_{0}\rangle \;=S({R}_{w}{R}_{{s}^{\perp }}| s\rangle \otimes {R}_{{s}^{\perp }}{R}_{w}| s\rangle )={R}_{{s}^{\perp }}{R}_{w}| s\rangle \otimes {R}_{w}{R}_{{s}^{\perp }}| s\rangle $, which is precisely Grover's iterate (1) on the first tensor factor. Thus the success probability reaches $1\;\mathrm{in}\;\pi \sqrt{N}/2$ applications of U, which is an improvement over the success probability of 1/2 without any self-loops.

To find the behavior of the algorithm for general l $\gt $ 0, consider the search operator (2) or (3), which in the $\{| {aa}\rangle ,| {ab}\rangle ,| {ba}\rangle ,| {bb}\rangle \}$ basis is

Equation (6)

where θ is defined such that

and ϕ is defined such that

Repeatedly applying this to the initial state, the success probability evolves as shown in figure 4. Beyond l = 1, additional self-loops causes the buildup of success probability to stall, resulting in a lower maximum success probability. The figure also reveals that the maximum success probability only depends on l, which is reasonable since the l = 0 and l = 1 cases achieve success probabilities of 1/2 and 1, independent of N.

Figure 4.

Figure 4. Success probability as a function of the number of discrete-time applications of U with the ${C}_{1}^{{\rm{flip}}}$ coin for search on the complete graph with N vertices and l self-loops at each vertex. The solid black, dashed red, and dotted green curves correspond to N = 1024 with l = 1, 2, and 3, respectively, and the dotted–dashed blue curve corresponds to N = 2048 with l = 2.

Standard image High-resolution image

To find the precise behavior of the algorithm, we find the eigenvalues and eigenvectors of the search operator U. The eigenvalues are

where

and the corresponding (un-normalized) eigenvectors are

Then

is dominated by the last term because $\mathrm{sin}\phi \approx \phi $ in the denominator of the second and third terms is small for large N, which implies that 1 $-\mathrm{cos}\phi \approx {\phi }^{2}/2$ in denominator of the last term. Thus if we normalize it to leading-order

Note that the initial state $| {\psi }_{0}\rangle \approx | {bb}\rangle $. Then after t applications of U, the system is in the state

We choose t such that αt = π, i.e., the runtime is

for large N. At this runtime, the state of the system is

Then the success probability p is given by the sum of the squares of the first two terms:

Plugging in for $\mathrm{cos}\alpha ,\mathrm{sin}\phi ,\mathrm{cos}\phi ,\mathrm{sin}\theta $, and $\mathrm{cos}\theta $, this is

for large N. These expressions for t and p agree with figure 4; for search with N = 1024 vertices and l = 1, 2, 3, the runtimes are respectively $\pi \sqrt{1024}/\sqrt{2(l+1)}\approx 50,41,$ 36 with corresponding success probabilities $4\;l/{(l+1)}^{2}=1,0.889,$ 0.75. With N = 2048 and l = 2, the runtime is $\pi \sqrt{2048}/\sqrt{2(2+1)}\approx 58\;$ with success probability $4(2)/{(2+1)}^{2}\approx 0.889$.

These results indicate that the maximum success probability decreases as l increases. Even so, there is still an improvement over the loopless success probability of 1/2, so long as l $\leqslant $ 5. For l beyond this, the success probability is less than 1/2, but if l is any constant, the overall runtime is still Grover's ${\rm{\Theta }}(\sqrt{N})$. When l scales greater than a constant, the quadratic quantum speedup is lost due to the classical repetitions of the algorithm needed to boost the success probability. Despite this, when l = o(N), we still obtain an improvement over the classical algorithm's ${\rm{\Theta }}(N)$ runtime. Finally, when l = Ω(N), the success probability fails to increase beyond its initial scaling of Θ(1/N), and so the quantum algorithm is no better than the classical one.

Now consider ${C}_{1}^{{\rm{SKW}}}=-{I}_{d}$. The search operator (2) in the $\{| {aa}\rangle ,| {ab}\rangle ,| {ba}\rangle ,| {bb}\rangle \}$ basis is

Equation (7)

where

Clearly, $| {aa}\rangle $ is an eigenvector of U with eigenvalue −1. The remaining part of U corresponding to $| {ab}\rangle ,| {ba}\rangle $, and $| {bb}\rangle $ takes the same form as U for the l = 0 case (4). Since θ is small for large N, those results carry over: the success probability reaches 1/2 in

applications of U. The scaling of this with N depends on the scaling of l. In particular, for large N,

An example of this evolution is shown in figure 5, with the success probability reaching the expected 1/2 at time $\pi \sqrt{1024}/2\sqrt{2}\approx \;$ 36 for both l = 0 and l = $\sqrt{N}=32$, time $\pi \sqrt{1+2}\sqrt{1024}/2\sqrt{2}\approx 62\;\mathrm{for}\;l=2\;N=2048$, and time $\pi \sqrt{32\;768}/2\sqrt{2}\approx 201\;\mathrm{for}\;l={N}^{3/2}\;=32768$.

Figure 5.

Figure 5. Success probability as a function of the number of discrete-time applications of U with the ${C}_{1}^{{\rm{SKW}}}$ coin for search on the complete graph with N = 1024 vertices and l self-loops at each vertex. The solid black, dashed red, dotted green, and dotted–dashed blue curves correspond to l = 0, $\sqrt{N}=32,2N\;=\;$ 2048, and ${N}^{3/2}=32\;768$, respectively.

Standard image High-resolution image

With this coin, self-loops cause the success probability to take longer to reach 1/2. As long as the number of self loops scales less than or equal to N (i.e., l = O(N)), the runtime still scales as Grover's ${\rm{\Theta }}(\sqrt{N})$. Furthermore, there is still a speedup over the classical algorithm so long as $l$ scales less than N2 (i.e., l = o(N2)). Compared to the ${C}_{1}^{{\rm{flip}}}$ coin, which obtains Grover's ${\rm{\Theta }}(\sqrt{N})$ runtime when l = Θ(1) and a speedup over classical so long as l = o(N), this ${C}_{1}^{{\rm{SKW}}}$ coin is in some sense more robust to self-loops; it takes more of them for the walk to lose its quantum speedup.

5. Continuous-time quantum walk with self-loops

Let us see how the continuous-time quantum walk algorithm is affected by the presence of l self-loops at each vertex. If we count each self-loop to contribute 1 to the diagonal of the full N-dimensional adjacency matrix so that Aii = l at vertex i1 , then in the two-dimensional subspace spanned by $\{| a\rangle ,| b\rangle \}$, the Hamiltonian is

Note this is simply the Hamiltonian with no self-loops (5) plus l I. Adding a multiple of the identity matrix to the Hamiltonian in this manner constitutes a rezeroing of energy or an overall phase, so it has no observable effects. Thus the self-loops do not change the evolution at all; with or without self-loops, at the critical γ = 1/N, the success probability reaches 1 at time $\pi \sqrt{N}/2$. Thus the continuous-time quantum walk algorithm is completely apathetic towards our lackadaisical model of using l self-loops at each vertex.

6. Generalization to multiple marked vertices

All of these results are straightforward to generalize to the case of k marked vertices. We assume that k = o(N) since the number of marked vertices cannot scale more than the number of vertices, and if k = cN, then one can classically find a marked vertex in a constant number of guesses. The classical search would take an expected Θ(N/k) time to find one of the k marked vertices on the complete graph of N vertices. As for the quantum walk, let us consider each of the cases above.

Beginning with discrete-time quantum walks, with k > 1 marked vertices and l self-loops at each vertex, the system evolves in a 4D subspace spanned by $\{| {aa}\rangle ,| {ab}\rangle ,| {ba}\rangle ,| {bb}\rangle \}$. With the ${C}_{1}^{{\rm{flip}}}=-{C}_{0}$ coin, the search operator (2) or (3) is

where θ is defined such that

and ϕ is defined such that

This has the same form as the case of one marked vertex (6), and since ϕ is small for large N, the solutions carry over: define α such that

Then after

applications of U, the success probability reaches a maximum value of

This is shown in figure 6, where the success probability reaches $1\;\mathrm{at}\pi \sqrt{1024}/\sqrt{2(2\cdot 16+1-1)}$ $\approx \;13\;\mathrm{and}\;4\cdot 16(16+32-1)/{(2\cdot 16+32-1)}^{2}$ $\approx \;0.7\;\mathrm{at}\pi \sqrt{1024}/\sqrt{2(2\cdot 16+32-1\mathrm{)}}\approx $ 9 applications of U, as expected.

Figure 6.

Figure 6. For search on the complete graph with N = 1024 vertices, k = 16 marked vertices, and l self-loops at each vertex, the success probability as a function of the number of discrete-time applications of U with the ${C}_{1}^{{\rm{flip}}}$ coin. The solid black and dashed red curves are respectively l = 1 and 32.

Standard image High-resolution image

With the ${C}_{1}^{{\rm{SKW}}}=-{I}_{d}$ coin, the search operator (2) in this basis is

where

This has the same form as the case of one marked vertex (7), and since θ is small for large N, the solutions carry over: we reach a success probability of 1/2 in

applications of U. This is shown in figure 7, where the success probability reaches $1/2\;\mathrm{at}\pi \sqrt{1024}/2\sqrt{2\cdot 16}\approx 9\;\mathrm{and}\;\pi \sqrt{2+1}\sqrt{1024}/2\sqrt{2\cdot 16}\approx 15\;$ applications of $U$, as expected.

Figure 7.

Figure 7. Success probability as a function of the number of discrete-time applications of U with the ${C}_{1}^{{\rm{flip}}}$ coin for search on the complete graph with N = 1024 vertices, k = 16 marked vertices, and l self-loops at each vertex. The solid black and dashed red curves are respectively l = 1 and 32.

Standard image High-resolution image

Finally for the continuous-time quantum walk, the Hamiltonian is

This simply adds lI to the Hamiltonian with no self-loops [22], which is a rezeroing of energy or global phase, so it has no observable effects.

7. Conclusion

We have proposed a quantum analogue of classical lazy random walks, called lackadaisical quantum walks, where the quantum walker has some preference to stay put by introducing l self-loops at each vertex of the graph. We have investigated the consequences of this for quantum search on the complete graph, showing the self-loops can have vastly different effects on quantum search depending on the type of quantum walk. For discrete-time quantum walks with the ${C}_{1}^{\mathrm{flip}}$ coin, one self-loop per vertex boosts the success probability, but additional self-loops hinders it. With the ${C}_{1}^{\mathrm{SKW}}$ coin, however, rather than hindering the maximum success probability, the self-loops slow down its buildup. This hindrance is less potent, eliminating all speedup over classical search when l = ω(N2) compared to the first coin's l = ω(N). Continuous-time quantum walks, on the other hand, are not affected at all by the self-loops. All of these results extend to multiple marked vertices.

Acknowledgments

This work was supported by the European Union Seventh Framework Programme (FP7/2007–2013) under the QALGO (Grant Agreement No. 600700) project, and the ERC Advanced Grant MQC.

Footnotes

  • Note that some treatments count each self-loop as 2 in the adjacency matrix, which would result in ${A}_{{ii}}=2l$, but it makes no difference to our result.

Please wait… references are loading.
10.1088/1751-8113/48/43/435304