Complexity Analysis and Stochastic Convergence of Some Well-known Evolutionary Operators for Solving Graph Coloring Problem

Abstract

The graph coloring problem is an NP-hard combinatorial optimization problem and can be applied to various engineering applications. The chromatic number of a graph G is defined as the minimum number of colors required to color the vertex set V(G) so that no two adjacent vertices are of the same color, and different approximations and evolutionary methods can find it. The present paper focused on the asymptotic analysis of some well-known and recent evolutionary operators for finding the chromatic number. The asymptotic analysis of different crossover and mutation operators helps in choosing the better evolutionary operator to minimize the problem search space and computational complexity. The choice of the right genetic operators facilitates an evolutionary algorithm to achieve faster convergence with lesser population size N through an adequate distribution of promising genes. The selection of an evolutionary operator plays an essential role in reducing the bounds for minimum color obtained so far for some of the benchmark graphs. This research also focuses on the necessary and sufficient conditions for the global convergence of evolutionary algorithms. The stochastic convergence of recent evolutionary operators for solving graph coloring is newly analyzed.

1. Introduction

A simple graph G = (V, E) consists of a set of vertices V = {v₁, v₂, v₃ … v_n} and a set of edges E = {e₁, e₂, e₃ … e_m} such that each e_i (1 ≤ i ≤ m) is uniquely associated with an unordered pair of vertices (v_j, v_k) (1 ≤ j, k ≤ n) and j ≠ k [1,2]. Its adjacency matrix is denoted by A(G), an n × n symmetric matrix where A(j, k) = 1 (1 ≤ j, k ≤ n) if (v_j, v_k) ϵ E(G); and A(j, k) = 0 (1 ≤ j, k ≤ n) otherwise [2].

χ(G), the chromatic number of G, is defined as the minimum number of colors required for V(G) so that no two adjacent vertices are of the same color [2]. The graph coloring problem (GCP) finds the value for χ(G) and applies it to register allocation, channel assignment, image segmentation, resource utilization, and scheduling [3,4,5,6,7,8,9,10]. With the increasing values of n, the complexity of determining χ(G) also increases. GCP is an NP-hard combinatorial optimization problem. Hence, a fast evolutionary and approximation method is expected to reduce the problem search space by maximizing the number of successful runs [1,11,12,13,14,15,16]. Tabu search [17], backtracking [18], branch and bound [11], evolutionary algorithm [19,20,21], branch and cut [22], particle swarm optimization (PSO) [23,24,25,26], ant colony optimization (ACO) [27], local and cuckoo search [28,29] are some existing methods for finding χ(G). Some recent applications of GCP are selective graph coloring [30,31], signed graphs coloring [32,33], scheduling, and resource allocation [7,8,9,10,34,35,36,37,38]. In comparison to other methods, GA is useful for solving multi-objective optimization problems with vast search space. Hence, it is expected to design new evolutionary operators to achieve faster stochastic convergence with minimal generations. Some recent evolutionary operators have achieved near-optimal solutions for some benchmark graphs [4,39,40,41]. Moreover, some recent genetic operators have increased the number of successful runs and reduced expected generations $\overline{g}$, expected crossovers $\overline{c}$, and the expected mutations $\overline{m}$. The notations $\overline{g},\overline{c}$, and $\overline{m}$ indicate respectively the average number of generations, the average number of crossovers, and the average number of mutations performed to obtain the near-optimal solution for the specified number of total runs and generations during the execution of the program. This paper focused on the asymptotic analysis and stochastic convergence of some well-known and current evolutionary operators.

Some of the recent recombination operators are similar to mutation and are executed in place of recombination operation [2]. Some of the well-known and recent recombination operators operate on multiple parent gene sequences [2]. The order-based uniform crossover operator [42] uniformly selects genes from various parents. The penalty based crossover operator [43] generates offspring, which results in a minimum penalty. The one-point and two-point crossover operators generate random numbers and inherit genes from their parents. The graph adapted crossover generates genes based on conflicting and neighboring vertices. The union independent set (UIS) crossover [44] operator unifies the pairs of independent color sets from the selected parents. The greedy partition crossover (GPX) [45] operator divides V(G) into k-sets and generates offspring. The multi-parent crossover [46] operator is the extension of GPX, which creates offspring from multiple parents. The well-informed partition crossover (WIPX) [47] operator selects the color classes from the randomly chosen parents based on a scoring function. The penalty-based color partitioning crossover (PCPX) [48] operator generates offspring based on the partition of V(G) and its penalty. The degree based crossover (DBX) [48] operator applies the heuristics of the largest degree ordering (LDO) to order-based crossover or permutation one point crossover (POP) [40]. POP crossover performs an order-based permutation operation. The multi-point guided crossover (MPGX) [48] operator incorporates problem-specific knowledge. The merging crossover (MOX) [40] operator merges two-parent gene sequences and generates order-based offspring. The merging independent sets (MIS) [40] crossover groups the color sets of parents and generates offspring.

A recent crossover operator, the single parent conflict gene crossover (SPCGX), similar to mutation, is applied to the single parent to identify the conflicting genes and generate better offspring [49]. SPCGX is combined with the conflict gene removal (CGR) procedure to identify and remove some conflicting genes [50]. SPCGX is also connected with the advanced local guided search (ALGS) operator [2] to fine-tune the offspring further and also to reduce the computational complexity. The single parent conflict gene extended crossover (SPCGEX) operator is applied to the selected single parent for fixed iterations. Extended SPCGEX (ESPCGEX) extends SPCGEX with CGR for fixed iterations to produce better offspring. The multipoint SPCGX (MSPCGX) performs several crossovers for conflicting genes. Some of the recent genetic operators have achieved the better solution for some large DIMACS benchmark graphs in the reasonable expected generations [2].

The mutation operators operate on offspring generated by crossover operations. The random mutation operator [43] randomly swaps the color of each vertex with low mutation probability p_m. The polynomial mutation operator rounds off the floating-point color values. The swap mutation is applied to offspring generated by the DBX operator [51]. Problem-specific mutation [51] operators operate on the offspring generated by the MPGX operator. The order mutation (OM) [52] operator generates a random number r and performs r interchanges between vertices. The block mutation (BM) [52] performs the translation of blocks of successive vertices. The color spread mutation (CSM) [52] randomly selects the conflicting edges and moves the genes to new positions. The bad edge stretch mutation (BESM) [52] reduces the number of conflicting edges. The conflict gene mutation (CGM) [2] assigns the conflict-free integers to the offspring and performs fixed iterations. The CGM-CGR operator further reduces the number of conflicts in the offspring. The extended CGM (ECGM) operator fine-tunes the offspring by extending CGM for finite iterations. The multipoint CGM (MCGM) performs multipoint mutations at the conflicting vertices to reduce the number of conflicts.

Section 2 explains the need for complexity analysis and stochastic convergence for evolutionary operators. Section 3 focuses on the general structure of the genetic algorithm for solving GCP. Section 4 and Section 5 explain some of the well-known and recent recombination and mutation operators. The necessary and sufficient condition for the global convergence of evolutionary algorithms and the stochastic convergence of recent genetic operators are newly analyzed in Section 6. Conclusions and future research directions are delineated in Section 7.

2. The Need for Complexity Analysis and Stochastic Convergence of Evolutionary Operators

GCP is very challenging for genetic algorithms because of its vast solution space. Hence, designing and choosing the right genetic operators in population-based methods are important for the following reasons [53,54,55,56]:

• Solution space of GCP consists of nⁿ candidate solutions, and nⁿ rapidly grows with n. The computational complexity of finding χ(G) is proportional to m and n. If the solutions are represented using χ(G) < n, then the solution space contains χ(G)ⁿ assignments. Therefore, the total number of different assignments in the solution space is χ(G)!
• The computational complexity of GCP is reduced only when the values of $\overline{c}$, $\overline{m}$, and $\overline{g}$ are minimized.
• The evolutionary operators are expected to improve the performance of the genetic algorithm by reducing the search space as well as by increasing the successful runs.
• The evolutionary operators should improve the near-optimal solution obtained from the existing methods [11,22,25,26,27,57,58,59].
• The evolutionary operators should avoid additional memory resources and complex computational operations.
• The performance of operators depends on how many parent gene sequences are considered for crossover and mutation. It also depends on the update of gene sequences [4,39,40,41].
• A smaller population size (N ≤ 15) is expected to reduce the complexity and to achieve a sufficient convergence rate. The crossover and mutation operations can be embedded with the right search operators to reduce the value of $\overline{g}$ further.
• The evolutionary operators should effectively distribute the promising genes from one generation to the next generation in order to reduce the fitness function values.
• The graph characteristics, graph instances such as n, m, and graph density, can be considered for choosing the right genetic operators [60].
• The evolutionary operators should quickly converge with the reduced computational complexity.

3. The General Structure of Genetic Algorithm for Solving GCP

Notations

• Degree, $\delta \left(G\right)$ and $\Delta \left(G\right)$
  The number of edges incident on v_i ($1\le i\le n$) is the degree, d(v_i) in G. $\mathrm{Let}\Delta \left(G\right)=\underset{1\le i\le n}{\max }\{d(v_i)|v_i\in V\left(G\right)\}$ and $\delta \left(G\right)=\underset{1\le i\le n}{\min }\{d(v_i)|v_i\in V\left(G\right)\}$ be the maximum and minimum degrees of G respectively.
• Encoding of Gene Sequence
  The color values of V(G) are encoded as (g₁, g₂, g₃ … g_n), where g_j (1 ≤ j ≤ n) is a non-zero integer.
• Density
  The density of G is $\frac{2m}{n\left(n-1\right)}$.
• Population Size, Crossover, Mutation Probability
  p_c is the crossover probability, and the mutation probability is denoted as p_m. P_g is the population, which represents the collection of gene sequences for generation g. N = |P_g| defines the population size for g.
• Fitness Function
  f(G), the general fitness function of G, is the number of distinct genes in the gene sequence [2]. The main objective of GCP is to minimize f(G), hence, χ(G) – f(G) = 0.
• Conflicting Genes
  When g_a = g_b and (v_a, v_b) $\in$ E(G), the genes g_a (1 ≤ a ≤ n) and g_b (1 ≤ b ≤ n) corresponding to vertices v_a and v_b conflict with the gene sequence (g₁, g₂, g₃ … g_n).

The general structure of the genetic algorithm for solving GCP is presented below.

Step 1: Initialization

First, initialize g = 0. The initialization of P_g randomly or heuristically generates values in [1, minimum color].

Step 2: Evaluation of Fitness Function and Selection of Individuals

The fitness of individuals in the population is evaluated, and one or more parent gene sequence(s) are selected for the generation of the subsequent gene sequences. Different selection methods can be applied to select gene sequences for crossover operation.

Step 3: Recombination or Crossover Operation

The recombination operation is performed on the selected gene sequence(s) with probability p_c (high value of p_c, for example, p_c = 0.8) to generate offspring.

Step 4: Performing Mutation

The crossover gene sequences or offspring are mutated with the chosen mutation probability p_m (low value of p_m, for example, p_m = 0.2) to generate new offspring.

Step 5: Termination

Find F_g (offspring) for the updated gene sequence. If F_g (offspring) = 0, the generation of offspring stops; otherwise, P_g is updated (g = g + 1). If F_g (offspring) < F_g−1 (worst), P_g is updated by replacing the worst gene with offspring. Then transfer the control to Step 2 for the next generation.

The pseudo-code of the general genetic algorithm is presented below.

// Pseudo code of the Genetic Algorithm

1: Initialization of individuals;

2: While termination conditions are not satisfied, do

3: Evaluate the fitness function and select better individuals;

4: Perform the recombination operation;

5: Perform the mutation operation;

6: Apply elitism operation;

7: Print the near-optimal results;

4. Asymptotic Analysis of Some Existing Well-known and Recent Crossover Operators

Some of the existing well-known and recent crossover or recombination operators for solving GCP are presented in this section. The asymptotic complexity of these operators is also analyzed in

Table 1. Asymptotic Complexity of Well-known and Recent Crossover Operators.

SNo	Crossover Operator	Asymptotic Complexity
1	Order-based Uniform Crossover	Θ(n)
2	Penalty Based Crossover	Θ(n2 χ(G))
3	One-point Crossover	Θ(n)
4	Two-point Crossover	Θ(n)
5	Graph Adapted Crossover	Θ(n2)
6	UIS Crossover	Θ(n χ(G))
7	Multi-Parent Crossover	Θ(n2)
8	WIPX Crossover	Θ(n2)
9	GPX Crossover	Θ(n2)
10	PCPX Crossover	Θ(n2)
11	DBX Crossover	Θ(n2)
12	MPGX Crossover	Θ(n2)
13	POP Crossover	Θ(n2)
14	MOX Crossover	Θ(n2)
15	MIS Crossover	Θ(n2)
16	SPCGX Crossover	Θ(n2)
17	SPCGX-CGR Crossover	Θ(n2)
18	SPCGEX Crossover	Θ(n2)
19	ESPCGEX Crossover	Θ(n2)
20	MSPCGX Crossover	Θ(n2)

. The simple control constructs if and if-else statements that can be implemented in a constant complexity, Θ(c). The control constructs for, while, do-while, and repeat-until can be implemented in a linear complexity, Θ(n). The quadratic complexity is represented in Θ(n²). For example, color assignments of V(G) can be verified in Θ(n²) complexity.

1.

Order-based Uniform Crossover

The order-based uniform crossover operator uniformly selects the genes from multiple parents. The procedure can be described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Generate the offspring by selecting the first n/2 length of genes from p₁ and the next n/2 length of genes from p₂.

c.

Randomly select any two vertices, v_i and v_j in the offspring, and scramble all vertices between v_i and v_j.

Analysis: Steps (a), (b) and (c) take Θ(n) complexity. Thus the order-based uniform crossover takes Θ(n) complexity.

2.

Penalty Based Crossover

The penalty based crossover operator generates the offspring, which results in a minimum penalty. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Generate the offspring by determining the color for each vertex in every parent by assigning colors, which results in a minimum penalty.

Analysis: Step (a) takes Θ(n) complexity. Step (b) takes Θ(n² χ(G)) complexity. The computational complexity of penalty based crossover is Θ(n² χ(G)).

3.

One-point Crossover

The one-point crossover operator generates random numbers and inherits genes from their parents. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Choose a random point r in between [1, n].

c.

Generate the offspring based on r by inheriting genes from both parents.

Analysis: Step (a) takes Θ(n) complexity. Step (b) can be implemented in constant running time. Step (c) requires Θ(n) complexity. Thus the one-point crossover takes Θ(n) complexity.

4.

Two-point Crossover

The two-point crossover operator generates random numbers and inherits genes from their parents. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Choose two random points, r and s in between [1, n].

c.

Generate the offspring based on r and s by inheriting genes from both parents.

Analysis: Step (a) takes Θ(n) complexity. Step (b) can be implemented in constant running time. Step (c) requires Θ(n) complexity. Thus the two-point crossover takes Θ(n) complexity.

5.

Graph Adapted Crossover

The graph adapted crossover generates genes based on the conflicting and neighboring vertices. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Choose a random vertex v in V(G).

c.

Color the vertices with respect to the parents that have no conflicts for vertex v.

d.

If p₁ and p₂ have conflicts with vertex v then assign the least color to its neighboring vertices.

Analysis: Step (a) takes Θ(n) complexity. Step (b) requires constant running time. Step (c) requires Θ(n²) complexity. Step (d) requires Θ(n²) complexity. The complexity of graph adapted crossover is Θ(n²).

6.

UIS Crossover

The UIS crossover operator unifies a pair of independent color sets from the selected parents. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Find the largest conflict-free subset of vertices having a color c in p₁.

c.

Find the largest conflict-free subset in p₂ such that a common number of vertices in these subsets are maximal.

d.

Repeat the steps (b) and (c) for every color.

e.

Generate the offspring o₁ and o₂ by performing set union operation.

Analysis: Steps (a), (b) and (c) require Θ(n) complexity. Step (d) requires Θ(n χ(G)) complexity. Step (e) requires Θ(n) complexity. Thus the complexity of UIS crossover is Θ(n χ(G)).

7.

Multi-Parent Crossover

Multi-parent crossover is an extension of GPX, which creates offspring from multiple parents. The procedure is described in the following steps.

a.

Select the parent color classes from multiple parents.

b.

Select the largest color class c in the population.

c.

Add the color class c to the offspring.

d.

Remove all vertices in c from all parent color classes.

e.

Repeat the operation until the required number of color classes has reached.

f.

Add the remaining vertices randomly to the color class.

Analysis: Steps (a), (b), (c) require Θ(n) complexity. Steps (d) and (e) require Θ(n²) complexity. Step (f) requires Θ(n) complexity. Thus the complexity of multi-parent crossover is Θ(n²).

8.

WIPX Crossover

The WIPX operator selects the color classes from the randomly selected parents based on a scoring function. The procedure is described in the following steps.

a.

Select the color classes from the randomly chosen parents based on a scoring function.

b.

Determine the score of the color set as:

$$\mathrm{Number}\mathrm{of}\mathrm{conflicts}-\frac{1}{|\mathrm{v}|}\left(\mathrm{classSize}+\mathrm{classDegree}/\left(\mathrm{n}\ast \mathrm{m}\right)\right)$$

where classSize is the cardinality of the color set, and classDegree is the sum of the degrees of the color class vertices.

c.

Apply the multi-parent crossover operation.

Analysis: Step (a) requires Θ(n) complexity. Step (b) requires Θ(n²) complexity. Step (c) requires Θ(n²) complexity. Thus the complexity of WIPX crossover is Θ(n²).

9.

GPX Crossover

GPX operator partitions V(G) into k sets and generates the offspring. The procedure is described in the following steps.

a.

Choose two parent configurations p₁ = (v₁¹, v₂¹, v₃¹… v_k¹) and p₂ = (v₁², v₂², v₃²… v_k²) where k is the number of color classes.

b.

For each j (1 ≤ j ≤ k) do

If j is odd then s =1, else s = 2;

Select i such that v_i^s has maximum vertices;

v_j = v_i^s;

Remove v_j from both p₁ and p₂

c.

Choose a random color class and assign V−(v₁ ∪ v₂ ∪ v₃… ∪ v_k).

d.

Generate an offspring o₁ = (v₁, v₂, v₃… v_k).

Analysis: Step (a) requires Θ(n) complexity. Step(b) requires Θ(n²) complexity. Steps (c) and (d) require Θ(n) complexity. Thus GPX crossover takes Θ(n²) complexity.

10.

PCPX Crossover

PCPX crossover operator generates offspring based on partitions of V(G) and its penalty. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Consider one parent at a time.

c.

Extract a subpartition V’(G), which results in a minimum penalty among V(G) of the main partition.

d.

Color V’(G) for the selected parent.

e.

Remove V’(G) in both parents.

f.

Find the largest color partition for the next parent.

g.

Repeat the procedure until all vertices in the offspring are colored.

Analysis: Step (a) requires Θ(n) complexity. Step(b) takes constant running time. Steps (c), (d), (e), (f) and (g) take Θ(n²) complexity. Thus PCPX crossover takes Θ(n²) complexity.

11.

DBX Crossover

DBX crossover operator applies the heuristics of LDO in order based crossover or POP. The procedure is described in the following steps.

a.

Apply the heuristics of LDO in order based crossover or POP operator.

b.

Select a pair of random individuals, say P₁ and P₂.

c.

Select a random crossover point r in P₁.

d.

Copy the vertex colors starting at an initial point to r in P₁ into the offspring O₁;

e.

Choose a vertex u in P₂ and v in O₁.

f.

If u is not assigned an order in O₁ and if degree(v) < degree(u) then

Find the vertex v having minimum order in O₁ with degree(v) < degree(u);

Increment the vertex orders by 1 for all vertices having order ≥ v;

Assign vertex u to the order of vertex v;

Else assign the least available order to vertex u.

Analysis: Step (a) requires Θ(n²) complexity. The selection and copy operations in steps (b), (d), and (e) require Θ(n) complexity. Step(c) takes a constant running time. Step (f) requires Θ(n²) complexity. Thus DBX takes Θ(n²) complexity.

12.

MPGX Crossover

MPGX operator incorporates problem-specific knowledge. The procedure is described in the following steps.

a.

Select a pair of random individuals, say P₁ and P₂;

b.

Choose a random crossover point;

c.

Assign count = Pc * n;

d.

While count ≠ 0 do

Select a random vertex i;

c₁= color[i] in P₁;

c₂ = color[i] in P₂;

If c₁ ≠ c₂ and if penalty of P₁ reduces with c₂ then replace c₁ by c₂;

If c₁ ≠ c₂ and if penalty of P₂ reduces with c₁ then replace c₂ by c₁;

count = count − 1

e.

Generate offspring.

Analysis: Step (a) requires Θ(n) complexity. Steps (b), (c), and (e) take a constant running time. Step (d) takes Θ(n²) complexity. Thus MPGX crossover takes Θ(n²) complexity.

13.

POP Crossover

POP crossover performs an order based permutation operation. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Choose a random point r in between [1, n].

c.

Apply order based crossover.

d.

Swap the first portion of strings and apply permutation on the remaining unused vertices copied in the sequence.

Analysis: Steps (a) and (c) require Θ(n) complexity. Step (b) requires a constant running time. Step (d) requires Θ(n²) complexity. Thus the complexity of POP crossover is Θ(n²).

14.

MOX Crossover

The MOX operator performs merging of two-parent gene sequences and generates the order based offspring. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Merge p₁ and p₂ randomly into a single list, which consists of 2n elements.

c.

Assign the first occurrence of each gene to offspring₁.

d.

Assign the second occurrence of each gene to offspring₂.

Analysis: Steps (a) and (b) require Θ(n) complexity. Steps (c) and (d) take Θ(n²) complexity. The complexity of MOX crossover is Θ(n²).

15.

MIS Crossover

The MIS crossover operator groups the color sets of parents and generates the offspring. The procedure is described in the following steps.

a.

Select two parent gene sequences, say p₁ and p₂.

b.

Group the color sets in both p₁ and p₂.

c.

Copy the whole color sets from p₁ and p₂ into a single merged list.

d.

Assign the first occurrence of each gene into offspring₁.

e.

Assign the second occurrence of each gene into offspring₂.

Analysis: Steps (a), (b) and (c) require Θ(n) complexity. Steps (d) and (e) take Θ(n²) complexity. The complexity of MIX crossover is Θ(n²).

16.

SPCGX Crossover

SPCGX operation is applied to the selected gene sequences, i and j, to generate two new gene sequences as offspring. The offspring, iʹ and jʹ are generated by a chosen crossover probability p_c. SPCGX operator is defined as follows [50]:

a.

Let i = (i₁, i₂, i₃ … i_q … i_r … i_n) and j = (j₁, j₂, j₃ … j_s … j_t … j_n) be the two selected sequences.

b.

Generate random probability p_cr.

c.

If p_cr > p_c go to step (d).

d.

Find all pairs of conflicting edges in i and j.

e.

Let (q, r) and (s, t) be such two pairs of conflicting edges (i.e., i_q = i_r and j_s = j_t) in i and j, then generate two offspring: (i₁, i₂, i₃ … i_q … i_r+1 … i_n) and (j₁, j₂, j₃ … j_s … j_t+1 ... j_n).

f.

Repeat step (e) of crossover operation to all the identified conflicting pairs in step (d) of crossover operation and generate updated gene sequences i’ = (i_1’, i_2’, i_3’ … i_f’… i_g’ … i_n’) and j’ = (j_1’, j_2’, j_3’ … j_k’ … j_l’ …, j_n’).

Analysis: Step (a) requires Θ(n) complexity. Steps (b), (c), and (e) take a constant running time. Steps (d) and (f) require Θ(n²) complexity. SPCGX takes Θ(n²) complexity.

17.

SPCGX-CGR Crossover

SPCGX is applied with a CGR procedure with a chosen p_c. SPCGX-CGR is given in the following steps [50]:

a.

Apply the steps (a) to (e) of SPCGX crossover.

b.

Check if the new genes at r and t (i.e., i_r and j_t) corresponding to an edge (r, t) are in conflict with its corresponding adjacent genes. If so, generate i_r = i_r + 1 and j_t = j_t + 1 such that i_r + 1 ≤ χ(G) and j_t + 1 ≤ χ(G).

c.

Repeat step (f) of SPCGX with CGR procedure to all the conflicting pairs and generate updated gene sequences: i’ = (i_1’, i_2’, i_3’ … i_n’) and j’ = (j_1’, j_2’, j_3’ … j_n’).

Analysis: Steps (a) and (c) require Θ(n²) complexity. Step (b) takes a constant running time. SPCGX-CGR takes Θ(n²) complexity.

18.

SPCGEX Crossover

The SPCGEX operator is applied on the selected gene sequences i = (i₁, i₂, i₃ … i_n) and j = (j₁, j₂, j₃ … j_n) as follows [2]:

a.

Randomly select any two most conflicting vertices, r, and t in gene sequences i and j.

b.

Generate offspring (i₁, i₂, i₃ … i_r+1 … i_n) and (j₁, j₂, j₃ … j_t+1 … j_n) such that i_r + 1 ≤ minimum color and 1 + j_t ≤ minimum color.

c.

Repeat the steps (a) and (b) for fixed iterations to obtain the updated offspring i’ and j’ as (i_1’, i_2’, i_3’ … i_n’) and (j_1’, j_2′, j_3’ … j_n’).

Analysis: Steps (a) and (c) require Θ(n²) complexity. Step (b) takes a constant running time. SPCGEX takes Θ(n²) complexity.

19.

ESPCGEX Crossover

The steps in ESPCGEX crossover are defined as follows [2].

a.

Perform SPCGEX crossover steps (a) and (b).

b.

If the new genes i_r and j_t are conflicting, then apply SPCGEX at the conflicting edges (q, r) and (s, t).

c.

Repeat the steps (a) and (b) for fixed iterations to obtain the updated offspring i’ and j’ as (i_1’, i_2’, i_3’ … i_n’) and (j_1’, j_2’, j_3’ … j_n’).

Analysis: Steps (a), (b) and (c) require Θ(n²) complexity. Hence ESPCGEX takes Θ(n²) complexity.

20.

MSPCGX Crossover

The steps in MSPCGX crossover are defined as follows [2].

a.

Find the conflicting edges that count to every vertex in gene sequences j and i.

b.

Determine the conflicting vertices in j and i.

c.

Select arbitrarily conflicting vertices, r in i and t in j.

d.

Update i and j as (i₁, i₂, i₃ … i_r+1 … i_n) and (j₁, j₂, j₃ … j_t+1 … j_n) such that minimum color ≥ i_r + 1 and minimum color ≥ j_t + 1.

e.

If the new genes i_r and j_t are conflicting, then generate i_r = i_r + 1 and j_t = j_t + 1 such that minimum color ≥ i_r + 1 and minimum color ≥ j_t + 1.

f.

Repeat the steps (d)–(e) for remaining conflicting vertices and update i’ and j’ as (i_1’, i_2’, i_3’ … i_n’) and (j_1’, j_2’, j_3’ … j_n’).

Analysis: Steps (a), (b), (e) and (f) require Θ(n²) complexity. Step (c) takes Θ(n) complexity. Step (d) takes a constant running time. MSPCGX takes Θ(n²) complexity.

5. Asymptotic Analysis of Some Existing Well-known and Recent Mutation Operators

Some of the existing well-known and recent mutation operators for solving GCP are presented in this section. The asymptotic complexity of these operators is also analyzed. The asymptotic complexity of these operators is also analyzed in

Table 2. Asymptotic Complexity of Well-known and Recent Mutation Operators.

SNo	Mutation Operator	Asymptotic Complexity
1	Random Mutation	Θ(n)
2	Polynomial Mutation	Θ(c)
3	Problem-Specific Mutation 1	Θ(n2)
4	Problem-Specific Mutation 2	Θ(n2)
5	Problem-Specific Mutation 3	Θ(n2)
6	OM	Θ(n)
7	BM	Θ(n)
8	CSM	Θ(n)
9	BESM	Θ(n2)
10	CGM	Θ(n2)
11	CGM-CGR	Θ(n2)
12	ECGM	Θ(n2)
13	MCGM	Θ(n2)

.

1.

Random Mutation

The random mutation operator randomly swaps the color of each vertex with a low mutation probability p_m. The procedure is described in the following steps.

a.

Select crossover offspring o₁.

b.

Randomly swap the color class of each vertex with a low p_m.

Analysis: Step (a) requires a constant running time. Step (b) takes Θ(n) complexity. Thus the random mutation takes Θ(n) complexity.

2.

Polynomial Mutation

The polynomial mutation operator rounds off real values of colors to the nearest integer. The procedure is described in the following steps.

a.

Select crossover offspring o₁.

b.

Choose the random point and round off real values of colors to the nearest integer.

Analysis: Steps (a) and (b) require a constant running time. Thus the polynomial mutation takes Θ(c) complexity.

3.

Problem-Specific Mutation 1

The problem-specific mutation operator is defined with problem-specific knowledge. It is operating on the offspring generated by MPGX operator. The procedure is described in the following steps.

a.

Select crossover offspring o₁.

b.

Find the missing color c₁ in the range of maximum color [1, maximum color] used.

c.

Identify all the vertices V’(G) assigned with maximum color.

d.

Replace colors of V’(G) by c₁.

Analysis: Step (a) requires a constant running time. Steps (b) and (c) take Θ(n²) complexity. Step (d) takes Θ(n) complexity. This mutation takes Θ(n²) complexity.

4.

Problem-Specific Mutation 2

The problem-specific mutation operator is defined with problem-specific knowledge. It operates on the offspring generated by MPGX operator. The procedure is described in the following steps.

a.

Choose color c₁ randomly within one less than [1, maximum color].

b.

Identify all the vertices V’(G) assigned to a maximum color.

c.

Replace colors of V’(G) by c₁.

Analysis: Step (a) requires a constant running time. Step (b) takes Θ(n²) complexity. Step (c) takes Θ(n) complexity. This mutation takes Θ(n²) complexity.

5.

Problem-Specific Mutation 3

The problem-specific mutation operator is defined with problem-specific knowledge. It operates on the offspring generated by MPGX operator. The procedure is described in the following steps.

a.

Choose a vertex v randomly.

b.

Choose a color c randomly for v.

c.

If the penalty is reduced to v with color c, then set color[v] = c.

Analysis: Steps (a) and (b) require a constant running time. Step (c) takes Θ(n²) complexity. This mutation takes Θ(n²) complexity.

6.

OM

The OM operator generates a random number r and performs r interchanges between vertices. The procedure is described in the following steps.

a.

Let (v₁, v₂, v₃ … v_n) be the crossover offspring.

b.

Generate a random number r;

c.

Generate the offspring by performing r interchanges between vertices.

Analysis: Steps (a) and (b) require a constant running time. Performing r interchanges in Step(c) can also be done in linear time. The OM mutation takes Θ(n) complexity.

7.

BM

The BM operation performs a translation of blocks of k > 0 successive vertices. The procedure is described in the following steps.

a.

Let (v₁, v₂, v₃ … v_n) be the crossover offspring.

b.

If k = 2 and i $\in$ [1, n−1], j $\in$ [1, n] are randomly generated then generate the offspring (v₁, ….v_i−1, v_i+2… v_j, v_i, v_i+1, v_{j+1 …}).

Analysis: Step (a) requires a constant running time. Step (b) can take Θ(n) complexity. Thus BM operation takes Θ(n) complexity.

8.

CSM

The CSM randomly selects the conflicting edge and moves the genes to new positions. The procedure is described in the following steps.

a.

Let (v₁, v₂, v₃ … v_n) be the crossover offspring.

b.

Choose a randomly selected bad edge e = (v_i, v_j) and e’ = (v_k, v_l) be the next bad edge such that (i < j < k < l).

c.

Move the vertices from positions i + 1 to l − 1 to randomly chosen new positions.

Analysis: Step (a) requires a constant running time. Steps (b) and (c) need Θ(n) complexity.

9.

BESM

The BESM operation reduces the number of conflicting edges. The procedure is described in the following steps.

a.

Let (v₁, v₂, v₃ … v_n) be the crossover offspring.

b.

Choose a random bad edge e = (v_i, v_j).

c.

Choose a direction either left-to-right or right-to-left randomly.

d.

Let v_k be the farthest vertex adjacent to v_i so that k > j.

e.

Let e’ = (v_l, v_m) be the first bad edge so that l > k.

f.

If there is no vertex v_k or edge e’ with the specified properties, the mutation is void. Otherwise, the vertex v_i is moved to the position m + 1.

Analysis: Steps (a), (c) require a constant running time. Step (b) takes Θ(n²) complexity. Steps (d), (e) and (f) take Θ(n) complexity. Hence BESM takes Θ(n²) complexity.

10.

CGM

The CGM operates on offspring i’ and j’. The steps are given below [49]:

a.

Select any two conflicting genes i’_fʹ = i’_g’ and j’_k’ = j’_l’ in i’ and j’.

b.

Update i’ and j’ as (i_1’, i_2ʹ, i_3’ … i_f’−1 … i_n’) and (j_1’, j_2’, j_3’ … j_k’−1 … j_n’) such that 1 ≤ i_f’−1 and 1 ≤ j_k’−1.

c.

Update i” and j” as (i_1”, i_2”, i_3” … i_n”) and (j_1”, j_2”, j_3” … j_n”) by repeating steps (a)-(b) for fixed iterations.

Analysis: Steps (a) and (c) require Θ(n²) complexity. Step (b) requires a constant running time. Hence CGM mutation takes Θ(n²) complexity.

11.

CGM-CGR Mutation

The CGM-CGR mutation is applied to the offspring i’ and j’ and its steps are given below [50]:

a.

Perform CGM steps (a)–(b).

b.

If the new genes i_{f ʹ} and j_kʹ are conflicting then update i_f’ = i_f’−1 and j_k’ = j_k’−1 such that 1 ≤ i_f’−1 and 1 ≤ j_k’−1.

c.

Update i” and j” as (i_1”, i_2”, i_3” … i_n”) and (j_1”, j_2”, j_3” … j_n”) by repeating steps (a)–(b) for fixed iterations.

Analysis: Steps (a), (b) and (c) require Θ(n²) complexity. Hence CGM-CGR mutation takes Θ(n²) complexity.

12.

ECGM

The ECGM operation is defined as follows [2]:

a.

Perform CGM steps (a) and (b).

b.

If new genes i’_f’ and j’_k’ are conflicting, then perform CGM at f’ and k’.

c.

Update i” and j” as (i_1”, i_2”, i_3” … i_n”) and (j_1”, j_2”, j_3” … j_n”) by repeating steps (a) and (b) for fixed iterations.

Analysis: Steps (a), (b) and (c) require Θ(n²) complexity. Hence ECGM takes Θ(n²) complexity.

13.

MCGM

The MCGM operation is defined as follows [2]:

a.

Find the conflict edges count to every vertex in i’ and j’.

b.

Determine the conflict vertices in i’ and j’.

c.

Select arbitrarily two conflicting vertices f’ in i’ and k’ in j’.

d.

Update i’ and j’ as (i₁’, i₂’, i₃’ … i_f’−1 … i_n’) and (j₁’, j₂’, j₃’ … j_k’−1 … j_n’) such that 1 ≤ i_f’−1 and 1 ≤ j_k’−1.

e.

If new genes i’_f’ and jʹ_k’ are conflicting then perform CGM at f’ and k’.

f.

Update i” and j” as (i_1”, i_2”, i_3” … i_n”) and (j_1”, j_2”, j_3” … j_n”) by repeating steps (d) and (e) for fixed iterations.

Analysis: Steps (a), (b), (e) and (f) require Θ(n²) complexity. Steps (c) and (d) take Θ(c) complexity. Hence MCGM takes Θ(n²) complexity.

6. Global Convergence of Evolutionary Algorithms and Stochastic Convergence of Recent Genetic Operators

The necessary and sufficient condition for the global convergence of evolutionary algorithms is proved in this section [61,62]. The stochastic convergence of some recent genetic operators for solving GCP is also proved in the present section [2].

6.1. Markov Chain Model of Evolutionary Algorithms

Consider the following optimization problem:

Optimize {f(x); x $\in$ S} where S is a measurable space, f(x) is the objective or fitness function where the absolute value of (f(x)) is < +∞.

Represent the optimal solution set by S^* = {x^* such that f(x*) = optimize f(x), x $\in$ S}.

Let μ(S) be a measure to space S with μ(S^*) > 0.

Consider the set S^*_δ = {x such that f(x^*) − f(x) < δ} where δ > 0 is a small number.

Choose an appropriate δ to satisfy μ(S^*_δ) > 0.

The space S is called an individual space where each state s in S is called an individual.

N represents population size.

X = S^N is the population space.

Denote the elements in x as x = {x₁, x₂, x₃ … x_N}.

Denote the optimal solution set X^* = {x^* such that $\exists$ x_i $\in$ x: x_i $\in$ S*}.

An evolutionary algorithm to solve this optimization problem is formulated as follows:

a.

Initialization: Generate initial population P₀ at generation g = 0.

b.

Crossover operation: Update the new population P_t by a crossover operator P_C(g).

c.

Mutation operation: Update the new population P_t by a mutation operator P_M(g).

d.

Selection operation: Select a new population from P_M(g) by a selection operator P_S(g).

e.

Termination: If termination conditions hold, then stop; otherwise g = g + 1 and update P_g.

Since the state of P_g+1 is only dependent on the state of P_g, then {P_g: g = 0, 1, 2…} can be modeled by a Markov chain with the following transition function [61,62]:

$$\begin{gathered} P(g;x,dy)=P(P_g{+}_1=dy\mathrm{such}\mathrm{that}{P}_g=x) \\ ={{\displaystyle \int }}_{u\in X}{{\displaystyle \int }}_{v\in X}{P}_C(g;x,du)P_M(g;u,dv)P_S(g;v,dy) \end{gathered}$$

(1)

Then {P_g: g = 0, 1, 2…} converges to X^*, if for any initial population P₀,

$$\underset{g\to +\infty }{lim}{\mu }_g\left(X^{*}\right)=1^{}\mathrm{where}{\mu }_g\left(X^{*}\right)=\mu (P_g\in X^{*}).$$

6.2. Convergence Conditions of Evolutionary Algorithms

The necessary and sufficient condition for the convergence of evolutionary algorithms is as follows [61,62]:

Let {P_g: g = 0, 1, 2…} be the Markov chain given by (1). Define $\alpha \left(g\right)$ as the difference between flow from the non-optimal solution set to the optimal solution set and vice versa.

$$\alpha \left(g\right)=\underset{x\notin X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1}\in X^{*}|P_g=x){\mu }_g(dx)-\underset{x\in X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1}\notin X^{*}|P_g=x){\mu }_g(dx)$$

Then {P_g: g = 0, 1, 2…} converges to the optimal solution set X* iff

$${\displaystyle \sum }_{g=0}^{+\infty }\alpha \left(g\right)=1-{\mu }_0\left(X^{*}\right)$$

Proof: For any given generation g, we have

$${\mu }_{g+1}(X^{*})=\underset{x\notin X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1}\in X^{*}|P_g=x){\mu }_g(dx)+\underset{x\in X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1}\notin X^{*}|P_g=x){\mu }_g(dx)$$

$$\begin{gathered} {\mu }_{g+1}(X^{*})={\mu }_g(X^{*})-\underset{x\in X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1}\notin X^{*}|P_g=x){\mu }_g(dx)+\underset{x\notin X^{*}}{\overset{}{{\displaystyle \int }}}P(P_{g+1} \\ \in X^{*}|P_g=x){\mu }_g(dx) \end{gathered}$$

$$⇨{\mu }_{g+1}\left(X^{*}\right)-{\mu }_g\left(X^{*}\right)=\alpha \left(g\right)$$

$$⇨{\mu }_{g+1}\left(X^{*}\right)-{\mu }_0\left(X^{*}\right)={{\displaystyle \sum }}_{k=0}^g\alpha \left(k\right)$$

$$⇨\underset{g\to +\infty }{\lim }{\mu }_{g+1}\left(X^{*}\right)=1⟺{{\displaystyle \sum }}_{k=0}^{+\infty }\alpha \left(k\right)=1-{\mu }_0{\left(X^{*}\right)}^{}{}^{}$$

The initial population P₀ is not optimal, that is, ${\mu }_0\left(X^{*}\right)$ = 0. Then

$${\displaystyle \sum }_{g=0}^{+\infty }\alpha \left(g\right)=1∎$$

6.3. Stochastic Convergence of Recent Evolutionary Operators

Some of the recent genetic operators like SPCGX, SPCGEX, ESPCGEX, ECGM, MSPCGX, and MCGM modify P_g through successive stochastic transformations, which can be analyzed by the Markovian model. The subsequent value of P_g+1 is generated stochastically, and the evolutionary algorithm converges when the reachability and monotone conditions are fulfilled [2,41,63]. Some of the recent genetic operators converge stochastically.

6.3.1. Analyzing the Reachability Condition from j’

If j and j” be any two individuals in the finite search space S, then j” is reachable from individual j. That is, j’ = (j_1’, j_2’, j_3’ … j_n’) and j”= (j_1”, j_2”, j_3” … j_n”) are the two gene sequences generated from the gene sequences j = (j₁, j₂, j₃ … j_n) and j_’ = (j_1’, j_2’, j_3’ … j_n’) respectively. If (0 < Probability {j” = (crossover (j) & mutation (j’))} < 1) then the individual jʺ is reachable from individual jʹ [2].

First, consider the effect of crossover operation. Let S be the finite search space of the problem. Consider a gene sequence j $\in$ S such that j = (j₁, j₂, j₃ … j_n). The proposed crossover operators (incremental operators) SPCGX and SPCGEX produce a new gene as j_r = j_r + 1 if minimum color ≥ j_r + 1. Hence the new gene takes one of the values in (j_r, j_r+1). The CGR operator further checks the conflict at vertex r. If there is a conflict, then the new gene at vertex r is generated as j_r = j_r + 1 such that minimum color ≥ j_r + 1. Clearly, j_r assumes the value in (j_r, j_r + 1, j_r + 2). Thus the required probability of assigning a new gene at the conflicting vertex is 1/3 for a single crossover operation. Assume that the crossover operation is performed for k times.

⇨ Probability {j’ = crossover (j)} = 1/3^k > 0 (1 ≤ j, j’ ≤ N), k > 0

(2)

Now consider the effect of mutation operation. The recent mutation operators set a value of the conflicting gene in [1, f(G)]. Thus the required probability of assigning a gene at the conflicting vertex is 1/f(G) for a single mutation operation. Assume that the mutation operation is performed for l times.

⇨ Probability {j” = mutation (j’)} = 1/f(G)^l > 0, l > 0.

(3)

For the chosen crossover probability p_c and mutation probability p_m, the probability of generating new gene sequence j” is computed using the multiplication theorem of probability. The crossover and mutation operations are mutually independent. Hence the required probability of generating j” is computed as follows:

Probability of {j” = (crossover (j) & mutation (j’))} ≥

(Crossover probability) × (Probability of generating j’ from j) × (Mutation
probability) × (Probability of generating j” from j’)

That is

Probability of {j” = (crossover (j) & mutation (j’))} ≥ p_c. Probability {j’ = Crossover
(j)}.p_m. Probability {j” = Mutation (j’)}

(4)

$$\mathrm{Probability}\mathrm{of}(j\text{”}=\left(crossover\left(j\right)\&mutation\left(j\text{’}\right)\right)\}\ge p_c{p}_m\frac{1}{3^{\mathrm{k}}}\raisebox{1ex}{$1$}\!\left/ \!\raisebox{-1ex}{${\left(\mathrm{f}\left(\mathrm{G}\right)\right)}^{\mathrm{l}}$}\right.\text{>}0$$

Hence the gene sequence jʺ is reachable from j’.

6.3.2. Analyzing whether P_g is Monotone

During the iterations of an evolutionary algorithm, P_g is modified by successive probabilistic transformations. The proportionate fitness selection selects one worst and two better gene sequences in every generation as follows:

a.

Evaluate F_g(a) for each gene sequence a (1 ≤ a ≤ N) in P_g.

b.

Determine p(a) using

$$p\left(a\right)=F_g\left(a\right)/{\displaystyle \sum }_{a=1}^N{F}_g\left(a\right)$$

c.

Compute E(a) = N p(a) for all a (1 ≤ a ≤ N).

d.

Select the better gene sequences i and j and the worst gene sequence w.

The probability of selection of i and j is always greater than zero. P_g is then updated by performing the elitism operation.

The recombination and mutation operations are performed based on the values of p_cr and p_mr. For small graphs, some of the recent operators monotonically reduce F_g (i) and F_g(j) during the modification of population by a finite number of probabilistic transformations [2]:

1.

The values of F_g (i) and F_g (j) monotonically decreases in subsequent generations and converge to a better near-optimal solution.

That is, either F₀(i) ≥ F₁(i) ≥ F₂(i) ≥ … ≥ (F_q(i) = 0) or F₀(j) ≥ F₁(j) ≥ F₂(j) ≥ … ≥ (F_q(j) = 0).

2.

F_g (i) and F_g (j) monotonically decrease for a finite number of generations (say t).

i.e., F₀(i) ≥ F₁(i) ≥ F₂(i) ≥ … ≥ F_t(i) and F₀(j) ≥ F₁(j) ≥ F₂(j) ≥ … ≥ F_t(j).

Then, based on the values of p_cr and p_mr, the fitness-function values again increase for a finite number of generations (say s).

i.e., F_t(i) ≤ F_t+1(i) ≤ …≤ F_s(i) and F_t(j) ≤ F_t+1(j) ≤…≤ F_s(j).

For complex graphs, the successive probabilistic transformations find a better near-optimal solution after a finite number of generations. Hence, the successive probabilistic changes utilize P_g as a monotone in some of the subsequent generations to achieve a better near-optimal solution. These successive probabilistic changes, applying for over a large number of generations, for example, 1000 runs each with 5,000,000 generations of the genetic algorithm, achieve a better near-optimal solution [2].

7. Conclusions and Future Work

GCP is an NP-hard combinatorial optimization problem and can be applied to innumerable engineering problems. χ(G) can be obtained using different approximations and evolutionary methods. In comparison to other methods, genetic algorithms are useful in solving multi-objective optimization problems with vast search space [2]. Hence, it is expected to design new evolutionary operators to achieve faster stochastic convergence with a minimal number of generations.

This paper explored the asymptotic analysis of some well-known and recent evolutionary operators for finding chromatic numbers. The asymptotic analysis of different crossover and mutation operators helps in minimizing problem search space and computational complexity. The choice of the right genetic operators facilitates an evolutionary algorithm to achieve faster convergence with lesser population size (N) through an effective distribution of promising genes. The selection of evolutionary operators also plays an essential role in reducing the bounds for minimum color obtained for the benchmark graphs [2]. The necessary and sufficient condition for global convergence of the evolutionary algorithm and the stochastic convergence of some recent evolutionary operators for solving GCP are analyzed in this paper.

Our current work enlightens some new research directions [64,65,66].

i.

The recent genetic operators can be combined with better local search strategies in order to further reduce the computational complexity of GCP.

ii.

The self-adaptive evolutionary operators with heuristics can be designed to find chromatic numbers as well as can be applied to channel allocation problem (CAP) and scheduling problems. CAP is an extension of GCP, which assigns channels to mobile stations.

iii.

The performances of some recent operators can be evaluated under different parameter values, such as graph density, N, p_c, and p_m.

iv.

Some of the recent operators can be combined to reduce $\overline{g}$.

v.

The stochastic convergence of genetic algorithms can be extended to multi-objective optimization problems, and the necessary conditions for the global convergence of multi-objective optimization problems can be analyzed mathematically.

vi.

An algebraic framework that may lead to a unification of different evolutionary operators for combinatorial problems can be designed and analyzed [64,65,66].