Hybrid Classical–Quantum Branch-and-Bound Algorithm for Solving Integer Linear Problems

Abstract

Quantum annealers are suited to solve several logistic optimization problems expressed in the QUBO formulation. However, the solutions proposed by the quantum annealers are generally not optimal, as thermal noise and other disturbing effects arise when the number of qubits involved in the calculation is too large. In order to deal with this issue, we propose the use of the classical branch-and-bound algorithm, that divides the problem into sub-problems which are described by a lower number of qubits. We analyze the performance of this method on two problems, the knapsack problem and the traveling salesman problem. Our results show the advantages of this method, that balances the number of steps that the algorithm has to make with the amount of error in the solution found by the quantum hardware that the user is willing to risk. The results are obtained using the commercially available quantum hardware D-Wave Advantage, and they outline the strategy for a practical application of the quantum annealers.

1. Introduction

A Logistic optimization problem, whose goal is to find the solution which minimizes a suitable cost function given a set of constraints, can often be expressed in terms of binary combinatorial problems. One way to tackle this kind of problem consists of exploring all possible solutions, thus pursuing a brute-force strategy. A better strategy is found in the so called branch-and-bound (BB) algorithm [1] that explores sub-combinations of the problem and excludes those that either do not satisfy the constraints or those whose value of the cost function is higher than the solutions previously investigated. Paradigmatic examples that can be solved with the BB algorithm [2,3,4,5], are given by (i) The Knapsack Problem (KP) [2], in which one searches for the selection of objects (from a predefined set) that maximizes the load’s value while adhering to the capacity constraint of the carrier; (ii) The Traveling Salesman Problem (TSP) [3,6], which aims to find the minimal route that passes through different cities, with the constraint that the path crosses all of the cities exactly once.

In recent times, with physical platforms that have been made available to researchers, attention has been driven by the possibility that quantum computers can speed up the resolution of several NP-hard problems [7]. In this work we analyze a particular quantum computer, the quantum annealer of D-Wave, which is expected to be particularly suitable for solving binary optimization problems. It accomplishes optimization by translating a binary linear optimization problem (BLOP) with constraints into a quadratic unconstrained binary optimization (QUBO) problem. In this way the optimal solution of the BLOP can be described by the ground state of an equivalent Ising problem, which can natively be mapped on the quantum hardware manufactured by D-Wave Quantum Systems Inc. (Burnaby, BC, Canada).

The two problems mentioned above are perfect examples of combinatorial problems that may benefit from the use of a quantum computer. However, few works have been done on the actual resolution of the D-Wave machine. In Ref. [8] the authors tried to solve small KP using the D-Wave quantum annealer, finding results far from the global optimum. In Ref. [9] the authors analyzed the shortest path problem, a slight variant of the TSP. They successfully determined the optimal solution for graphs composed of up to six nodes, a limitation that may not align with current practical requirements. In fact, the quantum annealer is still a developing technology, currently affected by noise that makes it unable to find the global solution even to simple problems.

In order to overcome the apparent failure of the fruitful use of this device in the near period, we propose to use a classical–hybrid protocol, in which the quantum hardware is used as a subroutine for a variant of the classical BB algorithm. In particular, we show that thanks to the BB algorithm we can reduce the size of the problem down to a number of instances that are feasible for the quantum computer. With this strategy, the quantum computer can fully show its potential and find an optimal solution to the problem.

Our findings show that we can exploit near-term quantum computers to speed up the solution of a problem, reducing the number of queries to both the quantum and the classical computer. However, there is a trade off between the quality of the found solution, measured in terms of its proximity to the global optimal solution, and the achievable speed-up. A similar idea has been proposed in Ref. [10], where the BB algorithm was applied to a large number of QUBO problems by simulating the quantum annealer on a classical computer.

In the paper, we apply a hybrid algorithm to study both the KP and the TSP, making use of the real D-Wave machine Advantage [11,12,13]. The content is as follows. In Section 2.1 we review the definition of the TSP and the KP and we explain how they can be solved using the BB algorithm. In Section 2.4 we show how we can encode the optimal solution of the TSP and the KP as the ground state of a suitable Hamiltonian for the quantum annealer. In Section 3.1 we first discuss the issues related to directly solve the integer linear problems via an unrestricted algorithm on the quantum hardware. Next, we define our hybrid classical–quantum algorithm and study its performance on examples of the KP and TSP problems. In Section 4 we draw our conclusions and present outlooks.

2. Materials and Methods

2.1. The Binary Linear Problem

The BLOP aims to find the minimum of the cost function $z\left(\mathbf{x}\right)$ over a set of possible solutions $\Omega$, namely

$${min}_{\mathbf{x}\in \Omega }\left(\mathbf{x}\right)={\mathbf{c}}^T\mathbf{x}$$

(1a)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.& A\mathbf{x}\le \mathbf{b}\end{array}$$

(1b)

$$\mathbf{x}\in {\{0,1\}}^N,$$

(1c)

with $\mathbf{c}$ being an N-dimensional vector, A being an $m\times N$ matrix, and $\mathbf{b}$ being an m dimensional vector. $\mathbf{x}$ is an N dimensional vector whose components take a value of 0 or 1. Although the simple form of Equation (1), the BLOP is generally NP-hard [14].

In this section we explore one algorithm that is used to solve BLOPs, the BB algorithm. The core procedure of the BB algorithm for finding the solution to the problem ${\mathcal{P}}_{\Omega }$ on the set $\Omega$ consists of analyzing the restrictions ${\mathcal{R}}_{\overline{\Omega }}$ of the original set $\overline{\Omega }\subset \Omega$.

The lowest value of the cost function of the original problem ${min}_{\mathbf{x}\in \Omega }z\left(\mathbf{x}\right)$ is a lower bound of the minimum of the cost function of the restricted problem ${min}_{\mathbf{x}\in \overline{\Omega }}z\left(\mathbf{x}\right)$. As we are dealing with a linear problem, the minimum and the maximum of the cost function is to be found at the borders of the set $\Omega$. However the optimal solution could have non-binary values.

Dividing the original problem into sub-problems allows us to consider the restricted problems separately and choose the one with minimum cost. Figure 1a shows the procedure of the BB algorithm when applied to a three-dimensional system. In Figure 1b the procedure is represented as a tree, where each branch represents a restriction of the problem into a selected subset.

We define $z_{\mathcal{P}}$ as the current upper bound of the cost function. We initialize it to the upper bound of the cost function over the set $\Omega$. This is done at the root of the tree and is equivalent to initializing $z_{\mathcal{P}}$ to the value ∞. In the example shown in Figure 1, we analyze the restricted problem ${\mathcal{R}}_0$, where $\overline{\Omega }$ is a lower dimensional set that has the value of the first variable fixed to zero, i.e., $x_1=0$. The lower bound of the cost function in the restricted region is $z_{{\mathcal{R}}_0}<z_{\mathcal{P}}$, because of the original large value of $z_{\mathcal{P}}$. We then proceed by restricting the second variable $x_2=0$, thus defining the problem ${\mathcal{R}}_{00}$, and finally the third one $x_3=0$ in order to specify the problem ${\mathcal{R}}_{000}$ and find the value of the cost function $z(0,0,0)$ for this restriction. This procedure is called branching and stands for the subsequent restriction of the problem into different sub-problems. Once the value of the cost function for a certain branch has been found, we proceed with the bounding procedure. The current upper bound $z_{\mathcal{P}}$ is updated to $z_{{\mathcal{R}}_{000}}$. From now on, we consider only subsets where the optimal cost function is less than the updated $z_{\mathcal{P}}$. We now relax the problem, going back to ${\mathcal{R}}_{00}$, and set $x_3=1$. If $z_{{\mathcal{R}}_{001}}<z_{\mathcal{P}}$, the latter is updated to this value.

We analyze other values of the variables, relaxing the problem and applying different restrictions, as long as we explore all the solutions. If the lower bound of the cost function $z_{{\mathcal{R}}_i}$ in the follow-up restriction ${\mathcal{R}}_i$ is greater than the current upper bound $z_{\mathcal{P}}$, we do not need to investigate that restricted region, and we can skip to another branch. If a node in the tree (a restricted subset) does not satisfy the constraints, the node is not considered valid and the bounding process does not take place.

In the tree of Figure 1a each branch develops on the assumption that the value of a variable is fixed to either 0 or 1, but the same method can be applied to integer values of the variables.

Finally, the optimal solution will minimize the cost function while satisfying the constraints.

2.2. The Knapsack Problem

In the KP, we have N objects, each with a value $v_i$ and a weight $w_i$, for $i=1,\dots ,N$. The problem consists of choosing the items to put in the knapsack so that their total value is maximum while not exceeding the knapsack capacity. This problem can be formulated by using N binary variables $x_i$ ($i=1,\cdots ,N$), with $x_i=1$ if the object i enters in the knapsack, and $x_i=0$ if it does not. The values and the weights can be collected in two vectors, $\mathbf{v}$ and $\mathbf{w}$, respectively. The BLOP (1) is written as

$${min}_{\mathbf{x}}z\left(\mathbf{x}\right)=-{\mathbf{v}}^T\mathbf{x}$$

(2a)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.& w\left(\mathbf{x}\right)={\mathbf{w}}^T\mathbf{x}\le W,\end{array}$$

(2b)

$$\mathbf{x}\in {\{0,1\}}^N.$$

(2c)

The KP can be solved using the BB algorithm. As we assume that all the weights $w_i$ and the values $v_i$ are positive numbers for all $i=1,\dots ,N$, we can slightly modify the BB algorithm in order to make it more efficient. We call this version KP-BB. We start from the string ${\mathbf{x}}^0=(0,\dots ,0)$, which describes the empty knapsack. The value function z and the weight function w are both zero. The first branch has the value of the first variable set, $x_1=1$. The value function z is updated to $-v_1$ and the weight function takes value $w_1$. The k-th branch sets the k-th variable $x_k=1$ and sets the previous $(k-1)$ variables to zero. At each k-th branch, the value function is $-v_k$ and the weight function is $w_k$. With this ordering, each of the k branches defines a new knapsack problem, where the k-th object has been chosen and the problem is to choose among the remaining $N-k$ objects. The loading capacity of the new problem is $W-w_k$ and the value of the empty knapsack is initialized to $-v_k$. The KP-BB algorithm recursively applies this restriction of the problem to each branch, following a so-called depth-first search, where the search scouts a tree until it ends, then traces back its steps. At this point, the algorithm passes to another branch. In Figure 2 we show the tree representation of the KP-BB algorithm for a problem with three objects. In the node’s box the value of the upper bound of the cost function is shown. When a new solution is explored, the algorithm identifies it as optimal (green), valid but not optimal (yellow), or not valid (red). It stops either when all the variables have been considered, or when the total weight of the knapsack has exceeded its limit.

2.3. The Traveling Salesman Problem

The traveling salesman problem describes an agent that has to visit different cities starting from the depot and returning to it at the end of the journey. The problem consists of finding the route with the lowest cost that visits all the nodes exactly once, where the cost can describe time, distance or money used during the travel. TSP can be modeled by a weighted graph, where the nodes are the cities and the weights of the edges represent the transportation cost from one node to another one. One can always assume the graph to be fully connected, by putting the corresponding cost to be very high (possibly infinity) if two cities are not actually connected by a direct path.

The graph is represented by the pair $G=(V,C)$, with $V=\{d,1,2,\cdots ,N-1\}$ being the set of N vertices and C being the weighted adjacency $N\times N$ matrix of the graph. The component $C_{ij}$ represents the cost of traveling from node i to node j and it is not necessarily symmetric. A solution for the TSP is the cycle path along the edges of the graph that starts from the depot node, named d, passes through all the other $N-1$ nodes exactly once, and ends in the initial node d. One mathematical description of TSP is given by the Dantzig–Fulkerson–Johnson formulation [15], which considers $N^2$ binary variables $x_{ij}$, each representing the edge that connects the node i with the node j. The corresponding linear problem is obtained in the form of Equation (1), collecting the binary variables $x_{ij}$ into a $N\times N$ matrix $\mathbf{x}$.

$${min}_{\mathbf{x}}z\left(\mathbf{x}\right)=\mathrm{Tr}\left[C\mathbf{x}\right]={\sum }_{i\ne j}{C}_{ij}{x}_{ij},$$

(3a)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.\hspace{1em}& {\sum }_{j=1}^n{x}_{ij}=1,\forall i\end{array}$$

(3b)

$${\sum }_{i=1}^n{x}_{ij}=1,\forall j$$

(3c)

$$\begin{array}{c}{\sum }_{i,j\in S}{x}_{ij}\le \left|S\right|-1,\\ \forall S\subset V,2\le \left|S\right|\le N-2,\end{array}$$

(3d)

$$x_{ij}\in \{0,1\}.$$

(3e)

The first line, Equation (3a) is the objective function that we want to minimize. The other equations are the constraints given by the TSP. In particular, Equations (3b) and (3c) state that each vertex must have one inward and one outward edge, respectively. Equation (3d) avoids the presence of sub-paths that do not cover the whole set of vertices. Here, S is a subset of V and $\left|S\right|$ is the number of elements in S. Equation (3e) states that the $x_{ij}$ are binary variables.

The TSP can be solved with the BB algorithm [3,4]. Similar to the knapsack problem, the BB algorithm offers a strategy to systematically explore all solutions, which can be tailored for the specific problem at hand. We refer to this customized version of the branch-and-bound algorithm as TSP-BB.

We start from the depot with initial cost function $z=0$ and we choose the path to one of the $N-1$ cities, that we denote with $\overline{k}$. Then, the TSP-BB algorithm defines a new TSP made of $N-2$ cities, where the cost matrix is modified to include the previous choice. The new TSP has $N-1$ vertices and new adjacency matrix $C^{\prime }$ with adjacency components $C_{i\overline{k}}^{\prime }=C_{id}$. Thus, the initial cost of the new TSP has the updated value $z\to z+C_{d\overline{k}}$. Different from the KP-BB defined before, the TSP-BB has a best-first search approach, where the next node analyzed by the algorithm is the one with the current best z value. When all the variables have been explored in one branch, we define the upper bound of the travel cost z. Any time the initial travel cost of a branch exceeds z, we neglect that branch. On the contrary, we explore the branches with a travel cost lower than z until we find the optimal solution. Figure 3 shows a schematic representation of the TSP-BB algorithm as a tree when applied to a graph with 5 cities.

2.4. The QUBO and Ising Formulation

In this work we analyze the use of the D-Wave Advantage quantum computer to solve the combinatorial problems introduced in the previous sections. The D-Wave machine belongs to the class of quantum annealers that work through the application of a global time-dependent Hamiltonian. An introduction to quantum annealers is presented in Appendix A.

The D-Wave machine evolves with an Ising-like Hamiltonian,

$$\begin{array}{ccc}\hfill H\left(s\right)& =& -A\left(s\right)\sum _i{\widehat{\sigma }}_x^i\hfill \\ & & +B\left(s\right)(\sum _i{h}_i{\widehat{\sigma }}_z^i+\sum _{i>j}{J}_{ij}{\widehat{\sigma }}_z^i{\widehat{\sigma }}_z^j).\hfill \end{array}$$

(4)

The coefficients $A\left(s\right),B\left(s\right)$ have the role of the schedule function f in Equation (A2) and s is the adimensional time $s=t/t_a$, normalized with respect to the annealing time.

We can write any binary linear problem with constraints as an Ising problem. In fact, any BLOP can be written as a quadratic unconstrained binary optimization (QUBO) problem. This defines a new cost function

$$Q=-\sum _{i=1}^{N+n^{\prime }}{c}_i{x}_i+\sum _{j=1}^m{\lambda }_j{(b_j-\sum _{i=1}^{N+n^{\prime }}{A}_{ij}{x}_i)}^2,$$

(5)

where we have introduced new $n^{\prime }={log}_2(\max \left(b_j\right)+1)$ binary slack variables that make the problem unconstrained. Each additional i-th slack variable with $i=N+1,\dots ,N+n^{\prime }$ has cost coefficient $c_i=0$ and constraint matrix components $A_{ij}=2^{i-1}/2^N$, with $j=1,\dots ,m$. The m parameters ${\lambda }_j$ are called Lagrange multipliers. Generally speaking, if ${\lambda }_j$ are too small, the minimization of the first term is favored, which corresponds to the minimization of the cost function without any constraints. On the other hand, if ${\lambda }_j$ is too large, the second term acquires more importance and the optimal solution tends to satisfy the j-th constraint, ignoring the other terms. There is a range of values for each ${\lambda }_j$ s.t. and the optimal solution of Q is the optimal solution of Equation (1). However, this range of values is both problem and size dependent.

In order to pass from binary variables into spin variables we define $M=N+n^{\prime }$ new variables

$$\begin{array}{ccc}\hfill s_i& =& 2x_i-1,s_i\in \{-1,1\},\hfill \end{array}$$

(6)

and set

$$\begin{array}{ccc}\hfill h_i& =& \frac{c_i}{2}+\sum _{j=1}^m{\lambda }_j{b}_j{A}_{ij}-\sum _{j=1}^m\frac{{\lambda }_j}{2}{A}_{ij}\sum _{k=i}^M{A}_{kj}\hfill \\ \hfill J_{ij}& =& \sum _{k=1}^m\frac{{\lambda }_k}{2}{A}_{ik}{A}_{jk},\hfill \end{array}$$

(7)

that transform the QUBO function Q of Equation (5) into

$$H_Q=\sum _i{h}_i{s}_i+\sum _{i>j}{J}_{ij}{s}_i{s}_j,$$

(8)

whose minimal energy solution corresponds to the ground state of the quantum Hamiltonian (4) at $t=t_a$.

Although we have a variety of results that show the power of quantun annealers, other results show that when the number of qubits is large the D-Wave machine has difficulty finding the global solution [8]. In the next section we are going to propose a way to circumvent this problem.

3. Results

3.1. Efficient Use of Quantum Annealers in Hybrid Classical–Quantum Algorithm

In this section we propose a hybrid way to use the currently available quantum annealers to produce reliable solution to some NP-hard problems. In Section 2.1 we explained how the BB algorithm can be used to treat either the KP and the TSP. Here, we apply this algorithm to both the problems, stopping when the restricted sub-problems have a size that is small enough that the optimal solution can be obtained by the D-Wave machine.

3.2. The Knapsack Problem

Suppose we want to solve a KP with N objects and capacity W. In order to be able to tract the optimal solution of problem (2), we choose N objects with increasing value $v_i=i$ and with same weight $w_i=1$ for $i=1,\dots ,N$. Thus, the optimal solution is the knapsack filled with just the last W objects with the highest value, ${\mathbf{x}}_{\mathrm{opt}}=(0,\dots ,0,{\mathbf{e}}_W)$, with ${\mathbf{e}}_W$ being the W-dimensional vector of ones, ${\mathbf{e}}_W=(1,\dots ,1)$, and with the total value $z_{\mathrm{opt}}=W[N+\frac{1}{2}(1-W)]$. After including the slack variables, the vector ${\mathbf{x}}_{\mathrm{opt}}$ has $M=N+\lceil {log}_2(W+1)\rceil$ components.

The QUBO function (5) is

$$Q=-\sum _{i=1}^M{v}_i{x}_i+\lambda {(W-\sum _{i=1}^M{w}_i{x}_i)}^2.$$

(9)

Using Equations (2) and (6) we can write the Ising Hamiltonian of the problem. Because Equation (2) has only one constraint, we just need to adjust the one parameter $\lambda$. In order to find the optimal value of $\lambda$ we proceed as follows.

We suppose $\mathbf{y}$ is a solution that satisfies the constraint. If we add a single object, say $x_l$, that overloads the knapsack, the QUBO function should be s.t.

$$Q(\mathbf{y}+x_l)>Q\left(\mathbf{y}\right).$$

(10)

As it has to be valid for any possible solution, we need to take the maximum of the right side of Equation (10). Thus, we set $\lambda ={max}_i{v}_i+1$. This choice ensures that the Hamiltonian ground state is also the optimal solution of the KP.

We have performed an analysis of the bandgap for this particular configuration and we have seen that it scales polynomially with the size of the problem as $M^{-\alpha }$. For some exponent $\alpha$, see Appendix B. This is a promising feature which means the total annealing time scales as $t_a\sim M^{\alpha }$, and therefore, makes the problem solvable in polynomial time. We have to stress the fact that the polynomial scaling refers to this particular configuration of the problem, and it is not applicable to all the possible KPs.

Let us first examine what happens when we solve the unrestricted BLOP on the D-Wave machine. In this case, we find that not only is the solution not the optimal one but also the constraint is not satisfied. Indeed, when the number of qubits is too large, the system is not able to act as an ideal quantum annealer [8], as the results are affected by thermal noise [16]. One may think of increasing the value of the parameter $\lambda$ in order to force the system to prefer the fulfillment of the constraint. We have analyzed the measured state with lowest energy for different values of $\lambda$ within the range where the ground state is the optimal solution of our problem, but we have not seen any changes in the outcomes distribution.

Furthermore, we have analyzed how the probability $p_0$ of measuring the ground state depends on the annealing time, finding it is almost independent of the annealing time, reaching a plateau of the probability. This occurs for any case we consider, including the simple case $W=N$ when the capacity constraint (but not slack variables) becomes ineffective. This is shown in Figure 4, where we plot $p_0$, obtained as the frequency of the ground state appearing as the outcome, measured out of 1000 reads for different annealing times $t_a$, calculated for a KP with N-objects and capacity $W=N$.

In Figure 5 we show also the mean value of the minimal energy found on 20 runs of the quantum annealer, each with 1000 measurements. We see that the result is independent of the annealing time. A similar result was found in [9]. The authors analyzed another combinatorial problem, the shortest path problem, with the D-Wave quantum processor and they did not find correspondence between the annealing time and the frequency nor the energy distribution. This means that the behavior of the processor is not dependent on the annealing time, although the theory says otherwise. These results allow us to fix our annealing time to a value of 10 $\mathsf{\mu }$s.

To better analyze the quality of the results obtained by the quantum annealer, we can introduce the following three figures of merit that estimate the quality of the obtained solution ${\mathbf{x}}_a$ with respect to the optimal one ${\mathbf{x}}_{\mathrm{opt}}$:

–

The normalized knapsack value distance

$$\Delta \tilde{v}=\frac{z\left({\mathbf{x}}_a\right)-z\left({\mathbf{x}}_{\mathrm{opt}}\right)}{z\left({\mathbf{x}}_{\mathrm{opt}}\right)};$$

(11)

–

The normalized knapsack weight

$$\tilde{w}=\frac{w\left({\mathbf{x}}_a\right)}{W};$$

(12)

–

The Hamming distance H [7]

$$H({\mathbf{x}}_a,{\mathbf{x}}_{\mathrm{opt}})=\sum _{i=1}^M({\mathbf{x}}_a^i\oplus {\mathbf{x}}_{\mathrm{opt}}^i).$$

(13)

where M is the string length of the solutions and ⊕ stands for the sum module 2.

Figure 6 shows these metrics as a function of the number of qubits M used by the quantum annealer in the the case $W=N$. The width of the shaded region is the variance calculated over 20 different runs. We see that already for $M>8$ the result can differ from the optimal solution and have a variance different from zero.

A good trade-off between the certainty of the result and the size of the problem can be provided by the BB algorithm that divides the problem into sub-problems that are described by a lower number of qubits, for which the quantum annealer can provide more reliable solutions.

The BB algorithm applied to the knapsack problem, as explained in Section 2.1, explores a number of nodes that go as $\mathcal{O}\left(2^N\right)$, since any time they explore a new branch, they create a new KP with one less object and an updated knapsack capacity. In the toy problem we are considering, the number of nodes that saturate the constraint are $\left(\begin{array}{c}N\\ W\end{array}\right)=\frac{N!}{W!(N-W)!}$, that is, the number of combinations with W objects chosen from a set of N. This corresponds to the exploration by the KP-BB algorithm of a number of branches

$$n_b=\sum _{k=1}^W\left(\begin{array}{c}N\\ k\end{array}\right).$$

(14)

This value is lower than the exponential value obtained by applying the BB algorithm depicted in Figure 1 and the reason why is that the optimized KP-BB algorithm makes restrictions on more than one variable at once. But there is no point in making use of a quantum processor, since, for each node, all the variables have been set to a fixed value.

Here, we propose an alternative scheme: we can devise a hybrid classical–quantum protocol by first exploiting the advantage of the BB algorithm to reduce the problem down to a chosen size $N^{\prime }$, which corresponds to a number of variables $M=N^{\prime }+{log}_2(W^{\prime }+1)$ given by the number of remaining objects $N^{\prime }$ and by the remaining loading capacity of the knapsack $W^{\prime }$. Then, we solve the residual problem with the quantum annealer, which might be efficient to solve problems with a relatively small number of qubits; see the diagram in Figure 7.

We consider a KP with $N=25$ objects and loading capacity $W=10$. The problem can be described as QUBO by a number of binary variables $M_{\mathcal{P}}=29$.

Figure 8 shows the number of branches explored by the BB algorithm (green squares) and the number of calls made to the quantum annealer (red circles) as a function of the chosen size M. The horizontal dotted blue line represents the number of branches explored by the optimized KP-BB algorithm, which is constant since it depends on $N,W$ only. We see that when the number of qubits $M>14$, the number of times the branch-and-bound procedure is applied in the hybrid algorithm is lower than the number of times this is done in the optimized KP-BB algorithm. Each reduced problem is eventually solved by the quantum annealer. In the extreme case of $M=M_{\mathcal{P}}$, the number of branches operated by the classical algorithm is one, as the original problem is defined and promptly sent to the quantum annealer.

Figure 9a–c shows the metrics defined in Equations (11)–(13) for the best obtained solution ${\mathbf{x}}_a$ as a function of the number of available qubits M for a KP with $N=25$ and $W=10$. The width of the shaded region is the variance obtained over 20 different runs. The results are compared with a random outcome of strings, constructed as follows. In order to make a proper comparison, we randomly extract 1000 strings, as many as the number of measurements taken per sample. Then, we choose as our optimal solution the one that has a lower energy, in analogy with the procedure of the D-Wave machine. We then repeat the procedure 1000 times in order to get the statistics.

We see that the outcomes of the quantum annealer are not comparable with random guesses. Figure 9a,b shows that the solution found by the D-Wave machine has a cost value closer to the optimal one and loading closer to the threshold set by the loading capacity. Finally, Figure 9c shows that the Hamming distance is lower than the one reached by random outcomes.

Depending on what is our tolerance with respect to the different quality measures $\Delta \tilde{v},\tilde{w}$, and H, we may decide to restrict our problem until a certain number of qubits, thus speeding up the resolution of the problem. For instance, we may choose the value $\Delta \tilde{v}=0.1$ as acceptable, and consider valid any solution that has the constrained satisfied ($\tilde{w}\le 1$) and a discrepancy between the optimal knapsack value and the obtained value of $10\%$. In this case, we have analyzed what is the maximum number of qubits $M_{10\%}$ that are necessary to obtain the desired solution. We have kept the knapsack capacity fixed to $W=10$ and varied the number of items N, thus changing the total size of the problem $M_{\mathcal{P}}=N+4$. For each $M_{\mathcal{P}}$ we have applied the hybrid–BB algorithm with different values of M. We have then measured 1000 times the system and we have considered only the states for which the constraint was satisfied, discarding the others.

Figure 10a shows the values of $M_{10\%}$ that we obtained for different values of $M_{\mathcal{P}}$. We see that the scaling is almost linear, with a relation $M\sim 0.87M_{\mathcal{P}}$. The linear scaling is provided by the extra care used to choose the acceptable measurement outcomes. For these cases, we plot in Figure 10b the number of branches generated by the BB algorithm (green squares) and the number of runs of the quantum annealer (red circles). We see that the important variable here is the difference $M_{\mathcal{P}}-M$ that defines the size of the problem tackled by the BB algorithm.

Figure 11a–c shows the same experiment performed keeping $W=10$ and varying the number of objects N and using the maximum number of necessary qubits $M=N+4$. Although the optimal solution is never reached, the D-Wave machine performs better than random guessing even in this case, as is evident from the results of the metrics. In fact, although the average $\Delta \tilde{v}$ of the D-Wave outcomes is larger then the corresponding value for random guessing, Figure 11a, this is mainly due to the fact that the machine tries to satisfy the capacity constraint, as shown in Figure 11b. Hence, it prioritizes a lower number of objects over the desire for a higher load value. The better performance of the D-Wave machine is captured by the lower value of the Hamming distance in Figure 11c.

3.3. The Traveling Salesman Problem

Let us move now to solve a TSP with N cities using the quantum annealer, by means of a hybrid classical–quantum protocol similar (but not equal) to the one presented for the KP.

The first step is to write the QUBO formulation of the problem as a function of a $N^2$ binary vector $\mathbf{x}$ with components $x_{i,j}$, with $i,j=1,\dots ,N$. We use here the formulation suggested in Ref. [17], such that the first subscript indicates the city and the second indicates the step. Thus, $x_{i,j}=1$ if the i-th city is visited at step j. Following Equation (3) we can write the QUBO function (5) as [17]

$$\begin{array}{ccc}\hfill Q^{\mathrm{TSP}}\left(\mathbf{x}\right)& =& \sum _{i,j=1}^N{C}_{ij}\sum _{k=1}^N{x}_{i,k}{x}_{j,k+1}\hfill \\ & & +\lambda \sum _{i=1}^N(1-\sum _{j=1}^N{x}_{i,j}{)}^2\hfill \\ & & +\lambda \sum _{j=1}^N(1-\sum _{i=1}^N{x}_{i,j}{)}^2,\hfill \end{array}$$

(15)

where the choice $\lambda >{max}_{ij}{C}_{ij}$ ensures that the state with minimal energy is the optimal solution of the TSP.

The TSP-BB algorithm differs from the KP-BB algorithm as it has to cross all the N cities. The maximum number of branches explored by the TSP-BB algorithm is ${\sum }_{n=1}^{N-1}(N-n)!$. If we decide to stop the BB algorithm when the total size of the problem is $M^2$ (with M cities left), the number of branches explored by the BB algorithm would be at maximum ${\sum }_{n=M}^{N-1}(N-n)!$ and the total number of calls to the D-Wave machine would be in the worst case scenario $N!/M!$. However, for the large majority of the problems we have examined, the D-Wave processor is called a very small number of times.

Let us consider a scenario of $N=10$ cities, all connected together by a route, with a non-symmetric cost matrix given by $C_{ij}=(i-j)\mathrm{mod}N$. The optimal solution ${\mathbf{x}}_{\mathrm{opt}}$ of this problem has components $x_{ij}=1$ if $i=j$ and 0 otherwise. This means that the nodes are crossed in the same order that they are labeled.

We have applied the hybrid algorithm to solve this problem and we have obtained a number of calls of the quantum hardware equal to 10 for a number of qubits between 36 ($M=6$) and 81 ($M=9$). Clearly these numbers are problem-dependent, but they give a good indication of the small number of calls to the quantum hardware when the hybrid approach is used.

For this problem, as a figure of merit of the quality of the protocol, we now use:

–

The travel cost of the found solution ${\mathbf{x}}_a$, normalized to the travel cost to the optimal solution ${\mathbf{x}}_{\mathrm{opt}}$:

$$\tilde{c}=\frac{z\left({\mathbf{x}}_a\right)}{z\left({\mathbf{x}}_{\mathrm{opt}}\right)};$$

(16)

–

The Hamming distance $H=H({\mathbf{x}}_a,{\mathbf{x}}_{\mathrm{opt}})$ of Equation (13).

These two metrics are shown in Figure 12a and Figure 12b, respectively, as function of the chosen number of qubits M. As in the previous section, the results are compared with a random path throughout the cities. Contrary to the KP problem, the random solutions can be chosen here to strictly satisfy the constraints, since it suffices to generate the solution with a random ordering of the M cities.

The normalized travel cost is lower than the one obtained for random paths for all the instances analyzed, up to a maximum of 100 qubits ($M=10$). We see that the optimal solution has been obtained only for the cases with $M=3,4$, whereas for larger TSP the D-Wave machine was not able to find it. Also, comparing Figure 12a,b, we see that the Hamming distance alone does not effectively measure the quality of the solution. Already for a TSP with $M=7$ cities, the results are not distinguishable from random outcomes in terms of H, yet they exhibit a significantly lower travel cost value.

4. Conclusions

In this paper we have investigated the resolution of two binary linear problems, the knapsack problem and the traveling salesman problem, that are known to be NP-hard. These are often solved with the branch-and-bound algorithm that we have described in Section 2.1. After introducing the two problems we have moved our attention to the quantum annealer in Section 2.4, which is a quantum computer that offers a global method for the resolution of binary linear problems. In this work we have merged the classical and quantum method for resolution of these NP-hard problems in order to show the advantage of a hybrid approach. In fact, the branch-and-bound algorithm does not offer a significant speed-up with respect to brute force strategies, whereas quantum annealers suffer from a low reliability when the number of instances is large. However, when merged together, branch-and-bound defines a new problem with a smaller size that can be handled efficiently by the global quantum solver.

Our findings in Section 3.1 show that, despite the annealer itself not demonstrating the theoretical expected sensitivity to variations of the annealing time, its outcomes prove to be significantly better than random, suggesting that a potential advantage can be indeed be obtained within a tailored hybrid framework. Importantly, the hybrid–BB algorithm emerges as a powerful tool which drastically reduces the number of branches generated in comparison with the completely classical counterpart. This, combined with the post-processing step where we select only the solutions that satisfy the constraint, enables us to achieve good results with remarkably few quantum computations (of the order of tens to hundreds). These findings underline the importance of developing hybrid strategies that leverage the strengths of quantum annealers while mitigating their limitations. Further research should explore refined annealing protocols and alternative optimization heuristics to fully unlock the potential of quantum annealing for real-world problems.