Function Maximization with Dynamic Quantum Search

TL;DR

This paper introduces an iterative quantum algorithm for dynamic function maximization, updating search results with a quantum search approach and verifying its effectiveness through simulations on the Knapsack problem.

Contribution

It presents a novel quantum algorithm that adapts to dynamic search results for function maximization, verified through extensive numerical simulations.

Findings

Successful simulation of the quantum algorithm up to 30 qubits

Effective implementation of the dynamic oracle function

Potential for improved optimization in quantum computing

Abstract

Finding the maximum value of a function in a dynamic model plays an important role in many application settings, including discrete optimization in the presence of hard constraints. We present an iterative quantum algorithm for finding the maximum value of a function in which prior search results update the acceptable response. Our approach is based on quantum search and utilizes a dynamic oracle function to mark items in a specified input set. As a realization of function optimization, we verify the correctness of the algorithm using numerical simulations of quantum circuits for the Knapsack problem. Our simulations make use of an explicit oracle function based on arithmetic operations and a comparator subroutine, and we verify these implementations using numerical simulations up to 30 qubits.

Tables

Table 1. Table 1: Candidate solutions and values for Knapsack problem data.

Candidate	Fitness	Weight	Validity
0 0 0 0	0	0	valid
0 0 0 1	30	3	valid
0 0 1 0	50	2	valid
0 0 1 1	80	5	valid
0 1 0 0	100	4	valid
0 1 0 1	130	7	valid
0 1 1 0	150	6	valid
0 1 1 1	180	9	valid
1 0 0 0	40	7	valid
1 0 0 1	70	10	valid
1 0 1 0	90	9	valid
1 0 1 1	120	12	invalid
1 1 0 0	140	11	invalid
1 1 0 1	170	14	invalid
1 1 1 0	190	13	invalid
1 1 1 1	220	16	invalid

Equations

$$(1/\sqrt{2^n})\sum _{i=0}^{2^n-1}{|i⟩}_q{|0⟩}_f\to (1/\sqrt{2^n})\sum _{i=0}^{2^n-1}{|i⟩}_q{|f(i)⟩}_f$$

$$n$$

$$\sum _{i=0}^7{|i⟩}_q{|00000⟩}_w{|000000⟩}_f+\sum _{i=8}^{15}{|i⟩}_q{|00111⟩}_w{|000100⟩}_f$$

$$\left(\sum _{i\in valid}{|i⟩}_q{|m(i)⟩}_w{|f(i)⟩}_f|0⟩+\sum _{i\in invalid}{|i⟩}_q{|m(i)⟩}_w{|-f(i)⟩}_f{|1⟩}_v\right){|001010⟩}_g$$

$$\sum _x{|i⟩}_q(-1{)}^{o(i)}{|-⟩}_r$$

$$\lceil \frac{\pi }{4}\sqrt{\frac{N}{M}}\rceil$$

$$\frac{1}{4}\left(\sum _{i\ne 0110,i\ne 0111}|i⟩-|0110⟩-|0111⟩\right)$$

$$\frac{1}{8}\left(\sum _{i\ne 0110,i\ne 0111}|i⟩\right)-\frac{5}{8}\left(|0110⟩+|0111⟩\right)$$

Full text

1 Introduction

Finding the maximal value in a poorly characterized function is a challenging problem that arises in many contexts. For example, in numerical simulations of particle dynamics, it is often necessary to identify the strongest interactions across many different particle trajectories. Prior results in quantum computing for unstructured search have shown that a quadratic speed up is possible when searching a poorly characterized function, and in this work, we consider an application of quantum search to the case of finding a maximal function value.

Quantum search was proposed originally to identify a marked item by querying an unstructured database [6]. By using an oracular implementation of the database function, Grover proved that a quadratic speedup in unstructured search could be obtained relative to brute force search by using superposition states during the querying phase. These ideas have been applied to a wide variety of application contexts including function maximization and minimization. In particular, Durr and Hoyer have shown how to design an iterative version of quantum search to find the minimizing argument for an unspecified oracle [5]. Their approach uses an updated evaluation of the oracle based on prior measurement observations, namely, to identify the smallest observed value. More recently, Chakrabarty et al. have examined the problem of using a dynamic Grover search oracle for applications in recommendation systems [3]. In addition, Udrescu et al. have cast the application of quantum genetic algorithms into a variant of dynamic quantum search [9].

In this contribution, we implement the principles of dynamic quantum search for the case of function maximization. We use the Knapsack 0/1 problem as an illustrative example, which is a constraint problem that finds the largest weighted configuration for a set of possible items. We extend recent work from Udrescu et al. [9] by using quantum circuits for arithmetic operations. Our implementation uses arithmetic operations to build the dynamic oracle for quantum search function maximization [1]. We test this implementation with a quantum program simulated using the Atos Quantum Learning Machine, which enables verification of the accuracy of the algorithm and estimation of the resources needed for its realistic implementation.

The paper is organized as follows: Sec. 2 formulates the quantum algorithm for function maximization using an iterative variant of quantum search, while Sec. 3 presents the explicit implementation of these ideas using quantum arithmetic circuits and results from numerical simulation of those circuits. Finally, we explain how quantum search is used in this context and show how we simulated the example step by step in Sec. 4.

2 Quantum Maximization of Dynamic Oracle

We show how to realize quantum search for function maximization using a dynamic oracle. As an illustrative example, we consider a Knapsack 0/1 problem introduced in Udrescu et al. as quantum version of a binary genetic algorithm called the reduced quantum genetic algorithm (RQGA) [9]. In particular, the genetic algorithm underlying RQGA was reduced to Grover search, thus removing the need for crossover and mutation operations for creating and selecting new candidate solutions. Rather, the complete set of candidate solutions is realized as an initial superposition over all the possible binary strings, e.g., using a Hadamard transform to prepare a uniform superposition state. We extend these ideas by developing an implementation using dynamic quantum search to solve the Knapsack problem.

Our method begins with an initial uniform superposition state of the candidate solutions stored in an $n$-qubit register $q$, where the size is determined by the number of possible items. The initial superposition is evaluated with respect to an objective function noted as $f$. For our example, the function $f$ computes the fitness of the candidate solution. The computed value for the fitness is stored in a second quantum register denoted as $f$. The register of size $p$ stores this value using two’s complement form, where the size is determined by the largest value of all items in the database. The fitness is computed explicitly using a unitary operator $U_{f}$ what applies to both quantum registers $q$ and $f$, i.e.,

[TABLE]

After preparing a uniform superposition of the candidate solutions and associated fitness values, the amplitudes with a fitness value greater than a current maximum value are marked by an oracle operator. The oracle operator is implemented explicitly below using a comparator circuit that takes as input the computed fitness register and a classical threshold value. The amplitude of all marked items are subsequently amplified to increase the probability to measure a better candidate. In practice, we extend the definition of the fitness operator to exclude certain candidates in the superposition as being valid or invalid candidate. For example, when valid candidates must have a positive fitness value, then a single register element may be used to indicate mark values that are negative and therefore invalid. Theoretically, Grover’s search requires $\approx 13.6\sqrt{M}$ steps to achieve an error rate of less than 0.5 with $M$ being the size of the list searched [1].