Quantum-Enhanced Generalized Pattern Search Optimization

Abstract

While the development of quantum computers promises a myriad of advantages over their classical counterparts, care must be taken when designing algorithms that substitute a classical technique with a potentially advantageous quantum method. The probabilistic nature of many quantum algorithms may result in new behavior that could negatively impact the performance of the larger algorithm. The purpose of this work is to preserve the advantages of applying quantum search methods for generalized pattern search algorithms (GPSs) without violating the convergence criteria. It is well known that quantum search methods are able to reduce the expected number of oracle calls needed for finding the solution to a search problem from $O\left(N\right)$ to $O\left(\sqrt{N}\right)$ However, the number of oracle calls needed to determine that no solution exists with certainty is exceedingly high and potentially infinite. In the case of GPS, this is a significant problem since overlooking a solution during an iteration will violate a needed assumption for convergence. Here, we overcome this problem by introducing the quantum improved point search (QIPS), a classical–quantum hybrid variant of the quantum search algorithm QSearch. QIPS retains the $O\left(\sqrt{N}\right)$ oracle query complexity of QSearch when a solution exists. However, it is able to determine when no solution exists, with certainty, using only $O\left(N\right)$ oracle calls.

1. Introduction

Traditional optimization algorithms rely on derivatives to obtain their results. However, in many cases, derivative information may be unavailable. Even if the derivatives of some order exist, it may be impractical or prohibitively expensive to calculate any of them. For example, it can be impractical to obtain gradient information when the objective function is computed using a black-box simulation. Similarly, approximation methods such as finite differences can become prohibitively expensive or inaccurate for objective functions that are expensive to calculate or noisy. Even for functions constructed recursively from elementary functions using composition and arithmetic operations, gradient computation may incur onerous costs in time and memory. Automatic differentiation can also be used to obtain gradient information in some cases, but is not always practical since it either needs the source code for the function to be available, or to be built into the original code through a method such as operator overloading. In these situations, we turn to derivative-free optimization (DFO) algorithms. DFO algorithms seek to solve a given optimization problem without the use of differential information of any order. Instead, they rely on calls to a given oracle to evaluate the objective function. These calls are often expensive and become the dominant cost of the algorithm.

In this work, we are concerned with a class of DFO algorithms known as Generalized Pattern Search (GPS). These algorithms generate a sequence of iterates with non-increasing objective function values by systematically selecting points to be evaluated and considered for the next iterate. This process is split into two steps: the search and poll steps. The only difference between them is how points are chosen to be evaluated. The search step is designed to allow for increased flexibility when selecting which points to consider, potentially reducing the number of iterations needed to find a solution. The poll step is constructed to ensure convergence of the algorithm, only considering those points necessary to satisfy the convergence criteria outlined in [1], Section 3. A typical iteration will begin with the search step. The poll step is invoked only if the search step fails to produce an iterate with a reduced objective function value.

Both the search and poll steps of GPS can be framed as unstructured search problems on finite sets. It is well known that quantum computers are able to reduce the expected number of oracle calls in such problems from $O\left(N\right)$ to $O\left(\sqrt{N}\right)$ [2,3]. As in [4,5,6], we make the standard assumption that any difference in the computational cost of a quantum and classical oracle call is negligible. At first glance, quantum search techniques would seem to be a natural fit for GPS. However, quantum search methods assume the existence of a solution within the set being searched and are not equipped to determine when no solution exists. Terminating the algorithm before an exhaustive search has been performed will invalidate the convergence properties provided by the poll step, and allowing the algorithm to run until an exhaustive search has been performed is not guaranteed to occur using a finite number of oracle calls. This presents a significant hurdle for applying quantum search methods to GPS algorithms since the sets searched during an iteration of GPS are not guaranteed to contain a point with reduced objective function value.

The application of the quantum search techniques developed in [2,3] for optimization was previously explored in earlier works such as [7,8]. However, these approaches restrict their search to a single finite set of points, obtaining an accurate solution with high probability using the error bounds initially presented in [9]. Applying this approach to GPS, as was first touched on by Arunachalam [10], allows for the potential of error during the poll step, violating necessary assumptions for convergence. The main contribution of this paper is the introduction of the Quantum Improved Point Search algorithm (QIPS), a quantum–classical hybrid variant of the quantum search algorithm QSearch ([3], Section 2). QIPS introduces a classical search process that runs in parallel with QSearch, designed to leverage the reduction in oracle calls provided by QSearch while ensuring the convergence criteria for GPS presented in [1] is satisfied.

The remaining sections of this paper are organized as follows. Section 2 is dedicated to reviewing the background material necessary for the rest of the paper. In Section 2.1, we discuss the fundamental aspects of quantum computing. In Section 2.2, we review the quantum search algorithm QSearch. In Section 2.3, we review classical GPS algorithms and their convergence criteria. In Section 3, we introduce our main result, the QIPS algorithm. We begin in Section 3.1, where we discuss how our optimization problem is represented in a quantum computer. In Section 3.2, we formally introduce the QIPS algorithm and show that it retains the advantages of quantum search methods while preserving convergence when used for GPS. We end the paper with some concluding remarks in Section 4.

2. Preliminaries

In this section, we review all of the technology and notation from quantum computing and classical GPS algorithms required to understand this paper’s main contributions. In Section 2.1, we discuss the fundamental components of quantum computing that will be used throughout the paper. Then, in Section 2.2, we review the quantum search algorithm QSearch introduced in [3], Section 2. In Section 2.3, we review classical GPS algorithms, following the formulation presented by Audet and Dennis in [1]. In the original formulation introduced by Torczon in [11], the search and poll steps are not treated as distinct steps. Audet and Dennis’s separation of GPS iterations into the search and poll steps allows for a clearer understanding of the algorithms convergence properties.

2.1. Quantum Computing

In this section, we provide a brief review on the fundamental details of quantum computing relevant to our results. As their name implies, quantum computers exploit the quantum mechanical behavior of a physical system in order to perform some specified computation. The state of a quantum computer is described by its state vector, a unit vector in a complex-valued inner product space, sometimes referred to as the state space. The state vector is stored using qubits, a quantum mechanical variant of the classical bit. A single qubit is a unit vector in ${\mathbb{C}}^2$, denoted as $|\psi ⟩=\alpha |0⟩+\beta |1⟩$, where $\alpha ,\beta \in \mathbb{C}$, and $\{|0⟩,|1⟩\}$ is the standard basis for ${\mathbb{C}}^2$, referred to here as the computational basis. For those unfamiliar with this notation, better known as Dirac notation, we note that $|0⟩={(1,0)}^T$ and $|1⟩={(0,1)}^T$.

Furthermore, the Dirac notation for the conjugate transpose of a vector $|\psi ⟩$ is ${\left(|\psi ⟩\right)}^{†}=⟨\psi |$ and thus the standard inner and outer products are written as $⟨\psi |\psi ⟩$ and $|\psi ⟩⟨\psi |$. As one may expect, quantum computers are not limited to states consisting of a single qubit. The state vector of a quantum computer containing N qubits is a unit vector in ${\mathbb{C}}^{2^N}$. Thus, the computational basis for a quantum computer containing N qubits is defined as the standard basis for ${\mathbb{C}}^{2^N}$. For example, the computational basis for a 2-qubit quantum computer is

$$\left\{|00⟩,|01⟩,|10⟩,|11⟩\right\}=\left\{{(1,0,0,0)}^T,{(0,1,0,0)}^T,{(0,0,1,0)}^T,{(0,0,0,1)}^T\right\}.$$

(1)

Let $|\psi ⟩\in {\mathbb{C}}^{2^N}$ be an arbitrary state vector for a quantum computer containing N qubits:

$$|\psi ⟩=\sum _{j=0}^{2^N-1}{\alpha }_j|j⟩.$$

(2)

Since all state vectors are unit vectors, we require that

$$\sum _{j=0}^{2^N-1}{\left|{\alpha }_j\right|}^2=1,$$

(3)

and we refer to the value ${\alpha }_j$ as the amplitude of the computational basis state $|j⟩$.

To simplify our notation, we denote the k qubit state vector consisting of k copies of the same state $|\psi ⟩$ by ${|\psi ⟩}^{\otimes k}$. Furthermore, when $|\psi ⟩\in \{|0⟩,|1⟩\}$, we often omit the superscript entirely and write the state simply as $|0⟩$ or $|1⟩$, so long as the number of qubits is clear from the context. A set of qubits is often referred to as a quantum register to distinguish between the set of qubits and the quantum computer itself. The quantum computational variant of logic gates is represented as unitary matrices that can be applied to the state vector of a quantum computer.

One of the properties that distinguishes quantum computers from their classical counterparts is the inability to view the state vector directly. Instead, we are only able to perform a measurement which will produce a computational basis vector, with probability determined by its amplitude. That is to say, the probability of obtaining $|j⟩$ upon measurement is given by $|{\alpha }_j{|}^2$. For a given state vector with more than one non-zero amplitude, we say that it is in a superposition of the corresponding states. Finally, a quantum algorithm is defined as a unitary operator applied to the state vector, possibly followed by measurement.

2.2. QSearch

Let $\mathcal{A}$ be a measurement-free algorithm such that $\mathcal{A}|0⟩=|\varphi ⟩$. Recall that the state vector $|\varphi ⟩$ is a unit vector in ${\mathbb{C}}^{2^m}$, where m is the number of qubits used to store the state. We can separate ${\mathbb{C}}^{2^m}$ into a subspace of desired states ($\mathcal{D}$) and its orthogonal compliment containing all undesired states ($\mathcal{U}$). These subspaces are determined by partitioning the computational basis into a set of desired measurement results $\overline{\mathcal{D}}$, and a set of undesired measurement results $\overline{\mathcal{U}}$. In [3], Section 2, this representation of a state vector is used to introduce amplitude amplification, a class of algorithms designed to increase the probability of obtaining an element of $\overline{\mathcal{D}}$ upon measurement. In this section, we review the amplitude amplification algorithm QSearch, beginning with the fundamental details of amplitude amplification itself.

A key component of amplitude amplification is a unitary operator Q, chosen such that applying it to the state $|\varphi ⟩$ increases the amplitudes of states in $\mathcal{D}$, while decreasing those of $\mathcal{U}$. Let $|{\varphi }_d⟩\in \mathcal{D}$ and $|{\varphi }_u⟩\in \mathcal{U}$ such that

$$|\varphi ⟩=|{\varphi }_d⟩+|{\varphi }_u⟩.$$

(4)

The reader should take care to note that since $|\varphi ⟩$ is a state vector, it is also a unit vector. Thus, if $|{\varphi }_d⟩$ and $|{\varphi }_u⟩$ are both non-zero vectors, then neither of them is a unit vector. Q is defined in [3], Section 2, as the unitary operator

$$Q=(I-2|\varphi ⟩⟨\varphi |)\left(I-{\displaystyle \frac{2}{⟨{\varphi }_u|{\varphi }_u⟩}}|{\varphi }_u⟩⟨{\varphi }_u|\right).$$

(5)

However, Q is more often implemented using the formula provided by the following theorem from [3], Section 2.

Theorem 1

([3], Section 2). We can express Q as $Q=-\mathcal{A}{\mathcal{S}}_0{\mathcal{A}}^{†}{\mathcal{S}}_{\mathcal{D}}$, where ${\mathcal{S}}_0$ and ${\mathcal{S}}_{\mathcal{D}}$ are the unitary operators defined by

$$\begin{array}{cc}\hfill {\mathcal{S}}_0& =I-2|0⟩⟨0|\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill {\mathcal{S}}_{\mathcal{D}}& =-\left(I-{\displaystyle \frac{2}{⟨{\varphi }_u|{\varphi }_u⟩}}|{\varphi }_u⟩⟨{\varphi }_u|\right).\hfill \end{array}$$

(7)

To see how Q can be used to increase the probability of obtaining a desired state upon measurement, we have from [3], Section 2, that for all $j\in \mathbb{N}$,

$$Q^j|\varphi ⟩={\displaystyle \frac{1}{\sqrt{⟨{\varphi }_d|{\varphi }_d⟩}}}sin\left((2j+1){\theta }_d\right)|{\varphi }_d⟩+{\displaystyle \frac{1}{\sqrt{⟨{\varphi }_u|{\varphi }_u⟩}}}cos\left((2j+1){\theta }_d\right)|{\varphi }_u⟩.$$

(8)

Thus, the probability of obtaining a desired state is increased by choosing j such that $si{n}^2\left({\theta }_d\right)<si{n}^2\left((2j+1){\theta }_d\right)\le 1$. However, the ideal choice of j depends on the value of ${\theta }_d$. In [3], Section 2, several amplitude amplification methods are presented, each differing based on our knowledge of ${\theta }_d$. For our purposes, we are only concerned with QSearch algorithm. This method assumes we have no prior knowledge of ${\theta }_d$. We now present Algorithm 1 ([3], Section 2).

Algorithm 1 QSearch

1: function QSearch($(Q,|\varphi ⟩,\mathcal{D})$) 2:      Let $l=0$ and $c\in (1,2)$. 3:      Let $|R⟩$ be the result of measuring $|\varphi ⟩$. 4:      while $|R⟩\notin \mathcal{D}$ do 5:           Set $l=l+1$. 6:           Select $j\in \left[1,\lceil c^l\rceil \right]\cap \mathbb{Z}$ uniformly at random. 7:           Let $|R⟩$ be the result of measuring $Q^j|\varphi ⟩$. 8:           if $|R⟩\notin \mathcal{D}$ then 9:                Let $|R⟩$ be the result of measuring $|\varphi ⟩$. 10:         end if 11:     end while 12:     return $|R⟩$. 13: end function

Our presentation of QSearch differs slightly from that in [3], Section 2. In our presentation, we pass Q and $|\varphi ⟩$ as input, whereas the original uses $\mathcal{A}$ and $\chi$, where $\chi$ is a binary function used in the construction of $S_{\mathcal{D}}$. Our version is equivalent, this change only being made to streamline the notation and better align with the results presented later in the paper. We are now prepared to present the following result for Qsearch, whose proof is omitted for the sake of concision. Interested readers are encouraged to review its original presentation in [3], Theorem 3. We note that in the original presentation, the authors emphasize the expected number of times the algorithm $\mathcal{A}$ and its inverse ${\mathcal{A}}^{†}$ are used. Since this is a direct result of the number of times Q is used, we have adjusted the language to emphasize this fact.

Theorem 2

(QSearch Complexity) ([3], Theorem 3). For some quantum algorithm $\mathcal{A}$, let $|\varphi ⟩$ and Q be as defined in (4) and 1. Furthermore, suppose $⟨{\varphi }_d|{\varphi }_d⟩={\displaystyle \frac{t}{N}}$, for some non-negative integer t and positive integer N. Exactly one of the following cases holds based on the value of t:

• $t>0$: The expected number of times QSearch will use the operator Q before returning a desired state is in $O\left(\sqrt{{\displaystyle \frac{N}{t}}}\right).$
• $t=0$: QSearch will fail to terminate.

That QSearch fails to terminate when $⟨{\varphi }_d|{\varphi }_d⟩=0$ presents a significant hurdle when attempting to use it as a subroutine in algorithms such as GPS. Traditional approaches, such as that in [7,8], make use of known error bounds originally established in [9] to terminate the algorithm when there is a high probability that $⟨{\varphi }_d|{\varphi }_d⟩=0$. However, this leaves a non-zero probability that $⟨{\varphi }_d|{\varphi }_d⟩\ne 0$. It is this non-zero probability that causes a direct application of QSearch in GPS algorithms to violate the convergence criteria.

2.3. Generalized Pattern Search Algorithms

In this section, we review the construction of GPS algorithms. Originally introduced by Torczon in [11] before being expanded on by Audet and Dennis in [1]. Here, we follow Audet and Dennis’s formulation, where iterations are separated into distinct search and poll steps that better illustrate the convergence behavior of the algorithm. To simplify our presentation, we restrict ourselves to the unconstrained optimization problem.

GPS algorithms solve the optimization problem

$$\underset{x\in {\mathbb{R}}^n}{min}f\left(x\right)$$

(9)

for some $f:{\mathbb{R}}^n\to \mathbb{R}$, by generating a sequence of iterates ${\left\{x_k\right\}}_{k=0}^{\infty }$ such that ${\left\{f\left(x_k\right)\right\}}_{k=0}^{\infty }$ is a non-increasing sequence. A single iteration consists of the search and poll steps.

In the search step, we evaluate f at a finite number of points from a set called the mesh. At the kth iteration, the mesh is the set defined by

$$M_k=\{x_k+{\mathrm{\Delta }}_{k}Dz:z\in {\mathbb{Z}}_{+}^p\},$$

(10)

where $x_k$ is our current iterate, ${\mathrm{\Delta }}_k$ is a positive real number called the mesh size parameter, and D is a real valued $n\times p$ matrix whose columns form a positive spanning set, i.e., every vector in ${\mathbb{R}}^n$ can be written as a non-negative linear combination of D’s columns. Additionally, D satisfies the restriction that its columns are the products of some non-singular generating matrix $G\in {\mathbb{R}}^{n\times n}$ and integer vectors $z_j\in {\mathbb{Z}}^n$ for $j=1,2,\dots ,p$. Symbolically, this restriction means D takes the form $D=\left[G{z}_1\dots G{z}_p\right]$. At iteration k, we fix a subset of $M_k$, denoted by $S_k$, that will be searched. Thus, the number of points evaluated during the search step is given by $n_s\left(k\right)=\left|S_k\right|$. We call a point $y\in S_k$ an improved mesh point if $f\left(x_k\right)>f\left(y\right)$. If such a point is found during the search step, we end the iteration. Otherwise, we begin the poll step.

During the kth iteration, we select a subset of the columns of D, denoted by $D_k$, which is a positive spanning set. The poll set $P_k$ is formed using the current iterate and the elements of $D_k$:

$$P_k=\{x_k+{\mathrm{\Delta }}_{k}d:d\in D_k\}.$$

(11)

If the poll step is invoked, we evaluate the objective function for each of the elements in $P_k$ to check for an improved mesh point. Thus, the number of points evaluated during the poll step is given by $n_p\left(k\right)=\left|P_k\right|$. If no improved mesh points are found, we call the current iterate $x_k$ a local mesh optimizer.

Whenever a point y is identified as an improved mesh point by either the search or poll steps, we immediately end the iteration, set $x_{k+1}=y$, and either increase or maintain the mesh size parameter. Alternatively, if $x_k$ is determined to be a local mesh optimizer, then we set $x_{k+1}=x_k$ and shrink the mesh size parameter. The changes in the mesh size parameter are determined by the mesh adjustment parameter, a rational number $\tau >1$, and the set of mesh adjustment exponents, a finite set of integers $\{\omega :\omega \in [{\omega }^{-},{\omega }^{+}]\bigcap \mathbb{Z}\}$ where ${\omega }^{-}\le -1$ and ${\omega }^{+}\ge 0$. When an improved mesh point is found, the mesh adjustment exponent is set for some $\omega \in [0,{\omega }^{+}]$ so that ${\mathrm{\Delta }}_{k+1}={\tau }^{\omega }{\mathrm{\Delta }}_k\ge {\mathrm{\Delta }}_k$. Conversely, when both the search and poll steps fail to produce an improved mesh point at iteration k, the mesh adjustment exponent $\omega$ is set for some $\omega \in [{\omega }^{-},-1]$ so that ${\delta }_{k+1}={\tau }^{\omega }{\mathrm{\Delta }}_k<{\mathrm{\Delta }}_k$. We now present Algorithm 2 ([1], Section 2).

Algorithm 2 Generalized Pattern Search

1: function GPS($\left(G,Z,{\mathrm{\Delta }}_0,\tau ,{\omega }^{-},{\omega }^{+},ϵ,x_0\right)$) 2:       Let $D=GZ$ and $k=0$. 3:       while ${\mathrm{\Delta }}_k>ϵ$ do 4:             Prepare $S_k\subset M_k=\{x_k+{\mathrm{\Delta }}_{k}Dz:z\in {\mathbb{N}}^p\}$,with $|S_k|=n_S\left(k\right)<\infty$. 5:             if There exists $x^{+}\in S_k$ such that $f\left(x^{+}\right)<f\left(x_k\right)$ then 6:                   Let $\omega$ be an integer in $[0,{\omega }^{+}]$ 7:                   Let $x_{k+1}=x^{+}$ and ${\mathrm{\Delta }}_{k+1}={\tau }^{\omega }{\mathrm{\Delta }}_k$. 8:             else 9:                   Select columns of D to form a positive spanning set $D_k$. 10:                  Let $P_k=\{x_k+{\mathrm{\Delta }}_{k}d:d\in D_k\}$. 11:                  if There exists $x^{+}\in P_k$ such that $f\left(x^{+}\right)<f\left(x_k\right)$ then 12:                        Let $\omega$ be an integer in $[0,{\omega }^{+}]$. 13:                        Let $x_{k+1}=x^{+}$ and ${\mathrm{\Delta }}_{k+1}={\tau }^{\omega }{\mathrm{\Delta }}_k$. 14:                  else 15:                        Let $\omega$ be an integer in $[{\omega }^{-},-1]$. 16:                        Let $x_{k+1}=x_k$ and ${\mathrm{\Delta }}_{k+1}={\tau }^{\omega }{\mathrm{\Delta }}_k$. 17:                  end if 18:           end if 19:           Let $k=k+1$. 20:     end while 21:     Let $x^{\prime }=x_{k+1}$. 22:     return $x^{\prime }$. 23: end function

We conclude this section with a critical but brief discussion of the convergence results for GPS originally presented in [1], Section 3, and how they must be delicately handled in the presence of quantum search subroutines. The following theorem embodies the main results of [1], Section 3.

Theorem 3.

Suppose $f:{\mathbb{R}}^n\to \mathbb{R}$ has bounded sublevel sets. Then, the following hold for the sequence $X={\left\{x_j\right\}}_{j=0}^{\infty }$ of GPS:

1. 

Ref. [1] (Theorem 3.6). The iterate set contains a refining subsequence, i.e., a subsequence ${\left\{x_{j_i}\right\}}_{i=0}^{\infty }$ of local mesh optimizers such that ${lim}_{i=0}^{\infty }{\mathrm{\Delta }}_{j_i}=0$, which converges to some $x_{†}$.

2. 

Ref. [1] (Theorem 3.7). Let ${\left\{x_{j_i}\right\}}_{i=0}^{\infty }$ be a convergent refining subsequence with limit point $x_{†}$ and d be an element of a positive spanning set. If the objective function is evaluated at $x_{j_i}+d$ for infinitely many iterates in ${\left\{x_{j_i}\right\}}_{i=0}^{\infty }$, and f is Lipschitz in a neighborhood of $x_{†}$, then the Clarke generalized directional derivative of f at $x_{†}$ in the direction of d is non-negative:

$$\begin{array}{c}\hfill f^o(x_{†},d)=\underset{y\to x_{†},t\downarrow 0}{lim\; sup}{\displaystyle \frac{f(y+td)-f\left(y\right)}{t}}\ge 0.\end{array}$$

3. 

Ref. [1] (Theorem 3.9). Let ${\left\{x_{j_i}\right\}}_{i=0}^{\infty }$ be a convergent refining subsequence with limit $x_{†}$. If the objective function f is strictly differentiable at $x_{†}$, then $\nabla f\left(x_{†}\right)=0$.

The proof of [1], Theorem 3.6, pivotally relies upon the mesh size parameter shrinking only at the local mesh optimizers. GPS will frequently violate this assumption when equipped with quantum search methods, such as QSearch, using the techniques in [7,8].

3. Adapting QSearch for Generalized Pattern Search Algorithms

In this section, we present our main result, the Quantum Improved Point Search algorithm (QIPS). We begin in Section 3.1, where we discuss how to represent our optimization problem on a quantum computer. In Section 3.2, we discuss how we have modified QSearch to develop QIPS and prove that it retains the expected reduction in oracle calls provided by QSearch while satisfying the previously mentioned convergence criteria required by GPS.

3.1. The Quantum Representation of Our Optimization Problem

In this section, we discuss how the elements of our optimization problem will be represented on a quantum computer. Our representation of real numbers on a quantum computer will mimic that of a classical computer, using qubits in place of classical bits. For example, the number 0100110 would be stored as $|0100110⟩$. Performing binary arithmetic on numbers stored in this manner is an active area of research, with a wide variety of approaches proposed. For simplicity, we have chosen to represent real numbers using a fixed point representation. We represent a point $y\in {\mathbb{R}}^n$ as a computational basis state where the number of qubits used corresponds to the fixed point representation chosen. Furthermore, we assume access to a quantum oracle F that is able to evaluate the objective function. To ensure that F is a valid unitary operator, we store the state $|f\left(y\right)⟩$ in a separate register than $|y⟩$. Thus, we assume F satisfies the following:

$$F|y⟩|0⟩=|y⟩|f\left(y\right)⟩.$$

(12)

Given F as defined above, the linear extension of F to a linear unitary operator is trivial. Since we are only concerned about F’s behavior on the elements in $span\left(\{|y⟩|0⟩:y\in {\mathbb{R}}^n\}\right)$, we assume any valid linear extension has been chosen to define F.

The advantage of using the quantum oracle F over its classical counterpart stems from the ability to apply F to a set of points stored in superposition, enabling the objective function to be evaluated for each point in the set using a single call to F. Let $Y={\left\{y_j\right\}}_{j=0}^{N-1}$ be a set of N points in ${\mathbb{R}}^n$. Using an algorithm such as those described in [12], we can prepare the state ${\displaystyle \sum _{j=0}^{N-1}}|y_j⟩|0⟩$. Applying F to this state then gives

$$F\sum _{j=0}^{N-1}|y_j⟩\to \sum _{j=0}^{N-1}|y_j⟩|f\left(y_j\right)⟩.$$

(13)

We are now prepared to begin our presentation of the QIPS algorithm.

3.2. Quantum Improved Point Search

In this section, we introduce the QIPS algorithm. Our algorithm aims to leverage the oracle query reductions provided by QSearch (Algorithm 1) while preserving the convergence properties of GPS presented in [1], Section 3. Recall from the Theorem governing the complexity of QSearch (Theorem 2) that QSearch fails to terminate if $⟨{\varphi }_d|{\varphi }_d⟩=0$. This presents a significant problem for its use in GPS (Algorithm 2) since $⟨{\varphi }_d|{\varphi }_d⟩=0$ during the poll step whenever the current iterate is a local mesh optimizer. For example, suppose we have the objective function $f\left(x\right)=x^2$, mesh size parameter $\mathrm{\Delta }=1$, positive spanning set $D=\{2,-3\}$, and current iterate $x_0=1$. Then, we have the poll set $P=\{3,-2\}$, and $x_0$ is a local mesh optimizer for P. It follows that QSearch would fail to terminate when applied in such a situation. The error bounds introduced in [9] allow the possibility of terminating the algorithm when the probability that $⟨{\varphi }_d|{\varphi }_d⟩=0$ is high. However, there remains a non-zero probability that $⟨{\varphi }_d|{\varphi }_d⟩\ne 0$. This can be remedied somewhat when prior knowledge of the state $|\varphi ⟩$ allows us to determine the number of states in the computational basis that have non-zero amplitude. As is the case with GPS algorithms. In terms of the search problem, this only requires that we know the number of items being searched. However, even when we have this prior knowledge, QSearch only guarantees $⟨{\varphi }_d|{\varphi }_d⟩=0$ with certainty once all possible states have been returned during the execution of lines 7 1). However, this is not guaranteed to occur using a finite number of oracle calls.

This presents a significant problem when applying QSearch in a GPS method since the convergence results shown in Theorem 3 require that the mesh size parameter shrinks only at local mesh optimizers, meaning a direct application of QSearch during the poll step eliminates the convergence guarantees it is designed to provide. To overcome this limitation, we introduce a classical search method we call Local Mesh Filter (LMF). This method takes as argument a classical oracle for our objective function f, the current iterate x, a list of points Y in the mesh, and an integer j, and checks j points from Y for improved mesh points. This process is run in parallel with QSearch to produce QIPS. Using this approach, we are able to ensure that for sets containing an improved mesh point, QIPS will find one using an expected number of oracle calls in $O\left(\sqrt{N}\right)$, and require an expected number of oracle calls in $O\left(N\right)$ to determine one does not exist. Algorithm 3 is then as follows:

Algorithm 3 Local Mesh Filter

1: function LMF($(f,x,Y,j)$) 2:      Set $k=1$ and $x^{+}=x$. 3:      Set $K=min\{j,|Y\left|\right\}$. 4:      while $k<j$ and $x^{+}=x$ do 5:           Choose $x_k$ from Y uniformly at random. 6:           if $f\left(x_k\right)<f\left(x\right)$ then 7:                Set $x^{+}=x_k$. 8:           else 9:                Set $Y=Y\setminus \left\{x_k\right\}$. 10:              Set $k=k+1$. 11:         end if 12:     end while 13:     return $x^{+}$, Y. 14: end function

Before we introduce QIPS, we must first discuss how to obtain the necessary inputs related to the QSearch portion of the algorithm. Each call to QIPS will require a unique choice of $\mathcal{A}$ corresponding to either the subset of the mesh $S_k$ or the poll set $P_k$, where k is an integer denoting the current iteration. Letting $Y={\left\{y_j\right\}}_{j=0}^{N-1}$ denote an arbitrary subset of the mesh or poll set, a natural approach would be to choose $\mathcal{A}$ such that

$$\mathcal{A}|0⟩={\displaystyle \frac{1}{\sqrt{N}}}\sum _{j=0}^{N-1}|y_j⟩|f\left(y_j\right)⟩.$$

(14)

However, this approach may be unnecessarily expensive when the cost of preparing the operator Q is considered. Recall from Theorem 1 that $Q=-\mathcal{A}{\mathcal{S}}_0{\mathcal{A}}^{†}{\mathcal{S}}_{\mathcal{D}}$, where

$$\begin{array}{cc}\hfill {\mathcal{S}}_0& =I-2|0⟩⟨0|\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill {\mathcal{S}}_{\mathcal{D}}& =I-{\displaystyle \frac{2}{⟨{\varphi }_u|{\varphi }_u⟩}}|{\varphi }_u⟩⟨{\varphi }_u|.\hfill \end{array}$$

(16)

Using Equation (14) to identify improved mesh points requires that our set of desired states $\mathcal{D}$ changes whenever an improved mesh point is found. This in turn requires that ${\mathcal{S}}_{\mathcal{D}}$ is recalculated each time an improved mesh point is found. This additional overhead may be avoided by choosing $\mathcal{A}$ in such a way that $\mathcal{D}$ does not depend on the value of the current iterate. Suppose we use an additional register that contains the state $|f\left(y_j\right)-f\left(x_k\right)⟩$, where $f\left(x_k\right)$ is the value of our objective function at the current iterate $x_k$. Then, $\mathcal{D}$ may be defined by the sign qubit of $|f\left(y_j\right)-f\left(x_k\right)⟩$. Thus, we choose ${\mathcal{A}}_Y$ such that

$${\mathcal{A}}_Y|0⟩={\displaystyle \frac{1}{\sqrt{N}}}\sum _{j=0}^{N-1}|y_j⟩|f\left(y_j\right)⟩|f\left(y_j\right)-f\left(x_k\right)⟩.$$

(17)

Our set of desired states is then

$$\mathcal{D}=\left\{|a⟩|b⟩|c⟩\right|c<0\}$$

(18)

for all iterations, and ${\mathcal{S}}_{\mathcal{D}}$ will only need to be computed a single time.

To implement $A_Y$, we will need three additional algorithms beyond F. Let B be a quantum algorithm such that for computational basis states $|a⟩,|b⟩,$ and $|c⟩$

$$B|a⟩|b⟩|c⟩=|a⟩|b⟩|b+c⟩$$

(19)

and let $V_Y$ denote a quantum algorithm such that

$$V_Y|0⟩={\displaystyle \frac{1}{\sqrt{N}}}\sum _{j=0}^{N-1}|y_j⟩|0⟩|0⟩.$$

(20)

Finally, let $W_k$ be a quantum algorithm such that

$$W_k|0⟩|0⟩|0⟩=|0⟩|0⟩| - f\left(x_k\right)⟩.$$

(21)

Since we are only concerned with the effects of B, $V_Y$, and $W_k$ as defined above, we assume any valid linear extensions have been chosen. Interested readers are directed to [12,13] for examples of valid choices. Thus, we define ${\mathcal{A}}_Y$ as the quantum algorithm

$${\mathcal{A}}_Y=BF{V}_Y{W}_k.$$

(22)

With these inputs defined, we return to the introduction of the QIPS algorithm. As previously mentioned, QIPS can be viewed as running QSearch and LMF in parallel, terminating the algorithm if an improved mesh point is found or LMF determines that the current iterate is a local mesh optimizer. We make the additional modification of setting a fixed value for c at $c=\frac{6}{5}$ and selecting our exponent to be strictly less than $c^l$ during the lth iteration. These last two changes follow the approach shown in [9], Theorem 3, and are made to simplify our results. Algorithm 4 is as follows:

Algorithm 4 Quantum Improved Point Search

1: function QIPS($(Q,|\varphi ⟩,\mathcal{D},f,x,Y)$) 2:      Let $l=0$, $c=\frac{6}{5}$, and $x^{+}=x$. 3:      Let $|R_0⟩ |R_1⟩ |R_2⟩$ be the result of measuring $|\varphi ⟩$. 4:      while $|R_0⟩ |R_1⟩ |R_2⟩\notin \mathcal{D}$, $x^{+}=x$, and $Y\ne \varnothing$ do 5:           Set $l=l+1$. 6:           Select $j\in \left[1,\lceil c^l\rceil \right]\cap \mathbb{Z}$ uniformly at random. 7:           Let $x^{+}$, $Y=LMF(f,x,Y,j+1)$. 8:           if $x^{+}=x$ and $Y\ne \varnothing$ then 9:                Let $|R_0⟩ |R_1⟩ |R_2⟩$ be the result of measuring $Q^j|\varphi ⟩$. 10:              if $|R_0⟩ |R_1⟩ |R_2⟩\notin \mathcal{D}$ then 11:                    Let $|R_0⟩ |R_1⟩ |R_2⟩$ be the result of measuring $|\varphi ⟩$. 12:              end if 13:         end if 14:         if $|R_0⟩ |R_1⟩ |R_2⟩\in \mathcal{D}$ then 15:              Let $x^{+}=R_0$. 16:         end if 17:     end while 18:     return $x^{+}$. 19: end function

Using QIPS during the search and poll steps of GPS, we are able to reduce the expected number of oracle calls from $O\left(N\right)$ to $O\left(\sqrt{N}\right)$ when an improved mesh point exists, while retaining the $O\left(N\right)$ complexity when one does not. Furthermore, we are guaranteed that QIPS will correctly identify local mesh optimizers, preserving the convergence results of GPS presented in [1], Section 3. We summarize this in the following Theorem.

Theorem 4

(Quantum Improved Point Search: Complexity and Correctness). Given $\mathcal{Y}={\left\{y_j\right\}}_{j=0}^{N-1}\subseteq {\mathbb{R}}^n$, $x\in {\mathbb{R}}^n$, $f:{\mathbb{R}}^n\to \mathbb{R}$, $\mathcal{A}$ as in (22), $\mathcal{D}$ as in (18), Q as in (5), and

$$\tilde{x}=\mathit{QIPS}(Q,|\varphi ⟩,\mathcal{D},f,x,\mathcal{Y})$$

(23)

The following hold:

1. 

(Correctness) QIPS correctly determines if $\mathcal{Y}$ contains an improved mesh point. More formally, $\tilde{x}=x$ if and only if $f\left(x\right)\le f\left(y\right)$ for all $y\in \mathcal{Y}$.

2. 

(Complexity: Improved Mesh Point) Suppose $\mathcal{Y}$ contains an improved mesh point; more formally, suppose there exists $y\in \mathcal{Y}$ such that $f\left(y\right)<f\left(x\right)$. Then, QIPS will return an improved mesh point using an expected number of calls to the oracles F and f in $O\left(\sqrt{{\displaystyle \frac{N}{t}}}\right)$, where t is the number of improved mesh points contained in $\mathcal{Y}$.

3. 

(Complexity: Local Mesh Optimizer) Suppose $\mathcal{Y}$ does not contain an improved mesh point; more formally, suppose $f\left(x\right)\le f\left(y\right)$ for all $y\in \mathcal{Y}$. Then, QIPS will return x using $O\left(N\right)$ calls to the oracles F and f.

• Proof. 

1.

From lines (7) and (15) of QIPS, we have that $\tilde{x}=x$ if and only if the while loop started on line (4) terminates because $\mathcal{Y}=\varnothing$. The result follows as line (7) returns $\mathcal{Y}=\varnothing$ if and only if each element originally in $\mathcal{Y}$ was evaluated by the classical oracle f and failed to be an improved mesh point.

2.

Suppose $\mathcal{Y}$ contains $t>0$ improved mesh points. For any iteration that does not return an improved mesh point, the number of calls to f is identical to those of F. Furthermore, if an improved mesh point is found on lines 3, 9, or 11, then no further calls to f are made. Thus, we proceed by bounding the expected number of calls to F. We obtain an upper bound on the expected number of times F is called following a similar approach to that used in [9] (Lemma 2 and Theorem 3) and [3] (Theorem 3). The oracle F is called only when the oracle Q is called. This occurs a single time on line 3, and then again each time lines 9 and 11 are executed. Lines 3 and 11 return an improved mesh point with probability ${\displaystyle \frac{t}{N}}$. On the kth iteration of the while loop begun on line 4, we have that line 9 returns an improved mesh point with probability $si{n}^2\left(\left(2j+1\right){\theta }_d\right)$ (recall that $si{n}^2\left({\theta }_d\right)={\displaystyle \frac{t}{N}}$.) Let ${\mathcal{P}}_k$ denote the probability of obtaining an improved mesh point on the kth iteration of the while loop. Since j is chosen as an integer in $[1,\lceil c^k\rceil ]$ uniformly at random, it follows that ${\mathcal{P}}_k$ is given by

$${\mathcal{P}}_k={\displaystyle \frac{1}{\lceil c^k\rceil }}\sum _{j=0}^{\lceil c^k-1\rceil }{\displaystyle \frac{t}{N}}+\left({\displaystyle \frac{N-t}{N}}\right)si{n}^2\left(\left(2j+1\right){\theta }_d\right).$$

(24)

For all positive integers k, we can establish a lower bound for ${\mathcal{P}}_k$ as follows:

$$\begin{array}{cc}\hfill {\mathcal{P}}_k& ={\displaystyle \frac{1}{\lceil c^k\rceil }}\sum _{j=0}^{\lceil c^k\rceil -1}{\displaystyle \frac{t}{N}}+\left({\displaystyle \frac{N-t}{N}}\right)si{n}^2\left(\left(2j+1\right){\theta }_d\right)\hfill \end{array}$$

(25)

$$\begin{array}{cc}\hfill & \ge {\displaystyle \frac{1}{\lceil c^k\rceil }}\sum _{j=0}^{\lceil c^k\rceil -1}{\displaystyle \frac{t}{N}}si{n}^2\left(\left(2j+1\right){\theta }_d\right)+\left({\displaystyle \frac{N-t}{N}}\right)si{n}^2\left(\left(2j+1\right){\theta }_d\right)\hfill \end{array}$$

(26)

$$\begin{array}{cc}\hfill & ={\displaystyle \frac{1}{\lceil c^k\rceil }}\sum _{j=0}^{\lceil c^k-1\rceil }si{n}^2\left(\left(2j+1\right){\theta }_d\right)\hfill \end{array}$$

(27)

$$\begin{array}{cc}\hfill & ={\displaystyle \frac{1}{2\lceil c^k\rceil }}\sum _{j=0}^{\lceil c^k\rceil -1}1-cos\left(\left(2j+1\right)2{\theta }_d\right).\hfill \end{array}$$

(28)

By [9], Lemma 1, it follows that

$$\begin{array}{cc}\hfill {\mathcal{P}}_k& \ge {\displaystyle \frac{1}{2\left(\lceil c^k\rceil \right)}}\sum _{j=0}^{\lceil c^k-1\rceil }1-cos\left(\left(2j+1\right)2{\theta }_d\right)\hfill \end{array}$$

(29)

$$\begin{array}{cc}\hfill & ={\displaystyle \frac{1}{2}}-{\displaystyle \frac{sin\left(4\left(\lceil c^k\rceil \right){\theta }_d\right)}{4\left(\lceil c^k\rceil \right)si{n}^2\left(2{\theta }_d\right)}}\hfill \end{array}$$

(30)

$$\begin{array}{cc}\hfill & \ge {\displaystyle \frac{1}{2}}-{\displaystyle \frac{1}{4\left(\lceil c^k\rceil \right)sin\left(2{\theta }_d\right)}}.\hfill \end{array}$$

(31)

In particular, this implies ${\mathcal{P}}_k\ge \frac{1}{4}$ when $\lceil c^k\rceil \ge {\displaystyle \frac{1}{sin\left(2{\theta }_d\right)}}$.

If $t>\frac{3N}{4}$, then the expected number of times line 11 will be executed is bounded above by 4 and the result follows. We now assume $0<t\le \frac{3N}{4}$. In this case, we have that

$${\displaystyle \frac{1}{sin\left(2{\theta }_d\right)}}={\displaystyle \frac{N}{2\sqrt{(N-t)t}}}<\sqrt{{\displaystyle \frac{N}{t}}}.$$

(32)

Let $\lambda =\lceil lo{g}_c\left({\displaystyle \frac{1}{sin\left(2{\theta }_d\right)}}\right)\rceil$, During the kth iteration of the while loop, the total number of calls to F is bounded above by $c^k+1$. It follows that the total number calls to F while $l\le \lambda$ is then bounded above by

$$\begin{array}{cc}\hfill \sum _{k=0}^{\lambda }{c}^k+1& =\lambda +\sum _{k=0}^{\lambda }{c}^k\hfill \end{array}$$

(33)

$$\begin{array}{cc}\hfill & \le \lambda +{\displaystyle \frac{1-\sqrt{\frac{N}{t}}}{1-c}}\hfill \end{array}$$

(34)

$$\begin{array}{cc}\hfill & =\lambda +{\displaystyle \frac{1}{c-1}}\left(\sqrt{{\displaystyle \frac{N}{t}}}-1\right).\hfill \end{array}$$

(35)

Hence, if an improved mesh point is returned during iteration $k\le \lambda$, we have that it does so using $O\left(\sqrt{{\displaystyle \frac{N}{t}}}\right)$ calls to F. Now suppose an improved mesh point is not found during the first $\lambda$ iterations of the while loop. Since the probability of obtaining an improved mesh point after iteration $\lambda$ is bounded below by ${\displaystyle \frac{1}{4}}$, it follows that the expected number of calls to F needed to obtain an improved mesh point is bounded above by

$$\begin{array}{cc}\hfill \sum _{k=0}^{\infty }{\displaystyle \frac{1}{4}}{\left({\displaystyle \frac{3}{4}}\right)}^k\left(c^{k+\lambda }+1\right)& ={\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{3}{4}}\right)}^k+{\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{3}{4}}\right)}^k\left(c^k{c}^{\lambda }\right)\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill & \le {\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{3}{4}}\right)}^k+{\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{3}{4}}\right)}^k{\left({\displaystyle \frac{6}{5}}\right)}^k\sqrt{{\displaystyle \frac{N}{t}}}\hfill \end{array}$$

(37)

$$\begin{array}{cc}\hfill & ={\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{3}{4}}\right)}^k+{\displaystyle \frac{1}{4}}\sum _{k=0}^{\infty }{\left({\displaystyle \frac{9}{10}}\right)}^k\sqrt{{\displaystyle \frac{N}{t}}}\hfill \end{array}$$

(38)

$$\begin{array}{cc}\hfill & =1+{\displaystyle \frac{10}{4}}\sqrt{{\displaystyle \frac{N}{t}}}.\hfill \end{array}$$

(39)

Thus, the expected number of calls to the oracle F is in $O\left(\sqrt{{\displaystyle \frac{N}{t}}}\right)$.

3.

Suppose $\mathcal{Y}$ contains no improved mesh points. Then, $|R_0⟩ |R_1⟩ |R_2⟩\notin \mathcal{D}$ during each measurement on lines (3), (11), and (9). The while loop terminates if $\mathcal{Y}=\varnothing$. This occurs only once the LMF algorithm has evaluated each point originally in $\mathcal{Y}$ on line (6) and determined that $\mathcal{Y}$ has no improved mesh points. Line (9) of LMF guarantees that no point in $\mathcal{Y}$ is evaluated by the oracle f twice, ensuring f is called at most N times. Since the number of times the oracle F is called on lines (9) and (11) of QIPS is bounded above by the number of times f is called, it follows that the number of times F is called is also bounded above by N.

□

4. Conclusions

Quantum algorithms are theorized to hold numerous potential advantages over classical methods. However, the probabilistic nature of these algorithms may pose significant problems when used as a subroutine within a larger algorithm. In this work, we considered the impact of using quantum search methods to perform the search and poll steps of GPS. These methods provide a significant reduction in the expected number oracle calls needed when a solution exists. Unfortunately, they are not guaranteed to accurately determine that no solution exists using a finite number of oracle calls. Here, we have solved this problem by introducing QIPS, a quantum–classical hybrid variant of the quantum search algorithm QSearch. QIPS allows us to preserve the reduction in oracle calls provided by QSearch when an improved mesh point exists, while accurately determining that no improved mesh point exists using $O\left(N\right)$ oracle calls. We expect to build upon this work in two ways. First, we will analyze the behavior of QIPS when used in similar DFO algorithms such as Mesh Adaptive Direct Search [14]. Second, we plan to explore alternative DFO algorithms that utilize quantum search methods, but do not share the convergence criteria of GPS.