# Efficient quantum circuit implementation of quantum walks

###### Abstract

Quantum walks, being the quantum analogue of classical random walks, are expected to provide a fruitful source of quantum algorithms. A few such algorithms have already been developed, including the ‘glued trees’ algorithm, which provides an exponential speedup over classical methods, relative to a particular quantum oracle. Here, we discuss the possibility of a quantum walk algorithm yielding such an exponential speedup over possible classical algorithms, without the use of an oracle. We provide examples of some highly symmetric graphs on which efficient quantum circuits implementing quantum walks can be constructed, and discuss potential applications to quantum search for marked vertices along these graphs.

###### pacs:

03.67.Lx, 03.67.-a, 89.20.Ff## I Introduction

The considerable, ongoing interest in quantum algorithms has been sparked by the possibility of practical solutions to problems that cannot be efficiently solved by classical computers. In other words, the opportunity to achieve exponential speedups over classical techniques by harnessing entanglement between densely encoded states in a quantum computer. Quantum walks have been the focus of several recent studies (see for example, Kempe (2003); Aharonov et al. (2001); Brun et al. (2003); Ribeiro et al. (2004); Wójcik and Dorfman (2003)), with particular interest in possible algorithmic applications of the walks Childs et al. (2003); Ambainis (2003); Shenvi et al. (2003a); Ambainis (2007); Magniez et al. (2007). A few such algorithms have already been developed, perhaps the most notable being the ‘glued trees’ algorithm developed by Childs et al. Childs et al. (2003), in which quantum walks are shown to traverse a family of graphs exponentially faster than any possible classical algorithm, given a certain quantum oracle.

In this paper we discuss the possibility of a quantum walk algorithm providing such an exponential speedup over possible classical algorithms without the use of an oracle. Firstly, we present a formal construction of quantum walks, and show that they can be implemented classically in a time that scales polynomially with the size of the state space. We then consider an efficient quantum implementation of quantum walks to be one in which the resources required scales logarithmically with the size of the state space, and present examples of graphs for which such an implementation is possible.

## Ii Quantum random walks

Quantum walks can be thought of as the quantum analogue of simple classical random walks. They are a unitary process, and can be naturally implemented by quantum systems. The discrete-time walk consists of a unitary operator , where and are termed the shifting and coin operators respectively, acting on the state space.

Consider a discrete-time quantum walk along a general undirected graph , with vertex set , and edge set , being unordered pairs connecting the vertices. The quantum walk acts on an extended position space, in which each node with valency is split into subnodes. This space then consists of all states , where and . The shifting operator acts on this extended position space, with its action defined by:

for some such that . The coin operator comprises a group of unitary operators, or a set of coins, each of which independently mix the probability amplitudes associated with the group of sub-nodes of a given node. For example, given a vertex with valency , the coin can be represented by a unitary matrix.

This definition is necessarily vague, allowing significant freedom in the construction of shifting and coin operators, depending on the desired properties. If, for example, a specific labeling of the vertices of the graph was not known, the shifting and coin operators may be required to act symmetrically with respect to any arbitrary labeling. This means that the coin matrix must be symmetric, and the shifting can take place only along edges, with equaling the identity operator.

Consider an undirected graph, having order and edges, with no self loops or multiple edges between pairs of vertices. Then the above definition yields a state space with states. The shifting operator can then be represented by a permutation matrix, and if we group the states derived from a common vertex, the coin operator can be represented by a block diagonal matrix. Since has an upper bound of , it follows that a step of the walk, , can be simulated efficiently on a classical computer, in a time that scales with . In fact, the shifting operator, being a permutation of the states, can be implemented more efficiently with an upper bound scaling of Douglas and Wang (2008), as can the coin operator, containing blocks of size at most . Hence, quantum walks on graphs can be classically simulated in polynomially time, scaling with graph size. So for even the possibility of exponential speedups, quantum implementations must scale logarithmically with graph size.

Many of the currently proposed ‘natural’ physical implementations of quantum walks Travaglione and Milburn (2002); Dür et al. (2002); Agarwal and Pathak (2005); Sanders et al. (2003) cannot achieve this, as the walks evolve on nodes that are implemented by physical states, on which operations are directly performed. Hence the resource requirements grow polynomially with the state space. In order to achieve an exponential gain, the nodes need to foremost be encoded by a string of entangled states, such as qubits in a quantum computer, making use of memory that grows exponentially with the number of qubits. In addition, the number of elementary gates required to perform the walk needs also grow logarithmically with the size of the state space.

So far, this has only been found to be possible for structures with a high degree of symmetry - where symmetry in this case refers to the ability to characterize the structure by a small number of parameters, increasing at most logarithmically with the number of nodes. Note that this may not necessarily imply that the structure has geometric or combinatorial symmetry in the typical sense of the terms. For instance, sparse graphs with efficiently computable neighbors fall into this category, and as a consequence of Aharonov and Ta-shma (2003); Berry et al. (2007) have been shown to allow efficient implementations of quantum walks. Here sparse graphs of order are defined as in Aharonov and Ta-shma (2003) to have degree bounded by O(polylog()), with the further condition that the neighbors of each vertex are efficiently computable. Possessing efficiently computable neighbors implies the existence of an O(log()) sized function characterizing the graph, such that the information contained in the O() edges can be compressed to size O(log()). This compression seems to require the presence of some kind of structure to the system, for example, the graph cannot contain more than O(log()) completely random edges. An interesting open question is whether sparse graphs can have no automorphisms apart from the identity.

## Iii Efficient quantum circuit implementation

In this section, we give examples of a few such graphs for which relatively simple quantum circuits can be designed to efficiently implement quantum walks along them. Firstly, we will look at a simple cycle. To implement a quantum walk along it, we first note that each node has two adjacent edges, and hence two subnodes. Proceeding systematically around the cycle, we assign each node a bit-string value in lexicographic order, such that adjacent nodes are given adjacent bit-strings. For a cycle of order , qubits are required to encode the nodes, and an additional qubit to encode the subnodes. The coin operation can be implemented by a single Hadamard gate acting on the subnode qubit, and the shifting operation by a cyclic permutation of the node states, in which each state (or bit-string) is mapped to an adjacent state (either higher or lower depending on the value of the subnode qubit).

This permutation can be achieved via ‘increment’ and ‘decrement’ gates, shown in Figure 1, made up of generalized CNOT gates. These gates produce cyclic permutations (in either direction) of the node states. The resulting shifting operator is . Here the tensor space description separates the node and subnode states. So to implement a walk along a cycle of size we require qubits. additional ancillary qubits may also be required for the generalized CNOT gates involved in the cyclic permutations, depending on the specific implementation used. The number of elementary gates required is limited to , hence both memory and resource requirements scale logarithmically with graph size. An example of the circuit for a cycle of size 16 is given in Figure 2. Note that although this specific implementation requires a cycle of order , only trivial alterations are required to efficiently implement cycles of any size. For instance, an equivalent circuit for a cycle of size 25 is given in Figure 3.

A similar method can be used to efficiently implement a walk along a dimensional grid or hypercube, by partitioning the labels of the nodes into distinct sets, corresponding to each coordinate. An example for the 2D () hypercycle is given in Figure 4. As an extension, a quantum circuit implementing a walk along a twisted toroidal supergraph as shown in Figure 5 is given in Figure 6. This structure was employed by Menicucci et al Menicucci et al. (2008) to set up QC-universal toroidal lattice cluster states.

Other highly symmetric structures, such as the complete graph, a complete graph with self loops and a binary tree also allow efficient implementations of quantum walks with a qubit based quantum circuit. Walking along the complete graph, using the Hadamard coin operator, can be naturally implemented using only single qubit gates and CNOT gates ( Hadamard gates and CNOT gates). The circuit for a complete graph (), in which each node has a self loop, is shown in Figure 7, and is fairly intuitive. Alternatively, if the Grover coin operator is used, extra single qubit gates, one extra gate (which is a generalized CNOT gate with control bits and one target bit), and Hadamard gates are required, as shown in Figure 8. Here

is a permutation of the Hadamard operator. Note that even using the Grover coin , the coin operator is still mostly separable, requiring only single qubit operators apart from the one gate.

Walks along highly symmetric variants of the complete graph (as opposed to sparse graphs, such as those considered previously) can also be efficiently implemented. For instance if we consider the complete graph on vertices, together with an arbitrary labeling of the nodes from 1 to . Removing edges between nodes whose labels differ by a multiple of 2 leads to a regular graph of degree , shown in Figure 9 for . This is then a complete bipartite graph, and a walk along such a graph can be efficiently implemented by the circuit of Figure 9, an even simpler circuit than for the complete graph.

Given the results of Childs et al. Childs et al. (2003) and Cleve et al. Cleve et al. (2008), in which quantum walks are shown to traverse a family of ‘glued trees’ exponentially faster than any possible classical algorithm, relative to a quantum oracle, we decided to look into quantum walks along glued trees in the non-oracular setting. Note that the algorithm presented in Childs et al. (2003) employs continuous-time quantum walks, while in Cleve et al. (2008) it was shown to also be implementable by discrete-time quantum walks. Both require the use of a quantum oracle. In the non-oracular case, efficient implementation of a quantum walk along the glued trees is not possible given random interconnections between the central levels (as in Figure 10(a)), since this would be equivalent to performing a random permutation of states in time . Instead we are restricted to considering regular interconnections, such as those of Figure 10(b). Here ‘regular’ interconnections are those that can be completely characterized by parameters. The algorithm of Childs et al. (2003) requires a symmetric coin operator - hence we use the Grover coin, defined on dimensions by , the only purely real symmetric coin Douglas and Wang (2008). We also restrict the shifting operator to , where is the identity operator. In this case an efficient quantum circuit can be constructed, for example that of Figure 11, for tree depth 4 (with 62 nodes). Here the gate represents a three dimensional Grover coin operator acting on two qubits (mixing three of the four states, while the fourth is not accessed). For a tree depth of , the circuit requires qubits, together with elementary gates.

Related to the problem of which structures quantum walks can be efficiently implemented on is the question of which permutations of a set of states can be efficiently implemented. Given a set of qubits encoding quantum states, we wish to know which permutations of these states can be implemented using elementary gate operations. Cyclic rotations of the states (relative to the lexicographic order of their bit-strings) can be implemented efficiently, as shown above. In fact any rotation of the states can be performed efficiently, by first decomposing it into a series of rotations of size , for some integer . For instance, an incremental rotation of 7 states applied to the 32 states represented by 5 qubits is explicitly shown in Figure 12. Generalized control-not operations can also be used to transpose pairs of states differing in label by a single qubit. Similarly, any two states differing by qubits can be efficiently transposed using generalized CNOT operations. For example, given 16 states encoded by 4 qubits, the lexicographically 1st and 10th states (represented by and respectively) can be transposed via 3 controlled swap operations, as shown in Figure 13. Using this method any transposition of states on qubits can be performed using a maximum of generalized CNOT gates, or gates. This may not be the optimal way to implement a particular transposition, however it does scale logarithmically with the number of states.

Using similar methods, other permutations with essentially binary characters can also be efficiently implemented, such as swapping every second state, or performing some given internal permutation to each consecutive group of 8 states (or states, for some fixed integer ). Note that permutations which may not seem to have a binary character can be transformed to efficiently implementable permutations. For instance, if we wished to split the set of states into groups of 6, and swap every 4th element, we could achieve this by expanding the state space - embedding each group of 6 into a group of 8, with the last two states remaining unused, ‘empty states’.

For simplicity, given an implementation on qubits, the preceding examples have all been essentially binary in nature. Efficient implementations using qubits are equally possible on other, non-binary structures, such as ternary trees or complete graphs. For example, implementing the complete graph (with self-loops) using a qubit circuit requires many more 2-qubits gates, given the need to approximate a 9D Hadamard or Grover coin operator over 16 states, without mixing into the other 7 states. As would be expected, a more natural implementation is possible if qutrits are used instead. In this case, the coin operator is again nearly separable if using the Grover coin operator, and completely separable if using a qutrit equivalent of the Hadamard operator. Here we take a qutrit equivalent of the Hadamard operator to be an operator acting on qutrits, satisfying:

Qutrit circuits implementing a quantum walk along the complete- graph using the coin operator or the Grover coin operator can then be constructed as in Figure 14. Nevertheless, the use of a more natural base still provides a polynomial efficiency gain.

## Iv Conclusions

We have presented here a set of highly symmetric graphs all amenable to exact, efficient quantum circuits implementing quantum walks along them. The examples considered here are quite simple, and more complex variations can still be efficiently implemented such as composites of highly symmetric graphs, symmetric graphs with a small number of ‘imperfections’, as well as graphs possessing a certain bounded level of complexity.

Quantum walks have been used to search for marked vertices along highly symmetric graphs, including the hypercube, complete graphs and complete multipartite graphs Reitzner et al. (2009); Shenvi et al. (2003a). These studies have dealt with the computational complexity of such searches relative to an oracle - looking at the number of steps of a quantum walk required to find a marked vertex, with individual steps of the walk itself largely left to the oracle. In such cases searching using quantum walks has yielded a quadratic speedup over classical search algorithms.

In a practical implementation of such a search algorithm, the computations performed by the oracle (that is, performing a step of the walk in which the coin operator differs for marked and unmarked nodes) would of course affect the running time. The work presented here can be used to efficiently implement such an oracle - using O(log()) elementary gates for a graph of order - given a highly symmetric graph such as those considered in Shenvi et al. (2003a); Reitzner et al. (2009) and in this paper.

###### Acknowledgements.

We thank N. Menicucci and S. Flamia for use of their Mathematica code, which was adapted to construct the toroidal graph figure used here.## References

- Kempe (2003) J. Kempe, Contemp. Phys. 44, 307 (2003).
- Aharonov et al. (2001) D. Aharonov, A. Ambainis, J. Kempe, and U. V. Vazirani, in ACM Symposium on Theory of Computing (2001), pp. 50–59.
- Brun et al. (2003) T. A. Brun, H. A. Carteret, and A. Ambainis, Phys. Rev. Lett. 91, 130602 (2003).
- Ribeiro et al. (2004) P. Ribeiro, P. Milman, and R. Mosseri, Phys. Rev. Lett. 93, 190503 (2004).
- Wójcik and Dorfman (2003) D. K. Wójcik and J. R. Dorfman, Phys. Rev. Lett. 90, 230602 (2003).
- Childs et al. (2003) A. M. Childs, R. Cleve, E. Deotto, E. Farhi, S. Gutmann, and D. A. Spielman, in STOC ’03: Proceedings of the thirty-fifth annual ACM symposium on Theory of computing (2003), pp. 59–68.
- Ambainis (2003) A. Ambainis, Int. J. Quant. Inf. 1, 507 (2003).
- Shenvi et al. (2003a) N. Shenvi, J. Kempe, and K. B. Whaley, Phys. Rev. A 67, 052307 (2003a).
- Ambainis (2007) A. Ambainis, SIAM J. Comput. 37, 210 (2007).
- Magniez et al. (2007) F. Magniez, M. Santha, and M. Szegedy, SIAM J. Comput. 37, 413 (2007).
- Douglas and Wang (2008) B. Douglas and J. Wang, J. Phys. A 41, 075303 (2008).
- Travaglione and Milburn (2002) B. C. Travaglione and G. J. Milburn, Phys. Rev. A 65, 032310 (2002).
- Dür et al. (2002) W. Dür, R. Raussendorf, V. M. Kendon, and H.-J. Briegel, Phys. Rev. A 66, 052319 (2002).
- Agarwal and Pathak (2005) G. S. Agarwal and P. K. Pathak, Phys. Rev. A 72, 033815 (2005).
- Sanders et al. (2003) B. C. Sanders, S. D. Bartlett, B. Tregenna, and P. L. Knight, Phys. Rev. A 67, 042305 (2003).
- Aharonov and Ta-shma (2003) D. Aharonov and A. Ta-shma, in Proc. ACM STOC (2003), pp. 20–29.
- Berry et al. (2007) D. Berry, G. Ahokas, R. Cleve, and B. Sanders, Commum. Math. Phys. 270, 359 (2007).
- Menicucci et al. (2008) N. Menicucci, S. Flammia, and O. Pfister, ArXiv Quantum Physics e-prints (2008), eprint quant-ph/0804.4468.
- Cleve et al. (2008) R. Cleve, D. Gottesman, M. Mosca, R. Somma, and D. Yonge-Mallo, ArXiv Quantum Physics e-prints (2008), eprint quant-ph/0811.4428.
- Reitzner et al. (2009) D. Reitzner, M. Hillery, E. Feldman, and V. Buzek, Phys. Rev. A 79, 012323 (2009).