Quantum-Inspired Evolutionary Algorithm for Optimal Service-Matching Task Assignment

Abstract

This paper proposes a quantum-inspired evolutionary algorithm (QiEA) to solve an optimal service-matching task-assignment problem. Our proposed algorithm comes with the advantage of generating always feasible population individuals and, thus, eliminating the necessity for a repair step. That is, with respect to other quantum-inspired evolutionary algorithms, our proposed QiEA algorithm presents a new way of collapsing the quantum state that integrates the problem constraints in order to avoid later adjusting operations of the system to make it feasible. This results in lower computations and also faster convergence. We compare our proposed QiEA algorithm with three commonly used benchmark methods: the greedy algorithm, Hungarian method and Simplex, in five different case studies. The results show that the quantum approach presents better scalability and interesting properties that can be used in a wider class of assignment problems where the matching is not perfect.

1. Introduction

This paper considers a linear optimal service-matching task assignment problem defined by

$$\begin{array}{cc}\hfill & Z^{*}=argmin\sum _{i\in \mathcal{S}}\sum _{j\in \mathcal{T}}{c}_{i,j}{Z}_{i,j}\mathrm{s}.\mathrm{t}.\hfill \end{array}$$

(1a)

$$\begin{array}{cc}\hfill & Z_{i,j}\in \{0,1\},i\in \mathcal{S}=\{1,\cdots ,N\},j\in \mathcal{T}=\{1,\cdots ,M\},\hfill \end{array}$$

(1b)

$$\begin{array}{cc}\hfill & \sum _{j\in \mathcal{T}}{Z}_{i,j}=1,\forall i\in \mathcal{S},\hfill \end{array}$$

(1c)

$$\begin{array}{cc}\hfill & \sum _{i\in \mathcal{S}}{Z}_{i,j}\le 1,\forall j\in \mathcal{T},\hfill \end{array}$$

(1d)

where $Z=\left[Z_{i,j}\right]$ is the assignment matrix with N rows and M columns. We refer to $\mathcal{S}$ as service agent set and its elements as service agent, and to $\mathcal{T}$ as task set and its elements as task. Thus, $c_{i,j}>0$ is the cost of the assignment of service agent $i\in \mathcal{S}$ to task $j\in \mathcal{T}$, and $Z_{i,j}=1$ means that service agent $i\in \mathcal{S}$ is assigned to task $j\in \mathcal{T}$. Without loss of generality, we assume that $N\le M$, i.e., the task set, is larger than the service agent set. The imposed constraint (1c) ensures that each service agent gets only one task, while constrain (1d) limits the assignment of any task to, at most, one service agent. $Z^{*}$ is the adjacency matrix of the resultant matching graph after the assignment is peformed.

An example scenario inspired by the service-matching mobile-agent deployment for coverage over a dense set of targets studied in [1] is shown in Figure 1. In this service-matching problem, service UAVs A1, A2, A3 (flying at the same altitude), whose spatial service over the horizontal two-dimensional (2D) plane is described by a Gaussian distribution, should be deployed to provide coverage to a set of dense targets in a 2D flat plane. The targets are clustered into subgroups TC1, TC2, TC3, and TC4, each described by a Gaussian distribution of the targets. The assignment cost $c_{i,j}$ is the measure of similarity between the service distribution of agent Ai and the distribution of targets in subgroup TCj, measured in terms of the Kullback–Leibler divergence (KLD) ([2], p. 34). More details are provided in Section 4, where we conduct a numerical study of this service-matching task assignment.

There are many other service-matching applications which can be used with the optimal AP problem (Section 1). For example, in manufacturing, in assembly lines, where there must be a planning between the operators and the tasks [3,4]. Other situations such as in delivery tasks or ridesharing [5] can also be formulated in the same way. In addition, some social, economical or political situations are no more than an AP [6].

As in other combinatorial optimisation problems, there is a lack of methods that can achieve a good approximation factor in polynomial time with good scalability. Currently, the main algorithms still used to solve service-matching problems (Section 1) are classical methods such as the greedy algorithm, which, theoretically, ensures an approximation factor of 63% [7] with a complexity of $\mathcal{O}\left(NM\log M\right)$[8]. The Hungarian method, with an approximation factor of 1 and a complexity of $\mathcal{O}\left(NM\right(N+M\left)\right)$[8], or the Simplex method with, also, an approximation factor of 1 and a complexity of $\mathcal{O}\left(N^2{M}^2\right)$[8]. The reader should note that the aforementioned complexity bounds for the Hungarian and Simplex algorithms are based on execution of these algorithms when $N=M$.

With the rise of machine learning, new techniques such as neural networks, reinforcement learning or evolutionary algorithms have been formulated to solve combinatorial optimisation problems. Related to all these techniques, the advances in quantum computation have originated a new field of study: quantum-inspired algorithms. Quantum-inspired algorithms try to formulate classical algorithms in a quantum way, using qbits and its properties, in order to increase the speed of these methods (Quantum-computing- related terminologies used here are defined in Section 2. The interested reader can find more detailed information in [9], Chapter 1.) For example, in [10], they use the superposition property in order to accelerate distribution shaping in the travelling salesman problem, or in [11], they use entanglement to prevent a two-agent autonomous system from cyber-physical attacks. In [12] is seen how quantum formulation helps in clustering problems and in [13,14] is seen how quantum properties are interesting for obtaining a better balance between exploration and exploitation in reinforcement learning. The same idea of reducing model size and increasing robustness is seen in other deep-learning techniques in [15]. One of the interesting applications of quantum-inspired algorithm development is explored in [16], where a quantum-inspired version of an evolutionary algorithm (EA) is implemented to solve a knaspack problem with a proven improvement with respect to classical EA.

This paper focuses on developing a computationally efficient suboptimal solution for the service-matching assignment problem (Section 1) using a quantum-inspired EA (QiEA) algorithm and demonstrates its application in solving a service-matching coverage problem illustrated in Figure 1. Special attention is given to the design of the collapsing procedure to make it more coherent with the real collapsing process of qbits and to speed up the process. In Section 2, preliminary notions about quantum theory are presented. The proposed method is presented in Section 3. In Section 4, a numerical study focused on a service-matching task assignment demonstrates the efficacy of our proposed algorithm. The conclusions and our plan for future work are explained in Section 5.

2. Preliminaries

This section gives the definition of the quantum formulation notion and terminologies we use throughout the paper. For the convenience of the reader, we also provide the definition of the KLD measure.

First, following [17], we introduce the notion and the definitions from the quantum formulation. In quantum computation, the basic unit of information is called a Qbit and it is neither one nor zero, but the superposition of both states. That means that, in one timestamp, there is a certain probability that the qbit is in in state zero or in state one. This can be formulated using Dirac’s notation, also known as brakets, as,

$$|\psi \rangle =\alpha |0\rangle +\beta |1\rangle$$

(2)

where $|\psi \rangle$ is the qbit, $|0\rangle$ and $|1\rangle$ are the two possible states and $\alpha$ and $\beta \in \mathbb{C}$ are the amplitudes of these states. The Born’s rule tells us that these amplitudes are directly related to the probability of being in state $|0\rangle$ or $|1\rangle$ as the probability of one state is the power of its amplitude,

$$p\left(\langle 0|\psi \rangle \right)={\left|\langle 0|\psi \rangle \right|}^2={|\alpha \langle 0|0\rangle +\beta \langle 0|1\rangle |}^2={\left|\alpha \right|}^2,$$

(3)

$$p\left(\langle 1|\psi \rangle \right)={\left|\langle 1|\psi \rangle \right|}^2={|\alpha \langle 1|0\rangle +\beta \langle 1|1\rangle |}^2={\left|\beta \right|}^2,$$

(4)

$${\left|\alpha \right|}^2+{\left|\beta \right|}^2=1,$$

(5)

One qbit remains in this superposition until it is measured or observed. When that happens, the qbit becomes fixed in one of the states in the function of the amplitudes, this process is called collapsing.

As explained in Equation (2), in the superposition state, a qbit depends on two parameters, $\alpha =a_{\alpha }+\mathrm{j}{b}_{\alpha }$ and $\beta =a_{\beta }+\mathrm{j}{b}_{\beta }$, that are indeed complex numbers. Therefore, qbits can be represented with spherical coordinates,

$$|\psi \rangle =\alpha |0\rangle +\beta |1\rangle =(a_{\alpha }+\mathrm{j}{b}_{\alpha })|0\rangle +(a_{\beta }+\mathrm{j}{b}_{\beta })|1\rangle =r_{\alpha }{\mathrm{e}}^{\mathrm{j}{\phi }_{\alpha }}|0\rangle +r_{\beta }{\mathrm{e}}^{\mathrm{j}{\phi }_{\beta }}|1\rangle$$

(6)

applying the Born’s rule, Equation (5),

$$|\psi \rangle ={\mathrm{e}}^{-\mathrm{j}{\phi }_{\alpha }}\left(cos\left(\frac{\theta }{2}\right)|0\rangle +sin\left(\frac{\theta }{2}\right){\mathrm{e}}^{\mathrm{j}({\phi }_{\beta }-{\phi }_{\alpha })}|1\rangle \right)$$

(7)

were $0\le \theta \le \pi$ and $0\le \phi \le 2\pi$. It can be demonstrated that ${\mathrm{e}}^{-\mathrm{j}{\phi }_{\alpha }}$ has no observable effects [18]; therefore, effectively, we only have to consider the following equation,

$$|\psi \rangle =cos\left(\frac{\theta }{2}\right)|0\rangle +{\mathrm{e}}^{\mathrm{j}\varphi }sin\left(\frac{\theta }{2}\right)|1\rangle$$

(8)

From Equation (8), it can be seen that a qbit belongs to a Hilbert space $\mathcal{H}$ and can be represented as a sphere. This representation is known as a Bloch Sphere, Figure 2.

From the Bloch Sphere, it can be seen that the state of a qbit can be modified using rotations. Indeed, in quantum computation, the logic gates used to develop circuits are no more than rotation operations. In this work, the only important rotation is the $\theta$ rotation, as it is the one that makes the superposition state closer or further to states $|0\rangle$ or $|1\rangle$. Therefore, in this case, qbits can be represented as circles and, in order to modify them, a simple rotation matrix will be used.

$$R\left(\theta \right)=\left[\begin{array}{cc}cos\left(\theta \right)& -sin\left(\theta \right)\\ sin\left(\theta \right)& cos\left(\theta \right)\end{array}\right]$$

(9)

KLD is a measure of similarity (dissimilarity) between two probability distributions $p\left(x\right)$ and $q\left(x\right)$, where the smaller the value the more similar two distributions are. KLD is zero if and only if the two distribution are identical ([2], p.34). For Gaussian distributions, $p\left(x\right)=\mathcal{N}({\mu }_0,{\Sigma }_0)$ and $q\left(x\right)=\mathcal{N}({\mu }_1,{\Sigma }_1)$, the KLD has a closed form expression ([19], Equation (2))

$$\begin{array}{cc}\hfill D_{\mathrm{KL}}\left(p\left(x\right)\left|\right|q\left(x\right)\right)=& \frac{1}{2}\left(ln\frac{|{\Sigma }_1|}{|{\Sigma }_0|}+{({\mu }_0-{\mu }_1)}^{\top }{\Sigma }_1^{-1}({\mu }_0-{\mu }_1)+\top \left({\Sigma }_1^{-1}{\Sigma }_0\right)-n\right),\hfill \end{array}$$

(10)

where n is the dimension of the distributions.

In what follows, we rely on a function best defined as

$$\begin{array}{c}\hfill \widehat{Z}=\mathsf{best}(Z^1,Z^2,\cdots ,Z^p),\end{array}$$

(11)

which, given any finite number of assignment matrices $Z^1,\cdots ,Z^p$, return the assignment matrix $\widehat{Z}\in \{Z^1,Z^2,\cdots ,Z^p\}$ that results in the smallest of cost ${\sum }_{i\in \mathcal{S}}{\sum }_{j\in \mathcal{T}}{c}_{i,j}{Z}_{i,j}^l$, $l\in \{1,\cdots ,p\}$, computed according to the assignment cost (1a).

3. QiEA for Optimal Service Matching

Inspired by the concept of quantum computing of qbit representation, rotation, observation and qbit collapsing, we propose the QiEA Algorithm 1 as a suboptimal solution to the optimal service-matching problem (1). To design this algorithm, we proceeded as follows.

Consider the assignment matrix $Z=\left[Z_{i,j}\right]$. For any given service agent $i\in \mathcal{S}$, every feasible assignment consists of assigning 1 to one of the elements of $Z_{i,j}$, $j\in \mathcal{T}$ and zero to the rest, while respecting also (1d). Since we do not know which element should be 1, the idea is to start by a probabilistic approach and, for every service agent $i\in \mathcal{S}$, attach a notion of probability to every $Z_{i,j}$, which indicates with what probability that element is 1. Then, at each iteration t of the algorithm, this probability is adjusted as we describe below. The notion of probability for each element $Z_{i,j}$ can be realised using quantum qbits, $|{\varphi }_{i,j}\rangle \left(t\right)={\alpha }_{i,j}\left(t\right)+\mathrm{j}{\beta }_{i,j}\left(t\right)$. Thus, at each step t of the algorithm, for each individual l in population set $\mathcal{P}=\{1,\cdots ,K\}$, there is a qbit matrix

$${|\Phi \rangle }^l\left(t\right)=\left[\begin{array}{c}\left[\begin{array}{cccc}{\alpha }_{1,1}^l\left(t\right)& {\alpha }_{1,2}^l\left(t\right)& \cdots & {\alpha }_{1,M}^l\left(t\right)\\ {\beta }_{1,1}^l\left(t\right)& {\beta }_{1,2}^l\left(t\right)& \cdots & {\beta }_{1,M}^l\left(t\right)\end{array}\right]\\ ⋮\\ \left[\begin{array}{cccc}{\alpha }_{N,1}^l\left(t\right)& {\alpha }_{N,2}^l\left(t\right)& \cdots & {\alpha }_{N,M}^l\left(t\right)\\ {\beta }_{N,1}^l\left(t\right)& {\beta }_{N,2}^l\left(t\right)& \cdots & {\beta }_{N,M}^l\left(t\right)\end{array}\right]\end{array}\right]$$

(12)

with size $2N\times M$ where each element $(i,j)$ is the mentioned probability ${|{\varphi }_{i,j}\rangle }^l\left(t\right)$ of the assignment between agent $i\in \mathcal{S}$ and task $j\in \mathcal{T}$.

Algorithm 1 QiEA algorithm for service-matching assignment

1: procedureQiEA 2:     Input size of population K, number of iteration MAX_GEN 3:     $t\leftarrow 0$ 4:     initialise ${|\Phi \rangle }^1\left(t\right),\cdots ,{|\Phi \rangle }^K\left(t\right)$ 5:     generate K individuals $Z^1\left(t\right)=\left[Z_{i,j}^1\left(t\right)\right],\cdots ,Z^K\left(t\right)=\left[Z_{i,j}^K\left(t\right)\right]$ by collapsing ${|\Phi \rangle }^l\left(t\right)$ 6:     for $l\in \{1,\cdots ,K\}$ do 7:         $B_{\mathrm{local}}^l\left(t\right)\leftarrow$ evaluate $Z^l\left(t\right)=\left[Z_{i,j}^l\left(t\right)\right]$ 8:     end for 9:     $B\left(t\right)\leftarrow \mathrm{best}(B_{\mathrm{local}}^1\left(t\right),\cdots ,B_{\mathrm{local}}^K\left(t\right))$ 10:     while $t\le$MAX_GEN do 11:         $t\leftarrow t+1$ 12:         for $l=\{1,\cdots ,K\}$ do 13:            generate $Z^l\left(t\right)=\left[Z_{i,j}^l\left(t\right)\right]$ by collapsing ${|\Phi \rangle }^l(t-1)$ 14:            $B_{\mathrm{local}}^l\left(t\right)\leftarrow$ evaluate $Z^l\left(t\right)=\left[Z_{i,j}^l\left(t\right)\right]$ 15:            update ${|\Phi \rangle }^l\left(t\right)$ 16:            Update $B_{\mathrm{local}}^l(t-1)$ if $B_{\mathrm{local}}^l\left(t\right)$ is better 17:            if migration condition then 18:                $B_{\mathrm{local}}^l\left(t\right)\leftarrow B\left(t\right)$ 19:            end if 20:         end for 21:     end while 22:     ${\widehat{Z}}^{☆}\leftarrow$$\mathrm{best}(B_{\mathrm{local}}^1$(MAX_GEN)$,\cdots ,B_{\mathrm{local}}^K$(MAX_GEN)$,B$(MAX_GEN)$)$ 23: end procedure

Evolutionary algorithms are based on the Darwinian explanation of species evolution where, step by step, there are mutations in each individual of the species and, by the end, only the individuals with better adaptation to the new environment survive. The evolutionary algorithms follow a two-step procedure [20]. First, we generate an initial population of individuals randomly. Next, we repeat the following re-generational steps until termination: (a) the fitness of each individual in the population is evaluated (lowest cost, feasibility), (b) the fittest individuals are selected as parents for reproduction, (c) new individuals are bred (from parents) through crossover and mutation operations to give birth to offspring, (d) the least-fit individuals of the population are replaced with new individuals.

QiEA is a probabilistic algorithm similar to other evolutionary algorithms. We use an evolutionary method to go from an initial state of uncertainty ${|\Phi \rangle }^l\left(0\right)$ to a final determined system ${\widehat{Z}}^{*}$, which is a suboptimal solution to (Section 1). The underlying concept in QiEA is that ${|\Phi \rangle }^l\left(t\right)$ informs us on how to select individual $Z\left(t\right)=\left[Z_{i,j}\left(t\right)\right]$ at each step of the algorithm (an individual is selected by collapsing ${|\Phi \rangle }^l\left(t\right)$). ${|\Phi \rangle }^l\left(t\right)$, which determines the probability of each element of $Z\left(t\right)=\left[Z_{i,j}\left(t\right)\right]$ being 0 or 1, is updated at each step based on the fitness of the generated individuals at step $t-1$ using the rotation method, which will be described below. The advantage of QiEA is, indeed, in this step of updating the probabilities of selecting future individuals based on feedback from the fitness of the generated individuals. The schematic procedure of our QiEA algorithm is shown in Figure 3. Our proposed QiEA is shown in Figure 3: there is a K parallel process to generate K individuals that constitutes the population set of the algorithm. Each individual generation process $l\in \mathcal{P}=\{1,\cdots ,K\}$ has its own ${|\Phi \rangle }^l\left(t\right)$, initialised at ${|\Phi \rangle }^l\left(0\right)$ and updated at each iteration of the algorithm.

Our proposed QiEA algorithm consists of three main procedural steps, collapsing, evaluation and updating and migration.

Collapsing procedure: This process is a novel contribution of this work and it is a faithful representation of the quantum-like collapsing of the qbit systems. With this purpose, the collapsing is performed using the maximum randomness possible. At each step t to generate individual $Z^l\left(t\right)$, first, one random service i and one random target j are selected to form the agent–task pair $(i,j)$. Then, with a uniform probability, we generate a random value ${\gamma }_{i,j}^l\left(t\right)\in [0,1]$. Then, $Z_{i,j}^l\left(t\right)$ is generated using the collapsing procedure below

$$Z_{i,j}^l\left(t\right)=\left\{\begin{array}{cc}1\hfill & \mathrm{if}{\gamma }_{i,j}^l\left(t\right)\le {\left|{\beta }_{i,j}^l\left(t\right)\right|}^2\hfill \\ 0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(13)

After collapse, the agent–task pair $(i,j)$ is removed from the random selection, and the process is repeated until there is no service agent left to be selected (recall our assumption that there is more service agents than the tasks). Our collapsing procedure is summarised in Algorithm 2. It is important to note that, if a service agent is assigned to one task (qbit $(i,j)$ is collapsed to one), no other service agent can be assigned to that task and that service agent can not perform any other task. That is exactly what we formulated in constraints  (1c) and (1d). That is, our individual generation procedure always generates feasible individuals $Z^l\left(t\right)$, and does not need the costly and often ad-hoc repairing of the individuals that other quantum-inspired algorithms, e.g., [10,21,22], need. The elimination of the repair step also results in faster convergence.

Algorithm 2 Collapsing

1: procedureCollapsing 2:     Input Qbit system ${|\Phi \rangle }^l\left(t\right)$ 3:     $\overline{\mathcal{S}}\leftarrow [1,\cdots ,N]$ 4:     $\overline{\mathcal{T}}\leftarrow [1,\cdots ,M]$ 5:     while $\overline{\mathcal{S}}\ne \left\{\right\}$ do 6:         select random service $i\in \overline{\mathcal{S}}$ 7:         select random service $i\in \overline{\mathcal{T}}$ 8:         generate ${\gamma }_{i,j}^l\left(t\right)$ uniformly from $[0,1]$ 9:         collapse: $Z_{i,j}^l\left(t\right)\stackrel{\mathrm{Equation}\left(13\right)}{\leftarrow }({|\varphi \rangle }_{i,j}^l\left(t\right),{\gamma }_{i,j}^l\left(t\right))$ 10:         if $Z_{i,j}^l\left(t\right)=1$ then 11:            remove i from $\overline{\mathcal{S}}$ 12:            remove j from $\overline{\mathcal{T}}$ 13:         end if 14:     end while 15: end procedure

Evaluation procedure: This procedure has two parts, the computation of the cost for fitness test, and the formulation/updating of the rotation matrix based on the feedback from the fitness analysis. Given the collapsed individuals $Z^1\left(t\right),\cdots ,Z^K\left(t\right)$, at step t, firstly, the cost of the assignment $f\left(Z^l\left(t\right)\right)={\sum }_{i\in \mathcal{S}}{\sum }_{j\in \mathcal{T}}{c}_{i,j}{Z}_{i,j}^l\left(t\right)$ is computed. The fitness evaluation not only depends on the cost at time t due to $Z^l\left(t\right)$ but also has temporal information about the evolution of the system by saving the best obtained solution until that iteration, which is stored as $B_{\mathrm{local}}^l\left(t\right)$. The variable $B_{\mathrm{local}}^l$ for each individual $l\in \{1,\cdots ,K\}$ is initialised by collapsing ${|\Phi \rangle }^l\left(0\right)$, as described in step 5 of Algorithm 1. The fitness analysis relies on function (11) and updates each local $B_{\mathrm{local}}^l$ according to $B_{\mathrm{local}}^l\left(t\right)=\mathsf{best}(Z^l\left(t\right),B_{\mathrm{local}}^l(t-1))$. Next, in the evaluation procedure, we update the qubit matrix ${|\Phi \rangle }^l$ according to

$$\begin{array}{c}\hfill \left[\begin{array}{c}{\alpha }_{i,j}^l\left(t\right)\\ {\beta }_{i,j}^l\left(t\right)\end{array}\right]=R({\theta }_{i,j}^l,t)\left[\begin{array}{c}{\alpha }_{i,j}^l(t-1)\\ {\beta }_{i,j}^l(t-1)\end{array}\right],\end{array}$$

(14)

where rotation angle ${\theta }_{i,j}^l\in \{0,\delta \pi ,-\delta \pi \}$ is determined from

Table 1. Evaluation cases to define rotation angle.

Case	${\mathit{Z}}_{\mathit{i},\mathit{j}}^{\mathit{l}}\left(\mathit{t}\right)$	${\mathit{B}}_{{\mathbf{local}}_{\mathit{i},\mathit{j}}}^{\mathit{l}}(\mathit{t}-1)$	$$\begin{gathered} \mathit{f}\left({\mathit{Z}}^{\mathit{l}}\left(\mathit{t}\right)\right)\ge \\ \mathit{f}\left({\mathit{B}}_{\mathbf{local}}^{\mathit{l}}(\mathit{t}-1)\right) \end{gathered}$$	${\mathit{\theta }}_{\mathit{i},\mathit{j}}$
1	0	0	false	0
2	0	0	true	0
3	0	1	false	$\delta \pi$
4	0	1	true	0
5	1	0	false	$-\delta \pi$
6	1	0	true	0
7	1	1	false	0
8	1	1	true	0

. Here, $0<\delta \pi <\frac{\pi }{2}$ is a design parameter which normally is a very small angle. Recall that, according to the circular qbit representation (8), which is visualised in Figure 2, a positive rotation $0<\delta \pi <\frac{\pi }{2}$ results in increasing the probability of collapsing to 1 and a negative rotation $0<-\delta \pi <\frac{\pi }{2}$ results in increasing the probability of collapsing to 0. We proposed Table 1 based on the logic that if the value of $Z_{i,j}^l\left(t\right)$ and $B_{{\mathrm{local}}_{i,j}}^l(t-1)$ are the same, we make no changes to the qbit corresponding to the agent–task pair $(i,j)$, thus setting ${\theta }_{i,j}^l\left(t\right)=0$ (cases 1, 2, 7 and 8 in Table 1). If changing from $B_{{\mathrm{local}}_{i,j}}^l(t-1)=1$ to $Z_{i,j}^l\left(t\right)=0$ results in decreasing the total cost, we want to encourage collapsing to $Z_{i,j}^l\left(t\right)=0$ by increasing this probability by using a positive rotation ${\theta }_{i,j}^l=\delta \pi$ (case 3 in Table 1). On the other hand, if changing from $B_{{\mathrm{local}}_{i,j}}^l(t-1)=0$ to $Z_{i,j}^l\left(t\right)=1$ results in decreasing the total cost, we want to encourage collapsing to $Z_{i,j}^l\left(t\right)=1$ by increasing such probability by using a negative rotation ${\theta }_{i,j}^l=-\delta \pi$ (case 5 in Table 1). If the changes in the values result in increasing the total cost, we do not make any changes to ${|\Phi \rangle }_{i,j}^l$, i.e., ${\theta }_{i,j}^l\left(t\right)=0$ (cases 4 and 6 in Table 1). To summarise, we make an adjustment to ${|\Phi \rangle }_{i,j}^l$ if $Z_{i,j}^l\left(t\right)\ne B_{{\mathrm{local}}_{i,j}}^l(t-1)$ and the best value at step t is set to $Z^l\left(t\right)$; thus, we can interpret the change in $B_{{\mathrm{local}}_{i,j}}^l(t-1)$ value as a contributor to decreasing the cost. Algorithm 3 summarises our evaluation procedure.

Algorithm 3 Evaluation

1: procedure Evaluation 2:     Input collapsed system $Z^l\left(t\right)$, best saved solution $B_{\mathrm{local}}^l(t-1)$ 3:     $B_{\mathrm{local}}^l\left(t\right)=\mathsf{best}(Z^l\left(t\right),B_{\mathrm{local}}^l(t-1))$ 4:     ${\theta }_{i,j}^l=0$ for any $i\in \mathcal{S}$ and $j\in \mathcal{T}$ 5:     if $B_{\mathrm{local}}^l\left(t\right)=Z^l\left(t\right)$ then 6:         for $i\in \mathcal{S}$ do 7:            for $j\in \mathcal{T}$ do 8:                if $Z_{i,j}^l\left(t\right)<B_{{\mathrm{local}}_{i,j}}^l(t-1)$ then 9:                    ${\theta }_{i,j}=\delta \pi$ 10:                end if 11:                if $Z_{i,j}^l\left(t\right)>B_{{\mathrm{local}}_{i,j}}^l(t-1)$ then 12:                    ${\theta }_{i,j}=-\delta \pi$ 13:                end if 14:            end for 15:         end for 16:     end if 17:     for $i\in \mathcal{S}$ do 18:         for $j\in \mathcal{T}$ do 19:            update ${|\Phi \rangle }_{i,j}^l\left(t\right)$ according to (14) 20:         end for 21:     end for 22: end procedure

Migration procedure: Like other evolutionary algorithms, to avoid getting stuck in local maxima or minima we perform a migration procedure when the migration condition$(t-t_{\mathrm{last}\mathrm{migration}})\ge n\times$ MAX_GEN, where n is a percentage that defines when the process is completed. In the migration step, we simply replace the current best local value $B_{\mathrm{local}}^l\left(t\right)$ of all the individuals $l\in \{1,\cdots ,K\}$ with $B\left(t\right)=\mathsf{best}(B_{\mathrm{local}}^1\left(t\right),\cdots ,B_{\mathrm{local}}^K\left(t\right))$, i.e., $B_{\mathrm{local}}^l\left(t\right)=B\left(t\right))$ for all $l\in \{1,\cdots ,K\}$.

4. Numerical Demonstration

To demonstrate the efficacy of our proposed QiEA, consider the service-matching robot-deployment example we described in Section 1 and depicted in Figure 1. Recall that, in this example, we have a set $\mathcal{S}$ of N service agents with spatial service distribution $p_i\left(x\right)$, $i\in \mathcal{S}$ with Gaussian distribution $\mathcal{N}({\mu }_i,{\Sigma }_i)$. Each target cluster $TCj$, $j\in \mathcal{T}$, extracted from a GMM model of the entire targets distribution, has a Gaussian distribution $q_j\left(x\right)\sim \mathcal{N}({\overline{\mu }}_j,{\overline{\Sigma }}_j)$. According to [1], Theorm 2, the best value for $c_{i,j}=D_{\mathrm{KL}}\left(p_i\left(x\right)\left|\right|q_j\left(x\right)\right)$ is obtained when the robot is moved such that ${\mu }_i={\overline{\mu }}_j$ and the principle axes of the two uncertainty ellipsoids corresponding to ${\Sigma }_i$ and ${\overline{\Sigma }}_j$ are parallel. Considering this configuration, for each service agent we compute $c_{i,j}=D_{\mathrm{KL}}\left(p_i\left(x\right)\left|\right|q_j\left(x\right)\right)$ to form the weighting matrix $\left[c_{i,j}\right]$. Next, through a set of numerical simulations, we evaluate the efficacy of our QiEA algorithm in solving this optimal service-matching deployment problem.

In this work, all the simulation codes are developed with Python using well-known open-source libraries. The optimal deployment for service-matching data is randomly generated. We carry out a simulation study that compares the performance of our proposed Algorithm 1 to that of three well-known algorithms: the greedy algorithm, the Hungarian method and the Simplex linear-programming method. The greedy algorithm is an iterative method that greedily selects the smallest value of $c_{i,j}$ to set $Z_{i,j}=1$, eliminates the row and the column corresponding to $(i,j)$ from the weight matrix $\left[c_{i,j}\right]$ and repeats the procedure. The Hungarian method is a similar technique to the Greedy Algorithm but, instead of picking direct assignments from a static cost matrix, the cost matrix is modified at each step in the function of the minimum values of each row and column. Therefore, this method considers not only the minimum cost for each assignment, but also the rest of the assignments, which is why it can achieve the optimal solution. To have a comprehensive study, we also compare our result to that of the Simplex method, which solves the continuous relaxation of the optimal service-matching problem (Section 1).

4.1. Simulation Results

This section presents the results of our numerical experiments. The proposed algorithm is compared to the benchmark methods in five different scenarios. The simulations are conducted via Python programming on a PC with processor Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz 2.30 GHz and a RAM of 16 GB.

4.1.1. Case Studies

We simulate five different scenarios, which are described in

Table 2. Case studies.

Case	Number of Service Agents (N)	Number of Target Clusters (M)
1	10	10
2	5	8
3	2	8
4	90	100
5	2	100

. Case 1 is the perfect-matching case, where $N=M$. However, there can also be unbalanced cases where the number of target clusters is bigger than the number of the service agents. To demonstrate how our algorithm scales with respect to N and M and also their relative size, we consider various scenarios for when $N<M$. The normal distributions for each target/service in each experiment are randomly created using Python.

4.1.2. Hyper-Parameters of the QiEA Algorithm 1

To execute the QiEA Algorithm 1, the set of hyper-parameters listed in the first column from the left of

Table 3. Hyper-parameters of and the assigned possible values for the grid search.

Hyperparameters	Possible Values
Population size (K)	2, 5, 10
Rotation angle ($\delta \pi$)	$0.0025\pi$, $0.01\pi$, $0.05\pi$
Epochs ($MAX\_GEN$)	10, 20, 50
Migration frequency	$0.25$, $0.5$, $0.75$

should be selected. We chose three candidate values for each hyper-parameter as reported in Table 3. To tune the hyper-parameters for each case study listed in Table 2, a grid search over 81 different combinations was implemented. During this grid search, it was observed that there can be two groups of hyperparameters: the ones that make the algorithm more accurate and the ones that make the algorithm faster (compared over same number of epochs). As such, we report the simulation results for two different executions of Algorithm 1 for solving our problem of interest for the cases listed in Table 2: the accurate quantum-inspired evolutionary algorithm (AQiEA) and the fast quantum-inspired evolutionary algorithm (FQiEA).

Table 4. Grid search results.

Case	Type	Population Size (K)	Rotation Angle ($\mathit{\delta }\mathit{\pi }$)	Epochs ($\mathbf{MAX}\_\mathbf{GEN}$)	Migration Frequency
1	Accurate	2	$0.05\pi$	20	0.5
	Fast	2	$0.0025\pi$	20	0.5
2	Accurate	2	$0.0025\pi$	50	0.5
	Fast	2	$0.01\pi$	50	0.75
3	Accurate	2	$0.0025\pi$	10	0.5
	Fast	2	$0.01\pi$	50	0.75
4	Accurate	10	$0.0025\pi$	20	0.75
	Fast	2	$0.01\pi$	10	0.75
5	Accurate	2	$0.05\pi$	20	0.25
	Fast	2	$0.0025\pi$	50	0.75

gives the chosen hyper-parameters for each case study. Notice that the hyper-parameters are not necessarily the same for each case study.

4.1.3. Metrics

In order to compare and evaluate the performance of the methods, three metrics have been considered, which include optimality gap, execution time complexity and a quality metric. The optimality gap, denoted by $\alpha$, is defined as

$$\alpha =\frac{\cos \mathrm{t}\mathrm{computed}\mathrm{by}\mathrm{the}\mathrm{algorithm}-\mathrm{optimal}\cos \mathrm{t}}{\mathrm{optimal}\cos \mathrm{t}}.$$

(15)

When $N=M$, the Hungarian and the Simplex methods are guaranteed to produce an optimal solution; however, this guarantee is not the case when $N<M$. To obtain the optimal value for $N<M$, a suggested practice is adding $M-N$ virtual service agents whose assignment costs to task clusters are much greater than the actual service agents’. This way, a perfect matching problem is created, which we use to generate the optimal cost value for computing the optimality gap. Notice that adding virtual agents increases the computational complexity of the algorithms. The simulation results reported below for all the algorithms consider the actual matching cases when no virtual agent is added.

The execution time, measured in milliseconds (ms), is the time it took to run the algorithm. To unify both prior metrics and for the sake of the comparison, the quality metric Q was implemented in order to have a faster and easier way of comparing and discussing the algorithms. This metric is computed as

$$Q=\frac{100-\alpha }{\mathrm{execution}\mathrm{time}}.$$

(16)

4.1.4. Simulation Results

The simulation results for the three aforementioned performance metrics are reported in

Table 5. Optimality gap $\alpha$ for the case studies.

Case	Greedy	Hungarian	Simplex	AQiEA	FQiEA
1	0.4059	0	0	0.2150	0.4579
2	0.2336	0	0	0.1825	1.135
3	0	0	0	0	4.910
4	0.6298	0	−	0.7622	0.9125
5	0.6365	0	0	2.0178	3.007

,

Table 6. Execution time in ms for the case studies.

Case	Greedy	Hungarian	Simplex	AQiEA	FQiEA
1	10.03	11.05	537.9	4.591	3.866
2	5.000	7.970	112.5	2.910	2.464
3	4.521	3.000	26.62	2.393	1.530
4	552.9	544.9	-	226.7	32.61
5	19.04	27.90	781.6	1.845	1.418

and

Table 7. Quality metric for the case studies.

Case	Greedy	Hungarian	Simplex	AQiEA	FQiEA
1	9.930	9.050	0.1859	21.73	25.75
2	19.95	12.55	0.8889	34.30	40.12
3	22.12	33.33	3.757	41.79	62.15
4	0.1797	0.1835	−	0.4377	3.039
5	5.252	3.584	0.1279	52.57	31.73

. Per definition (15), the best optimality result is when $\alpha =0$. Thus, for a suboptimal solution, we desire an $\alpha$ closer to zero. For Case 1, as expected, the results in Table 5 show that the Hungarian and Simplex methods have zero optimality gap. Notice that in Case 1, AQiEA outperforms the greedy method in the optimality gap, while FQiEA delivers a close performance to that of the greedy algorithm. In the rest of the cases, the Hungarian and the Simplex methods also deliver a zero optimality gap, but as Table 6 shows, this comes with a high execution time, especially when the scale of the system grows. In Case 4, the Simplex algorithm failed to converge in a reasonable time, so no results are listed for this case in Table 5, Table 6 and Table 7. Per definition (16), the quality metric Q is designed to be 100 when the optimality gap is zero and the execution time is 1 ms. As the results in Table 7 show, both QiEA algorithms outperform the rest of the methods in terms of the quality metric.

5. Conclusions

This work showed how a quantum-inspired evolutionary algorithm could be used as a practical solution method to solve combinatorial optimisation problems such as an optimal service-matching coverage problem. Our numerical studies showed that the quantum approach presents better scalability and interesting properties that can be used in a wider class of assignment problems where the matching is not perfect. Our future work will apply our proposed quantum-inspired evolutionary algorithm framework in solving submodular maximisation problems, particularly the optimal welfare problem. We will also study the automated tuning of the algorithm hyper-parameters using a machine-learning approach.