A novel quantum grid search algorithm and its application

TL;DR

This paper introduces a quantum grid search algorithm that leverages multiple Grover operators in parallel, providing exponential speedup for high-dimensional optimization problems compared to classical methods.

Contribution

The paper presents a novel quantum grid search algorithm that extends Grover's search to solve complex, high-dimensional optimization problems with exponential efficiency gains.

Findings

Offers exponential improvement over classical search algorithms.

Uses parallel Grover operators for efficient search.

Applicable to high-dimensional trajectory optimization.

Abstract

In this paper we present a novel quantum algorithm, namely the quantum grid search algorithm, to solve a special search problem. Suppose $ k $ non-empty buckets are given, such that each bucket contains some marked and some unmarked items. In one trial an item is selected from each of the $ k $ buckets. If every selected item is a marked item, then the search is considered successful. This search problem can also be formulated as the problem of finding a "marked path" associated with specified bounds on a discrete grid. Our algorithm essentially uses several Grover search operators in parallel to efficiently solve such problems. We also present an extension of our algorithm combined with a binary search algorithm in order to efficiently solve global trajectory optimization problems. Estimates of the expected run times of the algorithms are also presented, and it is proved that our proposed algorithms offer exponential improvement over pure classical search algorithms, while a traditional Grover's search algorithm offers only a quadratic speedup. We note that this gain comes at the cost of increased complexity of the quantum circuitry. The implication of such exponential gains in performance is that many high dimensional optimization problems, which are intractable for classical computers, can be efficiently solved by our proposed quantum grid search algorithm.

Equations

$$|\psi ⟩=H^{\otimes n}({|0⟩}^{\otimes n})=\frac{1}{\sqrt{N}}\sum _{x=0}^{N-1}|x⟩.$$

$$G=\left(H^{\otimes n}(2|0⟩⟨0|-I)H^{\otimes n}\right)O=\left(2|\psi ⟩⟨\psi |-I\right)O.$$

$$\left(2|\psi ⟩⟨\psi |-I\right)(\sum _{k=0}^{N-1}{\alpha }_k|k⟩)=\sum _{k=0}^{N-1}\left(-{\alpha }_k+2m\right)|k⟩$$

$$|\psi ⟩=\sum _{x,x\text{ marked}}\alpha |x⟩+\sum _{x,x\text{ not marked}}\beta |x⟩.$$

$$G^j|\psi ⟩=\sum _{x,x\text{ marked}}\alpha \sin \left((2j+1\right)\theta )|x⟩+\sum _{x,x\text{ not marked}}\beta \cos \left((2j+1\right)\theta )|x⟩,$$

$$f_i(t)=\{\begin{array}{ll}& 1\text{if the element t is a marked element in Xi, }\\ & 0\text{otherwise.}\end{array}$$

$$f(y_1,y_2,\cdots y_k)=\{\begin{array}{ll}& 1\text{if, for i=1 to k, the element yi is a marked element in Xi, }\\ & 0\text{otherwise.}\end{array}$$

$$m>\max \left(\frac{1}{\sin (2{\theta }_1)},\frac{1}{\sin (2{\theta }_1)},\cdots \frac{1}{\sin (2{\theta }_k)}\right),\text{ where }{\theta }_i={\sin }^{-1}\left(\sqrt{\frac{m_i}{n_i}}\right).$$

$$P_m\ge \frac{1}{4^k}.$$

$$p_{i,j}:={\sin }^2((2j+1){\theta }_i).$$

$$P_m$$

$$=\frac{1}{m^k}\sum _{j_1,j_2,\cdots j_k=0}^{m-1}\prod _{i=1}^k{\sin }^2((2j_i+1){\theta }_i).$$

$$=\prod _{i=1}^k\frac{1}{m}\sum _{j_i=0}^{m-1}{\sin }^2((2j_i+1){\theta }_i)$$

$$=\prod _{i=1}^k\frac{1}{2m}\sum _{j_i=0}^{m-1}1-\cos ((2j_i+1)2{\theta }_i)$$

$$=\prod _{i=1}^k\left(\frac{1}{2}-\frac{\sin (4m{\theta }_i)}{4m\sin (2{\theta }_i)}\right).$$

$$\sum _{j=0}^{m-1}1-\cos \left((2j+1)\theta \right)=m-\frac{1}{2}\frac{\sin 2m\theta }{\sin \theta }.$$

$$m>\max \left(\frac{1}{\sin (2{\theta }_1)},\frac{1}{\sin (2{\theta }_1)},\cdots \frac{1}{\sin (2{\theta }_k)}\right),$$

$$\frac{\sin (4m{\theta }_i)}{4m\sin (2{\theta }_i)}\le \frac{1}{4m\sin (2{\theta }_i)}\le \frac{1}{4}.$$

$$\frac{1}{2}-\frac{\sin (4m{\theta }_i)}{4m\sin (2{\theta }_i)}\ge \frac{1}{4},\text{for i=1,2⋯k.}$$

$${\alpha }_i=\frac{1}{\sin (2{\theta }_i)}=\frac{n_i}{2\sqrt{(n_i-m_i)m_i}}\le \sqrt{\frac{n_i}{m_i}}.$$

$$\frac{k}{2}\sum _{i=1}^{\lceil {\log }_{\lambda }{\alpha }^{\ast }\rceil }{\lambda }^{i-1}<\frac{k}{2}\frac{\lambda }{\lambda -1}{\alpha }^{\ast }.$$

$$\frac{k}{2}\sum _{s=0}^{\infty }{\left(1-\frac{1}{4^k}\right)}^s\left(\frac{1}{4^k}\right){\lambda }^{s+\lceil {\log }_{\lambda }{\alpha }^{\ast }\rceil }$$

$$<\left(\frac{k\lambda }{2^{2k+1}(1-(1-2^{-2k})\lambda )}\right){\alpha }^{\ast }.$$

$$\mathcal{J}(\vec{U}(.),\vec{X}(.),{\tau }_f)=\mathcal{M}(\vec{X}({\tau }_f),{\tau }_f)+{\int }_{{\tau }_0}^{{\tau }_f}\mathcal{L}(\vec{U}(\tau ),\vec{X}(t),t)dt.$$

$$f_l\le f(\vec{U}(\tau ),\vec{X}(t),\overrightarrow{X^{{}^{\prime }}}(t),t)\le f_{u}t\in [{\tau }_0,{\tau }_f].$$

$$h_l\le h(\vec{X}({\tau }_0),\vec{X}({\tau }_f),{\tau }_f-{\tau }_0)\le h_u,$$

$$g_l\le g(\vec{U}(t),\vec{X}(t),t)\le g_u,$$

$$\mathrm{SolutionPaths}(a,b)=\left\{(y_1,y_2,\cdots y_k)\in \prod _{i=1}^k{X}_i|a<\mathrm{Cost}\left((y_1,y_2,\cdots y_k)\right)<b\right\}.$$

$${\tau }_f={\int }_0^{\pi }\sqrt{\frac{1+(\frac{dy}{dx}{)}^2}{2gy}}dx,$$

$$f_{a,b}(y_1,y_2,\cdots y_k)=\{\begin{array}{ll}& 1\text{if, a<Cost((y1,y2,⋯yk))<b,}\\ & 0\text{otherwise.}\end{array}$$

Full text

1 Introduction

A powerful quantum search algorithm was presented by Grover grover1996fast to find a marked item in a given $N$-item database, in ${\mathbb{O}}(\sqrt{N})$ evaluations of the oracle function $f$. Here the oracle function $f$ is a black-box function such that $f(x)=1$ if $x$ is a marked item, otherwise $f(x)=0$. Grover’s algorithm offers a quadratic speedup, as clearly a classical search in this situation requires ${\mathbb{O}}(N)$ function calls. Although, a quadratic speedup is impressive, it is natural to ask if it can further be improved. However, it is well-known that Grover’s quantum search algorithm is optimal articleZalka . In this paper, we present an algorithm and describe its applications in solving a class of optimization problems, where exponential gains could be achieved in comparison to non-parallel classical algorithms. We remark that if we consider parallel classical algorithms then the computational speedup is only quadratic.

Now we describe a formulation of the search problem that we solve in this work. Consider $k$ non-empty buckets, labeled $X_{1},X_{2},\cdots X_{k}$, with each bucket containing some marked and some unmarked items. Suppose one item is taken out blindfolded from each bucket, say $x_{i}$ is taken out from $X_{i}$ for $i=1,2,\cdots k$. If each $x_{i}$ is marked, then the search is considered successful. To illustrate a practical example, we consider the blending problem in which a product is made by blending various components in different quantities. More explicitly, suppose $X_{1},X_{2},\cdots X_{k}$ are the $k$ components needed to manufacture the product. Further, suppose that in the manufacturing process, for $i=1,2,\cdots k$, the quantity of the component $X_{i}$ used is chosen from the set $X_{i,1},X_{i,2},\cdots X_{i,n_{i}}$. Here $X_{i}$ is a bucket and $X_{i,1},X_{i,2},\cdots X_{i,n_{i}}$ are the items in the bucket $X_{i}$. We assume that there exists an oracle function $f$ which assigns a number denoting the quality of the finished product, for any given choice of the quantities of the components selected. The goal of the optimization problem is to select the quantities of the components to manufacture a product of desired quality, i.e., to find $x_{1},x_{2},\cdots x_{k}$, with $x_{i}$ being the quantity of the component $X_{i}$ chosen such that $m\leq f(x_{1},x_{2},\cdots x_{k})$. Here $m$ denotes the minimum threshold of the quality for the product to be accepted. Suppose only one item is marked in each bucket. Then, clearly in the worst case a non-parallel classical algorithm will need $\prod_{i=1}^{k}n_{i}$ searches to discover the desired composition of the product. However, our proposed algorithm will find success within the expected run time of the order of ${\mathbb{O}}\left(\max\left(\sqrt{n_{i}}\right)_{i=1}^{i=k}\right)$.

We present another important class of problems which can be efficiently solved by our proposed algorithms. This is the global trajectory optimization problem using the discretization framework presented in shuklavedula2019 . We note that in shuklavedula2019 we used quantum algorithms based on Grover’s search algorithm for solution of global trajectory optimization problems, and demonstrated that a quadratic speedup could be achieved in comparison to classical search based algorithms. Our proposed algorithms (Algorithm 1 and Algorithm 2) in the present work offer further improvements over the quantum search algorithms presented in shuklavedula2019 . Further, we recall that in shuklavedula2019 , we presented a discretization scheme, wherein both the independent variables (such as time) and the dependent variables were discretized. Our discretization scheme involved the selection of a finite number of coarse-grained states, with a cost function defined on each state. Thereby, the continuous optimization problem was transformed to a discrete search problem on the discretization grid, in which a state with the minimum associated cost is to be determined. Further, the discretization scheme in shuklavedula2019 treated discretization in both the physical space as well as the coefficient space, and it also provided mathematical bounds using the coefficients of Chebyshev polynomials while discretizing in the coefficient space. We refer readers to shuklavedula2019 for further details on the discretization scheme. Once discretization is carried out using the framework presented in shuklavedula2019 , the resulting discrete search problem is amenable to treatment by our proposed quantum grid search algorithms. One additional assumption is the availability of local oracles, which will be described later.

As noted earlier, the key idea in our proposed Algorithm 1 is the use of several Grover search operators in parallel to solve the discrete search problem efficiently. Algorithm 1 gives a solution within the specified bounds. Algorithm 2 uses Algorithm 1 along with the classical binary search on the cost function, to efficiently solve global trajectory optimization problems, as accurately as required.

In the first half of the paper, we describe the quantum grid search algorithm, and in the second half of this work, we give its application in solving trajectory optimization problem. More specifically, in Sect. 2 we briefly recall Grover’s search algorithm, and subsequently in Sect. 3 we describe our grid search algorithm. Further, to describe the application of quantum grid search algorithm, we present a formulation of the general trajectory optimization problem, in Sect. 4. Then in Sect. 5, we describe how quantum grid search algorithm, Algorithm 1, can be combined with Algorithm 2 to solve a given trajectory optimization problem with greater efficiency. Finally, we present our concluding remarks in Sect. 6.

2 **Quantum search: Grover’s algorithm **

Quantum computing is an exciting field which nicely combines quantum physics with computer science. There has been a lot of progress not only in theoretical development of quantum algorithms, but also in their practical implementation on quantum computers. We refer the readers to any standard book on the subject for a more in-depth treatment (for eg., nielsen2002quantum , rieffel2011quantum or yanofsky2008quantum ).

Here we will briefly recall Grover’s quantum search algorithm grover1996fast for finding one or more marked items out of a list of $N$ given items. Access to an oracle $O$, which is a black-box function, is assumed. This black-box function is such that for any item with index $x$ in the list, i.e., with $0\leq x\leq N-1$, we have $f(x)=1$ if $x$ is a marked item, otherwise $f(x)=0$.

For simplicity, we assume that $N=2^{n}$ and so the discrete search space can be represented by a $n$ qubit system. The algorithm begins with the system in $\ket{0}^{\otimes n}$. Then the Hadamard transform $H^{\otimes n}$ is applied on the input $\ket{0}^{\otimes n}$ to transform it to a uniform superimposed state, say $\ket{\psi}$, such that

[TABLE]

We note that at the heart of Grover’s algorithm lies the Grover operator $G$ (Fig. 1), which is essentially the following unitary transformation

[TABLE]

The phase shift $\phi$, in Fig. 1, is the unitary operator $(2\ket{0}\bra{0}-I)$, which transforms all non-zero basis state $\ket{x}$ to $-\ket{x}$ with $\ket{0}$ remaining unchanged. In fact, as noted earlier $G=\left(2\ket{\psi}\bra{\psi}-I\right)O$. The action of oracle $O$ amounts to changing the phase of the marked item. On the other hand, it can be checked that

[TABLE]

where $m=\frac{1}{N}\sum_{k=0}^{N-1}\alpha_{k}$ is the mean of $\alpha_{k}$. Hence, the action of $\left(2\ket{\psi}\bra{\psi}-I\right)$ is essentially an inversion about the mean. Therefore, one iteration of Grover operator results in amplification of the amplitude of the marked item (See Fig. 2).

We note that if $M=1$, then the Grover operator $G$ is applied $R\approx\frac{\pi}{4}\sqrt{N}$ times. After $R$ iteration of $G$, the measurement of the system yields the marked item. To summarize, Grover’s algorithm for the case $M=1$ is as follows.

1:  Initialization: Initialize the input $n$ qubits as $\ket{\psi}=\ket{0}^{\otimes n}$.

2:  Iteration: Apply $H^{\otimes n}$ on $\ket{\psi}$.

3:  Grover operator: Apply Grover operator $G$ a total of $R\approx\frac{\pi}{4}\sqrt{N}$ times.

4:  Measurement: Measure the $n$ qubits and obtain candidate solution $x$.

We refer readers to boyer1998tight , articleZalka for a tight analysis of this algorithm.

2.1 Unknown number of marked items

We consider the case when the number of marked items is unknown. Suppose $M$ items out of $N$ are marked, with $M$ is not known to the algorithm in advance. Let $\alpha=\frac{1}{\sqrt{M}}$ and $\beta=\frac{1}{\sqrt{N-M}}$. The initial state $\ket{\psi}$ is given by

[TABLE]

It can be verified that after $j$ iteration of the Grover operator $G$, the initial state $\ket{\psi}$ is transformed to

[TABLE]

where $\theta=\sin^{-1}(\sqrt{\frac{M}{N}})$.

3 Quantum grid search algorithm

We recall the search problem that we proposed to solve in Sect. 1. We consider $k$ non-empty buckets labeled $X_{1},X_{2},\cdots X_{k}$, with each bucket containing some marked and some unmarked items. Suppose one item is taken out blindfolded from each bucket at the same time. Then the search is considered successful is all items picked are marked. Here, we consider an alternate formulation of the search problem, with the intention of applying this algorithm to solve trajectory optimization problems. In this alternate formulation, our quantum grid search algorithm solves the problem of finding “a marked path” on a grid out of many such possible “paths”. More explicitly, for $i=1$ to $i=k$, we define $X_{i}$ as follows. Let $X_{i}=\{x_{ij}\}$, with $j$ running from $1$ to $n_{i}$, be a set of cardinality $n_{i}$. We also assume that out of $n_{i}$ elements, a fixed but unknown number of $m_{i}$ elements are marked. A “path” is an element of the set $X=\prod_{i=1}^{k}X_{i}$ and a path $(y_{1},y_{2},\cdots y_{k})$ will be called “a marked path” if $y_{i}$ is a marked element in $X_{i}$ for $i=1,2,\cdots k$.

We assume that, for $i=1$ to $i=k$, local oracle function $f_{i}$ is available such that $f_{i}(t)=1$, if $t$ is a marked item in $X_{i}$, i.e.,

[TABLE]

The objective of the quantum grid search algorithm is to find a marked “path”, i.e., to find a tuple

$(y_{1},y_{2},\cdots y_{k})$ with $y_{i}\in X_{i}$ for $i=1$ to $k$, such that $f(y_{1},y_{2},\cdots y_{k})=1$.

Using the local oracle functions defined above, one can obtain a global oracle function $f$ from $X$ to $\{0,1\}$ such that $f(y_{1},y_{2},\cdots y_{k})=1$ if and only if $y_{i}$ is a marked element in $X_{i}$ for $i=1,2,\cdots k$; otherwise $f(y_{1},y_{2},\cdots y_{k})=0$, i.e.,

[TABLE]

A schematic diagram of the quantum circuit for Algorithm 1, for $k=3$, is given in Fig. 3. We note that essentially the main components of the circuit are $k=3$ Grover operators acting in parallel.

Now we briefly describe the working of the quantum grid search algorithm, Algorithm 1. At the heart of the algorithm is $k$ Grover operator working in parallel. The local Grover operator $G_{i}$ is set up to search for a marked item in $X_{i}$ and it is implemented in the standard way using the local oracle function $f_{i}$ defined in Eq. $\!\eqref{Eq:localoracle}$. The algorithm proceeds by initializing the values of parameter $\lambda$ and the variable $m$. The variable $m$ is initially set to $1$, and later in the algorithm it is adaptively scaled by $\lambda$, by setting its value to $\lambda m$, if the search for a state that satisfying the criterion set up by the function $f$ is unsuccessful. The variable $m$ effectively controls the number of Grover’s rotation that is performed, as $j$ gets selected randomly from the set $\{0,1,\cdots\lceil m-1\rceil\}$, for $i=1,2,\cdots k$. A priori, the number of marked elements in $X_{i}$ is not known therefore $m$ is adaptively scaled to ensure that the correct number of iterations of Grover operator is selected as required by Grover’s search algorithm.

Lemma 3.1**.**

Let $m$ be a positive integer such that

[TABLE]

Let $\displaystyle{P}_{m}=\text{the average probability of success of Algorithm \ref{alg:grid}}$, during the iteration wherein Grover operator $G_{i}$ is applied $j$ times, and $j$ is chosen randomly from the set $\{0,1,\cdots\lceil m-1\rceil\}$, for $i=1,2,\cdots k$. Then

[TABLE]

Proof.

From Eq. $\!\eqref{eq_Grover_iteration}$, the probability of finding a marked element in $X_{i}$ after $j$ iterations is given by

[TABLE]

We note that the average probability of success, when the Grover operator $G_{i}$ is applied $j$ times and $j$ is chosen randomly from the set $\{0,1,\cdots\lceil m-1\rceil\}$, is given by

[TABLE]

In the last step we have used the trigonometric identity

[TABLE]

Since,

[TABLE]

we have

[TABLE]

Therefore,

[TABLE]

Hence, the average probability of success $\displaystyle{P}_{m}\geq\frac{1}{4^{k}}$. ∎

Theorem 3.2**.**

Algorithm 1 finds success within the expected running time of the order of ${\mathbb{O}}\left(\max\left(\sqrt{\frac{n_{i}}{m_{i}}}\right)_{i=1}^{i=k}\right)$.

Proof.

First, we assume $m_{i}\leq\,0.75n_{i}$, for $i=1,2,\cdots k$. Let

[TABLE]

The algorithm is said to be in the critical stage, if it goes through the main loop more than $\lceil\log_{\lambda}\alpha^{*}\rceil$ times, where $\alpha^{*}=\max(\alpha_{1},\alpha_{2},\cdots\alpha_{k})$.

During the $i^{\text{th}}$ iteration of the main loop in Algorithm 1, the value of $m$ is $\lambda^{i-1}$. As Grover operator $G_{i}$ is applied $j$ times, and $j$ is chosen randomly from the set $\{0,1,\cdots\lceil m-1\rceil\}$, on the average the Grover operator $G_{i}$ will run less than $\frac{\lambda^{i-1}}{2}$ times during $i^{\text{th}}$ iteration of the main loop. Also, there are $k$ Grover operators are running in parallel. Therefore, an upper bound on the expected total number of Grover iterations needed to reach the critical stage, if the algorithm ever reaches it, is given by

[TABLE]

Therefore, the running time of the algorithm will be of ${\mathbb{O}}(\alpha^{*})$, if it succeeds before reaching the critical stage. On the other hand, if the critical stage is reached, every iteration thereafter will have a probability of success bigger than $\frac{1}{4^{k}}$. Therefore, an upper bound on the expected number of Grover iterations needed for the algorithm to succeed, if the critical stage is reached, is given by

[TABLE]

It is clear that the run time of the algorithm is of the order of ${\mathbb{O}}(\alpha^{*})$, as desired. The remaining case, when $m_{i}>0.75\,n_{i}$, can be easily dealt with using a classical sampling in a constant expected time. ∎

4 Trajectory optimization: Problem formulation

We describe below the problem formulation given in shuklavedula2019 . Suppose $\vec{U}(t)\in{\mathbb{R}}^{m}$ and $\vec{X}(t)\in{\mathbb{R}}^{n}$ denote the control function and the corresponding state trajectory respectively at time $t$. The goal is to determine the optimal control function $\vec{U}(t)$ and the corresponding state trajectory $\vec{X}(t)$ for $\tau_{0}\leq t\leq\tau_{f}$ such that the following Bolza cost function is minimized:

[TABLE]

Here $\mathcal{M}$ and $\mathcal{L}$ are ${\mathbb{R}}$-valued functions. Moreover, we also assume that the system satisfies the following dynamic constraints.

[TABLE]

In addition, we also specify the following boundary conditions

[TABLE]

where $h$ an ${\mathbb{R}}^{p}$-valued function and $h_{l},h_{u}\in{\mathbb{R}}^{p}$ are constant vectors providing the lower and upper bounds of $h$. Finally, we note the mixed constraints on control and state variables

[TABLE]

with $g$ a ${\mathbb{R}}^{r}$-valued function and $g_{l},g_{u}\in{\mathbb{R}}^{r}$ are constant vectors providing the lower and upper bounds of $g$.

4.1 Discretization approaches

We refer readers to shuklavedula2019 for our discretization approaches. We note that with this discretization the trajectory optimization problem is transformed into a discrete search problem and where the objective function to be minimized is the discrete form of Eq. $\!\eqref{Eq_Main_Cost}$.

In principle, one can now solve the problem by traversing the discrete search space and finding the state that corresponds to the minimum cost and satisfies all the imposed constraints. Still, in practice, the problem is the massive size of the discrete search space. The quantum grid search algorithm offers a promising method to tackle such problems.

5 Application of quantum grid search algorithm in trajectory optimization

The quantum grid search algorithm (Algorithm 1) described earlier, is applicable in the general context of the problem of finding the minimum cost for the problem described in Sect. 4.1, with the cost function being the discrete version of Eq. $\!\eqref{Eq_Main_Cost}$. We explain in the following how the quantum grid search algorithm can be used to solve a trajectory optimization problem under some mild assumptions. First, we will consider a two-dimensional problem and then subsequent we will describe how a general $d$-dimensional problem, with $d>2$ can be tackled using our algorithm. For illustrating the key idea we will first consider the brachistochrone problem, with the objective of minimizing the time $\tau_{f}$ given by a discrete version of Eq. $\!\eqref{eq_cost}$, and then give the most general case.

Before proceeding further, we define precisely some relevant terms. The definitions given below are applicable for any two-dimensional trajectory optimization problem. However, it makes more intuitive sense in the context of the brachistochrone problem described in Sect. 5.1.

Definition 5.1** (Path).**

An element $(y_{1},y_{2},\cdots y_{k})\in\prod_{i=1}^{k}X_{i}$ is called a path.

Definition 5.2** (Cost).**

$\operatorname{Cost}$* is a real valued function $\{\operatorname{Cost}\ |\ \prod_{i=1}^{k}X_{i}\to{\mathbb{R}}\}$, such that $\operatorname{Cost}\left((y_{1},y_{2},\cdots y_{k})\right)$ gives the cost associated to the path $(y_{1},y_{2},\cdots y_{k})$ (or more precisely, for the continuous path $y(x)$ obtained via interpolation from the path $(y_{1},y_{2},\cdots y_{k}))$. For example, for the brachistochrone problem the cost is calculated using Eq. $\!\eqref{eq_cost}$.*

We remark here that although we are using the ‘term’ cost, in general it could be any quantity of interest, such as in the context of the brachistochrone problem it is basically the ‘time’.

Definition 5.3** ($\operatorname{SolutionPaths}(a,b)$).**

A path $(y_{1},y_{2},\cdots y_{k})\in\prod_{i=1}^{k}X_{i}$ belongs to the set $\operatorname{SolutionPaths}(a,b)$, if $a<\operatorname{Cost}\left((y_{1},y_{2},\cdots y_{k})\right)<b$. In other words,

[TABLE]

Definition 5.4** (Marked Element).**

An element $x_{i,j}\in X_{i}$ is considered a marked element of $X_{i}$ with respect to $\operatorname{SolutionPaths}(a,b)$, if there exist a path say $(y_{1},y_{2},\cdots y_{k})\in\operatorname{SolutionPaths}(a,b)$, such that $y_{i}=x_{i,j}$.

5.1 Brachistochrone problem

The objective in the brachistochrone problem is to find the required trajectory of a particle starting from the rest under the influence of gravity, without any friction, such that it slides from the one fixed point to the other in the least possible time. Let $\vec{X}(t)=x(t)\vec{i}+y(t)\vec{j}$ be the position of the particle. The goal is to minimize $\tau_{f}$ given by

[TABLE]

under the boundary conditions $(x(\tau_{0}),y(\tau_{0}))=(0,2)$ and $(x(\tau_{f}),y(\tau_{f}))=(\pi,0)$ with $\tau_{0}=0$. We describe a possible discretization approach to solve the brachistochrone problem.

5.1.1 Global discretization in physical space

Out of infinitely many possible paths, the goal is to pick the path with the minimum time. For practical purposes it is sufficient to find a ‘good enough’ approximate solution (based on acceptable levels of errors). The discretization is chosen based on what constitute a ‘good enough’ solution in a given context. In our present example, the physical space consists of the rectangle $[0,\pi]\times[0,2]$ in ${\mathbb{R}}^{2}$. Of course, one may as well consider a bigger rectangle to allow for the possibility of better solutions. One can now discretize the rectangle $[0,\pi]\times[0,2]$ in several possible ways. For example, let $x_{i}=\frac{\pi i}{k}$ for $i=1\cdots k$. Let $y_{i}\in\{x_{i,j}=\frac{2j}{n_{i}}:\>j=0,1\cdots n_{i}\}$ for $i=1$ to $n_{i}$. We set $y_{1}=2$ and $y_{k}=0$ to account for the boundary condition.

Essentially, it means that once a discretization of $x$ is carried out then we require that at $x=x_{i}$, the corresponding $y(x_{i})$ can only have values from the set $\{x_{i,j}:\>j=0,1\cdots n_{i}\}$ (see Fig. 4). We remark here that the definition of “path” given in Def. 5.1 makes sense, as given $(y_{1},y_{2},\cdots y_{k})\in\prod_{i=1}^{k}X_{i}$, one can use Lagrange interpolation to find a continuous path $y(x)$ such that $y(x_{i})=y_{i}$, for $i=1,2,\cdots k$, and $y(x)$ is then a candidate solution of the brachistochrone problem under consideration. We note that with the above discretization there are $N=\prod_{i=1}^{k}n_{i}$ total possible cases need to be considered. The minimum time can now be obtained by considering all the paths in this search space.

If needed, one can always approach the correct solution to the desired accuracy by making the discrete grid finer. However, the discrete search space grows very rapidly, therefore, an efficient algorithm, such as the quantum grid search algorithm described in Sect. 3, is needed to solve the problem.

5.2 Solution of Brachistochrone problem

In the following we give Algorithm 2, which uses Algorithm 1, and the idea of a classical binary search, to successively improve the bounds $(a,b)$ such that $\operatorname{SolutionPaths}(a,b)$ is non-empty.

We assume that an upper bound $b_{0}$ for the minimum time is known. For example, this can be achieved by carrying out a classical measurement after selecting a random path $(y_{1},y_{2},\cdots y_{k})\in\prod_{i=1}^{k}X_{i}$ and calculating the associated cost $\operatorname{Cost}\left((y_{1},y_{2},\cdots y_{k})\right)$. Then $b_{0}=\operatorname{Cost}\left((y_{1},y_{2},\cdots y_{k})\right)$. We also require a choice for the desired possible lower bound on the minimum time $a_{0}$. Of course, $a_{0}$ could just be set to [math]. Next, we define oracle function $f_{a,b}$ as follows

[TABLE]

Advantages:

We now discuss the advantages offered by Algorithm 1 and Algorithm 2. First of all, we note that the set $X=\prod_{i=1}^{k}n_{i}$ has the cardinality of $\prod_{i=1}^{k}n_{i}$, i.e., there are possible $\prod_{i=1}^{k}n_{i}$ number of paths. For ease of analysis assume that $n_{i}=N$ for all $i$. Then there are total $N^{k}$ paths, with each path having an associated cost (or time in this case). The goal here is to find the path with the minimum associated cost, out of these $N^{k}$ paths. A classical algorithm will clearly need ${\mathbb{O}}(N^{K})$ searches in the worst case. If we use any known minimization algorithms based on Grover’s search algorithm directly, treating each path as an input, then with a quadratic speed-up the quantum algorithm will succeed with probability close to $1$ within ${\mathbb{O}}(\sqrt{N^{k}})$. Now we consider our quantum grid search algorithm, i.e., Algorithm 1. Clearly in the situation under consideration, in the worst case the running time of Algorithm 1 is of the order of ${\mathbb{O}}(\sqrt{N})$. Finally, Algorithm 2 calls Algorithm 1, c number of times. Therefore, Algorithm 2 will succeed in $c\,{\mathbb{O}}(\sqrt{N})$. Of course, Algorithm 2 does not actually find the minimum solution, it just gives the bound $(a,b)$ on the solution, and given $(a,b)$ a direct application of Algorithm 1 with the Oracle function $f_{a,b}$, a path in $\operatorname{SolutionPaths}(a,b)$ can be discovered easily. However, it should be clear that in many situations Algorithm 1 and Algorithm 2 offer great computational advantages over the classical methods. In fact, for some practical applications, if one is not looking for an absolute minimum, but just a ‘good enough’ solution path with the associated cost less than a predetermined value, then Algorithm 2 will be even more efficient in discovering such a solution.

5.3 Generalization to higher-dimensional problems

Now we consider how Algorithm 1 and Algorithm 2 could be employed to treat higher dimensional optimization problems. Suppose the discretization is carried out as described in shuklavedula2019 . This will result in a discrete search space (similar to the discrete grid described earlier for the brachistochrone problem, but possibly of a higher dimension with a large value of $k$ and with the role of $x$ variable being played by the time variable $t$). To make this point clear we revisit the two dimensional trajectory, say $y=f(x)$, used in the brachistochrone problem. One of the key features in our discretization scheme is that we discretize both the independent variable $x$ as well as the dependent variable $y$. Which means we take samples at $x=x_{i}$ for $i=1,2,\cdots k$, and for each $x_{i}$ then the corresponding $y$-coordinate, i.e., $y_{i}=f(x_{i})$, can only take values from a finite set. We refer to Fig. 4 which illustrates this and wherein $y_{i}=f(x_{i})$ can only take values from the set $X_{i}=\{x_{i,j}:\>j=0,1\cdots n_{i}\}$. Clearly, each choice of an element in $(y_{1},y_{2},\cdots y_{k})\in\prod_{i=1}^{k}{X_{i}}$ defines a “path” (one can use Lagrange interpolation using the points $(x_{i},y_{i})$ for $i=1,2,\cdots k$ to construct the continuous path $y=f(x)$ passing through these points). Now consider motion in the $3$-dimensional space. Of course, mathematically a curve with the parametric equation $r(t)=x(t)\vec{i}+y(t)\vec{j}+z(t)\vec{k}=\langle x(t),y(t),z(t)\rangle$ for $t\in[t_{0},t_{f}]$ can describe this motion. Now we discretize the parameter $t$ by taking samples at $t=t_{i}$ for $i=1,2,\cdots k$, and for each $t_{i}$ then the corresponding $x,y$ and $z$-coordinates, i.e., $x_{i}=x(t_{i}),y_{i}=y(t_{i})$ and $z=z(t_{i})$ can only take values from finite sets, $X_{i},Y_{i}$ and $Z_{i}$, respectively. Clearly this means the motion of the particle is restricted on a $3$-dimensional discrete grid. Now the concept of “path” and the “marked path” can easily be defined. Therefore, essentially the problem formulation in this case will be quite similar to the formulation in the brachistochrone problem described earlier. Indeed, it is clear that in order to implement our quantum grid search algorithm , i.e., Algorithm 1, in this case the set $X$ therein should be replaced by $\prod_{i=1}^{k}X_{i}Y_{i}Z_{i}$, with each element in $\prod_{i=1}^{k}X_{i}Y_{i}Z_{i}$ defining a “path”. Then for each of $X_{i},Y_{i}$ and $Z_{i}$ for $i=1,2,\cdots k$ a Grover operator will be required for implementing Algorithm 1.

From the previous discussion, it should be now clear that this method could be generalized, similarly, to even higher dimensional trajectory optimization problems. Indeed, for each discretized state and control variable at chosen sampling points, a Grover operator will be needed, and all such Grover operator will work in parallel. For example, suppose $X_{i}$, for $i=1$ to $p$, are $p$ state variables, and $Y_{i}$, for $i=1$ to $q$, are $q$ control variables. In this case, in Algorithm 1, the set $X$ should be replaced by $\prod_{i=1}^{k}\prod_{r=1}^{p}\prod_{s=1}^{q}{X_{r}}_{i}{Y_{s}}_{i}$, with each element in $\prod_{i=1}^{k}\prod_{r=1}^{p}\prod_{s=1}^{q}{X_{r}}_{i}{Y_{s}}_{i}$ defining a “path”. Therefore, we conclude that Algorithm 1 is applicable to higher dimensional trajectory optimization problems.

Here we want to point out a limitation to our proposed approach. It is obvious that for a high dimensional problem, with a very large value of $k$, the number of Grover operators needed will be very big. This means the number of components and logic gates needed for the quantum circuit implementing Algorithm 1 will be very high. In a sense the gain in computational speed is limited by the increased complexity of the quantum circuit. Still, even with this limitation many optimizations problems will be amenable to being treated by Algorithm 1 and Algorithm 2.

6 Conclusion

In this paper, we proposed two quantum search algorithms, Algorithm 1 and Algorithm 2. The first algorithm, Algorithm 1, addresses a class of special search problems involving identification of “marked elements” associated with specified bounds on a discrete grid. This class of problems is relevant to many fields, including global trajectory optimization. The second algorithm, Algorithm 2, is a binary search algorithm based on Algorithm 1), that efficiently solves global trajectory optimization problems. We note that the key idea behind Algorithm 1 is the use of parallel Grover operators for quantum search. We proved (using Theorem 3.2,) that Algorithm 1 finds success within the expected running time of ${\mathbb{O}}\left(\max\left(\sqrt{\frac{n_{i}}{m_{i}}}\right)_{i=1}^{i=k}\right)$. This is a big improvement over a pure non-parallel classical algorithm which is of the order of $\prod_{i=1}^{k}n_{i}$. It is important to note that such enhanced computational efficiency of our proposed algorithms comes at a cost of increased complexity of the underlying quantum circuitry. We also note that our assumption on the availability of local oracle functions may not be true in many cases. Still, if these conditions are satisfied, then the computational advantages offered by our quantum algorithms could potentially enable us to tackle very high dimensional problems, which are beyond the capability of classical computers. The proposed algorithms are especially valuable in cases where solutions within specified bounds might be sufficient for practical use, instead of absolute global optimum solutions that can be difficult to find. Although, quantum computing is still in its infancy, and limited by the number of qubits available, hopefully, in the future with the advent of more powerful quantum computers the practical implementation of the algorithms presented in this work will become feasible.