Graph coloring using the reduced quantum genetic algorithm

Quantum computing

Classical computers are built according to the laws of classical physics. Therefore, a full specification of its state can be specified by a measurable set of numbers. According to Häner et al. (2016), sustaining the pace of Moore’s law has become increasingly difficult such that an alternative should be considered to meet the power and performance requirements; one of the most prominent such alternatives is quantum computing.

According to Spector (2004), quantum computing describes computational processes that rely for their efficacy on information processing hardware having quantum mechanical properties. Thus, as mentioned in Nielsen & Chuang (2002), quantum computers offer an essential speed advantage over their classical equivalents.

While in classical computers the bit is the basic information unit, the qubit is the analogous concept for quantum computers; as mentioned in Udrescu-Milosav (2009), qubits are the fundamental information storage unit. Like the classical bit that has a state (either 0 or 1), the qubit can be in either |0⟩ or |1⟩, which correspond to the classical ones, respectively. Additionally, the qubit can also be in a superposition state

(1) $$|\psi ⟩=\alpha |0⟩+\beta |1⟩,$$where

(2) $$\alpha ,\beta \in \mathbb{C},|\alpha {|}^2+|\beta {|}^2=1,$$until it is observed/measured. As presented in Nielsen & Chuang (2002), the first postulate of quantum mechanics states that the state of a quantum system is described by a unit vector in a complex Hilbert space, $\mathscr{H}$. Thus, a system of n-qubits (referred as quantum register) has 2ⁿ computational basis states of the form |x₀x₁ … x_{n − 1}⟩, and its quantum state is a normalized vector in ${\mathscr{H}}^{2n}$,

(3) $$|\psi ⟩=\sum _{i=0}^{2^{n-1}}{\alpha }_i|i⟩,\sum _{i=0}^{2^{n-1}}|{\alpha }_i{|}^2=1.$$

According to the second postulate of quantum mechanics, the evolution of a closed quantum system is described by a unitary transformation. Considering that |ψ₁⟩ is the quantum state of the system at time t₁, |ψ₁⟩ is related to the quantum state |ψ₂⟩ at time t₂, t₁ < t₂, by a unitary operator U. The unitary transformation U applied by a quantum computer with n-qubits, also called a gate, is represented by a unitary matrix in ${\mathbb{C}}^{2^n\times 2^n}$.

As presented in Nannicini (2020), unitary matrices are norm-presenting; considering a unitary matrix U and a vector x, ‖Ux‖ = ‖x‖. Therefore, for a n-qubit system, the quantum state $|{\psi }_1⟩\in {\mathbb{C}}^{2^n}$ is an unitary vector and the result of applying U onto state |ψ₁⟩,

(4) $$|{\psi }_2⟩\to U|{\psi }_1⟩,U\in {\mathbb{C}}^{2^n\times 2^n},$$is the unitary vector $|{\psi }_2⟩\in {\mathbb{C}}^{2^n}$, leading to the observation that quantum operations are linear and reversible.

According to Barenco et al. (1995), any unitary transformation can be expressed as a composition of gates. Thus, infinitely many quantum gates can be constructed. A finite set of quantum gates are universal for quantum computation since any unitary transformation may be approximated by a quantum circuit involving only those gates. In Table 1 we present some basic quantum unitary transformations we use in this paper, along with the unitary matrix and the graphical representation used in the implementation of the RQGA.

Table 1:

Quantum unitary transformations (i.e., gates) used in the implementation of the RQGA.

Gate	Graphical representation	Unitary matrix	Description
Hadamard		$H={\displaystyle \frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]}$	$|0⟩\to {\displaystyle \frac{1}{\sqrt{2}}\left(|0⟩+|1⟩\right)}$ and $|1⟩\to {\displaystyle \frac{1}{\sqrt{2}}\left(|0⟩-|1⟩\right)}$
Pauli-X		$X=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]$	$|0⟩\to |1⟩$ and $|1⟩\to |0⟩$
Pauli-Y		$Y=\left[\begin{array}{cc}0& -i\\ i& 0\end{array}\right]$	$|0⟩\to i|1⟩$ and $|1⟩\to -i|0⟩$
Pauli-Z		$Z=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right]$	$|1⟩\to |-1⟩$ and |0⟩ is left unchanged
Controlled-Not		$CNOT=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right]$	$|c⟩|t⟩\to |c⟩|t\otimes c⟩$, where |c⟩ is the control qubit and |t⟩ is the target Nielsen & Chuang (2002)

DOI: 10.7717/peerj-cs.836/table-1

The third postulate of quantum mechanics states that quantum measurement is described by a measuring transformation of the quantum state (i.e., the measurement operator M_m). For a quantum state |ψ⟩, the probability that the outcome of the measurement is m is $P\left(m\right)=⟨\psi M_m^{\text{†}}{M}_m|\psi ⟩$.

The single qubit |ψ⟩ = α|0⟩ + β|1⟩ where $\alpha ,\beta \in \mathbb{C}$ and |α|² + |β|² = 1 is projected by the measurement onto the basis {|0⟩,|1⟩}, thus yielding the outcome |0⟩ with probability α² or |1⟩ with probability β². By measurement, the quantum state is irrevocably disturbed and collapsed to the specific Hilbert space basis state, consistent with the measurement result. Therefore, for any basis states |a⟩ and |b⟩ and the quantum state |ψ⟩ = α|a⟩ + β|b⟩ with |α|² + |β|² = 1 expressed in terms of the orthonormal base {|a⟩,|b⟩}, the measurement can be performed with respect to the |a⟩ and |b⟩ basis and the outcome will be |a⟩ with probability α² or |b⟩ with probability β².

According to Nielsen & Chuang (2002), two principles are applied to measurement: the Principle of deferred measurement and the Principle of implicit measurement. The principle of deferred measurement states that the measurement can be moved from an intermediate stage of the circuit to its end. The principle of implicit measurement states that any unterminated quantum wires may be assumed as measured at the end of the circuit.

As presented in Nielsen & Chuang (2002), the fourth postulate describes the state space of a composite physical system as the tensor product of the state spaces of the component physical system.

Genetic algorithms and quantum computing

The literature proposes several quantum genetic algorithms, from algorithms that combine operations running on classic computers with quantum operators to genuine quantum evolutionary algorithms (Lahoz-Beltra, 2016). Using evolutionary algorithms for synthesizing quantum circuits has been thoroughly investigated and relevant progress has also been reported in the field of Quantum-Inspired Genetic Algorithm (QIGA) (Ruican et al., 2007).

In Ruican et al. (2007), the authors propose a method of synthesizing quantum circuits using genetic programming. The chosen approach is to split the potential circuits into vertical and horizontal levels used for chromosome definition. Furthermore, Ruican et al. (2008) propose an object-oriented framework for genetic algorithms in quantum circuit synthesis.

In Gepp & Stocks (2009), the authors analyze evolutionary algorithms for synthesizing quantum algorithms. They claim that genetic algorithms and genetic programming have been used with great success to analyse and optimize quantum algorithms. Moreover, by successfully evolving small new quantum algorithms, scalable quantum algorithms are proven.

In Malossini, Blanzieri & Calarco (2008), the authors propose a quantum genetic algorithm called Quantum Genetic Optimization Algorithm (QGOA). The algorithm starts with a qubit representation of the population and a quantum evaluation unit. Then, the selection step of the GA uses the quantum selection procedure, while the remaining steps (e.g., crossover, mutation, and substitution) are performed on a classical computer.

Nowotniak (2010) briefly presents Quantum-Inspired Evolutionary Algorithm (QIEA). Moreover, in Nowotniak & Kucharski (2010) the authors present the results after applying a meta-optimization algorithm for tuning the QIEA parameters for numerical optimizations problems coded in real numbers. The algorithm used for meta-optimization is based on local unimodal sampling and is applied to adjust the crossover rate and the contraction factor. According to Nowotniak & Kucharski (2010), the results show that the local unimodal sampling is an effective method for the meta-optimization of QIEAs.

Zhang (2011) presents a survey of the research in QIEAs; the author shows the differences between different solutions and compares the advantages and limitations of the various solutions. The author introduces the Binary Observation QIEA, shows that the use of Q-gates as a variation operator instead of crossover, recombination and mutation have a positive impact on the optimality of the solutions. Compared to Binary Observation QIEA, Binary Observation QIEA with crossover and mutation employs the mentioned operators to replace the migration operator with benefits in population diversity, especially in the later stages of evolution. Binary Observation QIEA with the novel update method for Q-gates, defines the Q-gate angle θ = kf(α,β), which directly influences the convergence speed. According to Zhang (2011), the algorithm also introduces the catastrophe operator; the scope of the new operator is to replace the best individual with the best individual of a new population if the best solution remains unchanged over some generations.

SaiToh, Rahimi & Nakahara (2014) introduces a novel quantum genetic algorithm with quantum crossover operation applied to all chromosomes in parallel. The proposed solution uses two identical copies of a superposition corresponding to a generation to relabel the qubits. They also show that the quantum genetic algorithm with quantum crossover operations achieves a quadratic speedup over its classical counterpart.

Kumar & Kumar (2018) propose a novel Quantum-Inspired Evolutionary View Selection Algorithm (QIEVSA). The authors also bring forward an experimental comparison with other evolutionary view selection algorithms. The method makes use of the Binary Observation QIEA algorithm to select the Top-K views from a multidimensional lattice. The authors experimentally show that QIEA is able to select good quality Top-K views for higher dimensional data sets (Kumar & Kumar, 2018).

In Moussa, Calandra & Humble (2019), the authors present an iterative quantum algorithm for finding the maximum value of a function along with the corresponding implementations. The approach utilizes quantum search and extends the RQGA with a dynamic oracle function.

Lahoz-Beltra (2016) presented a comparison between three algorithms: Quantum Genetic Algorithm (QGA), Hybrid Genetic Algorithms (HGA), and RQGA. QGA and HGA represent classical optimization methods, inspired by the principles of quantum computing. The first QGA step is the initialization of a quantum population of chromosomes; each chromosome is defined by a string of qubits. Hadamard gates and rotation around Y-axis with a random number process each qubit. Then, a classical computer performs the fitness evaluation, while a quantum computer (employing rotation gates) performs the selection. The quantum computer also performs mutation using inversion gates. Likewise, an HGA implements the above steps, the difference being that the crossover operator is also quantum.

Graph coloring applications

As mentioned in Mahmoudi & Lotfi (2015), the graph coloring problem is a well-studied NP-hard problem because of its multiple applications that include timetabling, scheduling, radio frequency assignment, computer register allocation, printed circuit board testing, and so forth.

The authors of Bincy & Presitha (2017) present the application of graph coloring in scheduling problems, such as timetable scheduling, aircraft scheduling, and seating plan design. In Dondi, Fertin & Vialette (2011), the authors present the use of graph coloring in pattern matching.

In Hennessy & Patterson (2018), the authors also present the application of graph coloring in register allocation algorithms; to this end, they build a graph representing all possible candidates for allocation to a register.

In Orden et al. (2018), the authors present the application of graph coloring to WI-FI channel assignment. Therefore, for a given spectrum of colors and a matrix of interferences between each pair of colors, the authors use the Threshold Spectrum coloring problem for fixing the number of colors available to minimize the interference threshold. Moreover, they use the Chromatic Spectrum Coloring and a given threshold to find the smallest number of colors that respect the constrain.

In Demange et al. (2015), the authors present the applications of graph coloring in routing and wavelength assignment, dichotomy-based constrained encoding, frequency assignment problems, and scheduling. As the authors mentioned, the routing and wavelength assignment problem involves generating a set of light paths for each request—routing—and selecting a light path per request, and assigning wavelengths to the selected path–wavelength assignment. To solve the problem, the optical network is transformed into a graph and the wavelengths are assigned using graph coloring. The dichotomy-based constrained encoding problem can be reduced to a graph coloring problem and, as mentioned by the authors, is used to generate asynchronous implementations of finite state machines.

Therefore, considering the large number of applications, solving graph coloring has received a great deal of research interest Dokeroglu & Sevinc (2021). For instance, in Aragón Artacho & Campoy (2018), the authors present a method for solving the graph coloring problem using the Douglas-Rachford Algorithm. Indeed, they prove that the algorithm is an effective heuristic for solving this NP-hard problem.

In Dokeroglu & Sevinc (2021), the authors propose a novel memetic Teaching-Learning-Based Optimization (TLBO) algorithm, combined with tabu search, for solving the graph coloring problem. Furthermore, they developed a version of TLBO that makes use of parallelism for solving large graphs. The authors claim that the results of the parallel version of the algorithm are better than those of its sequential counterpart, and the solution is competitive with state-of-the-art solutions presented in the literature.

Mahmoudi & Lotfi (2015) present a new approach for solving the graph coloring problem using a discrete Cuckoo Optimization Algorithm (COA). As stated by authors, the success rate of the proposed solution is above 60% for solving DIMACS (Center for Discrete Mathematics and Theoretical Computer Science) benchmark graphs, while in most cases is close to 100%.

In Tomar et al. (2013), the authors propose a novel artificial bee colony optimization algorithm for solving the graph coloring problem and compare the solutions with other algorithms such as first fit, largest degree based ordering, and saturation degree based ordering. They claim that the proposed solution can converge in a few iterations and optimally allocate colors to the vertices of a graph. As mentioned by the authors, compared to the other algorithms, their proposed solution can converge to the optimal solution in very few iterations. Moreover, they show that the performance of the artificial bee colony optimization algorithm improved with the increase of the graph size.

Graph coloring in quantum computing

Lately, quantum heuristic solutions for the graph coloring problem have received a great deal of interest. Most of the proposed solutions rely on quantum implementations of simulated annealing. In Kudo (2018), the authors use the Constrained Quantum Annealing (CQA) to solve the graph coloring problem with the advantage of reducing the Hilbert space dimension. Also, in Tabi et al. (2020) the authors introduce a space-efficient embedding for quantum circuits that solve the graph coloring problem and present the performance gain for this method. The authors indicate the limitation of the existing Quantum Annealing (QA) hardware solutions by running various numerical simulations and comparing results obtained with standard and enhanced Quantum Approximate Optimization Algorithm (QAOA) circuits.

Titiloye & Crispin (2011) propose comparing Classical Annealing and QA in solving graph coloring problems. The QA algorithm used in the comparison utilizes the Path-Integral Monte Carlo for Quantum Annealing—a population-based extension to simulated annealing inspired by quantum mechanics Titiloye & Crispin (2011). According to the authors, the QA algorithm outperforms its classical counterpart, and even finds the best algorithm solutions.

In Silva et al. (2020), the authors start by formulating the Quadratic Unconstrained Binary Optimization Problem (QUBO)—a powerful mathematical tool that can map any problem to a quantum annealing computer. Silva et al. (2020) solve the problem using different approaches: QUBO with classical simulated annealing in a simulated quantum environment, using a D-Wave quantum machine, and reducing polynomial degree using both the D-Wave library and their implementation. The results show that both Simulated Annealing and QA produce good heuristics for the graph coloring problem, although more solutions can be found using the quantum approach.

Kwok & Pudenz (2020) propose a comparison between a heuristic graph coloring approximation algorithm—based on QA—and a fully classical implementation. The metrics for calculating performance are success probability, wall clock time, and time-to-solution. For wall clock time and time-to-solution, the quantum solution performs better than its classical equivalents. As mentioned in Kwok & Pudenz (2020), the classical algorithm takes significantly longer to return a graph coloring for all graph sizes. The same is also true in the case of time-to-solution. The probability of success for the classical algorithm is lower than the quantum algorithm in the case of smaller size graphs. As the authors mention, the results of their experiments suggest a potential quantum advantage (Kwok & Pudenz, 2020).

Fabrikant & Hogg (2002) also present a quantum computer heuristic search algorithm for graph coloring. The authors consider the NP-complete case of 3 colors. For the problem representation, the authors introduce the idea of associating each node with a value from 0 to 3 (using two bits per node). As mentioned in Fabrikant & Hogg (2002), 0 represents an uncolored node, and any other value represents a specific color assigned to the node. Since the generalized Hamming distance underpins the quantum algorithm, using this representation has the benefit that the distance between the states is a simple function of their bit strings.

Shimizu & Mori (2021) present an exponential-space quantum algorithm computing the chromatic number using the Quantum Random Access Memory (QRAM); the authors also describe a polynomial-space quantum algorithm not using QRAM for the 20-coloring problem. Their main result is the theorem that states that, to solve the chromatic number problem, the running time for the exponential-space bounded error quantum algorithm using QRAM is $\mathcal{O}\left({1.9140}^n\right)$ (Shimizu & Mori, 2021).

Problem statement

We consider an undirected graph G = (V,E) where V is the set of nodes and E is the set of edges. We define K as the set of colors. Our problem is to find the best way of assigning the colors in K to nodes from V, such that no two adjacent nodes have the same color (e_ij ∈ E with $k\left(v_i\right)\ne k\left(v_j\right)$ for distinct nodes v_i and v_j). Thus, coloring G is the mapping $k:V\to E$ such that $k\left(v_i\right)\ne k\left(v_j\right)$ if ∃e_ij ∈ E, as mentioned in Titiloye & Crispin (2011). The chromatic number of the graph, χ(G), can be found by first detecting the coloring for a high estimate of χ(G) and then successively narrowing the available colors.

Test graphs

Let the K be the set of colors and G = (V,E) a randomly generated Erdős-Rényi graph with a defined edge probability (Wang & Chen, 2003). In G, the number of edges in the graph is |E|, and |V| is the number of nodes.

Implementation

The first step initializes all individual–fitness register pairs |u⟩_i ⊗ |0⟩_i as

(5) $$|\psi {⟩}_1={\displaystyle \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|u{⟩}_i\otimes |0{⟩}_i.}$$

The representation we use for graph coloring uses (Fabrikant & Hogg, 2002) work; the difference is that we consider each binary combination a color. If the number of colors used for coloring the graph is not a power of 2, then the unused combinations are considered invalid. The chromosome is a (n × |V|)-qubit quantum register, where each color is represented using n-qubits. Since there are 2ⁿ − 1 possible colors, we define a subset $F\subset K$ of invalid color combinations. The quantum chromosome is a superposition of all (n × |V|)-bit classical chromosome values, representing valid and invalid individuals, see Udrescu, Prodan & Vlăduţiu (2006) (an invalid individual represents a combination that contains at least one of the invalid colors codes). The same approach can be used for edge coloring with the difference that the chromosome is a (n × |E|)-qubit quantum register. Algorithm 1 shows how to create the initial population.

We represent the individual using a (n× |V|)-qubit individual quantum register and the fitness value using a M-qubit fitness register (see Fig. 2). As such, our algorithm uses 2^{n× |V|} − 1 quantum register pairs. In order to maintain correlation between each individual and its corresponding fitness value, the fitness function must be an unitary operator, U_fit, corresponding to the Boolean function $f:\{0,1{\}}^{n\times |V|}\to \{0,1{\}}^M$.

The next step is to calculate the fitness value for all individuals. The step is achieved by defining the function $f:\{G,K\}\to \mathbb{N}\cup \{-1\}$, $G=\left(V,E\right)$ as

(6) $$f((V,E),k)=\{\begin{array}{cc}-1& k\in F\\ 0& \nexists k\left(v_i\right),k\left(v_j\right)\in K,k\left(v_i\right)\ne k\left(v_j\right),e_{ij}\in E\\ x& \mathrm{\exists }k\left(v_i\right),k\left(v_j\right)\in K,k\left(v_i\right)\ne k\left(v_j\right),e_{ij}\in E,x\in \mathbb{N}.\end{array}$$

K is a set of colors

(7) $$K=\{x_{n-1}\dots x_i\dots {x_0}_0,x_{n-1}\dots x_i\dots {x_0}_1,\dots x_{n-1}\dots x_i\dots {x_0}_j,\dots ,x_{n-1}\dots x_i\dots {x_0}_{|V|-1}\},$$where x_i ∈ {0,1} is a single bit and $x_{n-1}\dots x_i\dots {x_0}_j$ is the binary representation of a color from the set K. The fitness function returns ’−1’ if the individual is invalid and ‘0’ if there are no two adjacent nodes with different coloring. If there are adjacent nodes with different coloring, then the fitness function will return $x\in \mathbb{N}$, representing the number of edges between those nodes that met the criteria.

For solving the edge coloring problem, we can apply the same fitness function with minimal adjustments. Thus, the fitness function $f:\{G,K\}\to \mathbb{N}\cup \{-1\}$, $G=\left(V,E\right)$, returns ’−1’ if the individual is invalid (the chromosome contains at least one of the invalid colors), ’0’ if there are no two incident edges with different coloring and $x\in \mathbb{N}$, representing the number of nodes with incident edges of different coloring. Equation

(8) $$f((V,E),k)=\{\begin{array}{cc}-1& k\in F\\ 0& \nexists k\left(e_{ij}\right),k\left(e_{ik}\right)\in K,k\left(e_{ij}\right)\ne k\left(e_{ik}\right),e_{ij},e_{ik}\in E\\ x& \mathrm{\exists }k\left(e_{ij}\right),k\left(e_{ik}\right)\in K,k\left(e_{ij}\right)\ne k\left(e_{ik}\right),e_{ij},e_{ik}\in E\end{array}$$defines the fitness function for the edge coloring problem.

In both Eqs. (6) and (8), the fitness function accepts both valid and invalid individuals as arguments. As mentioned in Udrescu, Prodan & Vlăduţiu (2006), the values of the fitness function represented in the two’s complement belong to distinct areas in the quantum state vector representation, corresponding to valid and invalid individuals. Negative fitness values represent invalid individuals, with the most significant bit indicating the validity (‘0’ on the most significant bit position represents an invalid individual and ‘1’ represents a valid one). Thus, U_fit characterized by the fitness function f is an unitary operator

(9) $$U_{fit}:|u⟩\otimes |0⟩\to |u⟩\otimes |f_{fit}(u)⟩,$$where |u⟩ ⊗ |0⟩ is the individual-fitness value quantum pair register. After applying

(10) $$U_{fit}:{\displaystyle \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|u{⟩}_i\otimes |0{⟩}_i\to {\displaystyle \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|u{⟩}_i\otimes |f_{fit}(u){⟩}_i}}$$on the initial population, we obtain an assessed population

(11) $$|\psi {⟩}_2=U_{fit}|\psi {⟩}_1={\displaystyle \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|u{⟩}_i\otimes |f_{fit}(u){⟩}_i.}$$

We implement the fitness sub-circuit using n-qubit Controlled-Not gates. In Fig. 3, we present the U_fit sub-circuit with input and output qubits, and in Algorithm 2 we present the description of the subcircuit.

According to the algorithm presented in Udrescu, Prodan & Vlăduţiu (2006), the next step involves the random generation of value $max\in \mathbb{N},max>0$ from the interval [2^{M + 1}, 2^{M + 2} − 1), with M representing the size of the fitness quantum register, such that the search for the individual with the highest fitness will not occur in the invalid individuals area.

In the implementation of the graph coloring problem, an individual is invalid if it contains at least one of the invalid colors; the fitness value is −1 in that case. On the other hand, the fittest individual contains the configuration that colors the biggest number of nodes from G such that no two adjacent nodes v_i,v_j have the same color. The fitness value of the fittest individual represents the number of edges between adjacent nodes with different coloring. Thus, instead of the randomly generated max value, we can use the number of edges in the graph, and so the search of the highest fitness will occur in the valid individuals area.

In the next step, we apply the Oracle and Grover diffuser m − 1 times, where m is the number of Grover Iterations.

The Oracle operates on the fitness register qubits except the validity qubit v and uses two’s complement number representation for marking the states. As such, by adding − (max + 1), (when $max\in \mathbb{N},max>0$) to the fitness value, the most significant qubit will always be 0. The corresponding basis states are marked by shifting their amplitudes and the fitness value is restored by adding max + 1. This way, the oracle ${\tilde{O}}_{max}(f_{fit}(u))$ is applied

(12) $$|\psi {⟩}_3={\tilde{O}}_{max}|\psi {⟩}_2=(-1{)}^{g(u)}{\displaystyle \frac{1}{\sqrt{2^N}}\sum _{i=0}^{2^N-1}|u{⟩}_i\otimes |f_{fit}(u){⟩}_i}$$such that

(13) $$g(u)=\{\begin{array}{cc}1& if|f_{fit}(u){⟩}_i\ge max\\ 0& otherwise,\end{array}$$

then the corresponding |f_fit(u)⟩_i basis states are marked.

In our algorithm, the oracle is implemented as described in Udrescu, Prodan & Vlăduţiu (2006), using a quantum two’s complement subtractor and a quantum two’s complement adder, and it is then applied on the entire fitness register (except for the validity qubit). By using the two’s complement addition, the correlation between an individual and its corresponding fitness value is not affected because—as presented in Udrescu, Prodan & Vlăduţiu (2006)—the addition is a pseudo-classical permutation function. Figure 4 shows the Oracle circuit implementation, while Algorithm 3 provides the pseudocode for the Oracle description. All basis states for which the fitness value is greater than the number of edges are marked by multiplying their amplitudes with −1. For the subtractor and adder implementation, we use a Quantum Ripple Carry Adder circuit, as presented in Cuccaro et al. (2004). The gate-level implementation of the adder subcircuit is presented in Fig. 5. We analyzed the possibility of using a Quantum Carry Look-Ahead Adder (Cheng & Tseng, 2002), but it presented the disadvantage of a higher number of qubits. Considering M the size of the fitness register and $m=\mathcal{O}\left(\sqrt{2^M}\right)$ the number of Grover Iteration, by using the Ripple Carry Adder circuit we utilize one carry-in qubit and 2 qubits for carry-out in each iteration (1 carry-out qubit for each adder), thus a total of $2\sqrt{2^M}+1$ qubits. For the Quantum Carry Look-Ahead Adder, we need a total of 2(M + 1) carry qubits in each iteration (M + 1 carry qubits for each adder), hence not an acceptable solution to be used in our implementation.

Next, we use the Grover diffuser, G, to augment the amplitude of the marked states, |ψ⟩_i = |f_fit(u)⟩_i with f_fit(u) ≥ 0, in the fitness register:

(14) $$|\psi {⟩}_4=G|\psi {⟩}_3.$$

We update the value of max with the state found. Figure 6 shows the Grover diffuser sub-circuit and its implementation; f is the fitness quantum register, v is the valid qubit and ws is the oracle workspace. In our implementation, we used the Hadamard Gate, the Pauli-X gates and the n-qubit Toffoli gate.

The last step in the algorithm is to measure |ψ⟩_{m − 1} register to obtain the corresponding individual. The measured value represents the solution found to solve the problem.

Complexity analysis

RQGA, as presented in Udrescu, Prodan & Vlăduţiu (2006), is an adaptation of the quantum maximum finding algorithm introduced in Ahuja & Kapoor (1999). According to Ahuja & Kapoor (1999), the algorithm requires $\mathcal{O}\left(\sqrt{N}\right)$ queries made to the oracle. Since in RQGA the initial state processed using Grover’s Algorithm is an equally weighted superposition, it means that no extra Grover Iterations are required in order to augment the amplitudes (Udrescu, Prodan & Vlăduţiu, 2006)—the algorithm maintains the number of steps of the quantum maximum finding algorithm. Thus, RQGA’s complexity is $\mathcal{O}\left(\sqrt{N}\right)$, where N is the search space size.

For solving the graph coloring problem using RQGA, we define a M-qubit fitness quantum register. As shown, the size of the search space is 2^M. Therefore, according to Grover (1996) and Nielsen & Chuang (2002), the number of operations in which the oracle is consulted is $\mathcal{O}\left(\sqrt{2^M}\right)$. Considering that there are N possible solutions to the problem, according to Nielsen & Chuang (2002), the algorithm only needs to consult the oracle $\mathcal{O}\left(\sqrt{\frac{2^M}{N}}\right)$; thus, the complexity of the algorithm in solving the graph coloring problem is $\mathcal{O}\left(\sqrt{\frac{2^M}{N}}\right)$ if there are N possible solutions.

Experimental results

In Supplemental Information, Figs. S1, S2, and S3 we notice that the algorithm finds only the best solutions, starting from the first Grover Iteration. As expected, we achieve the best outcome in terms of the number of best solutions after 4 Grover iterations. In these cases, our algorithm also found the chromatic number.

For the graphs in Fig. S4 from Supplemental Information, and Fig. 8—graphs with a higher number of edges–the algorithm found valid and best solutions, with the best outcome (in terms of number of solutions) obtained after 3 and 4 Grover iterations.

For the graphs presented in Supplemental Information, Figs. S5 and S6, the algorithm determines both the best coloring and chromatic number, with best outcome (in terms of number of solutions) obtained after 3 and 4 Grover iterations. In the case of graphs presented in Figs. S7 and S8 from Supplemental Information, and Fig. 9—graphs with a higher number of edges—the algorithm determined the best coloring after 2 Grover iterations.

In Figs. 10 and 11, we present the relationship between the number of Grover iterations and the minimum, maximum, and average number of valid and best solutions found after testing the node coloring algorithm on graphs with 4 and 5 nodes.

In Figs. 12 and 13, we present the results after using the algorithm to solve the edge coloring problem. For the graph presented in Fig. 12, the algorithm determined the best results after 1 Grover iteration. In Fig. 3, the algorithm finds the best solution after 2 Grover iterations. We obtain the best outcome from the point of view of valid and best solutions, after 3 oracle queries.