Quantum Dueling: an Efficient Solution for Combinatorial Optimization

In this paper, we present a new algorithm for generic combinatorial optimization, which we term quantum dueling. Traditionally, potential solutions to the given optimization problems were encoded in a ``register'' of qubits. Various techniques are used to increase the probability of finding the best solution upon measurement. Quantum dueling innovates by integrating an additional qubit register, effectively creating a ``dueling'' scenario where two sets of solutions compete. This dual-register setup allows for a dynamic amplification process: in each iteration, one register is designated as the 'opponent', against which the other register's more favorable solutions are enhanced through a controlled quantum search. This iterative process gradually steers the quantum state within both registers toward the optimal solution. With a quantitative contraction for the evolution of the state vector, classical simulation under a broad range of scenarios and hyper-parameter selection schemes shows that a quadratic speedup is achieved, which is further tested in more real-world situations. In addition, quantum dueling can be generalized to incorporate arbitrary quantum search techniques and as a quantum subroutine within a higher-level algorithm. Our work demonstrates that increasing the number of qubits allows the development of previously unthought-of algorithms, paving the way for advancement of efficient quantum algorithm design.


I. INTRODUCTION
Since the realization that quantum systems can be used to establish a new computational infrastructure [1,2], many quantum techniques have been developed for general optimization problems.For example, the Grover adaptive search (GAS) iteratively maintains a current best guess to find the optimal solution [3][4][5].Meanwhile, quantum annealing and quantum adiabatic evolution encode the problem as a Hamiltonian and find the lowest energy state [6][7][8].Lastly, variational techniques such as QAOA have recently gained significant attention, where we interchange two different Hamiltonians to find the desired state [9][10][11].
In this article, we propose a new general strategy for quantum approximation.Our algorithm is inherently based on the Grover search, which amplifies the amplitude components of the state vector that satisfy a given condition [12][13][14][15][16][17].In previous designs, the candidates for the problem are encoded as basis vectors for the Hilbert space.Our algorithm doubles the number of qubits used.This means that the basis vectors of our Hilbert space represent a pair of two potential candidates from the search space as opposed to one.As an example, after obtaining a well-optimized state with the procedures that would be introduced later, a measurement will give us a pair of candidates for the original problem instead of one.Then, we can use a classical comparison to find the better one as the final output of the program.
But how do we optimize the state under such a representation?We realize that a sequence of controlled Grover amplifiers can achieve such an objective.Let the two sets of qubits that are used to represent two candidates of the given problem be two registers.Each time, we can use one register as the control and apply Grover's gate to amplify states in the other register that are more optimal (than the control).Since we have two choices for the control register each time, different choices will direct the evolution of the state vector to different paths.After a sufficient number of gates, we will obtain a state with a significant probability of finding the best solution after measurement.In this paper, we will define an adjustable parameter to describe the sequence of our choices, making our algorithm variational.Since we have two candidates, one optimizing the other in each gate application, we term the algorithm "quantum dueling." In this work, we examined the performance of quantum dueling via classical simulation and certain quantitative analysis.We found that compared with the classical brute-force method, quantum dueling bolsters a quadratic speed-up under optimal parameters.As a fully quantized algorithm, we believe that it would be useful as a quantum subroutine for generic optimization.It is worth noting that the algorithm does show some limitations.Most notably, a good choice of parameter is required when the search space is significantly large (10 6 ), and we would like to find the global optimal with high probability; without a well-considered parameter, the state will stop being further boosted once some threshold is reached.However, we do believe that if we can find an approximate solution to the evolution of the state vector during the algorithm, there should be ways to determine the optimal parameter rigorously.Never-arXiv:2302.10151v5[quant-ph] 2 Jan 2024 theless, the main purpose of our research is less about the algorithm itself, but to demonstrate that spending extra qubits and enlarging the search space would provide more flexibility in quantum algorithm design, sometimes leading to previously unthought-of algorithms.
The structure of the paper is organized as follows.Initially, Sec.II delineates the combinatorial optimization problem central to this study and introduces the fundamental construction of quantum dueling.Subsequent to this foundation, Sec.III A presents the recursive formula for state evolution, accompanied by an in-depth examination of solution distributions under the naive parameter choice of α i = β i = 1.Sec.III B provides a more computationally efficient version of the algorithm, while Sec.III C extends the discussion to encompass the entire algorithm within a Hamiltonian framework, elucidating its connections to established quantum algorithms like Grover's search and QAOA (Quantum Approximate Optimization Algorithm).To address the nuances of parameter selection in quantum dueling, Secs.IV A,IV B dissect the algorithm's performance across a variety of solution distributions with alternate parameter schemes.For certain unique solution distributions, Sec.IV C employs a classical greedy approach to obtain locally optimal parameters.Building upon these foundational elements, Sec.V explores the practical applications of quantum dueling.In Sec.VI, we broaden the perspective to consider the mechanisms of dueling, its extended variants, and its potential as a subroutine within larger quantum or hybrid algorithmic structures.The paper culminates in Sec.VII with a comprehensive conclusion that encapsulates the insights and implications derived from our exploration of quantum dueling.

II. ALGORITHM
The general combinatorial optimization problem can be formulated as follows.Consider a search space S of size N , without loss of generality, we can assume that N = 2 n , where n ∈ N. We define a measure function v : S → R, and a function f : S → {0, 1} that labels solutions with 1 and others 0. 1 Let M denote the total number of solutions in S. We wish to find a solution x ∈ S such that f (x) = 1 and v(x) is minimized.In other words, x satisfies: Such a problem can be seen as an extension of the search problem, where we are looking for a solution x with f (x) = 1, without a measure function v.For search, Grover has shown that there is a quantum algorithm that performs quadratically better than the classical counterpart.In his algorithm, verifying whether a candidate is 1 The need for f is justified in Sec.III A.
a solution is achieved via an oracle gate, which is essentially a black box that can be constructed based on the problem itself.In this paper, we will show that such quantum advantage can be extended to the combinatorial optimization problem via a fully quantized approach.
Algorithm 1 shows the classical algorithm for combinatorial optimization.At any stage after initialization, we store a current best guess and iterate through the sample space (or randomly select an element).We repeatedly conduct this procedure to find a better solution.The complexity of the algorithm is O(N ) = O(2 n ).

Algorithm 1: Classical Brute-Force Optimizer
Input: Measure function v, solution indicator f in the form of an oracle Output: An element x in the search space satisfying f (x) = 1 and v(x) (approximately) minimized Initialize some best to any element from the search space S; for all other elements x ∈ S do Use an oracle to compare x and best; if x is better then best ← x; end Amplitude amplification has offered us a promising way to approach quantum combinatorial optimization problems with the potential of maintaining the quantum advantage.Brassard [14] formulated the general amplitude amplification algorithm using unitaries, including the oracle and the diffusion operator, to solve the original search problem starting from an arbitrary initial state vector.
Despite the difference in problem formulation, we can still use the general idea of amplitude amplification by iteratively applying the oracle O and the diffusion operator D. But the major problem here is to encode the measure function v(x) into our algorithm design.One possible solution, as mentioned in [18], is to encode the function v(x) in the problem Hamiltonian, Ĥp = x v(x) |x⟩ ⟨x| in a Hamiltonian-based approach, letting the system gradually progress to the global minima of v(x) via a QAOAlike quantum gradient descent.
In this paper, we consider a different method.Rather than using the Hamiltonian to represent the function, we encode the clause of comparison v(x) < v(y) into the oracle, which is then used to build a new algorithm in a circuit-based approach.However, due to the "No Cloning Principle", it is impossible to achieve comparison via the quantum oracle with only one n-qubit register, using B = {|x⟩ | x ∈ S} as a basis for a Hilbert space H S .
To address this problem, we employ two registers with n-qubtis each, based on the idea that we need at least two copies of the same information to achieve comparison.In other words, the Hilbert space of our concern is H = H S ⊗ H S .This means that the basis is now Indices k and l stand for the labels for elements in the first and the second register, respectively.Each cell in the grid can be filled with a number that represents the component ψ kl as defined in Eq. ( 2).Cells such that either k or l is a solution are highlighted.In this problem, the best solution is x = 2. Cells at which either k = 2 or l = 2 are shaded.When the state vector is a basis vector (or a linear combination of basis vectors) corresponding to the cells in the shaded region, the best solution will be obtained upon measurement.
The index k denotes elements represented by the first register and l elements from the second register.Thus, the state vector can be decomposed as the following: A good interpretation is to put ψ kl in a matrix format, as in Fig. 1.
We term our new algorithm "quantum dueling," as we now use two registers to "compete" against each other throughout the quantum state evolution in the augmented Hilbert Space H = H S ⊗ H S .
In quantum dueling, a measurement of both registers independently at the end of the quantum state evolution is needed and thus will yield two potential solutions.We need to evaluate the f and v values for both candidates, taking the better result as the final output.For clarity, we say that an element x ∈ S is better than y ∈ S if and only if f (x) = 1 ∧ (f (y) = 0 ∨ v(x) < v(y)).This paper uses logical operators ∧, ∨ to represent and, or operations.Meanwhile, we will use &, | operators to represent and, or operations in {0, 1} space.If neither candidate is a solution to the original problem or a better approximation ratio is desired, we can repeat the algorithm.
On the augmented Hilbert space H = H S ⊗ H S , we define the quantum oracle as follows: The result of the oracle applied to an arbitrary state is the linear combination of the oracle applied to its basis decomposition by linearity.Therefore, The oracle operates in two registers and outputs the "better" result.For states x, y ∈ S, our quantum oracle will multiply a basis state by a factor of −1 if and only if f (x) = 1 and v(x) < v(y), which is our criterion for "betterness".Thus, it can distinguish the better states from the entire search space, similar to the oracle in traditional amplitude amplification.
Here, we use the square bracket to denote conversion from a proposition to {0, 1} space.For example, the clause [v(x) < v(y)] returns 1 if v(x) < v(y) is satisfied, and 0 otherwise.The same definition also applies to clause f (x).For simplicity, in the future, the term (−1) f (x)&[v(x)<v(y)] will become o(x, y).
Usually, we can achieve the oracle by evaluating the f and v values of the two input elements and making a comparison.All these steps can be achieved using quantum arithmetic techniques with the help of additional qubits in polynomial time.
Note that in Eqs. ( 3) and (4), we use x and y as the free indices rather than symbols k and l.This is because x and y can each represent basis states from either the first or the second register.Substituting x, y with k, l respectively gives the oracle that compares the first register against the second, and substituting x, y with l, k gives the oracle that compares the second against the first.That is we have oracles O 1←2 and O 2←1 satisfying: Equivalently, Similarly, we define the diffusion operators D 1←2 and D 2←1 in the augmented Hilbert space H = H S ⊗ H S as follows: where |x⟩ is the equal superposition of all the basis states.
To understand how the oracles and diffusion operators on the augmented Hilbert space impact some state vector |ψ⟩ in the augmented Hilbert space.we consider it's decomposition: |ψ l ⟩, |ψ k ⟩ can be defined as: where ψ kl are the state vector's components.An interesting property of |ψ l ⟩, |ψ k ⟩ is that their norm squared represent the probability of obtaining the corresponding results l and k when a measurement is conducted for either the first or the second register.
We then define a sequence of oracles {O y } that act only in the smaller Hilbert space H S .We can interpret the register corresponding to the notation y as the control register that directs the oracle to act on the register corresponding to the notation x in a specific way.
Formally speaking, we have: This allows us to define the corresponding Grover gates {G y } that satisfy G y = DO y for all 1 ⩽ x ⩽ N .Similarly to what was discussed previously, the notation x and y can be replaced with k or l according to implementation.
Thus, it is possible to re-express the oracles in the following manner: The oracle O 1←2 uses the second register as a control and acts on the first register, while the oracle O 2←1 uses the first as a control and operates on the second.The operation of either of the two oracles entangles the two registers.The generation of entanglement between the registers may serve as a major feature of quantum dueling.
The result of the oracles on an arbitrary state vector |ψ⟩ will be: When viewed in this way, it is intuitive to perform a controlled Grover search to the state vector.In one iteration, we have We define these gates as dueling operators.They can also be written as: In matrix visualization, the result of applying G 1←2 is that for each column corresponding to l, components such that k is "better" than l will get boosted from components that are not better.Fig. 2 illustrates how this is done in one column starting from one cell at which k is not "better" than l.
Similarly, an illustration of the amplifying result of G 2←1 can be found in Fig. 3.
Dueling operators G 1←2 , G 2←1 give us two symmetrical ways to boost the probability amplitude corresponding to the best solutions.If we apply gates G 1←2 and G 2←1 alternatively, we will slowly evolve the state towards the desired direction.We use two arrays of integers {α i } and {β i } to quantify the exact sequences of gates applied to the state.In the i-th iteration, we apply G 1←2 by α i times and G 2←1 by β i times.The resulting Algorithm 2 is the quantum dueling algorithm we proposed in this paper.A circuit diagram can be found in Fig. 5.
The route for a given component boosted under the iterative application of dueling operators is shown in Fig. 4, where α i = β i = 1.The intuitive understanding is that each time we use the first register to boost states in the second register and then use the second register to boost states in the first register.In combination, the state will evolve in the desirable direction.
It is important to note here that at any stage after initialization, the general state vector |ψ⟩ remains in a pure state, while each register is not necessarily pure, as the

III. ANALYSIS
In this section, we will dive into several mathematical properties of quantum dueling, and conduct simulations of dueling over various solution distributions based on classical hardware.
To provide convenience for both mathematical analysis and computer simulation, we may want to figure out the recursive formula of quantum dueling on each component of the augmented Hilbert space H .
In Eq. ( 2), we use indices kl to represent the components of a vector in H .For an operator such as G 1←2 , its components should thus be denoted via four index symbols in the format of klk ′ l ′ .Under that tradition, the where by Eqs. ( 15) and (17), components of G 1←2 and G 2←1 can be written as where δ denotes the Kronecker delta, and function o is defined previous satisfying (−1) f (x)&[v(x)<v(y)] = o(x, y) for all x, y ∈ S.

A. General Understanding
Eqs. ( 17) and ( 18) provide a mechanism for a simulation algorithm on the basis of a classical computer that will build the groundwork of the analysis of quantum dueling.Using the two formulae directly under the matrix multiplication schema gives us an algorithm with time complexity of O(N 4 ) per Grover iteration via classical simulation.
Such an algorithm can be easily optimized.Combining and simplifying Eqs. ( 17) and ( 18) guarantees a simulation strategy of O(N 3 ) per Grover iteration, as seen in the following equation: Fig. 6 documents the result of this simulation for a near-uniform solution distribution.An intuitively chosen parameter, α i = β i = 1, was chosen as a starting point of analysis. 2he probability of obtaining the most optimized solution after combining measurements from both registers, which we term the success probability, exhibits an oscillating trend similar to that of the Grover algorithm.However, several differences remain.First, in Figs.6b  and 6c, the local maximum of P 1 and P ′ 1 vary from peak to peak.For given {α i } and {β i } arrays, we would like to set the termination count p such that the first local maximum is reached.Second, it is clear that unlike Grover algorithm, such a local maximum is not asymptotically close to 1.To compensate this problem, we can repeat the algorithm to boost success probability.In principle, if known information is not sufficient to determine p, we can vary rotation count for each repetition just as done in [14], though this option is not of great interest to us.Overall, Fig. 6 suggests that it is difficult to find an exact solution for the state vector in quantum dueling.However, an approximate solution might be obtained with appropriate mathematical expertise.
Since Fig. 6 only documents a single case, we ran the simulation for a variety of scenarios, on the assumption that α i = β i = 1.Table I and Fig. 7 summarize the performance of quantum dueling for different distributions of solution and different values of M , while N remains fixed.The first local maximum success probabilities and the corresponding iteration counts vary.For uniform distribution, as in Table I, the performance of quantum dueling is hindered by the increasing number of non-solution elements with smaller measure function v values than the most optimized solution, but the resulting success probability remains valid for efficient algorithm design.A better selection of parameters {α i } and {β i } can compensate for this issue.We will tackle this problem in IV.
For non-uniform distributions, quantum dueling behaves poorest when all solutions have v values that are within a range in which little or no non-solutions lie, with success probability dropping to less than 10%.The worst case happens when all non-solutions take v values greater than those of all solutions.In this case, the components The first local maximum success probability P max and the first local maximum first-register success probability P ′ max , as a function of M , which is in logarithmic scale.(b) The number of iterations p max after which P max is achieved, and the number of iterations p ′ max after which P ′ max is achieved, as a function of M , which is in logarithmic scale.More details regarding this formula can be found in Appendix C. of the state vector that represent non-solutions in both registers take most of the weight of the state vector, and such weight cannot be transferred to solutions via amplitude amplification.On the other hand, if there is a clear separation between the desired best solution and other solutions, i.e., between measure function values v of the most optimized solution and that of the second most optimized solution lies all or most of the non-solutions, the algorithm achieves the best result, reaching a success probability of over 99%.This means that the maximum probability of quantum dueling depends on the separation between solutions in the distribution of measurement function values.Fig. 7 documents the maximum success probability and the required number of iterations for uniform solution distribution when we slowly increase the number of solutions M and decrease their separation.We can see success probability slowly drops, and the required number of iterations slowly increases for an increasing M .However, after a critical point M 0 = N 4 , both success probability and (especially) corresponding iteration counts drop significantly, indicating a collapse in the efficacy of the algorithm.As an explanation, for each y, define a sequence of operators G y = DO y .The result of dueling gates can be decomposed as: Given y ∈ S and an initial state vector in H S in uniform distribution, assuming the size of target space is m, by [19], the preferred number of repetitions of {G y } gates to reach 100% success probability r max must satisfy where θ = arcsin m N .When m > M 0 = N 4 , Eq. ( 21) suggests r max < 1, meaning that after one iteration, the success probability has been moved past its peak, breaking the amplitude amplification mechanism of Grover algorithm.Consider dueling gates applied to an initial state vector H ⊗2n |0⟩.When M > M 0 , for significant values of y, m will be sufficiently close to or greater than M 0 such that G y will no longer boost the weight of the target.Therefore, a collapse is observed for quantum dueling, at least with The results of such simulations justify several definitions made in previous sections.First, when we defined the problem of combinatorial optimization in Sec.II, we introduced the f function to mark out solutions against non-solutions.However, one can also define combinatorial optimization without using the f function by forcing the measure function v of non-solutions to be infinity.In this case, we essentially have M = N , leading to the collapse of efficacy as shown in Fig. 7.For optimization problems without f or cases where M > M 0 , we can augment the search space by introducing several extra qubits and mark out an element as solution if the extra qubits take some arbitrarily chosen value.Alternatively, we can separate solutions into different groups and search these groups separately.
Second, going back to the design of Algorithm 2, one might want to modify O x such that it selects for element that are better than x, i.e., where | is the equivalent of logical disjunction on {0, 1}.However, this redefinition would produce a total order in S, meaning that we can find functions v ′ (x) and f ′ (x) = 1 ∀x ∈ S such that the algorithm after redefinition is equivalent to the original Algorithm 2 with these new functions v ′ and f ′ .This, in turn, implies M = N , so we would see our algorithm collapsing in efficacy under naive parameters α i = β i = 1.This is why we define the oracle as it was in Sec.II.
Despite the problems described above, in most common cases where the solution distributions are not that extreme, and the number of solutions is controlled below the critical point M 0 = N 4 , quantum dueling with naively chosen parameters α i = β i = 1 performs quite well, increasing the success probability to a constant regardless of the increase of N .Under the extreme cases where the number of solutions exceeds the critical limit, or all of the solutions are distributed higher than most of the non-solutions in the measure function spectrum, we can add a few more ancilla qubits, making the entire Hilbert space larger and thus making the solutions dilute.This treatment will be analyzed in Sec.V A.
Another promising way is adjusting the variational parameters, along with classical optimization heuristics, which will be discussed in detail in Sec.IV.

B. Cluster Representation
Analysis in Sec.III A suggests that it is difficult, yet potentially possible, to quantify the behavior of quantum dueling mathematically by carefully studying the behavior of the system using the recursive formulas in Eq. 19.While we have not yet solved such evolution, this section provides some insights to simplify the formulation of quantum dueling.
We observe in Fig. 6d that for a given first-register component |ψ l ⟩, in a v range where no solutions lie, the non-solutions seem to have the same weight within the total state vector.Additionally, if several solutions share equal measure function values, they also have the same weight at any stage.To formalize these conclusions, we define the following relation ∼ on S satisfying Definition III.1.
Definition III.1.∼ is an equivalence relation on S such that for all x, y ∈ S, x∼y if and only if either of the following conditions is true: We verify that ∼ is an equivalence relation in Appendix D. Intuitively, ∼ produces equivalence classes containing either all solutions with the same v value or all non-solutions between two adjacent solutions when all elements are sorted by v value, which we term "clusters".We can observe this intuitively by Fig. 8.Our observation from Fig. 6d thus becomes Theorem.III.2, which states elements from the same equivalence class take the same weight in the state vector of quantum dueling.We leave its proof in Appendix.D.
To formulate the evolution of the state vector on the language of clusters, we need to consolidate our understanding of their properties.It is clear the f values of cluster i 1 FIG. 8: A graphic illustration of the solution space S under cluster representation when all the elements are sorted.The cluster i 1 is an example of all the non-solutions with their measure function values lying between two adjacent solutions being classified together.The cluster i 2 illustrates a case in which all the solutions with the same measure function values are classified as one.The total q clusters make up the quotient search space S/ ∼.
elements from the same cluster are equivalent, so we can allow f to take in a cluster as the argument, outputting the f value of the cluster's elements.While the v values of elements within a cluster might be distinct, for a S ∈ S/ ∼, we can use max v S and min v S to denote the minimum and maximum v value.The details regarding this construction can be found in Appendix D.
For simplicity, we would like to sort all the clusters and index them accordingly.We first define total order ⩽ v and ⩽ f to rank the f and v values of corresponding clusters.Thus, we are able to define ⩽ ∼ as in Definition III.3.The detailed statements and proofs are provided in Appendix D.
Therefore, we could use the relation ⩽ ∼ to sort all the clusters by indexing them from 1 to q = |S/ ∼|.Such relabelling gives rise to a new, contracted basis for the state vector formulated in Definition III.4.For clarity, all indices under this basis will be denoted in Greek letters.
Definition III.4.Consider S ∈ S/∼ and ξ = idx S. Function idx is a bijection from (S/∼) to [n] (set of integers from 1 to n), such that for S, T , idx S ⩽ idx T if and only if S ⩽ ∼ T .
We then Define N ξ and |ξ⟩ as: In this case, the Hilbert Space H S formulated in Sec.II will give rise to a subspace H ∼ such that {|ξ⟩} is a basis.Theorem III.2 suggests that at any stage after initialization in Algorithm 2, |ψ⟩ ∈ H ∼ ⊗ H ∼ .
Under the new basis, we can use κ and λ to index the basis vectors from the first and the second register.Let q = |S/∼|, Eqs. ( 2), (8) thus become: Meanwhile, after applying the Hadmard gates in Algorithm 2, the state vector is: To obtain the formula for state evolution similar to what we have done in Eq. ( 19), we first find an expression for the criterion of the oracle, [v(x) < v(y)]&f (x), where we allow f to take the index of a cluster (denoted in Greek letter) as an input, outputting the f value of that cluster.We will list the detailed proof in Appendix D.
To formulate the oracle in terms of clusters, we define O ξ such that for x ∈ S, where S satisfies idx S = ξ, O ξ = O x .Thus: where the (−1) f (η)& [η<ξ] term can be simplified to o(η, ξ).
We call this process contracting the oracle.Similarly, we then contract the Grover gates {G x } into {G ξ } as: where |m⟩, the mean state vector, can be decomposed in the cluster basis: It is intuitive to rewrite Eq.( 14) as: To show Eq. ( 29) is correct, we notice that there is only a constant term difference between corresponding |ψ l ⟩ and |ψ λ ⟩ and between corresponding |ψ k ⟩ and |ψ κ ⟩.By linearity of quantum gates, there should be no difference in the formula for state evolution, i.e., Eq. ( 29).
As we have done in Sec.III A, we combine Eqs.( 26)- (29) to get the most simplified equation for state evolution: where values h κ and h λ can be pre-processed as: In total, Eqs. ( 25), (30), and (31) allow us to simplify quantum dueling to the most contracted form.In Grover algorithm, such a strategy leads to only 2 clusters: one made up of solutions, and one made up of non-solutions.This would allow us to solve the state vector after an arbitrary number of iterations [14].In quantum dueling, however, the simplified form remains complex, hindering efforts to find a quantitative expression.Nevertheless, we are now guaranteed with a O(q 2 ) per iteration simulation strategy, which will prompt us to understand quantum dueling from a new and comprehensive perspective.

C. Hamiltonian Version of Dueling
Aside from its circuit interpretation using unitary quantum gates, [20,21] have shown that Grover search can be transplanted into a Hamiltonian setup, similar to Hamiltonian-based algorithms like QAOA.As an algorithm inspired by Grover search, quantum dueling can also be represented by the time evolution of a series of Hamiltonians.
Extending the Hamiltonian forumlation in [20,21] into the augmented Hilbert space H = H S ⊗ H S , we can define our mixer Hamiltonians H 1←2 M , H 2←1 M as follows: where |x⟩ is the equal superposition of all basis states in H S .In this way, the diffusion operators D 1←2 , D 2←1 in the augmented Hilbert space H will be generated as long as we choose the evolution time of each mixer Hamiltonian to be π, as already mentioned in [20,21].
When it comes to the problem Hamiltonians H 1←2 Therefore, we can write: |kl⟩ ⟨kl| In this way, the oracles O 1←2 , O 2←1 can be written in the form: Evolving the quantum state |ψ⟩ with respect to time, we obtain: As mentioned in [22], QAOA can be viewed as a generalization of Grover search algorithm.The time parameters of the problem and the mixer Hamiltonians H P , H M are fixed to be π in Grover search, while QAOA introduces 2p additional degrees of freedom to the state evolution by converting the time parameters to two sets of variational parameters {γ i } and {η i } corresponding to the evolution of problem and mixer Hamiltonians, respectively, adding complexity to the quantum state evolution.The notation p stands for the depth of the QAOA circuit, as a common practice starting from [9].More generally, the problem Hamiltonian need not be restricted to the sum of projectors over the target states.Instead, it could be any Hamiltonian tailored to the specific problem, and the mixer Hamiltonian also has different definitions in different QAOA versions.
Quantum dueling, on the other hand, is a game changer.The generalizations that dueling makes to the original Grover search are completely orthogonal to those made by QAOA.To realize comparison, we augment the entire Hilbert space, double the number of qubits, and thus construct two groups of Hamiltonians.Evolving each group of Hamiltonians with respect to time, the result would be a controlled unitary operation of one register over the other.In this manner, we assign two new sets of parameters {α i }, {β i } to the system, one set for each group, making the algorithm variational.In quantum dueling, the variational parameters are defined in the "outer layer" of the Hamiltonians, while the parameters for the "inner layer" Hamiltonians remain fixed as π.Unlike QAOA, the parameters {α i }, {β i } have nothing to do with the evolution time of problem and mixer Hamiltonians; instead, they represent the evolution time of the " averaged" Hamiltonians H 1←2 , H 2←1 , if we use some Trotter-like strategies to combine the two Hamiltonians in one group into one Hamiltonian.The total parameter degrees of freedom is also 2p for quantum dueling, where p is defined in Algorithm 2.
Interestingly, the fixed-point algorithm [23][24][25] modifies the original Grover search so that the evolution time of each operator is not necessarily π.Yoder points out in [24] that the quadratic speedup of Grover can be preserved along with the fixed-point properties, meaning that the success probability will be bounded within an error δ 2 away from 1 asymptotically.
This construction suggests that we may add new degrees of freedom to our inner layer of quantum dueling, changing the evolution time π of each operator to an arbitrary angle θ ranging from 0 to 2π.This can be done by defining two new sets of parameters {γ i }, {η i } in the inner layer, transforming our algorithm into "fixed point dueling".The details may be discussed in our future works.
In a similar fashion as QAOA, we can generalize quantum dueling by modifying the problem and the mixer Hamiltonians to different forms, tailored to the specifics of the target problem.This would fundamentally change the dynamics of the system, unveiling new opportunities that can be explored in future research.
Therefore, we have made an elegant connection between Grover-based algorithms using a unified, Hamiltonian setup, by adding variational parameters and augmenting the Hilbert space, making the state evolution non-trival.The reason for the existence of such representation is simply rooted in quantum mechanics, as the unitary operators could be expressed as time evolution under some specific Hermitian operators, which can be understood as Hamiltonians.

IV. PARAMETER SCHEME
One of the most important features of Algorithm 2 is the need for two additional sets of hyperparameters {α i } and {β i } to dictate the evolution of the state vector.In an equivalent formulation, at any stage after initialization, we can either apply G 1←2 or G 2←1 to the current state vector.A binary string s could be used to represent the application of G 1←2 , G 2←1 operators, where In total, there are 2 depth possible choices when the length of the string is depth, and any one of the possibilities in principle might be the ones that maximize the success probability upon measurement.
At first glance, it might seem that such a need for hyperparameters poses a major concern for the algorithm.In QAOA, for example, it has been shown that as the circuit depth p increases, directly obtaining the optimal parameters becomes extremely difficult.Naturally, we may assume that similar problems are also present for quantum dueling.As we know, different machine learn- ing techniques have been proposed [26,27] as a subroutine of QAOA.Recently, a Hamiltonian backpropagation scheme also came to light [28].Similarly, using machine learning to find optimal hyperparameters for quantum dueling might be one of the choices.However, despite these efforts, we still hope to determine the hyperparameters in advance, designing a relatively easy parameter scheme in most cases.In this way, we hope to resolve the concern of hyperparameters without the need of designing complicated neural networks.This section addresses such a concern in detail.In particular, we use "parameter scheme" to refer to a way to select parameters {α i } and {β i }.Quite often, these parameter schemes are based on some other (usually very few) parameters that can be selected to maximize the performance of the algorithm.In our analysis, we let c be an extra parameter and considered two separate parameter schemes: This means that the algorithm only relies on two parameters, the extra parameter c and the circuit depth p.It is clear that such a parameter scheme is very naive.However, even for such a simple scheme, we show that quantum dueling exhibits strong performance, reaching a quadratic speedup for all our problem setups.In other words, it seems that the parameters in quantum dueling do not pose a huge concern for the practical use of the algorithm.All we need to do is to find a reasonable parameter scheme and use variational or learning techniques to predict very few number of parameters.As will be discussed in Sec.VI A, a better, mathematical understanding of the mechanisms of quantum dueling will help us identify what really counts as a "reasonable parameter scheme", and such a question should be subject to future research.

A. Parameter scheme αi = βi = c
From this point onward, we simulate a slightly modified version of quantum dueling, where the stop parameter is replaced with T , the total number of calls to dueling gates.Since each dueling gate calls once one of the two oracles, T is also the total number of oracles called during the algorithm-an indicator of time complexity.The modified algorithm is described in Algorithm 3.
With this algorithm, we set parameter α i = β i = c, where c is some positive integer.Thus, the algorithm essentially depends on two parameters, c and T .Based on observations made in Sec.III A, we would like to select T such that the state is evolved to the point where the first local maximum success probability is reached.Then, we would like to find a c value that maximizes this first local maximum.
After simulations across a broad spectrum of scenarios, we compile all outcomes in Fig. 9. Within the figure, the subplot Fig. 9a illustrates the evolution of the success probability for some given solution distributions with the optimal c selections.Consistently, the observed trend aligns with the discussions in Sec.III A, characterized by an oscillating success probability.An intriguing deviation occurs in the case of the full square number distribution; while the oscillatory pattern persists, there's a notable variation in the local maxima.Since the full square number distribution is the only distribution that differs significantly from the uniform case, this suggests that the evolution of the state vector is intricately tied to the problem setup.However, the mathematical details of such a pattern remain an open question.Interestingly, this finding challenges previous practices.Typically, we select T to align with the first local maximum, avoiding waiting for the second one.The rationale is efficiency: the same time spent waiting for the second maximum could be used to rerun the algorithm classically and yield a better result.Yet, the full square number distribution presents a compelling counterpoint.Here, the second maximum significantly outstrips the first, suggesting that delaying for the second maximum could be a viable alternative.If this is the case, it is entirely possible that we can find solution distributions where awaiting the second local maximum is definitively more advantageous.Nonetheless, in the interest of maintaining a consistent analytical approach, our focus remains on employing the first local maximum probability in our evaluations.
In addition, Fig. 9b shows the performance of quantum dueling with varying hyperparameter c for some fixed problem setups.In general, c is best chosen as a small odd number unless for extremely sparse M .As delineated in Appendix A, for an arbitrary initial state, a single Grover search gate not only alters the mean components of solutions and non-solutions but introduces a −1 phase shift in the deviation of non-solution components from their mean.Within quantum dueling, such phase shift is cancelled when Grover gates are applied an even number of times consecutively.Our findings suggest that retaining the −1 phase through an odd c introduces greater variability in the state evolution, thereby enhancing the probability of success.Furthermore, the preference for a small optimal c underscores the importance of alternating between different types of gates--a cornerstone concept in quantum dueling.For a fixed-size search space, Figs.9c-9e depict quantum dueling's effectiveness for the given solution distributions.Trends in Fig. 9c implies that the optimal value of c can be quantified with simple functions based on specific solution distribution without any other knowledge.Specifically, for the uniform distribution U0, the best parameter is consistently α i = β i = 1.Results in Figs.9d and 9e largely echo the patterns observed in Fig. 7 where the efficacy of quantum dueling is slowly reduced with an increasing solution concentration.The most notable revelation is the observed non-linear behavior in the number of oracle calls required to attain the first maximum success probability.This unexpected and intriguing finding presents an open avenue for further research and exploration.
Lastly, Figs.9f-9h summarize the performance of quantum dueling for an increasing N .Similarly, Fig. 9c implies that the practical determination of hyper-parameter c is trivial.By Fig. 9g, even for large N , quantum dueling with parameter scheme α i = β i = c can boost the success probability to a significant quantity.For uniform distribution U0, in addition to the best parameter being α i = β i = 1, the success probability is asymptotically close to 1.With the full square number distribution FS, the success probability tends toward a constant value, another intriguing aspect requiring further investigation.For other distributions, the decrease in success probability is so slow that the asymptotic trend is unclear.Nonetheless, it is clear that the number of classical repetitions to boost success probability to a constant, even if needed, is minimal.
In particular, the number of oracle calls T required to achieve the first local maximum success probability is delineated in Fig. 9h.For each type of solution distribution, a linear fit is conducted on the logarithms.The results are shown in Table II   In Sec.IV A we investigated the performance of quantum dueling with parameter scheme α i = β i = c in great detail.Our results demonstrated that even such a naive scheme enhances the success probability efficiently to a high value.However, one can argue that such strong performance is exclusive to this scheme.To address such skepticism, we examined an alternative scheme where α i = 1 but β i is set to some parameter c ∈ N + .Intuitively, this represents an asymmetric design where the first register is primarily utilized as the control to optimize the second, interspersed with occasional updates.
The cumulative findings are compiled in Fig. 10 and Table III, employing the same methodology as in Sec.IV A. For brevity, we selected plots of state evolution, the impact of varying parameter c, and performance changes with different N .These result affirm that the trends discussed in Sec.IV A persist for this parameter scheme, with quantum dueling achieving notable success probabilities within O( √ N ) time.Consequently, we can conclude that the hyperparameter required in quantum dueling does not pose a significant challenge for practical implication.Instead, it brings a beneficial versatility to the algorithm, further enhancing its efficacy.

C. Quantum Dueling under Locally Optimal Parameters
In Sec IV A and Sec IV B, we found that quantum dueling exhibits a strong performance even for naive parameter schemes.However, it is worth noting that our analysis focuses on non-extreme solution distributions where, when sorted by target function value, the solutions are dispersed into non-solutions in some manner.For cases where all solutions are cramped together without separation, our analysis in Sec.III A shows that quantum dueling, at least for α i = β i = 1, effectively loses efficacy.
A natural question to ask is for these extreme cases, is it possible that there still might be ways to achieve a significant boost of success probability with a proper selection of hyper-parameters?In other words, we would like to simulate how quantum dueling would perform for a near-optimal parameter selection without the restriction of specific parameter schemes.Then, we would test our simulation against these extreme solutions to explore the limit of quantum dueling.Since our research is primarily aided by classical simulation, our purpose is simply to demonstrate the limit of quantum dueling without any practical consideration.We are free to use the benefit of classical simulation, i.e., the ability to store and copy quantum states with knowledge of the entire state vector.Using the binary string s formulation as discussed at the start of Sec IV, one of the approaches to finding a near-optimal parameter is a greedy strategy that iteratively finds the best sequence of gates to apply in the next depth gates.If needed, such a search can be pruned to situations where the switch from one gate to another is sparse in the s string, reflecting the {α i }, {β i } formulation of hyperparameter. 3The exact 3 In particular, with parameters defined in Algorithm 4, let change be the number of locations i in s where s i ̸ = s i−1 , we can set the pruning condition to be change < change limit, where change limit is some parameter.In principle, this would reduce the computational load and allow us to estimate quantum dueling's performance for an increasing N .An example diagram can be found in [29].
algorithm is sketched in Algorithm 4. Before we tackle these intractable cases, first, we run Algorithm 4 against several different forms of uniform solutions distribution and summarize the results in Fig. 11.It is clear that under such an optimal scheme, quantum dueling can significantly boost success probability towards a high probability, usually to a better extent than the parameter schemes discussed in Secs.IV A and IV B. Note that in Fig. 11a, for uniform solutions distribution where the element with smallest measure function value happens to be the solution, the heuristics algorithm is able to find the best parameter to be α i = β i = 1 before the maximum probability is reached. 4Moreover, as shown in Fig. 11c, for an increasing N , we observed longer continuous sequences of G 1 and G 2 being applied.This justified the {α i }, {β i } formulation of hyperparameter as opposed to the binary string s formulation.Lastly, as seen in Fig. 11b, the use of better parameters found by heuritics algorithm alleviates the collapses of efficacy at M = N 4 as discovered in Sec.III A. With this in mind, we then test the aforementioned perplexing solution distributions, along with some other non-uniform distributions, and present the results in Fig. 12.It is clear that with proper parameters, quantum dueling manages to achieve a significant boost of success probability regardless of solution distribution, even for these onerous cases.Note that the distribution where all non-solutions have function values higher than solutions is of particular interest to us.Since our oracle is assumed to distinguish between solutions and non-solutions, we can arbitrarily shift the v distributions of all solutions by alternating the construction of the oracle using quantum arithmetic.In principle, we can thus morph all forms of solution distributions to such a distribution.Our simulation suggests that there exists a parameter scheme for this problem that is sufficiently good.If future research can make such a scheme explicit, we will obtain a universal method for all combinatorial optimization and can potentially offer a lower bound for the performance of dueling.
For the worst-case scenario, where all solutions have measure function values higher than all non-solutions and therefore cannot be boosted, quantum dueling can still boost the success probability towards a high constant, albeit at a much slower rate.This result has defied our expectations, and fullying understanding this effect remains an open question.Lastly, in some cases, a decrease in success probability is observed in order to achieve the maximum, increased success probability after depth moves.This seems to suggest that aggregations of locally optimal decisions do not necessarily result in the globally optimal decision, because in such cases the probability may experience a longer decrease first.Therefore, the parameter suggested by Algorithm 4 is not necessarily the optimal parameter and should be taken with a grain of salt.
Overall, this section discussed the performance of quantum dueling with different parameter setups in detail.While quantum dueling in its definition requires a set of hyperparameters, Secs.IV A and IV B suggest even a naive scheme can help to find parameters that enable dueling to boost success probability to a sufficient value.
In these examples, the degree of freedom in the hyperparameter is essentially reduced to 2, which, in practice, can be determined via manageable methods.Furthermore, in Sec.IV C we investigated a near-optimal parameter scheme that could possibly be approached with the use of more complex parameter-determining methods such as machine learning.In this case, quantum dueling will exhibit an even stronger performance for almost all, if not all solution distributions, becoming a powerful tool for generic combinatorial optimization.

V. APPLICATION A. Quantum Dueling without Solution Labeling
The solution distributions discussed in the earlier sections of this paper are often idealized and not reflective of real-world scenarios.In this section, we shift our focus to more practical distributions.Quite often, we encounter cases when all elements in the search space are labeled as solutions or, equivalently, when M = N .In this case, the combinatorial optimization problem defined in Sec.II could be reduced to simply finding an element x that minimizes the measure function, namely: As an example, we consider the specific case when all elements share distinct measure function values.In other words, there is no degeneracy of the measure function v(x).
As previously outlined in Sec.III A, when confronted with the challenge of quantum dueling's diminished effectiveness in scenarios where M = N , we proposed two potential solutions.One is to manually add ancilla qubits, sparsing out the solution distribution in the new search space, while the other is to design better parameter schemes.The latter approach has already been discussed in Sec.IV.In this section, we focus on the former approach.
Formally speaking, we could add ∆n ancilla qubits to the system, extending the original search space S into S ′ .In this manner, we can define an extra parameter η = M N , indicating the ratio of the number of solutions to the total number of elements in the search space.As the number of ancilla qubits ∆n increases, the ratio η = M N = 1 2 ∆n decreases monotonically, so that we are free to choose η as the control parameter.Originally, the size of the search space S is N , with N = M .In this section, to avoid confusion, we use M to represent the size of the original search space, also corresponding to the number of solutions in the augmented search space S ′ .This is due to the fact that we could manually set all the new elements x ′ added to the original search space to be nonsolutions, which means f (x ′ ) = 0, ∀ x ′ ∈ S ′ \ S, where \ is the notation for set difference.
In principle, we can set the value of v(x ′ ) arbitrarily.The goal is to achieve a solution distribution such that quantum dueling shows robust performance.For all x and its corresponding x ′ , we can set v(x ′ ) to be any value in (v(x), v(x) + ∆v(x)).In that way, by results in Sec.III B, we will end up with a solution distribution that effectively equals U0.
In our simulation, we execute Algorithm 5 in the augmented search space S ′ with ancilla qubits added with parameter scheme α i = β i = c. 5,6We set the number of oracle calls per round T to be the number of calls when the first maximum probability p max is achieved in Algorithm 3. Our goal is to achieve some constant success probability P bar .Therefore, we set a = log 1−pmax (1 − P bar ) and T last to correspond to the time when the combined success probably reaches the threshold P bar .We then perform Algorithm 5 with the η value that minimizes the total number of calls to oracle.
As we add more ancilla qubits, making η smaller, we expect an increase of the first maximum success probability p max , a corresponding increase of the number of calls to the oracle per round T , as well as the total number of calls to the oracle num.In particular, we are interested in the growing trend of the total number of calls to the oracle num with respect to the size of the original search space M under the optimized η for each M , because this trend might give us a hint into the computational complexity of quantum dueling under the naive parameter scheme α i = β i = c when all M = N originally.Fig. 13 illustrates the increasing trend of the total number of calls to the oracle with respect to the size of the FIG.12: Quantum dueling for different solution distributions.We ran heuristics under depth = 18 to collect relevant data.Data points that are achieved after applying G 1←2 are denoted using , and those achieved after applying original search space M , given the optimal selection of control parameters η.Notably, as M enlarges, the increase in oracle calls aligns with an O( √ M ) trend.This suggests that the strategy of adding ancilla qubits is effective for large-scale initial search spaces, reflecting on the computational complexity considerations.

B. Quantum Dueling for PMAX-3SAT
Besides the specific case when M = N mentioned in Sec.V A, we also want to apply quantum dueling to a practical combinatorial optimization problem, namely PMAX-3SAT.
In PMAX-3SAT, we are given a set of boolean variable FIG.13: Log-log plot of the number of calls to the oracle with respect to the size of the original search space M .For any element x in the original search space S, we have the measure function difference of adjacent elements ∆v(x) = 2.As we add ancilla qubits, for every x ∈ S, we add its corresponding x ′ elements with measure function values v(x ′ ) = v(x) + 1.We then run Algorithm 5 under the parameter scheme α i = β i = c.P bar is set to be 2 3 .We execute the algorithm under different control parameters η and obtain the most optimal η for each M .
and a literal is one single variable in its original form x or negation form ¬x. The disjunction of literals form clause C, and since this is 3SAT so each clause contains exactly 3 literals, e.g.C = x 1 ∨ x 2 ∨ ¬x 3 .The final formula, denoted as e, is a set of such clauses in conjunction, e.g.
where part of the formula F 1 is used to determine whether an assignment satisfies the formula, and the other part F 2 is to determine how optimal an assignment is if it satisfies F 1 .Under PMAX-3SAT, our goal is to find an assignment x 1 x 2 • • • x n that satisfies F 1 and satisfies the 3 .We randomly generate 10000 cases of Boolean formulas for each N. We then take the average value of the total number of calls to the oracle when N is fixed.most number of clauses in F 2 .
In the encoding stage, our search space has size N = 2 n , where n is the number of variables.This means that there are in total N possible assignment configurations.We define y i as a binary indicator.When clause C i is satisfied, y i takes the value of 1, otherwise, y i = 0.In practice, each assignment X within this search space is a solution if it satisfies the first half of F, F 1 , which means 0≤i<m ′ y i = m ′ where m ′ is the number of clauses in F 1 .
Furthermore, the measure function for each assignment X is formed by u(X) = m ′ ≤j<m y j , which is the number of clauses that are satisfied in F 2 .In PMAX-3SAT, we want to maximize u(X), and since our formulation of quantum dueling minimizes the measure function, in practice we set the measure function to v(X) = −u(X).
For simplicity, we want to randomly generate PMAX-3SAT formulas and restrict the number of solutions M to be around √ N .Therefore, we use the fraction M N to determine the number of clauses we have for the generated formula.Specifically, since for each assignment, the probability that it satisfies a single clause is 7  8 , so each clause is satisfied by around 7  8 fraction of all possible assignments.Therefore, the number of clauses m ′ in F 1 determines the expected M, that is E(M ) = N  .We then decide to make m = 2m ′ so that we have same amount of clauses in F 2 to determine how optimize a solution is, so we generate 2 log 7 number of clauses for N = 1, 2, 4, • • • , 4096.
The result of our program simulation is shown in Fig. 14, from which we observe a complexity trend around O( √ N ).Although a more exact determination of time complexity requires running with higher N and more possible parameter scheme, the trend shown in the graph confirms our conclusion that quantum dueling under some parameter scheme has the potential to solve PMAX-3SAT problem efficiently.Furthermore, a lot of known non-polynomial problem reduce to PMAX-3SAT.Being able to solve PMAX-3SAT efficiently proves quantum dueling's potential to solve more non-polynomial problems that are "hard" to solve by classical computers.

A. Mechanisms of Dueling
In previous sections, we have presented many methods to understanding the performance of quantum dueling in a wide range of circumstances.However, one key question remains: How does the algorithm actually work?
One main question regarding quantum dueling is the fact that when we repeatedly apply Grover gates, after O( N M ) times the states will be "overcooked."If we try to apply Grover gates again, the corresponding quantum states will no longer be optimized but worse.
As an intuitive answer, quantum dueling circumvents this problem because the number of Grover iterations required for such a phenomenon to happen is not the same when we choose different elements from the search space as the "opponent" in dueling.Consider different y ∈ S and corresponding G y gates as used in Eq. ( 12).For better y, the number of rotations required for overcooking is larger.As long as {α i } and {β i } are sufficiently small compared with √ N , by the time that overcooking takes place among the worse elements, the amplitudes are already boosted away towards the more desirable elements, so this effect generally does not occur before quantum dueling already boosted the amplitudes to the largest.
Another puzzling issue is that at times during the algorithm, we do not actually apply Grover gates on a uniform linear combination of all the solutions and also non-solutions.Rather, the components ψ kl follow an unknown trend, where its absolute value is usually decreasing with k and l representing worse and worse candidates for the search space.In such a case, the Grover amplifier should only have a boosting effect for the projection of the state onto the space spanned by the mean of solutions and the mean of non-solutions identified by the oracle.In that way, we should expect the Grover gates not to have boosted quantum states significantly such that the success probability can by any means be boosted to a significant value.
Our results, especially those in Sec.IV, show the opposite.While in some extreme cases, a naive parameter scheme fails to boost success probability significantly, in almost all other situations, quantum dueling boosted success probability towards a significant value even for a large N .It seems that the iterative procedures of switching between G 1→2 and G 2→1 gates somehow hybridized the state in a way that the issue raised is completely circumvented.To truly understand how this can happen, we need to find an approximate solution for the evolution of the state vector.In fact, we believe solving such a task is not only extremely important for the quantum dueling algorithm itself, but would be interesting mathematical research that might offer new insights to the field of quantum computing in general.

B. Generalizations of Quantum Dueling
In Sec.IV, we found that while quantum dueling in principle relies a sequence of external parameters that need to be fixed, the degree of freedom in these parameters can be drastically reduced with a good parameter scheme.In such an event, quantum dueling demonstrate a strong performance, exhibiting a quadratic speedup compared with classical search.Yet, are there any other ways to improve our result furthermore?For example, can we boost the success probability to arbitrarily high value without classical repetition of the algorithm as done in Sec V?
As discussed in Sec.VI A, the main reason behind quantum dueling's dependency on solution distribution is not its design idea itself, but the underlying issues with Grover's algorithm.In Sec.III C, we mentioned that quantum dueling can be further generalized with arbitrary controlled phase factors and also different mixer and problem Hamiltonian setups.Putting things further, quantum dueling should be even more generalized to the idea of augmenting the Hilbert space and transforming optimization into comparison, utilizing the underlying entanglement principles.If that is the case, in principle, any quantum search algorithm that can perform amplitude amplification can be used as an underlying mechanism for quantum dueling.For example, adiabatic search as algorithms as discussed in [20,30] can be used in place of Grover gates in the construction of quantum dueling.If we can find a way to realize comparison via adiabatic means, it would be possible to realize quantum dueling even in NISQ (noisy intermediate-scale quantum) devices.A more thoroughly thought quantum search scheme can not only reduce quantum dueling's dependence on solution distributions and hyperparameters but also offer unexpected gains.

C. Quantum Dueling as a Quantum Subroutine
In Appendix B, we note that quantum dueling can, in some ways, be seen as a quantized version of Grover Adaptive Search (GAS), which also achieved a quadratic speedup-the theoretical limit of quantum computing for generic optimization problems.This raises a pertinent question: if both algorithms attain similar speedups, what distinguishes quantum dueling from GAS? Why is such algorithm design important?Quantum dueling's primary strength is its fully quantum nature, in contrast to the hybrid approach of GAS, which relies on periodic measurements to optimize the state based on the objective function.This intrinsic advantage of quantum dueling allows it to function as an integrated subroutine within broader quantum algorithms, a capability not feasible with hybrid models.As an example, consider a quantum circuit with two registers; so its basis states can be written as |x⟩ |y⟩ in some Hilbert space H x ⊗ H y .Given some entangled state, we would like to optimize only the second register based on some objective function that is dependent on both x and y, say v(x, y).In other words, starting with some |ψ 0 ⟩ ∈ H x ⊗ H y we would like to achieve some quantum state |ψ⟩ H x ⊗ H y such that for each |x⟩, the projected state of |ψ 0 ⟩, i.e., ⟨x|ψ 0 ⟩ is optimized to ⟨x|ψ⟩7 such that | ⟨y optimal (x)| (⟨x|ψ⟩) | 2 is sufficiently large.Here y optimal (x) is a function of x that represent the y that optimize v(x, y) for each x.
Note that such a task cannot be completed with a hybrid algorithm such as GAS.We cannot use measurement to obtain a current best guess and further optimize.Rather, a measurement on the register corresponding to y will leave us with only one y value and the corresponding projection to H x , losing the broader context provided by the quantum state.Quantum dueling, however, is a fully quantized algorithm without the need of measurement.Therefore, it can, in principle, complete such a task.There are two issues that need to be resolved.First, since quantum dueling would essentially be run parallel for all possible x, the best hyper-parameter for different x values may be different.Choosing a single fixed hyperparameter might not produce desirable results.This can be resolved by using a quantized, controlled operation to automatically determine which gate to apply based on the specifics of x, embedded within the quantum circuit itself.Of course, this would require enormous quantum computational power that is not currently practical.However, this is possible theoretically and realizable in the future.Second, there are no assumptions made about the initial state.In all our experiments we initialized the state to be a uniform linear combination of all possible elements from the search space, however, the initial state in this case will depend on the algorithm itself.It is unclear how quantum dueling will perform for a more generic initial state.For this issue, note that the dependency of quantum dueling does not originate from the idea of dueling itself, but the dependence on initial state in Grover search.Therefore, we can consider other quantum search algorithms as discussed in Sec.VI B.
In the realm of optimization problems, it's rare to encounter scenarios devoid of any structure, where the only solution is a brute-force approach across all possible candidates.More often, these problems contain inherent properties that allow an efficient solution.While an algorithm like Grover Adaptive Search (GAS) offers a quantum-accelerated brute-force method, its application is confined to these generic cases.Quantum dueling, on the other hand, transcends this limitation.Its utility is not restricted to just accelerating brute-force searches but extends to enhancing any process aimed at identifying the best solution from a set of candidates, even if such a process is quantum-based.Such versatility makes quantum dueling an invaluable tool not only for direct optimization but also as a subroutine in more complex quantum algorithms where an optimization process is required.

VII. CONCLUSION
In this work, we proposed a quantum algorithm for combinatorial optimization.The algorithm, quantum dueling, operates on an augmented Hilbert space with twice the size of qubits.At each time, we can choose one register as a control to apply a controlled Grover gate to the other register, selecting states that are "better" than the control.In such a way, the state slowly evolves towards the optimal direction.We analyzed the performance of quantum dueling via computer simulation and offered some mathematical contraction that could potentially be useful to find an approximate solution for the evolution of the state vector.Using such a contraction, we investigated the performance of quantum dueling by setting a variety of parameter selection schemes.We demonstrated that while quantum dueling requires a set of hyper-parameters, even a naive set of parameter schemes can result in an algorithm reaching significant success probability in a quadratic speedup compared with a classical brute-force search.We further tested our hypothesis to more practical scenarios such as the case where there is no solution labeling and PMAX-3SAT.
Overall, it is clear that quantum dueling opens a new route by which optimization problems can be realized, characterized by its efficiency, versatility, and general applicability.From a conceptual perspective, we demonstrated how, by multiplying the number of qubits used and utilizing the underlying entanglement principle, we can create previously unthought-of and interesting quantum algorithms that can offer new insights into theoretical quantum computing.Previously, such a procedure was only seen in quantum error correction, where several physical qubits are used to simulate one logical qubit [31].Our paper essentially applied such ideas to quantum algorithm design in general.Mathematically, there is so much to be learned.Can we truly understand how Algorithm 2 somehow bypasses the apparent impossibilities to effectively boost the state vector and finally provide a quantitative solution?Can we find a way to understand how hyper-parameters impact the performance of quantum dueling and apply such methodologies to other variational algorithms such as QAOA (quantum approximate optimization algorithm)?Most importantly, can we apply the idea of dueling to more specific optimization problems with underlying structures, utilizing a fully quantized oracle of comparison and more in highly entangled memory space?Trying to answer these questions will open up new ideas that can help advance the development of quantum algorithm design.
Codes to reproduce the data and figures in this paper are available online [29].
vector space spanned by the basis vector |φ⟩ and |γ⟩.The state can be specified by an angle σ, which the rotating state vector makes with the axis |γ⟩, with its initial value θ = arcsin M N .In this regard, at any stage after initialization, the state vector |ψ⟩ = sin σ|φ⟩ + cos σ|γ⟩, and when applied to the Grover Operator G = DO, the state becomes: A3) From Eq. (A3), we could conclude that each time the state vector |ψ⟩ is rotated by 2θ towards the |φ⟩ axis.After applying Grover Operator r max times, the angle which the state vector makes with the |γ⟩ axis in the 2-dimensional plane becomes: After conducting a measurement on the final state, the probability of finding one of the solutions is sin 2 σ max , which is close to unity when σ max ≈ π 2 .The least number of iterations needed for a near-optimal result is r ≈ π 4 √ N , which means the time complexity of Grover search is O( √ N ).We require N ≫ 1 for the above analysis to hold.
It has been shown in [16], [17] that Grover search algorithm is optimal for any oracle-based quantum search scheme, with its time complexity reaching O( √ N ).

Appendix B: Grover Adaptive Search
Similar to what was mentioned in Sec.II, Grover adaptive search copes with the problem of finding an element x in the search space, satisfying: For simplicity, we will abbreviate Grover Adaptive Search for GAS.
The condition labeled in Eq.B1 slightly differs from that proposed by Baritompa in the original version of GAS [5], as we have not only taken into account the value of measure function v(x) but also the value of the solution-indicator function f (x), distinguishing between solutions and non-solutions.
Algorithm 7 shows the process of GAS for solving combinatorial optimization problems formalized by [4,5].In the algorithm, a best current guess best is repeatedly updated via a Grover search.Ignoring ancilla qubits, there are two components of memory storage in GAS: (a) A quantum storage of n qubits.In each iteration, it is reset for a Grover search.(b) A classical storage documenting the current best guess.
The classical storage stores the current best guess best after i iterations as well as the measure function v(best), and the quantum storage stores the state vector |ψ⟩, which is initialized after each iteration.In the i th iteration, we apply Grover operator G on the quantum storage r i times, followed by a measurement.And we update the current best guess best if the measured result is "better" than the current one stored in the classical storage.Thus, GAS is a combination of Grover and the classical adaptive search.
According to [5], the rotation counts should vary to avoid the breakdown of GAS for certain specific solutions in the search space S. The choice of the Grover rotation counts r i of the i th iteration of GAS is determined by the parameter k, where r i is randomly chosen from the set {0, 1, • • • , ⌈k − 1⌉}.
The performance of GAS is shown to be dependent upon the choice of parameters, especially the parameter λ, which serves as the scaling factor of k when the result produced by one measurement is not satisfactory.Baritompa suggests in [5] via numerical simulations that when λ = 1.34, the performance of GAS reaches an optimal bound, with a relatively high success probability of finding the most optimized solution.He also shows that the time complexity of GAS is approximately O( √ N ).To develop the idea of GAS to quantum dueling, the current best guess, originally stored in a classical memory in GAS, will be stored in a quantum register.This register thus contains an entangled state of potential solutions, with more optimized solutions having higher amplitudes.In each iteration, the states in both registers are updated, leading to increases in amplitude of more optimized solutions.Compared to GAS, quantum dueling performs its algorithm in a fully quantized system without classical memory involved.Consequently, there will no longer be a requirement for measurements at the end of each iteration.Therefore, the first register serves the same purpose as the second one, storing the current best guess inside, which leads to a symmetry in the algorithm design.
In some ways, the idea of quantum dueling is generated from the observations of the original Grover adaptive search by quantizing the entire search process using an augmented Hilbert Space.When f (l 1 ) = 1, this is trivial;when f (l 1 ) = 0, f (k 2 ) = 0, o(k 2 , l 1 ) = o(k 2 , l 2 ) = 1.
It is worth noting that ∀S ∈ S/ ∼ , if f (S) = 1, I v (S) = ∅; otherwise, I v (S) ̸ = ∅.In general, we have outlined the range a given cluster spans in the space of measure function v(x).Therefore, the nonoverlapping properties of different clusters can be expressed as I v (S) ∩ I v (T ) = ∅ for arbitrarily different clusters S, T , as presented in Lemma D.6.Proof.Prove by contradiction.If I v (S) ∩ I v (T ) ̸ = ∅, then one of endpoints of either I v (S) or I v (T ) must be within the other interval.Without loss of generality, assume a endpoint of I v (S) belongs to I v (T ).Thus, either min v S ∈ I v (T ) or max v S ∈ I v (T ), implying that there is a x ∈ S such that v(x) ∈ I v (T ), i.e., min v T < v(x) < max v T .Meanwhile, if either f (S) = 1 or f (T ) = 1, I v (S) ∩ I v (T ) = ∅.Thus, f (S) = f (T ) = 0. Therefore, by Definition III.1 applied to the elements of T with smallest and greatest v values, no solution has v value within [min v T , max v T ).Consider a y ∈ T , it is clear that min v T ⩽ v(y) ⩽ max v T .Since min v T < v(x) < max v T , no solution has v value within [min(v(x), v(y)), max(v(x), v(y))), meaning that x ∼ y.Since we know that x ∈ S and y ∈ T , we must have S = T by properties of S/ ∼.We assume S ̸ = T , so we have a contradiction.
In order to prove the validity of sorting clusters with respect to their indices, we need to construct a total order on the space S/ ∼.First of all, we define the relations ⩽ v , ⩽ f on S/ ∼ in Definition D. As in Theorem D.8, ≤ v and ≤ f are total orders on S/ ∼.Theorem D.8. ⩽ v and ⩽ f are total orders if we define corresponding equivalence relations ∼ v and ∼ f to satisfy anti-symmetry.
Proof.Lemma D.6 implies that for each cluster S, we can find a v-indicator v(S), which is a generalization of the argument of v to allow it to intake a register.(For example, v(S) = 1 2 (min v S + max v S)) In this case, ⩽ v becomes ⩽ in mapped structure {v(S) | ∀S ∈ S/∼}.With the equivalence notation ∼ v , ⩽ v is a total order.Similarly, ⩽ f is a total order with properly defined relation ∼ f , since it is ⩽ on the mapped structure {f (S) | ∀S ∈ S/∼}.
After the definition of total orders ⩽ v , ⩽ f on S/ ∼ in Definition D.7, we could then define the relation ⩽ ∼ on S/ ∼, and prove that it is a total order on S/ ∼ in Theorem D.10.Note that Definition D.9 is a restatement of Definition III.3 for the sake of clarity.Definition D.9. ⩽ ∼ is the lexicographic combination of ⩽ v and ⩽ f .That is, for S, T ∈ S/∼, S ⩽ ∼ T if and only if S < v T (that is, ¬T ⩽ v S)) or (S ∼ v T and S ⩽ f T ).
Theorem D.10.⩽ ∼ is a total order on S/ ∼.The corresponding notion of equality is =.
Proof.By the property of lexicographic order, ⩽ ∼ is a total order.Thus, it suffices to show that anti-symmetry holds for =.For S, T ∈ S/∼, let S ⩽ ∼ T and S ⩽ T .Thus, S ∼ v T and S ∼ f T .By definition, we can find a c v and c f such that ∀x ∈ S ∀y ∈ T v(x) = v(y) = c v and f (S) = f (T ) = c f .Therefore, ∀x ∈ S ∀y ∈ T x ∼ y, so S = T .

FIG. 1 :
FIG.1: Matrix representation of the components ψ kl in the augmented Hilbert Space H = H S ⊗ H S .The example features the problem with N = 13, M = 4, f (x) = 1 when x = 2, 3, 7, 11 and 0 otherwise, where v(x) = x for all x ∈ S. Indices k and l stand for the labels for elements in the first and the second register, respectively.Each cell in the grid can be filled with a number that represents the component ψ kl as defined in Eq. (2).Cells such that either k or l is a solution are highlighted.In this problem, the best solution is x = 2. Cells at which either k = 2 or l = 2 are shaded.When the state vector is a basis vector (or a linear combination of basis vectors) corresponding to the cells in the shaded region, the best solution will be obtained upon measurement.

FIG. 6 :
FIG.6: Performance of quantum dueling for a search space of N = 256 with M = 16 solutions, which are distributed as v(x) = x, f (x) = [x ≡ 1 (mod 16)], where 1 ⩽ x ⩽ 256.The parameters are chosen naively such that α i = β i = 1.(a) Success probability P 1 of finding the most optimized solution (at x = 1), along with that of the second (probability P 17 at x = 17) and the third (probability P 33 at x = 33) as a function of number of iterations performed.(b) The last step of Algorithm 2 combines results from both registers to produce an output.If instead we only measure the first register, a set of parameters similar to those in (a) and (c) can be used to quantify the performance of quantum dueling.These figures show the success probability P ′ 1 of finding the most optimized solution (at x = 1), along with that of the second (probability P ′ 17 at x = 17) and the third (probability P ′ 33 at x = 33) as a function of number of iterations performed, on the assumption that only the first register is measured.(c) The (local) maximum success probability of measuring the most optimized solution is achieved after i max = 10 iterations.The figure visualizes, in a logarithmic scale, the probability distribution of elements 1 ⩽ x ⩽ 100 after this iteration.(d) The local maximum success probability (after only measuring the first register) is achieved after i ′ max = 10 iterations.The figure visualizes, in a logarithmic scale, the probability distribution (after only measuring the first register) of elements 1 ⩽ x ⩽ 100 after this iteration.

FIG. 7 :
FIG. 7: Performance of quantum dueling for different M , assuming N = 256, v(x) = x, and a near uniform solution distribution f (x) = x − 1 ≡ 0 (mod N M ) .(a) The first local maximum success probability P max and the first local maximum first-register success probability P ′ max , as a function of M , which is in logarithmic scale.(b)The number of iterations p max after which P max is achieved, and the number of iterations p ′ max after which P ′ max is achieved, as a function of M , which is in logarithmic scale.More details regarding this formula can be found in Appendix C.
P and H 2←1 P , due to our specific oracle constructions, they will be the sum of projectors onto the basis |kl⟩ in the augmented Hilbert space H that satisfy the corresponding constraints: o(k, l) = −1 and o(l, k) = −1, respectively.

FIG. 9 :
FIG. 9: Quantum dueling under parameter α i = β i = c.The figures show the performance of the algorithm on different solution distributions.In the legends of figures, U0 stands for f(x) = [x − 1 ≡ 0 (mod N M )], UH stands for f (x) = [x ≡ N M (mod N M )], FS stands for f (x) = [∃y ∈ N * x = y 2 ]and R stands for random distribution for solutions.All figures show trends where c takes the value that results the highest probability at the first peak, except figure (b).The random case has been treated by averaging over several runs.(a) Success probability trend under a large number of calls to Oracle.In this figure N = 4096, M = 64.(b) Success probabilities achieved with different c and N = 4096, M = 64.(c)(d)(e) show trends of best parameters, success probabilities and algorithm complexity against varying M with N = 4096 while (f)(g)(h) show them against varying N with M = √ N .

FIG. 11 :
FIG.11:Quantum dueling under near-optimal parameters.For uniform solution distribution, measure function v(x) = x, and no pruning of the search tree, we ran the classical heuristic algorithm under depth = 18 for three separate sets of data and recorded the evolution of success probability with respect to each application of dueling gate.Data points that are achieved after applying G 1←2 are denoted using , and those achieved after applyingG 2←1 .(a) N = 256, M = 16, f (x) = [x ≡ t (mod 16)],where t is 1,8, and 0, respectively.(b) N = 256, f (x) = [x − 1 ≡ 0 (mod N M )], where M is 4, 16, 32, 86, and 256 respectively.(c) M = √ N ,

Algorithm 5 :
Iterative Quantum Dueling Input: Functions f and v; Success probability threshold P bar ; Total number of complete rounds a; The stop timer T for each complete round; The stop timer P last for the last round; Two sufficiently long integer sequences: {αi} and {βi}.Output: An element x in the search space S satisfying f (x) = 1 and v(x) (approximately) minimized; the total number of oracle calls num num ← 0 ; for i ← 1 to a do Perform Algorithm 3 with parameters: {αi}, {βi} and T ; end Perform Algorithm 3 with parameters {αi}, {βi} and P last ; num ← a * T + T last ; Measure both registers.Let the result in the first register be x1 and the result of the second register be x2.Output the better result.

1 FIG. 14 :
FIG.14:Log-log plot of the number of calls to the oracle T with respect to the size of the search space N .Algorithm 5 is executed iteratively under the parameter scheme α i = β i = c to obtain a constant threshold success probability P bar = 2 3 .We randomly generate 10000 cases of Boolean formulas for each N. We then take the average value of the total number of calls to the oracle when N is fixed.

7 .Definition D. 7 .
Define relation ⩽ v on S/ ∼ such that for all S, T ∈ S/ ∼, S ⩽ v T if and only if ∀x ∈ S ∀y ∈ T v(x) ⩽ v(y).Define relation ⩽ f on S/ ∼ such that for S, T ∈ S/ ∼, S ⩽ f T if and only if f (S) ⩽ f (T ).

TABLE II :
Linear regression data of ln (Calls to Oracle) against ln N with parameter

TABLE III :
Linear regression data of ln (Calls to Oracle) against ln N with parameter α i = 1, β i = c.