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

: 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.


Introduction
A simple graph G = (V, E) consists of a set of vertices V = {v1, v2, v3 … vn} and a set of edges E = {e1, e2, e3 … em} such that each ei (1 ≤ i ≤ m) is uniquely associated with an unordered pair of vertices (vj, vk) (1 ≤ j, k ≤ n) and j ≠ k [1,60]. Its adjacency matrix is denoted by A(G), an n × n symmetric matrix where A(j, k) = 1 (1 ≤ j, k ≤ n) if (vj, vk) ϵ E(G); and A(j, k) = 0 (1 ≤ j, k ≤ n) otherwise [60]. χ(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 [60]. The graph coloring problem (GCP) finds the value for χ(G) and applies it to register allocation, channel assignment, image segmentation, resource utilization, and scheduling [2][3]29,34,[40][41][42][43]. 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,7,11,[14][15][16][17]. Tabu search [4], backtracking [9], branch and bound [7], evolutionary algorithm [13,[54][55], branch and cut [8], particle swarm optimization (PSO) [18][19][25][26], ant colony optimization (ACO) [24], local and cuckoo search [20,22] are some existing methods for finding χ(G). Some recent applications of GCP are selective graph coloring [36,37], signed graphs coloring [38,39], scheduling, and resource allocation [40][41][42][43][44][45][46][47][48]. 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 [3,[5][6]10]. Moreover, some recent genetic operators have increased the number of successful runs and reduced expected generations , expected crossovers ̅ , and the expected mutations . The notations , ̅ , and 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 [60]. Some of the well-known and recent recombination operators operate on multiple parent gene sequences [60]. The order-based uniform crossover operator [49] uniformly selects genes from various parents. The penalty based crossover operator [50] 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 [51] operator unifies the pairs of independent color sets from the selected parents. The greedy partition crossover (GPX) [31] operator divides V(G) into k-sets and generates offspring. The multi-parent crossover [52] operator is the extension of GPX, which creates offspring from multiple parents. The well-informed partition crossover (WIPX) [53] operator selects the color classes from the randomly chosen parents based on a scoring function. The penalty-based color partitioning crossover (PCPX) [21] operator generates offspring based on the partition of V(G) and its penalty. The degree based crossover (DBX) [21] operator applies the heuristics of the largest degree ordering (LDO) to order-based crossover or permutation one point crossover (POP) [6]. POP crossover performs an order-based permutation operation. The multi-point guided crossover (MPGX) [21] operator incorporates problem-specific knowledge. The merging crossover (MOX) [6] operator merges two-parent gene sequences and generates order-based offspring. The merging independent sets (MIS) [6] 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 [32]. SPCGX is combined with the conflict gene removal (CGR) procedure to identify and remove some conflicting genes [33]. SPCGX is also connected with the advanced local guided search (ALGS) operator [60] 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 [60].
The mutation operators operate on offspring generated by crossover operations. The random mutation operator [50] randomly swaps the color of each vertex with low mutation probability pm. The polynomial mutation operator rounds off the floating-point color values. The swap mutation is applied to offspring generated by the DBX operator [56]. Problem-specific mutation [56] operators operate on the offspring generated by the MPGX operator. The order mutation (OM) [57] operator generates a random number r and performs r interchanges between vertices. The block mutation (BM) [57] performs the translation of blocks of successive vertices. The color spread mutation (CSM) [57] randomly selects the conflicting edges and moves the genes to new positions. The bad edge stretch mutation (BESM) [57] reduces the number of conflicting edges. The conflict gene mutation (CGM) [60] 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. Sections 4 and 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.

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 [35,[61][62][63]: 1. Solution space of GCP consists of n n candidate solutions, and n 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) n assignments. Therefore, the total number of different assignments in the solution space is χ(G)! 2. The computational complexity of GCP is reduced only when the values of ̅ , , and are minimized. 3. 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. 4. The evolutionary operators should improve the near-optimal solution obtained from the existing methods [7][8][23][24][25][26]28,30]. 5. The evolutionary operators should avoid additional memory resources and complex computational operations. 6. 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 [3,5-6,10]. 7. 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 ̅ further. 8. The evolutionary operators should effectively distribute the promising genes from one generation to the next generation in order to reduce the fitness function values. 9. The graph characteristics, graph instances such as n, m, and graph density, can be considered for choosing the right genetic operators [27]. 10. The evolutionary operators should quickly converge with the reduced computational complexity.

Degree, and ∆
The number of edges incident on vi ( 1 be the maximum and minimum degrees of G respectively.

Encoding of Gene Sequence
The color values of V(G) are encoded as (g1, g2, g3 … gn), where gj (1 ≤ j ≤ n) is a non-zero integer.

Density
The density of G is .

Population Size, Crossover, Mutation Probability
pc is the crossover probability, and the mutation probability is denoted as pm. Pg is the population, which represents the collection of gene sequences for generation g. N = |Pg| 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 [60]. The main objective of GCP is to minimize f(G), hence, χ(G) -f(G) = 0.
The general structure of the genetic algorithm for solving GCP is presented below.
Step 1: Initialization First, initialize g = 0. The initialization of Pg 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 pc (high value of pc, for example, pc = 0.8) to generate offspring.
Step 4: Performing Mutation The crossover gene sequences or offspring are mutated with the chosen mutation probability pm (low value of pm, for example, pm = 0.2) to generate new offspring.
Step 5: Termination Find Fg (offspring) for the updated gene sequence. If Fg (offspring) = 0, the generation of offspring stops; otherwise, Pg is updated (g = g + 1). If Fg (offspring) < Fg−1 (worst), Pg 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.

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. 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 2 ). For example, color assignments of V(G) can be verified in Θ(n 2 ) complexity.

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 p1 and p2. b. Generate the offspring by selecting the first n/2 length of genes from p1 and the next n/2 length of genes from p2. c. Randomly select any two vertices, vi and vj in the offspring, and scramble all vertices between vi and vj.

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 p1 and p2. 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.

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 p1 and p2.
b. Choose a random point r in between [1, n]. c. Generate the offspring based on r by inheriting genes from both parents.
Step (b) can be implemented in constant running time.

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 p1 and p2. 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.

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 p1 and p2. 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 p1 and p2 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.

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 p1 and p2. b. Find the largest conflict-free subset of vertices having a color c in p1. c. Find the largest conflict-free subset in p2 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 o1 and o2 by performing set union operation.

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.

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: 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.

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 p1 = (v1 1  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.

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 P1 and P2. c. Select a random crossover point r in P1. d. Copy the vertex colors starting at an initial point to r in P1 into the offspring O1; e. Choose a vertex u in P2 and v in O1. f.
If u is not assigned an order in O1 and if degree(v) < degree(u) then Find the vertex v having minimum order in O1 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 2 ) complexity. The selection and copy operations in steps (b), (d), and (e) require Θ(n) complexity.
Step(c) takes a constant running time.

MPGX Crossover
MPGX operator incorporates problem-specific knowledge. The procedure is described in the following steps. If c1 ≠ c2 and if penalty of P1 reduces with c2 then replace c1 by c2; If c1 ≠ c2 and if penalty of P2 reduces with c1 then replace c2 by c1; count = count − 1 e. Generate offspring. Analysis: Step (a) requires Θ(n) complexity. Steps (b), (c), and (e) take a constant running time.

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 p1 and p2. 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.
Step (b) requires a constant running time.

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 p1 and p2. b. Merge p1 and p2 randomly into a single list, which consists of 2n elements. c. Assign the first occurrence of each gene to offspring1. d. Assign the second occurrence of each gene to offspring2.

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 p1 and p2. b. Group the color sets in both p1 and p2. c. Copy the whole color sets from p1 and p2 into a single merged list. d. Assign the first occurrence of each gene into offspring1. e. Assign the second occurrence of each gene into offspring2.

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 pc. SPCGX operator is defined as follows [33]: a. Let i = (i1, i2, i3 ... iq … ir … in) and j = (j1, j2, j3 … js … jt … jn) be the two selected sequences. b. Generate random probability pcr. c. If pcr > pc 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., iq = ir and js = jt) in i and j, then generate two offspring: (i1, i2, i3 … iq … ir+1 … in) and (j1, j2, j3 … js … jt+1 ... jn). f.

SPCGX-CGR Crossover
SPCGX is applied with a CGR procedure with a chosen pc. SPCGX-CGR is given in the following steps [33]: a. Apply the steps (a) to (e) of SPCGX crossover. b. Check if the new genes at r and t (i.e., ir and jt) corresponding to an edge (r, t) are in conflict with its corresponding adjacent genes. If so, generate ir = ir + 1 and jt = jt + 1 such that ir + 1 ≤ χ(G) and jt + 1 ≤ χ(G). c. Repeat step (f) of SPCGX with CGR procedure to all the conflicting pairs and generate updated gene sequences: i' = (i1', i2', i3' … in') and j' = (j1', j2', j3' … jn').

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

MSPCGX Crossover
The steps in MSPCGX crossover are defined as follows [60].
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 (i1, i2, i3 … ir+1 … in) and (j1, j2, j3 … jt+1 ... jn) such that minimum color ≥ ir + 1 and minimum color ≥ jt + 1. e. If the new genes ir and jt are conflicting, then generate ir = ir + 1 and jt = jt + 1 such that minimum color ≥ ir + 1 and minimum color ≥ jt + 1. f.

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.

Random Mutation
The random mutation operator randomly swaps the color of each vertex with a low mutation probability pm. The procedure is described in the following steps.
a. Select crossover offspring o1. b. Randomly swap the color class of each vertex with a low pm.

Analysis:
Step (a) requires a constant running time.

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

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. Step (d) takes Θ(n) complexity. This mutation takes Θ(n 2 ) complexity.

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 c1 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 c1.

Analysis:
Step (a) requires a constant running time.

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.

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 (v1, v2, v3 … vn) 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.

BM
The BM operation performs a translation of blocks of k > 0 successive vertices. The procedure is described in the following steps. Analysis: Step (a) requires a constant running time.

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 (v1, v2, v3 … vn) be the crossover offspring. b. Choose a randomly selected bad edge e = (vi, vj) and e' = (vk, vl) 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.

BESM
The BESM operation reduces the number of conflicting edges. The procedure is described in the following steps.
b. Choose a random bad edge e = (vi, vj).
c. Choose a direction either left-to-right or right-to-left randomly. d. Let vk be the farthest vertex adjacent to vi so that k > j.
e. Let e' = (vl, vm) be the first bad edge so that l > k.

f.
If there is no vertex vk or edge e' with the specified properties, the mutation is void. Otherwise, the vertex vi is moved to the position m + 1.
Analysis: Steps (a), (c) require a constant running time.
Step (b) requires a constant running time. Hence CGM mutation takes Θ(n 2 ) complexity.

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 [58,59]. The stochastic convergence of some recent genetic operators for solving GCP is also proved in the present section [60].

Markov Chain Model of Evolutionary Algorithms
Consider the following optimization problem: Optimize {f(x); x ∈ 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 ∈ S}. Let μ(S) be a measure to space S with μ(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 = {x1, x2, x3 … xN}. Denote the optimal solution set X * = {x * such that ∃ xi ∈ x: xi ∈ S*}. An evolutionary algorithm to solve this optimization problem is formulated as follows: a. Initialization: Generate initial population P0 at generation g = 0. b. Crossover operation: Update the new population Pt by a crossover operator PC(g). 1 where X * = Pg ∈ X * .

Convergence Conditions of Evolutionary Algorithms
The necessary and sufficient condition for the convergence of evolutionary algorithms is as follows [58,59]: Let {Pg: g = 0, 1, 2…} be the Markov chain given by (1). Define as the difference between flow from the non-optimal solution set to the optimal solution set and vice versa. ∉ * ∈ * ∈ * ∉ * Then {Pg: g = 0, 1, 2…} converges to the optimal solution set X* iff The initial population P0 is not optimal, that is, * = 0. Then α g 1 ∎

Stochastic Convergence of Recent Evolutionary Operators
Some of the recent genetic operators like SPCGX, SPCGEX, ESPCGEX, ECGM, MSPCGX, and MCGM modify Pg through successive stochastic transformations, which can be analyzed by the Markovian model. The subsequent value of Pg+1 is generated stochastically, and the evolutionary algorithm converges when the reachability and monotone conditions are fulfilled [10,12,60]. Some of the recent genetic operators converge stochastically.
First, consider the effect of crossover operation. Let S be the finite search space of the problem. Consider a gene sequence j ∈ S such that j = (j1, j2, j3 ... jn). The proposed crossover operators (incremental operators) SPCGX and SPCGEX produce a new gene as jr = jr + 1 if minimum color ≥ jr + 1. Hence the new gene takes one of the values in (jr, jr+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 jr = jr + 1 such that minimum color ≥ jr + 1. Clearly, jr assumes the value in (jr, jr + 1, jr + 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 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.
For the chosen crossover probability pc and mutation probability pm, 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'))} ≥ Hence the gene sequence jʺ is reachable from j'.

Analyzing whether Pg is Monotone
During the iterations of an evolutionary algorithm, Pg is modified by successive probabilistic transformations. The proportionate fitness selection selects one worst and two better gene sequences in every generation as follows: 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. Pg is then updated by performing the elitism operation.
The recombination and mutation operations are performed based on the values of pcr and pmr. i.e., Ft(i) ≤ Ft+1(i) ≤ …≤ Fs(i) and Ft(j) ≤ Ft+1(j) ≤…≤ Fs(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 Pg 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 [60].

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 [60]. 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 [60]. 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.
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, pc, and pm. iv.
Some of the recent operators can be combined to reduce . 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].
Author Contributions: Methodology, Software, Writing-original draft and formal analysis, Raja Marappan; formal analysis, writing-review and editing, Gopalakrishnan Sethumadhavan. All authors have read and agreed to the published version of the manuscript.
Funding: This research received no external funding.