A Heuristics for Graph Coloring Based on the Ising Model

1. Introduction

Graph coloring problem is among the most popular NP-hard problems [1] in combinatorial optimization both due to its esthetic appeal as a simple yet very hard combinatorial challenge and because of its many applications in science and real life. The first is demonstrated, for example, by more than a century long story of the famous four color map theorem [2]. As an example of applicability, let us just mention that the graph coloring problem is implicitly present in any nontrivial scheduling problem, c.f. timetabling [3]. Due to recent popularity of the quantum computing model that may hopefully answer questions of practical importance that may remain out of reach for classical computation [4,5], we also wish to note that graph coloring is closely related to the quantum computing. On one hand, it can be used for optimization of design of computing machines, for example depth optimization of quantum circuit is shown to be reducible to vertex coloring problem [6]. On the other hand, graph coloring is among the challenging problems on which the potential strengths of the quantum computation is studied [7,8,9,10]. Although there are high expectations that the model of quantum computing may provide means to solve problems that are beyond reach of the classical model, years or even decades of research and development are likely to be needed to achieve this [11]. An interesting avenue of research are quantum inspired algorithms that were shown to have an exponential asymptotic speedup compared to previously known classical methods [12]. Roughly speaking, it may be possible to use the quantum model, and with a clever dequantization obtain a competitive algorithm for the classical model of computation [13], or make use of a combination of both [14].

Due to intractability of the graph coloring, many algorithms including various heuristics and metaheuristics have been designed and applied, see, for example, [15]. Back in 1989, likely inspired by the Ising model in statistical mechanics, Petford and Welsh [16] proposed a simple randomized heuristic algorithm for coloring a graph with three colors that “does seem to work well in a wide variety of graph cases”. The Ising model (or Lenz–Ising model) is a mathematical model of ferromagnetism in statistical mechanics. In the model spins are arranged in a graph, usually a lattice, and a spin that can be in one of two states (+1 or -1) is assigned to each vertex. Each spin interacts with its neighbors. Neighboring spins that agree have a lower energy than those that disagree; the system tends to the lowest energy but heat disturbs this tendency, thus creating the possibility of different structural phases. Usually, minimal energy states are considered. Looking at the high energy states, the maximal arrangement clearly corresponds to a proper two coloring of a bipartite graph. If the graph is not bipartite, the high energy states correspond to colorings with few monochromatic edges. This observation may have led to the idea that a generalization allowing the spins to have more than two states might provide a model that would be useful as a mechanism that naturally converges to proper colorings of the underlying graph. Based on previous studies of the voter and antivoter models by Donnely and Welsh [17], Petford and Welsh proposed a 3-coloring algorithm [16]. Later experiments with slightly adopted versions of the algorithm have shown very competitive results on k-coloring problem [18], on channel allocation problem [19], and recently on clustering problems [20]. The basic algorithm [16] aims to solve the decision problem “is the given graph Gk-colorable ?”, given G and k by hopefully providing a witness, i.e., a proper k-coloring of G. Another version of the coloring problem is to answer the question “what is the minimal k such that G is k-colorable ?”, or equivalently “what is the chromatic number $\chi \left(G\right)$ of G ?”. In [21], the algorithm of Petford and Welsh was generalized to solve this optimization problem, showing good performance on several samples of randomly generated graphs. The algorithm is known [22] to in close relation to the Boltzmann machine [23]. More precisely, the algorithm of Petford and Welsh is equivalent to the operation of the generalized Boltzmann machine, and the energy that is aimed to be minimized is a generalization of the Ising Hamiltonian used in the classical model.

In this paper, we build upon the ideas of [21] to design and implement a randomized algorithm that gives an estimate (upper bound) for the chromatic number. In contrast to the original algorithm of Petford and Welsh, our algorithm does not need the number of colors as input, which makes it much more useful in various applications where the target number of colors is not known. In particular, we

• design and implement a randomized algorithm that is based on analogy to the Ising model in statistical mechanics;
• we test the performance on random graphs and on a subset of DIMACS that is a standard library of benchmark instances for graph coloring;
• we show that the algorithm designed is not only able to provide near optimal (or, even optimal) solutions, but it is also very robust in the sense that it is not very sensitive to the choice of parameter(s);

In summary, the main contribution of the work reported is a “proof of concept”, in other words, our aim was to show that the simple heuristics based on a generalization of the Ising model works. In conclusions we discuss some natural avenues of future research.

The rest of paper is organized as follows. In Section 2 we recall some preliminary information, including the definitions of graph coloring problems, the original algorithm of Petford and Welsh, and its relation to the Boltzmann machines and the Ising model. In Section 3 we define the new algorithm for estimating the chromatic number. Section 4 provides a report on the experiments. In the last section we write concluding remarks.

2. The Graph Coloring Problem and the Basic Algorithm

We say a mapping $c:V\left(G\right)\to \mathbb{N}$ is a proper coloring of G if it assigns different colors to adjacent vertices. Any mapping $c:V\left(G\right)\to \mathbb{N}$ will be called a coloring, and will be considered as one of the feasible solutions of the problem.

2.1. Graph Coloring Problems

Coloring of the vertices of a graph is usually asked either in the form of optimization or in the form of decision problem. The first asks for the chromatic number, i.e., the minimal number of colors that allows a proper coloring.

PROBLEM : Graph coloring optimization problem

Input: graph G,

Task: find the chromatic problem of G.

The k-coloring decision problem is a well known NP-complete problem for $k\ge 3$. It reads as follows:

PROBLEM : Graph coloring (decision problem).

Input: graph G, integer k

Question: is there a proper k-coloring of G?

2.2. The Algorithm of Petford and Welsh for k-Coloring Decision Problem

We start by defining the cost function $E\left(c\right)$ as the number of bad edges, i.e., edges whose endpoints receive the same color under a coloring c. A coloring is valid when $E\left(c\right)=0$. Thus, finding a coloring with $E\left(c\right)=0$ solves the decision problem, with the resulting coloring serving as a witness that verifies the solution.

The algorithm of Petford and Welsh [16] begins with a random 3-coloring of the input graph and then iteratively improves it. In each iteration, a vertex involved in a conflict (a bad vertex) is chosen uniformly at random. This vertex is then recolored according to a probability distribution that favors colors less common in its neighborhood, as given in equation (1).

This procedure naturally extends to the general k-coloring problem [18], with the special case $k=3$ recovering the original algorithm.

The algorithm can be expressed in pseudocode as follows:

Algorithm 1 Petford-Welsh algorithm for k-coloring

1: color vertices randomly with colors $1,2,\dots ,k$ 2: while not stopping condition do 3:     $v\leftarrow \mathrm{Randomly}\mathrm{select}\mathrm{bad}\mathrm{vertex}$ 4:     assign a new color to v 5: end while

The probability distribution for recoloring is defined as follows. Let $S_i$ denote the number of edges incident to v whose other endpoint has color i. Then the probability $p_i$ of recoloring v with color i is approximately

$$p_i\approx exp(-S_i/T),$$

(1)

where T is a parameter called temperature, for reasons explained later. Note that the newly chosen color may coincide with the current color of v; in fact, if other colors are heavily represented in the neighborhood, retaining the current color may be the most probable outcome.

2.3. The Algorithm of Petford and Welsh and Generalized Boltzmann Machine

It was shown in [22] that the Petford Welsh algorithm is in close correspondence to the operation of the generalized Boltzmann machine when applied to graph coloring. Generalized Boltzmann machine is a neural network that is defined [22] as follows. Let A be a finite alphabet of k symbols and $G(V,E)$ any graph with vertex set V and edge set E. A generalized Boltzmann machine $\mathcal{B}(G,A)$ is specified by a mapping w from the set of edges E into the set of matrices with real entries indexed by $A\times A$ and a mapping z from the set of vertices V to vectors indexed by A. The matrices are called weights and the vectors are thresholds. A state of the machine is an assignment $\sigma$ which specifies for each vertex a symbol from A. The energy of a state $\sigma$ is given by

$$\mathcal{E}(\mathcal{B},\sigma )=-0.5\sum _{(u,v)\in E}w{(u,v)}_{\sigma \left(u\right),\sigma \left(v\right)}+\sum _{u\in V}z{\left(u\right)}_{\sigma \left(u\right)}.$$

The update rule, as with the standard Boltzmann machine, depends on a real parameter T, referred as the temperature of the system. For a randomly selected vertex, the state of the vertex is changed from $\sigma \left(u\right)$ to b with probability

$$p{\left(u\right)}_b={\displaystyle \frac{e^{-\mathcal{E}(\mathcal{B},\sigma [u\to b\left]\right)/T}}{{\sum }_{a\in A}{e}^{-\mathcal{E}(\mathcal{B},\sigma [u\to a\left]\right)/T}}}$$

where $\sigma [u\to b]$ denotes the state obtained from $\sigma$ by setting the value $\sigma \left(u\right)$ to b. In [22] it has been shown that

• the generalized Boltzmann machine indeed generalizes the standard model and that probability $P\left(\sigma \right)$ of state $\sigma$ converges to

  $$P\left(\sigma \right)=\mu e^{-\mathcal{E}\left(\sigma \right)/T}$$

  as the number of steps tends to infinity ($\mu$ is a normalizing constant).
• the update rule of the model corresponds to the Petford Welsh algorithm when the problem considered is graph coloring.

It may be informative to recall that the generalization to a finite alphabet A from the usual case $A=\{0,1\}$ (or, $A=\{-1,1\}$) in classical Boltzmann machine [23] was motivated in [22] by the idea to handle the graph coloring problem more naturally. Furthermore note that the energy of the generalized Boltzmann machine generalizes the Ising model Hamiltonian used in the classical Boltzmann machine.

The algorithm of Petford and Welsh operates at fixed value of parameter T. They used $4^{-S_i}$ which is equivalent to using $T\simeq 0.72$ in (1). (Because $exp(-x/T)=4^{-x}$ implies $T\simeq 0.72$.) This corresponds to the operation of the generalized Boltzmann machine at fixed temperature. As there is no annealing schedule, the stopping criteria is either reaching a time limit (in terms of the number of calls to the function which computes a new color) or the event when a proper coloring is found. If no proper coloring is found, the solution with minimal cost $E\left(c\right)$ is reported and can be regarded as an approximate solution to the problem.

As already explained, the original algorithm of Petford and Welsh uses probabilities proportional to $4^{-S_i}$, which corresponds to $T\approx 0.72$. Larger values of T result in higher probability of accepting a move which increases the number of bad edges. Clearly, a very high T results in chaotic behavior similar to a pure random walk among the colorings ignoring the their energy. On the other hand, with low values of T, the algorithm behaves very much like iterative improvement, quickly converging to a local minimum. We do not intend to discuss the annealing schedules here. Just note that it is known that in order to assure convergence, the annealing schedule must be sufficiently slow [24]. In the experiments below we rather restrict attention to a selection of fixed temperatures that seemingly behave well.

3. The New DYNAMIC Algorithm for Estimating $Ø\left(\mathbf{G}\right)$

Here we generalize Petford-Welsh algorithm to dynamically adjust the number of colors, following and extending the ideas of [21]. The Dynamic k - Coloring Algorithm (Algorithm 2) incrementally tries to find a proper coloring of the graph. It begins with an initial coloring possibly using a small number of colors (e.g., two), and iteratively improves the coloring by randomly selecting a bad vertex and assigning it a new color based on neighborhood color frequencies. A temporary color expansion is allowed via a switch mechanism, enabling the algorithm to escape local conflicts as in Algorithm 3.

Once a valid coloring is found, the algorithm proceeds to the next phase, where it stores the solution and attempts to reduce the number of colors by decrementing max_color and recoloring weakly bad vertices (i.e., vertices colored with max_color). This process continues until the iteration limit is reached. This dynamic approach adapts the number of colors during execution and can be used to approximate the chromatic number of the graph.

Algorithm 2 Dynamic k-Coloring Algorithm

1: $G_{init}\leftarrow$Initializecoloring   2: Set max_color $\leftarrow \mathtt{max}\_\mathtt{color}($Ginit), switch$\leftarrow 1$   3: while not valid coloring or iteration limit not reached do   4:     $v\leftarrow \mathrm{Randomly}\mathrm{select}\mathrm{bad}\mathrm{vertex}$   5:     Recolor v using ChooseColor$(v,\mathtt{switch}=1)$   6: end while   7: switch $\leftarrow 0$   8: while iteration limit not reached do   9:     if coloring is valid then 10:         Save current solution 11:         max_color $\leftarrow \mathtt{max}\_\mathtt{color}-1$ 12:         for all weakly bad vertices do 13:            Recolor vertex using ChooseColor(vertex, switch=0) 14:         end for 15:     else 16:         $v\leftarrow \mathrm{Randomly}\mathrm{select}\mathrm{bad}\mathrm{vertex}$ 17:         Recolor v using ChooseColor$(v,\mathtt{switch}=0)$ 18:     end if 19: end while

Algorithm 3 Procedure: ChooseColor

1: function ChooseColor(node, switch) 2:     $C\leftarrow \{1,\dots ,\mathtt{max}\_\mathtt{color}+\mathtt{switch}\}$ 3:     Compute neighborhood color frequencies $S_i$ 4:     $w_i\leftarrow {\mathtt{base}}^{-S_i}$ for all $i\in C$ 5:     return random color from C using weights $w_i$ 6: end function

4. Experiments

In this section we first give information on the instances used in the experiments. Then we outline the results on random graphs, emphasizing some phenomena that were observed. Lastly, we provide the results on all small and medium size DIMACS graphs.

4.1. Datasets

4.1.1. Random k-Colorable Graphs

Petford and Welsh originally tested their algorithm on random graphs $G(N,k,\rho )$ that are generated as follows. The vertices are divided in k sets of size $N/k$ ($\lceil {\displaystyle \frac{N}{k}}\rceil$ and $\lfloor {\displaystyle \frac{N}{k}}\rfloor$ when N is not a multiple of k), and for each pair of vertices from different sets, an edge is added with probability $\rho$. The resulting graphs are clearly k-colorable, and k is an upper bound for the chromatic number $\chi \left(G\right)$.

We generate k-partite random graphs, where each partition consists of 20 vertices, following the method described earlier. Each graph is labeled in the format balanced_N_k_P_i, where:

• N is the total number of vertices,
• k is the number of partitions,
• P is the edge probability between vertices in different partitions, expressed as a percentage (e.g., $P=10$ means probability $0.1$),
• i is the instance number.

For example, balanced_60_3_10_4 refers to the fourth instance of a graph with 60 vertices, 3 partitions, and inter-partition edge probability of $0.1$.

We generate 5 instances each for $N\in \{60,100,140\}$, with edge probabilities $\rho \in \{0.1,0.25,0.5,0.75\}$. The corresponding graph family is denoted mathematically as $B{G}_{N,k,\rho }^{\left(i\right)}$, used in figures and discussions for clarity. While table entries use the compact balanced_... naming scheme for space efficiency, the same graphs are referred to as $B{G}_{N,k,\rho }^{\left(i\right)}$ in plots and analysis.

4.1.2. DIMACS Graphs

In addition to the randomly generated k-partite graphs, we test our method on several graphs from the DIMACS dataset. The DIMACS dataset of benchmark instances for graph coloring was used in the Second DIMACS Challenge: Cliques, Coloring, and Satisfiability [25]. Since then, graphs have been used frequently for studies of graph coloring heuristics [26,27]. There are several sites with DIMACS graphs, the instances for this study were downloaded from [28,29,30].

4.1.3. Some More Info on Experiments

To experiment with Algorithm 2, we consider four different values of bases, i.e., $b\in \{4,10,16,20\}$.

Based on the original idea of the heuristics, it may seem obvious that a random initial coloring is the most natural to start with. Already Petford and Welsh [16] observe that a small number of bad vertices at the beginning does not contribute to the speed of convergence. They offer the explanation that such a nearly good coloring can be regarded as being a solution close to a local optimum that can be a long way from the true optimum in the metrics of exchanges. Nevertheless, we have decided to test two other initialization strategies besides the random initial coloring. We used three initialization strategies:

• Random2: Coloring the vertices randomly with 2 colors.
• Greedy: Coloring the graph with greedy algorithm which colors the “largest first” strategy, i.e., nodes are colored in descending order of degree. Note that this method always yields a proper coloring.
• GreedyProp2: A local propagation-based coloring method that starts from a random node and greedily colors neighbors using the least frequent color in their neighborhood. Uses 2 colors and aims to minimize conflicts.

We set the maximum number of iterations to $500N$, where N is the number of vertices in the graph.

For random k-colorable graphs, with each combination of bases and initial coloring methods, we run 100 repetitions of Algorithm 2 for each graph and note the best coloring found. Similarly, for DIMACS graphs, we run the algorithm 10 times and report the best result.

We test Algorithm 2 with its Python implementation [31] on the HPC cluster at the Faculty of Mechanical Engineering, University of Ljubljana.

4.2. Experiment on $k-$Colorable Random Graphs

We first illustrate the behavior of Algorithm 2 on a representative graph instance using base $b=4$ and initialization method Random2. As shown in Figure 1, the number of colors initially increases as the number of bad vertices decreases - this corresponds to Phase I of the algorithm. Once the coloring becomes proper (i.e., zero bad vertices), the algorithm enters Phase II, attempting to reduce the number of colors while trying to find another proper coloring with less colors.

Table 1 reports results with base $b=10$ across three initialization strategies. For each case, we show the upper bound on the chromatic number (${\chi }_{UB}$), the best value found ($k_{best}$), how often this value was reached over 100 runs (${\mathrm{Tries}}_{k_{best}}$), and the average number of iterations to achieve it.

Overall, we observe that on the instances tested, the algorithm performs reliably, with $k_{best}\le k_{UB}$ in all cases. Recall that the graphs are generated in a way that the upper bound for the number of colors is known, and for sparse graphs (small p) it is possible that fewer colors are needed, which the algorithm indeed proves in some cases. So we conclude that the performance of the algorithm on the random k-colorable graphs is very good and we now provide some evidence that the algorithm is also very robust, both to the change of parameter base and to the variation of the initialization method.

In the experiments performed, Greedy initialization typically leads to faster convergence compared to GreedyProp2 and Random2. In several graphs, Greedy even yields $k_{best}$ immediately, which means that there is no improvement in the refinement phase. That said, Random2 occasionally outperforms Greedy in terms of convergence speed, e.g., in $B{G}_{60,3,0.1}^{\left(3\right)}$, $B{G}_{60,3,0.25}^{\left(3\right)}$, and $B{G}_{140,7,0.1}^{\left(2\right)}$.

We also compare performance across base values under different initialization methods. The results for Random2 initialization method are shown in Table 2.

To study the effect of base value b in relation to graph density, we compute Kendall’s $\tau$ correlation between b and the average number of convergence iterations. Kendall’s $\tau$ is a measure of rank correlation:

• A positive $\tau$ indicates that as b increases, the number of iterations tends to increase (i.e., slower convergence).
• A negative $\tau$ implies that higher base values are associated with fewer iterations (i.e., faster convergence).

Figure 2 shows these values, annotated with statistical significance: $p<0.001(***)$, $p<0.01(**)$, $p<0.05(*)$; unmarked values are not statistically significant.

A clear trend emerges for Random2 and GreedyProp2 initialization methods, the the case of denser graphs ($\rho \ge 0.5$). Larger bases are more effective (negative $\tau$), often with high significance. For graphs with $\rho =0.25$ and $N\ge 100$, smaller bases tend to converge faster (positive $\tau$). This supports the idea that the optimal base should be tuned based on density.

In contrast, the Greedy initialization exhibits no consistent pattern, indicating its performance is relatively insensitive to the base.

Figure 3 and Figure 4 visualize convergence behavior. The first shows how convergence varies with base values, while the second compares initialization strategies at fixed base $b=10$. In each case, the curves represent averages over 100 runs.

Figure 5 shows the best k found among all the bases considered with respect to the initialization methods. The ${\chi }_{UB}$ is also plotted. We can see that in two cases, the value of ${\widehat{k}}_{best}$ is less than that of ${\chi }_{UB}$. This is because a randomly generated $k-$partite sparse graph can be colored with fewer than k colors.

4.3. Experiments on DIMACS Graphs

We evaluate our approach on a variety of graphs from the DIMACS benchmark suite using different initialization strategies. Table 3 and Table 4 report the best chromatic number ($k_{best}$) found and the corresponding mean number of iterations across different base values. For certain DIMACS instances, we found that the number of nodes in the graphs is less than the reported nodes. This is due to the existence of isolated vertices in the graph. We report these values with an asterisk in Table 3 and Table 4.

Unlike in the synthetic balanced graphs, the DIMACS instances exhibit greater structural diversity, and our method does not consistently recover the true chromatic number ($k_{true}$). However, we observe that in many cases, even a simple greedy coloring initialization suffices to reach the optimal chromatic number. This indicates that for a subset of these graphs, the chromatic number is accessible with relatively straightforward heuristics.

At the same time, for several instances, the inferred chromatic number remains above the known optimum, suggesting that such graphs pose greater challenge because of their density or structure or both. The variation in performance across instances and base values highlights the sensitivity of the method to initialization and the graph’s internal structure.

While we do not identify a consistent trend as in the random k partite balanced graphs, these results suggest that simple heuristic methods can be surprisingly effective on real-world instances, although more adaptive or problem-specific strategies may be needed for harder cases. This is in fact well known, as for some instances in the DIMACS dataset, advanced heuristics fail to find near optimal solutions (See, for example, a very recent study [27]).

As a summary of our experiments on DIMACS graphs, Figure 6 shows the percent deviation in the best value of k achieved among all the considered bases from the true chromatic number, $\chi$.

5. Conclusions

We proposed a dynamic extension of the Petford–Welsh coloring algorithm that estimates the chromatic number of a graph without requiring k as an input. The method begins with a minimal coloring and adaptively adjusts the number of colors based on solution quality. By allowing a temporary increase in the color budget, the algorithm facilitates broader exploration, followed by controlled reduction to encourage convergence toward minimal valid colorings.

As already noted, we believe that the main contribution of the work reported here is a “proof of concept”. In other words, our aim was to show that the simple heuristics based on a generalization of the Ising model works. This may be of particular interest because of the relation of the algorithm to the Boltzmann machines and to the Ising model. The potential of the approach that we did not explore here, is the inherent parallelism. Namely, the current version of the algorithm is implemented and run on a classical processor and simulates the process in which the vertices selected for update are stored in a queue of bad vertices. This is clearly more efficient than allowing each vertex to be selected at random as the properly colored vertices will very likely be recolored with the same color. On the other hand, we believe that on a parallel architecture, full parallelism with minimal communication overhead is possible. In fact, this may be an important potential for future applications . (For a recent report of simulation of parallel version of the basic algorithm, see [32].)

We continue with a discussion of results of our experiments. The experiments highlight the importance of both initialization and the choice of base (serving a role analogous to temperature in simulated annealing). In particular, greedy initialization consistently leads to better convergence and more accurate estimates of the chromatic number than random strategies. Similarly, lower base values tend to encourage global refinement, whereas higher values promote local exploration.

This adaptive framework provides a practical approach to estimating chromatic numbers for large or structurally complex graphs, where exact methods may be infeasible. As directions for future work, we intend to:

• Investigate more principled strategies for base selection and initialization to improve reliability and convergence speed.
• Explore parallel or distributed implementations to enhance scalability on large graph instances.
• Benchmark the approach against recent heuristic solvers, including those based on deep learning and quantum optimization.