Quantum computing and the stable set problem

∗†
Aljaž Krpan Janez Povh‡§ Dunja Pucher¶
arXiv:2405.12845v3 [[Link]] 2 Jan 2025

Abstract

Given an undirected graph, the stable set problem asks to determine the cardinality of the
largest subset of pairwise non-adjacent vertices. This value is called the stability number of
the graph, and its computation is an NP-hard problem. In this paper, we solve the stable set
problem using the D-wave quantum annealer. By formulating the problem as a quadratic un-
constrained binary optimization problem with the penalty method, we show its optimal value
equals the graph’s stability number for specific penalty values. However, D-Wave’s quantum
annealer is a heuristic, so the solutions may be far from the optimum and may not represent
stable sets. To address these, we introduce a post-processing procedure that identifies samples
that could lead to improved solutions. Additionally, we propose a partitioning method to han-
dle larger instances that cannot be embedded on D-Wave’s quantum processing unit. Finally,
we investigate how different penalty parameter values affect the solutions’ quality. Extensive
computational results show that the post-processing procedure significantly improves the solu-
tion quality, while the partitioning method successfully extends our approach to medium-size
instances.
Keywords: The stable set problem, Quantum annealing, Graph partitioning, D-Wave
Math. Subj. Class. (2020): Primary 90C27, Secondary 81P68

1 Introduction
1.1 Motivation
The stable set problem is a fundamental combinatorial optimization problem. Given an undirected
simple graph G, the stable set problem asks for the largest subset of vertices that are pairwise
non-adjacent, known as the stability number of the graph. It is well-known that stable sets in G
correspond to cliques in the complement graph G, making the stable set problem in G equivalent to
the maximum clique problem in G. The maximum clique problem (and thus the stable set problem),
is an NP-hard problem. The decision variant of the maximum clique problem is included in Karp’s
1972 list of NP-complete problems [18]. Hence, unless P = NP, no polynomial time algorithm can
exactly solve the stable set problem in general. However, there are numerous real-life applications
of this problem, for instance, in bioinformatics and chemoinformatics [22], coding theory [10], and
scheduling [35]. Therefore, efficient algorithms are needed to solve this problem.
The most desired algorithms to solve it are the exact ones. They guarantee to find the optimal
solution to the problem. Since the stable set problem belongs to the family of discrete optimization
problems, the exact algorithms usually employ a variant of complete enumeration, like branch-and-
bound or branch-and-cut algorithms. There is a long list of exact solvers, which can be grouped
as academic solvers, developed and maintained by some research group and available by some
∗ Rudolfovo, Science and Technology Centre Novo mesto, Slovenia
† Faculty of mathematics and physics, University of Ljubljana, Slovenia, [Link]@[Link]
‡ Rudolfovo, Science and Technology Centre Novo mesto, Slovenia, [Link]@[Link]
§ Faculty of mechanical engineering, University of Ljubljana, Slovenia
¶ Department of Mathematics, University of Klagenfurt, Austria, [Link]@[Link]

1
variant of open source license, like BiqBin [12, 14], SCIP [1], and commercial solvers, developed
and maintained by some company and available under different commercial licenses, like Gurobi
[11] and CPLEX [15]. Other solvers to solve the stable set problem can be found also on GAMS
webpage [Link] Nevertheless, exact solvers have
significant limitations: they are always computationally very expensive, in both theory and practice
and can solve only small and medium-sized instances with the underlying graph that has up to
approximately 1500 vertices; see, for instance, [6] and [33].
Alternatives to exact solvers are the algorithms that find good, but not necessarily optimal,
solutions, the so-called heuristics. They can process large problems within acceptable computa-
tional time and usually find good solutions that are acceptable for real-life applications. However,
they have limitations, and the distance from the optimal solution is often unknown. In a review
of classical algorithms for the stable set problem from 2015 [36], 21 different heuristics were com-
pared. It turned out that the general swap-based multiple neighborhood tabu search approach
from [16] yielded the best results. A recent review on novel approaches [23] points out the al-
gorithm from [20] as extremely effective. The respective algorithm combines local search with
evolutionary and extended kernelization techniques.

1.2 Quantum annealing

In recent years, a new heuristic approach for solving combinatorial optimization problems has
emerged based on quantum annealing. Quantum annealers leverage quantum mechanics principles
to tackle optimization problems. They operate by exploiting one of the quantum phenomena,
quantum tunneling, to find the most efficient solution to complex computational challenges. A
review of mathematical and theoretical foundations of quantum annealing can be found in [25].
State-of-the-art quantum annealing machines integrate advanced technologies to achieve better
qubit coherence times, error rates, and connectivity between qubits. These machines rely on
superconducting circuits cooled to ultra-low temperatures, harnessing quantum effects to explore
vast solution spaces efficiently.
D-Wave Systems has been at the forefront of quantum annealing technology, pioneering the
development of quantum annealers. One of the distinguishing features of their quantum annealers
is the qubit architecture; see [2]. While traditional qubits rely on a coherent superposition of
states, D-Wave utilizes an approach where qubits represent a probabilistic combination of binary
states. This allows for an adaptive search through solution spaces, exploiting quantum tunneling
to navigate complex landscapes efficiently. Further details on the inner workings of D-Wave’s
quantum annealer can be found in their documentation [9].
However, challenges persist in achieving fault-tolerant quantum computation. Noise and main-
taining quantum coherence remain significant hurdles. D-Wave’s machines are subject to limita-
tions due to factors like thermal fluctuations and imperfections in the qubit layout. As a result,
achieving quantum advantage—where quantum computers outperform classical computers for spe-
cific tasks—remains an ongoing goal rather than a realized standard in practical applications.
Despite these challenges, D-Wave’s quantum annealers have demonstrated promising results in
tackling optimization problems. Indeed, several solvers for mathematical optimization problems
are an integral part of D-Wave systems. The most basic one, the quantum processing unit (QPU),
is declared a purely quantum solver. It is capable of solving optimization problems of small size.
Besides QPU, D-Wave offers a hybrid solver that combines classical and quantum computing to
solve optimization problems. Details about this solver are not disclosed but based on information
provided in [24], the hybrid solver combines classical and quantum computing to solve problems
beyond the reach of QPU. This solver seems to use a classical computer to preprocess the problem
and generate a set of subproblems that can be solved using QPU. When the subproblems are solved,
the results are returned to the classical computer, which combines them to produce a solution to
the original problem.
Although there is increased interest in using D-Wave systems for combinatorial optimization

2
problems and several authors have already published numerical results obtained by D-Wave sys-
tems, see Section 2, a thorough analysis of the results for the stable set problem, especially how
close are the results computed by D-Wave systems to the global optima, as well as the development
of strategies to enhance these results, are still missing.

1.3 Our contribution

In this paper, we extend our research presented in [19, 31] and address the aforementioned limita-
tions. We consider the stable set problem and investigate methods to obtain high-quality solutions
with algorithms that at least partially exploit the D-Wave systems.
The main contributions of this paper are:
1. We formulate the stable set problem as a quadratic unconstrained binary optimization
(QUBO) problem using a penalty approach, where the quadratic constraints, weighted by
the penalty parameter β, are added to the cost function. We show that if we use an exact
QUBO solver, then for β ≥ 21 , the optimum value of QUBO formulation equals the stability
number of the graph.
2. The D-Wave QPU solver could only compute local optimum solutions for instances with less
than 150 vertices. Our results show that very often, these solutions are quite far away from
the global solutions in terms of the objective value and may not even be stable sets. To
address these, we developed a post-processing procedure that enables us to detect samples
that could lead to improved solutions and to extract solutions that are stable sets. Also, we
provide theoretical guarantees about the quality of the extracted solutions. The procedure is
outlined in Algorithm 1. Table 2 contains detailed numerical results of the solution provided
by the QPU solver as part of Algorithm 1.
3. For instances with more than 150 vertices, we used the D-Wave hybrid solver and the classical
simulated annealing solver from the D-Wave’s library for interacting with QPU. Both solvers
again returned solutions that were often not stable sets, so we applied the post-processing
procedure from Algorithm 1, and we reported detailed numerical results in Tables 4 and 5.
A comparison of the results from these tables reveals that the solutions obtained using the
hybrid solver and simulated annealing are very similar. This may partially explain how the
hybrid solver is running.
4. For certain instances with more than 150 vertices, we also developed an alternative to the
hybrid solver, which we call the simple partitioning procedure. It enhances the so-called CH-
partitioning from [3, 7], which divides the original problem into many smaller subproblems,
solves them with the QPU, and finally takes the largest stable set across the subproblems as
the final solution. In order to improve solutions returned by the QPU, we combine the simple
CH-partitioning with the post-processing procedure, as outlined in Algorithm 2. Numerical
analysis is presented in Table 7.
5. All solvers used in this paper are only approximate solvers. Therefore, the theoretical guar-
antee mentioned in the first item does not apply, so we performed extensive numerical tests
1
using different values of the penalty term β in the range from 10 to 100 to evaluate which
1
values of β are most relevant. We observed that the value β = 2 gives the overall best solu-
tions, which is consistent with theoretical guarantees. Nevertheless, in combination with the
post-processing procedure, β smaller than 12 also often gives good, sometimes even optimal,
solutions, but this holds only for smaller graphs and does not scale with the graph size.

1.4 Outline and terminology

The rest of this paper is organized as follows. In Section 2, we give an overview of related work
that aims to solve the stable set problem with quantum annealing. A QUBO formulation for the

3
stable set problem is derived in Section 3. In Section 4, we discuss some aspects and shortcomings
of the given QUBO formulation and present our post-processing procedure. For larger instances,
we propose to use the CH-partitioning method and develop its modified version in Section 5.
In Section 6, we perform extensive computational study and present results for newly proposed
approaches. Finally, we conclude with a short discussion of our results in Section 7.
Throughout this paper, G = (V (G), E(G)) denotes a simple undirected graph with |V (G)| = n
vertices and |E(G)| = m edges. Without loss of generality, we assume that the set of vertices V (G)
is V (G) = {v1 , . . . , vn }. If a graph G is clear from the context, we write shortly G = (V, E). For
a graph G = (V, E), a stable set S ⊆ V is a subset of pairwise non-adjacent vertices. A clique
C ⊆ V is a subset of pairwise adjacent vertices. The cardinality of the maximum stable set in G is
denoted by α(G), and the cardinality of the maximum clique in G is denoted by ω(G). The stable
set problem asks to determine α(G), while the maximum clique problem asks to determine ω(G).
A non-empty graph G is called connected if any of its two vertices are linked by a path in G.
A maximal connected subgraph of G is called a component of G. The complement of a graph
G = (V, E) is the graph G = (V, E), where E is the set of non-edges in G, that is E = {vi , vj ∈
V | vi 6= vj ∧ {vi , vj } ∈/ E}. Hence, from the definitions it follows α(G) = ω(G) and α(G) = ω(G).
The relationship between the stable set and the maximum clique problem is visualized in Figure 1.

v1 v1

v5 v2 v5 v2

v4 v3 v4 v3

Figure 1: The left figure shows a graph G on five vertices. In this graph, the following subsets of vertices are stable
sets: {v1 , v2 }, {v1 , v3 }, {v1 , v5 }, {v1 , v3 , v5 }, {v3 , v5 }, {v4 , v5 }. The right figure shows the complement graph G,
where these same subsets form cliques. In particular, the maximum stable set {v1 , v3 , v5 } in G is equivalent to the
maximum clique in G, and therefore, α(G) = ω(G) = 3.

For a vertex vi ∈ V , the set of vertices adjacent to vi is called its neighborhood. The closed
neighborhood of vertex vi includes the vertex vi and its neighborhood. We denote this closed
neighborhood set by N (vi ). For X ⊆ V , we denote a subgraph of G induced by X by G[X]. The
closed neighborhood of vertices in X ⊆ V is N (X) = ∪vi ∈X N (vi ). The vector of all-ones of length
n is denoted by en , and we write In for the identity matrix of order n. If n is clear from the
context, we write shortly e and I.

2 Related Work
This section summarizes previous research on solving the stable set and maximum clique problems
using quantum annealers, explicitly focusing on results from D-Wave systems. First, we discuss the
architecture, methods, instances considered, and results obtained. Then, we highlight one aspect
of the problem formulation related to the penalization parameter β in prior studies and briefly
present our contribution within this framework.
One of the first numerical results on solving the stable set problem with D-Wave quantum
annealers is shown in [26]. The results were obtained on D-Wave Two AQO with 512 qubits
in Chimera graph architecture. The experiments were compared to Selby’s exact and heuristic

4
algorithms for Chimera graphs, revealing that Selby’s exact method performed better than the
heuristic and quantum annealing approaches, since it found optimal solutions in a shorter running
time.
Further numerical experiments were conducted in [3], where the authors compared quantum
annealing implementation to several classical algorithms, such as simulating annealing, Gurobi, and
some third-party clique-finding heuristics. For their tests, they used D-Wave 2X with roughly 1000
qubits in Chimera graph architecture. The experiments were performed on random graphs with 45
vertices and edge probabilities ranging from 0.3 to 0.9. D-Wave returned solutions of comparable
quality to classical methods, but classical solvers were generally faster for small instances. They
also tested subgraphs of D-Wave chimera graphs, where D-Wave returned the best solutions for
large instances and showed a substantial computing speed-up. For instances that did not fit D-
Wave’s architecture, they proposed decomposing the problem into subproblems and combining
solutions, which was effective for sparse graphs.
Similar experiments, but on D-Wave 2000Q, were done in [37]. The results obtained for random
graphs with up to 60 vertices and edge probabilities ranging from 0.05 to 0.425 were compared to
classical algorithms such as simulated annealing and the graphical networks package NetworkX. It
was shown that the D-Wave’s QPU can find optimal or near-optimal solutions for all considered
instances. However, it was outperformed by simulated annealing, which always found the optimal
solution and was always the fastest for problems with 30 or more vertices. Additionally, the
authors assessed the performance of D-Wave 2000Q as a function of edge probability. After running
100000 sample solutions per instance, they calculated the mean probability of obtaining the optimal
solution. For instances with density 0.20, the lowest success rate was noted, suggesting that these
instances represent the most difficult instances for the QPU in terms of computing the optimum
solution.
The decomposition method for instances that do not fit D-Wave’s architecture introduced in [3]
was further considered in [28]. A pruning strategy for subproblems arising from the decomposition
was introduced to reduce the computational complexity. Also, some reduction strategies were
considered. The experiments for selected DIMACS instances were performed on D-Wave 2000Q,
and it was shown that combining the decomposition method with proposed strategies is faster
at computing maximum cliques than the method introduced in [3], with a considerable speed-up
for very sparse as well as very dense graphs. Additionally, in [29], the algorithm from [28] was
combined with parallel quantum annealing and applied to graphs with up to 120 vertices and 6935
edges on the D-Wave Advantage System 4.1. in Pegasus graph architecture. It was found that this
combined approach can compute maximum cliques in high-density graphs significantly faster than
classical solvers.
Finally, a computational study of three generations of D-Wave quantum annealers was done
recently in [27]. The experiments were conducted on random graphs with 52 vertices and edge
probabilities ranging from 0.05 to 0.95. The computations were performed on systems D-Wave
2000Q, D-Wave Advantage System 4.1, D-Wave Advantage System 6.1 as well as on the prototype
of D-Wave Advantage2 System 1.1. in Zephyr graph architecture. The best results for the max-
imum clique problem were obtained on the newest prototype of D-Wave Advantage 2, showing a
progression of the quantum annealing technology over a relatively short time span of development.
To solve an optimization problem with D-Wave’s QPU, one should formulate it as an Ising
model or a QUBO problem. In [21], respective formulations for many NP-complete and NP-hard
problems were introduced. Among others, a QUBO formulation for the stable set was given.
The given formulation contains two terms, one for the vertices and one for the edges. While the
contribution of a vertex in the solution is rewarded, every edge in the solution is penalized. It is
suggested in [21] to set penalization for edge to be strictly greater than a reward for a vertex.
In the related work discussed in this section, the authors focused on penalizing edges without
rewarding vertices. Specifically, when adapting their formulations to the QUBO formulation given
in this work—where vertices are not rewarded, but edges are penalized using a penalty parameter
β—we observe that a value of β = 1 was used in all these studies.

5
 In contrast, we demonstrate that, with an exact QUBO solver, the optimal value of the given
QUBO formulation corresponds to the stability number of the graph when the penalty term β
is set to at least 12 . However, given the approximate nature of quantum annealing, the solutions
obtained may not always be optimal or they may not be stable sets. To address these issues, we
introduce methods for analyzing and post-processing computed solutions to improve them. Our
computational analysis suggests that setting the penalization term at β = 12 yields better outcomes
than the choice of β = 1 used in previous research.

3 QUBO formulation
In this section, we use the formulation of the stable set problem as an integer linear programming
problem in binary decision variables with many linear constraints, which is obviously not an in-
stance of QUBO. We first find an equivalent formulation where all linear constraints are replaced
by a single quadratic constraint, and in the next step, we apply a penalty approach and move
the new quadratic constraint, multiplied by a penalty parameter β, into the objective function,
resulting in a QUBO problem.
The optimum solution of this QUBO problem is not necessarily the same as the optimum
solution of the original stable set problem, which means that the optimum solution of QUBO may
not be a stable set, and its size may not be equal to the size of the maximum stable set in the
underlying graph.
We investigate which values of β ensure that the optimum solution of QUBO is also the optimum
solution of the original problem and provide theoretical guarantees in Section 3.1. We also illustrate
what can happen if they are not fulfilled. However, choosing the appropriate value for the penalty
parameter is a challenge when working with quantum annealers due to the so-called scaling problem,
which we briefly discuss in Section 3.2.

3.1 Formulation of the stable set problem

Let G = (V, E) be a graph and S ⊆ V a stable set. We can represent S by a binary vector x of
length |V | with xi = 1 if and only if vi ∈ S. Since the vertices in S cannot be adjacent, for every
edge at most one end vertex can be in S. A traditional way to formulate the stable set problem is
the following integer linear programming formulation:

α(G) = max{eT x | x ∈ {0, 1}n ∧ ∀{vi , vj } ∈ E, xi + xj ≤ 1}. (1)

Linear constraints in (1) can be replaced by quadratic ones. The condition that for every edge,
at most one end vertex can be in S, means that if vi ∈ S, then xj = 0 for all {vi , vj } ∈ E.
Hence, the stability number of a graph G can be computed as the optimal value of the following
optimization problem with linear objective function and quadratic constraints:

α(G) = max{eT x | x ∈ {0, 1}n ∧ ∀{vi , vj } ∈ E, xi xj = 0}. (2)

The problem
P (2) can be further reformulated. Since xi xj = 0 for every edge {vi , vj } ∈ E, we
have that {vi ,vj }∈E xi xj = 0. We can also show the reverse claim. Indeed, since x is a binary
P
vector, {vi ,vj }∈E xi xj = 0 implies that for every edge {vi , vj } ∈ E we have xi xj = 0. Therefore,
P the edge constraints xi xj = 0 for all {vi , vj } ∈ E if and only if it satisfies
binary vector x satisfies
the single constraint {vi ,vj }∈E xi xj = 0. Now, let A be the adjacency matrix of a graph G.
P
Then, {vi ,vj }∈E xi xj = 12 xT Ax. Obviously, 21 xT Ax = 0 ⇔ xT Ax = 0, so the formulation (2) is
equivalent to the formulation:

α(G) = max{eT x | x ∈ {0, 1}n ∧ xT Ax = 0}. (3)

6
 We apply a penalty method to (3) to obtain a QUBO problem, which will be the central problem
of this paper. Generally, a QUBO problem is a minimization problem of the following form:

z ∗ = min{f T x + xT Qx | x ∈ {0, 1}n }.

To get a QUBO formulation related to the stable set problem, we need to move the quadratic
constraint xT Ax = 0 in (3) into the objective function. The penalty method suggests simply
subtracting the left-hand side of this constraint, multiplied by a penalty parameter β > 0, from
the objective function. The new objective function would, therefore, be eT x − βxT Ax. Since
the QUBO problem is a minimization problem, we need also to reverse the sign of the objective
function.
With all this, we obtain the following QUBO problem closely related to the stable set problem:

α(G, β) = − min{−eT x + βxT Ax | x ∈ {0, 1}n}. (4)

For the sake of clarity, we denote the cost function in (4) as:

cost(x, β) = −eT x + βxT Ax.

Furthermore, for a subset of vertices X ⊆ V , we define:

cost(X, β) = cost(x, β), (5)

where x ∈ {0, 1}n is the indicator vector for X. The following observation can help us to better
understand the role of the penalty parameter β.
Observation 1. Suppose X ⊂ V , vi , vj ∈ X and there is an edge between vi , vj . Therefore, we
have xi = xj = 1, and the term xT Ax counts this edge twice. Since (4) is a minimization problem,
we have that for β > 0, the penalty term βxT Ax penalizes each edge in G[X] with the value of 2β.
Based on Observation 1, we can rewrite the cost function (5) as:

cost(X, β) = −|X| + 2β|E(G[X])|. (6)

Note that the optimal value of (4) may not be equal to α(G) for some values of the parameter
β. Likewise, the optimal solution X may not be a stable set. In the following, we provide insights
into how α(G) and α(G, β) are related for different values of β.
Lemma 2. Let G = (V, E) be a graph. If β ≥ 21 , then

α(G) = α(G, β).

Proof. Let x∗ ∈ {0, 1}n be an optimal solution for the problem (3). Since the formulation (3) is
equivalent to the formulation (2), we have that x∗i x∗j = 0 for all {vi , vj } ∈ E. Hence, the optimal
solution x∗ is a stable set. Furthermore, x∗ is a feasible solution for the formulation (4) with
−eT x∗ + β(x∗ )T Ax∗ = −eT x∗ , and therefore α(G) ≤ α(G, β).
Now let x∗ ∈ {0, 1}n be an optimum solution for (4) and X ∗ the corresponding subset of V . If
X is a stable set, then the optimum value of (4) is eT x∗ , hence α(G) ≥ α(G, β). Otherwise, there
∗

exists {vi , vj } ∈ E, such that x∗i = x∗j = 1. If we define new x̃, which differs from x∗ in the j-th
component only, which is set to 0, this implies eT x̃ = eT x∗ − 1 and β x̃T Ax̃ ≤ β(x∗ )T Ax∗ − 2β.
Therefore, this change has the following effect on the cost function of (4):

cost(x̃, β) = −eT x̃ + β x̃T Ax̃

≤ −eT x∗ + 1 + β(x∗ )T Ax∗ − 2β
= cost(x∗ , β) + 1 − 2β
≤ cost(x∗ , β)

7
where the second inequality follows from the fact that β ≥ 21 .
Therefore, since by assumption we have β ≥ 21 , we can iteratively remove one endpoint for each
remaining edge between two vertices in G[X ∗ ] without increasing the value of the cost function,
which finally yields a stable set X̂ with indicator vector x̂ such that:
cost(x∗ , β) ≥ cost(x̂, β) = −eT x̂ ≥ −α(G).
Hence, α(G, β) = −cost(x∗ , β) ≤ α(G). Combining with the first part of the proof, we get the
equality.
If β < 12 , then the equality α(G) = α(G, β) may not be true, as the following counterexample
shows.
Example 3. Let G = (V, E) with V = {v1 , v2 }, E = {{v1 , v2 }} and assume β < 12 . For x =
(1, 1)T , we have that cost(x, β) = −eT x + βxT Ax = −2 + 2β < −1. Therefore, the minimum of
cost(x, β) over all binary vectors is smaller than −1, and thus α(G, β) > 1 = α(G).
Corollary 4. Let G = (V, E) be a graph, and let β < 21 . Then we have
α(G, β) ≥ α(G).
Proof. The inequality α(G, β) ≥ α(G) follows from the first part of the proof of Lemma 2, which
is independent of β.
As the last step, we formulate the stable set problem so that it can be embedded on D-Wave
QPUs. D-Wave solvers are designed to minimize a QUBO formulated as:
min xT Qx,

where x is a binary variable. Since x2i = xi , we can write −eT x as xT (−I)x. Thus, we set
Q = −I + βA and obtain the following problem formulation:
α(G, β) = − min{xT (−I + βA)x | x ∈ {0, 1}n}. (7)
As mentioned in Section 2, several QUBO formulations for the stable set problem or related
to the stable set problem similar to the formulations (4) and (7) have already been introduced.
However, the value of the penalty parameter was usually set to β = 1. This is interesting since
the choice of parameters may impact the quality of solutions obtained from quantum annealers, as
discussed in the following text.

3.2 The scaling problem for quantum annealers

Several authors investigated the relationship between the values of the penalty terms in a QUBO
formulation and the quality of results; see, for instance, [4] and [32]. Nevertheless, although it is
empirically proven that such a relationship exists, there is still no exact rule on how to set penalty
terms efficiently. One reason is the scaling problem that occurs when working with QPUs. For
the sake of brevity, we will briefly present this problem by giving a toy example and omit the
theoretical framework. An interested reader can find further details in [38].
To present the scaling problem, we give an example similar to the one outlined in D-Wave’s
documentation [8]. We consider the following function, given as a QUBO problem:
E1 (q1 , q2 ) = 0.1q1 + 0.2q2 + 0.3q1 q2 .
This function can also be written in a form:
E2 (q1 , q2 ) = 0.1q1 + 0.2q2 + 5q1 q2 ,
which is equivalent to E1 in the sense that the values of the cost function for the solutions E1 and
E2 follow the same order, as it can be seen from the following table:

8
 q1 q2 E1 E2
0 0 0 0
0 1 0.2 0.2
1 0 0.1 0.1
1 1 0.6 5.3

However, a quantum annealer does not operate on the whole interval of the given coefficients,
but it scales the coefficients to its operating space. Assume a quantum annealer operates on
the coefficient interval [−1, 1]. Since the coefficients of the function E2 exceed this interval, the
quantum annealer will correct them by multiplying the function by 15 . This yields the new corrected
function E2′ :
E2′ (q1 , q2 ) = 0.02q1 + 0.04q2 + q1 q2 ,
with the following table of states:
q1 q2 E2′
0 0 0
0 1 0.04
1 0 0.02
1 1 1.06
As we can see, the difference between the lowest and the second-lowest solution has decreased
from 0.1 in E2 to 0.02 in E2′ . This is a problem because a quantum annealer is an analog device
sensitive to noise. Thus, the smaller the difference between the states of the cost function, the
greater the probability of error due to noise—this is called the scaling problem. Therefore, the
absolute relative scale between coefficients should be as small as possible.
In the given QUBO formulation for the stable set problem (7), we only have one penalty
parameter—the parameter β. Since we are interested in the relative scaling between the constants,
we set β in such a manner that the absolute values of the coefficients of all monomials are as similar
as possible. Since the monomials x2i have the coefficient −1, we note that 2β should be equal or
approximately equal to | − 1|, as this mitigates the scaling problem the most. This implies that β
should be close to 21 .

4 Analysis of solutions and the post-processing procedure

In this section, we provide an in-depth analysis of data returned by a quantum annealer and
develop methods that enable us to improve the quality of the results. In Section 4.1, we first focus
on the solutions returned by a quantum annealer and study how to set the penalty parameter β
for the most accurate results. Then, we analyze all samples returned by a quantum annealer in
Section 4.2. Finally, we propose the post-processing procedure and give its detailed explanation in
Section 4.3.

4.1 Analysis of solution

In Section 3, we derived two equivalent QUBO formulations (4) and (7) for the stable set problem
and showed that the optimal solution yields the stability number of a graph if the value of the
penalty parameter β is at least 12 . However, quantum annealing is a heuristic, so the solution
obtained is not necessarily optimal. Moreover, since any binary vector is feasible for (4) and (7),
the solution provided by a quantum annealer is not necessarily a stable set, which means that the
penalty term in the solution provided by a heuristic based on a QUBO formulation may not be
zero.
We now analyze how to set the penalty parameter β for the most accurate results. First, we
show how to estimate the size of a stable set contained in a solution to the QUBO problem that

9
is not a stable set and how to extract such a solution. Furthermore, we argue that, within our
method, the best choice for the value of the penalty parameter is β = 21 . This result confirms
our previous observation that in the context of the scaling problem presented in Section 3.2, the
parameter β should be close to 12 .
Let X ⊆ V be a solution returned by a quantum annealer, and let x ∈ {0, 1}n be the indicator
vector of X. If βxT Ax 6= 0, then the solution is not a stable set. Nevertheless, we can still obtain
a stable set from X, as shown in the next statement.
Proposition 5. Let G = (V, E) be a graph and let X ⊆ V . Then there exists a stable set X ′ ⊆ X,
such that
|X ′ | ≥ |X| − |E(G[X])|.
The computation of X ′ is done in O(|E(G[X])| + |V (G[X])|) time.
Proof. We consider the graph G[X]. If |E(G[X])| ≥ |X|, the statement trivially holds since we
can take X ′ to be a single vertex. Now assume that |E(G[X])| < |X|. Then, iterating over the
set E(G[X]), we remove for each edge one of its adjacent vertices. Since there are |E(G[X])|
edges, we remove at most that many vertices. As a result, we obtain a stable set of size at least
|X| − |E(G[X])|.
The calculation of the induced subgraph G[X] takes O(|E(G[X])| + |V (G[X])|) time while
iterating over all edges and removing adjacent vertices takes O(|E(G[X])|) time. Hence, the
computation of X ′ is done in O(|E(G[X])| + |V (G[X])|) time.
Proposition 5 asserts that even if a solution of (7) is not a stable set and the number of edges is
sufficiently small, we can still efficiently extract a stable set. We will now argue that when we are
solving (7) with a heuristic, a very reasonable choice for the penalization parameter is still β = 12 .
We start by giving the following example.
Example 6. Let β = 1. Then, the penalty component of the QUBO formulation (7) is xT Ax.
Expanding xT Ax, we notice that each quadratic term appears twice according to Observation 1,
resulting in a penalty of 2 for each edge. Let us assume there exists a stable set of size at least
of 25 included in a subset of vertices X ⊆ V such that |X| = 30 and |E(G[X])| = 5. Then,
cost(X, 1) = −20, so stable sets of sizes 21, 22, 23, 24 with respective costs of −21, −22, −23, −24
will be more favorable than the set X. Therefore, even if only approximate, the solver will likely
not return the set X as the optimum. On the other hand, as indicated in Proposition 5, we can
easily extract a stable set of size 25 from the set X, meaning that the cost function with β = 1 is
not accurately representing the desired solution quality.
From the given example, we note that in the context of the previously given method, choosing
the penalization parameter β > 21 may discard superior solutions due to the imprecise cost function.
To explain this in a more general context, we first need to prove the following statement.
Lemma 7. For every ǫ > 0 there exist a graph G and a subset X ⊆ V such that

2ǫ|E(G[X])| > 1. (8)

Proof. We will prove the lemma by providing an example of such graph. Let ε > 0 and set
1
m = ⌈ 2ǫ + 1⌉. The graph which will serve as an example is a union of m edges, i.e, we have
|E| = m, |V | = 2m and deg(v) = 1 for every v ∈ V . For X = V it follows that:
1
|E(G[X])| = |E(G[V ])| = |E| = m > ,
2ǫ
so the inequality (8) holds for this graph.

10
 1
Now, suppose we have a graph G = (V, E), a set X ⊆ V and β = 2 + ǫ where ǫ > 0. The value
of the cost function (6) is:

−|X| + 2β|E(G[X])| = −(|X| − (1 + 2ǫ)|E(G[X])|).

To improve clarity and simplify the explanation, we will flip the sign of the cost function and
approach the problem as a maximization problem. This adjustment transforms the cost function
into:
cost = |X| − (1 + 2ǫ)|E(G[X])|.
As established in Proposition 5, we can easily extract a stable set of size:

solution = |X| − |E(G[X])|

out of the X. Since we are dealing with an arbitrary graph, we can select G and the set X ⊆ V
such that:

solution − cost = 2ǫ|E(G[X])| > 1

holds, which implies that solution − 1 > cost. Existence of such graph is ensured by Lemma 7.
Since the cost function value of a stable set is equal to the cardinality of the stable set itself, this
means that some stable set X ′ of cardinality |X ′ | = solution − 1 has better cost function value
than our set X, even though we can easily extract a stable set of size solution out of the set
X. Therefore, the cost function imprecisely evaluates our solution and can potentially favor some
inferior solutions. To avoid this issue, ǫ should be set to 0, ensuring that solution − cost cannot
exceed 1. Consequently, β = 12 is the most suitable parameter value. If it is any larger, the best
candidate set might not be detected as we have just shown, and if it is smaller, Equation (4) does
not hold anymore due to Corollary 4.

4.2 Analysis of samples

We now analyze all other samples returned by a quantum annealer. When working with quantum
annealers from D-Wave, we can specify how often QPU should run a problem once the problem
has been programmed onto the QPU hardware. Each run of a problem is also known as a read,
an annealing cycle, or a sample. A sample with the lowest cost function will be returned as the
solution to the problem. In the following, we show that, when dealing with the stable set problem,
the solution returned by the solver does not necessarily imply that other samples cannot potentially
offer better results. Furthermore, we will develop a theory for identifying potential samples that
could lead to improved outcomes and present the idea of our post-processing procedure.
Let X ⊆ V be a solution returned by a quantum annealer. If X is not a stable set, we know
from Proposition 5 that we can extract a stable set of size |X| − |E(G[X])|. Now assume that
X ⊆ V is any sample returned by a quantum annealer. Then, if X is not a stable set, we could
again employ the procedure from Proposition 5 and extract a stable set. Nevertheless, we show
that for samples that are not stable sets, we can obtain even better estimations of the size of the
stable sets that can be extracted.
Let us return to Example 6. For a subset of vertices X ⊆ V with |X| = 30 and |E(G[X])| = 5,
Proposition 5 assures us that we can always extract a stable set of size at least 25 from it. However,
it may occur, for instance, that one of the vertices has a degree of 5, and by removing it, we obtain
a stable set of size 29. This property is generalized with the annihilation number of the graph, a
graph parameter that is also an uspper bound on the stability number of a graph, as shown in [30].
Definition 8. For a graph G = (V, E), where d1 ≤ d2 ≤ . . .P
≤ dn for di = d(vi ), the annihilation
a
number a = a(G) is defined as the largest index a such that i=1 di ≤ m, where m is the number
of edges.

11
 We have the following relationship between the annihilation number and the stability number
of a general graph.
Theorem 9. (Pepper, [30]) For any graph G,
α(G) ≤ a(G). (9)

The original paper details the justification for this upper bound, but the concept is rather
straightforward. Let degrees of vertices be defined as above. In each iteration, we remove one
vertex, and we repeat this until we have a stable set. To accelerate the formation of a stable set,
we aim to remove the maximum number of edges in each iteration. Consequently, we prioritize
removing the vertex with the highest degree in the graph, specifically vertex vn . Removing the
vertex of degree dn , the sum of all degrees drops by 2dn . Here we assume the best case scenario,
which is that this reduction occurs in vertices vi , . . . , vi+dn −1 , where vi represents the first non-zero
degree vertex. By preserving the highest degree vertices for as long as possible, we accelerate the
attainment of a stable set. When we remove enough vertices, the total number of edges will drop
to zero, leaving the remaining vertices as the upper bound for the stability number of G.
The bound (9) may not be effective for general graphs. However, we will not apply it to compute
upper bounds for general graphs. Instead, we will use it to compute bounds for graphs induced
from the samples returned by a quantum annealer. These induced graphs possess the property of
being highly sparse. This is due to the annealer’s objective of finding a set X that minimizes the
cost function −|X| + 2β|E(G[X])|. Consequently, in most cases, even when β = 12 , the returned
samples will have negative cost since otherwise, even a single vertex, constituting a stable set,
would have a lower cost function than the set X. Working with sparse graphs implies low vertex
degrees, so the aforementioned upper bound (9), which considers vertex degrees, effectively reduces
the number of samples that need to be evaluated.
The statements of Proposition 5 and Theorem 9 allow us to obtain bounds for the samples that
are not stable sets and to identify whether these samples may improve the solution returned by a
quantum annealer. To assess potential improvements, we need to recompute the stability numbers
of such samples. Given that these samples are sparse, we can reduce the computational costs by
considering their connected components, as stated in the next observation.
Observation 10. Let G be a graph and let C1 , C2 , . . . , Cl be connected components of G. Then
X
l
α(G) = α(Ci ).
i=1

Altogether, combining Proposition 5, Theorem 9, and Observation 10, we develop the method
for enhancing the solutions returned by a quantum annealer. In the following text, we provide a
detailed explanation of this method, which we call the post-processing procedure.

4.3 Post-processing procedure

The main goal of the post-processing procedure is to improve the solution returned by a quantum
annealer. For this purpose, we collect samples that could lead to better solutions and recompute
their stability numbers. Nevertheless, this recalculation can be done using heuristic or exact
methods, not necessarily a quantum annealer. It is also possible to apply a different penalty term
when recalculating the stability number compared to the one used for the computations with a
quantum annealer. To distinguish between the solvers utilized, we give the following definition.
Definition 11. We define solver S(G, β) as a function which takes as input a graph G and the value
of the parameter β and returns the array of solutions [X] = [X1 , . . . , Xk ] such that cost(X1 , β) ≤
cost(X2 , β) ≤ . . . ≤ cost(Xk , β). Furthermore, we define the computed value α̂(G, β, S) as:
α̂(G, β, S) = −cost(X1 , β).

12
 Let S = S(G, β) denote the solver we use to obtain the initial array of solutions [X] =
[X1 , . . . , Xk ], and let Spost = S(G[Xi ], βpost ) denote the solver for recomputing the stability num-
ber of a sample Xi . The post-processing steps are as follows: first, we take a look at X1 , which has
the lowest cost, and define the current best solution as best = |X1 | − |E(G[X1 ])|. If X1 is a stable
set, then |E(G[X1 ])| = 0, and |X1 | = −cost(X1 , β). Otherwise, from Proposition 5, we know that
we can extract a stable set of size at least |X1 | − |E(G[X1 ])| from X1 .
We go through each sample Xi for i = 1 . . . k and check whether a(G[Xi ]) > best. If G[Xi ] is
a stable set, then a(G[Xi ]) ≤ best trivially holds since samples are sorted by cost, implying that
reevaluating the stability number for this sample cannot yield an improved solution. However, if
G[Xi ] is not a stable set but a(G[Xi ]) > best, we recompute the solution on the induced graph
G[Xi ] using Spost . For this purpose, we use Observation 10 and calculate the stability number of
the sample G[Xi ] by considering its connected components. If the new solution surpasses best, we
update its value. However, if the condition a(G[Xi ]) > best is not fulfilled, and since a(G[Xi ]) is
the upper bound for α(G[Xi ]) according to Theorem 9, we know that the sample Xi cannot offer
a better solution than the one we currently have, so we can skip the recalculation on Xi .
In the end, the procedure returns the cardinality of the best solution found. We denote this
value by α̂post ([X], βpost , Spost ). The steps of the general post-processing procedure are outlined
in Algorithm 1.

Algorithm 1: Post-processing procedure, α̂post ([X], βpost , Spost )

Data: [X] from S, βpost , Spost
best ← |X1 | − |E(G[X1 ])|
for i ← 1 to k do
if a(G[Xi ]) > best then
[C1 , . . . , Cl ] ← connected components(G[Xi ])
Pl
s ← j=1 α̂(Cj , βpost , Spost )
if s > best then
best ← s
end
end
end
return best

Finally, we explain how we used Algorithm 1 for our computations. As solver S, we mostly use
D-Wave’s quantum annealer. Nevertheless, we do not use QPU to post-process samples. This is
because these samples are small compared to the overall problem and can be recomputed relatively
easily and cheaply. We have chosen to recompute them with the simulated annealing algorithm,
which is part of the D-Wave library we use to interact with QPU. Although the simulated annealing
again returns an array of solutions, we just focus on the best solution and check whether it is a
stable set. If the solution is a stable set, then we take the computed value. Otherwise, we extract
a stable set by using the procedure presented in the proof of Proposition 5 which removes vertices
with edges one by one until a stable set is obtained.
Regarding the parameter β, we will computationally study how different values of this param-
eter influence the quality of the solutions. If we make computations with β ≥ 21 , then we set
βpost = β. However, if we use β < 12 , we set βpost = 21 . We will perform computations with
β < 12 to explore the behavior of the QPU and assess whether it can produce useful samples for
post-processing. In this scenario, accurate solutions from the QPU are not expected. Thus, to
improve solution accuracy through post-processing, and as argued in Section 4.1, we set βpost = 21 .
Computational results for Algorithm 1 are presented in Section 6.

13
5 Dealing with large instances
As mentioned in Section 1.2, some graphs are too large to be directly embedded on the QPU. In
such cases, we can employ the method of CH-partitioning and divide a graph into multiple smaller
subgraphs, which can then be embedded on the QPU. This method considers a related problem,
namely the maximum clique problem, but, as we will observe, the conversion between the maximum
clique and the maximum stable set is trivial. Therefore, we can use the given method within our
framework for finding the maximum stable set. In Section 5.1, we describe the CH-partitioning
method, and in Section 5.2, we outline a modified version of the CH-partitioning we will use in our
work. Furthermore, in Section 5.3, we discuss bounding procedures that enable us to reduce the
number of partitions we have to consider and present an algorithmic framework that combines the
proposed modified partitioning with the post-processing procedure.

5.1 CH-partitioning
The concept of CH-partitioning was initially introduced in [7] and then further considered in [3]
and is defined as follows.
Definition 12. Given an input graph G = (V, E) with n vertices and a positive integer s ≤ n, a
CH-partition P of graph G is defined as:

P = {(Ci , Hi ) | 1 ≤ i ≤ s},

where
1. the sets Ci ⊂ V are called core sets and theS set {Ci | 1 ≤ i ≤ s} is called core partitioning
since the core sets must partition V , i.e.: i Ci = V and Ci ∩ Cj = ∅ for all i 6= j,
2. there is one complementary set Hi of vertices, also refereed as halo set, for each core set Ci ,
defined as Hi := N (Ci ) \ Ci .
The cost of a CH-partitioning P is defined as:

cost(P) = max (|Ci | + |Hi |).

1≤i≤s

The CH-partitioning problem is finding a CH-partitioning of G with minimum cost for some fixed
s.
The following proposition, which establishes a relation between the maximum clique problem
and CH-partitioning, was shown in [3].
Proposition 13. Given a CH-partitioning P of a graph G, the size of the maximum clique of G
is equal to maxi {ki }, where ki is the size of a maximum clique of the subgraph of G, induced by
Ci ∪ Hi .
Proof. Let K be a maximum
S clique of G = (V, E) and let v be any vertex of K. Since, by definition
of CH-partitioning, i Ci = V , there exists exactly one j such that v belongs to core set Cj , hence
v ∈ Cj ∪ Hj . To show the statement, it is sufficient to show that all other vertices of K are
contained in Cj ∪ Hj .
Let w ∈ K, w 6= v, and assume w ∈ Cj . Then, trivially, w ∈ Cj ∪ Hj , and the statement holds.
Now assume that w ∈ / Cj . Since K is a clique, there is an edge between any two vertices from
it, and hence there is an edge between v and w and w ∈ N (v). Since, by definition, Hj consists
of all neighbors of vertices from Cj that are not in Cj , and since v ∈ Cj and w ∈ / Cj according to
assumption, it follows that w ∈ N (Cj ) \ Cj . Hence, w ∈ Hj , and therefore w ∈ Cj ∪ Hj , so the
statement holds.

14
 Assume we use the presented CH-partitioning method in the following way. Let G = (V, E) be
a graph, where the vertices V are ordered in some ordering, and set Ci = {vi } for all i ∈ {1, . . . , n}.
Then Hi = N (vi ) \ {vi } for all i ∈ {1, . . . , n}. Altogether, this CH-partition consists of n pairs
(Ci , Hi ) and its cost is ∆(G) + 1. This is the CH-partition with the lowest cost function if we
enumerate over all s since each partition has to contain in each set Ci at least one vertex and all
of the neighbors of Ci .
An advantage of this approach is that the computation of the CH-partitioning itself is not
computationally intensive. However, this method also has a disadvantage. Let us assume that K
is a maximum clique such that |K| = k. Then, k partitions contain the same maximum clique.
Thus, we perform computations on k sets containing the same maximum clique. To overcome this
obstacle, we use a modified version of the CH-partitioning.

5.2 Simple CH-partitioning

Our goal is to develop a procedure that reduces the number of partitions containing a maximum
clique. To achieve this, we build upon the concept introduced in [39]. In that work, the authors
explored upper bounds on clique numbers by disregarding subgraphs. We have now adapted
this concept to our CH-partitioning framework. With this adaptation, we define the simple CH-
partitioning as follows.
Definition 14. Given an input graph G = (V, E), a simple CH-partition PS of graph G is defined
as:

PS = {(Ci , Hi ) | 1 ≤ i ≤ n},

where
1. in the core partitioning, the set of vertices V is partitioned into n nonempty disjoint core
sets, Ci = vi for all i ∈ {1, . . . , n},
2. the complementary set Hi of vertices for each core set vi is defined as Hi := N (vi ) \
{v1 , . . . , vi−1 }.
The cost of a simple CH-partitioning PS is defined in a similar way as before:

cost(PS ) = max (|Ci | + |Hi |).

1≤i≤n

An advantage of simple CH-partitioning is that the size of partitions will become smaller as
the partition number approaches n, enabling us to disregard partitions too small to contain a
maximum clique, thus reducing the computational expense. Furthermore, an appropriate vertex
ordering could reduce the size of the largest partitions to less than ∆ + 1. Finally, we show that
the statement of Proposition 13 can also be applied to this new method.
Proposition 15. Given a simple CH-partitioning PS = {(Ci , Hi ) | 1 ≤ i ≤ n} of a graph G, the
size of the maximum clique of G is equal to maxi {ki }, where ki is the size of a maximum clique of
the subgraph of G, induced by Ci ∪ Hi .
Proof. Let K be a maximum clique of G = (V, E), and let |K| = k. Without loss of generality,
let K = {vp1 , vp2 , . . . , vpk } such that 1 ≤ p1 < p2 < . . . < pk ≤ n. For the sake of simplicity, we
introduce also L = {v1 , v2 , . . . , vp1 −1 }, if p1 > 1, and L = ∅, if p1 = 1. Obviously, K ∩ L = ∅.
According to Definition 14, every vertex vj of K is equal to the core set Cj . Selecting the core
set containing the vertex vp1 , we have that Hp1 = N (vp1 ) \ L. For any w ∈ K, w 6= vp1 , we have
w ∈ N (vp1 ) \ L = Hp1 , therefore, K ⊆ Cp1 ∪ Hp1 .

15
Remark 16. Let PS be a simple CH-partitioning of a graph G, and let K be a maximum clique
in G. Then there exists exactly one j ∈ {1, . . . , n} such that K ⊆ Cj ∪ Hj .
Recall that X ⊆ V is a (maximum) clique in G if and only if X is a (maximum) stable set in
G. Since G = G, based on the statement of Proposition 15, we proceed as follows. Suppose we
want to find a maximum stable set in graph G. We first define a simple CH-partition for graph G,
in which we sort the vertices according to predefined ordering. Then we use Proposition 15, and
obtain:

max{ω(G[Ci ∪ Hi ])} = ω(G) = α(G).

i

By definition of the graph complement, we know that Xi is a maximum clique in G[Ci ∪ Hi ] if

and only if Xi is a maximum stable set in G[Ci ∪ Hi ]. Combining all this, we get:

max{α(G[Ci ∪ Hi ])} = max{ω(G[Ci ∪ Hi ])} = ω(G) = α(G).

i i

It is easy to see that G[X] is isomorphic to G[X], and therefore:

max{α(G[Ci ∪ Hi ])} = α(G).
i

This means we can compute the maximum stable set in G by computing maximum stable sets in
subgraphs G[Ci ∪ Hi ] and taking the largest one.
Finally, we note that using simple partitioning greatly reduces the cost of partitioning. We
consider some instances from the literature that cannot be directly embedded on QPU and compare
the costs of regular CH-partitioning for s = n with the costs for the proposed modified version,
where we sort the vertices based on their degrees in increasing order. The results are presented in
Table 1.
Table 1: Comparison of costs of the simple and regular CH-partitioning for s = n

Instance n m d cost(P) cost(PS ) Difference Reduction of cost

brock200 1 200 5066 0.25 166 136 30 18%
brock200 2 200 10024 0.50 115 87 28 24%
brock200 3 200 7852 0.39 135 109 26 19%
brock200 4 200 6811 0.34 148 120 28 19%
keller4 171 5100 0.35 125 103 22 18%
p hat500 1 500 93181 0.75 205 95 110 54%
san200 0 7 1 200 5970 0.30 156 131 25 16%
san200 0 7 2 200 5970 0.30 165 123 42 25%
sanr200 0 7 200 6032 0.30 162 127 35 22%
c-fat200-1 200 18366 0.92 18 17 1 6%
c-fat200-2 200 16665 0.84 35 33 2 6%
c-fat200-5 200 11427 0.57 87 84 3 3%
c-fat500-1 500 120291 0.96 21 20 1 5%
c-fat500-2 500 115611 0.93 39 38 1 3%
c-fat500-5 500 101559 0.81 96 93 3 3%

5.3 Bounding the partitions

The idea of pruning the subproblems in the context of CH-partitioning was previously explored
in [28]. For this purpose, the authors bounded partitions with several approaches, for instance, by

16
coloring the partitions or computing the Lovász theta function. In this work, we use properties of
the simple CH-partitioning and present two simple approaches.
As the first step, we use the previously mentioned advantage of the simple CH-partitioning.
Recall that the simple CH-partitioning yields altogether n pairs (Ci , Hi ). Nevertheless, the size
of partitions will become smaller as the number of partitions approaches n. Now, assume that we
have already computed or just estimated the largest stability number for some partition(s). Then,
if the upper bound of some other partition is at most the best-computed value, the respective
partition cannot contain a larger stable set.
Furthermore, we again use the annihilation number, as defined in Definition 8. Recall that the
annihilation number a(G) of a graph G is the largest integer k such that there exist k different
vertices in G with the degree sum at most m, and represents an upper bound on the stability
number of G, see Theorem 9. Thus, the annihilation number can be used as a reduction strategy:
if the annihilation number of a partition is less than or equal to the size of the largest stable set
found in other partitions, that partition can be disregarded. We also apply post-processing to
every solution, removing excess edges and potentially further improving the solution.
Following the given argumentation, we outline the steps of the simple partitioning procedure
combined with the post-processing in Algorithm 2.

Algorithm 2: Simple CH-partitioning with post-processing α̂part

post (G, β, βpost , S, Spost )
Data: Graph G, β, βpost , S, Spost
best ← 0
Define vertex ordering v1 , v2 , . . . , vn
for i ← 1 to n do
Ci ← {vi }
Hi ← NG (vi ) \ ∪i−1
k=1 {vk }
if a(G[Ci ∪ Hi ]) > best then
[X] ← S(G[Ci ∪ Hi ], β)
s ← α̂post ([X], βpost , Spost )
if s > best then
best ← s
end
end
end
return best

In our computational implementation of Algorithm 2, we use solvers S, Spost , and penalty terms
β, βpost as described in Section 4.3, and we sort the vertices based on their degrees in increasing
order.
However, it is important to note that alternative vertex orderings could also be employed.
Specifically, while introducing the concept of estimating clique size by discarding subgraphs in [39],
the authors explored different vertex orderings and found that these can lead to significantly
different upper bounds. Therefore, investigating the impact of vertex ordering within the context
of simple CH-partitioning combined with post-processing remains a topic for future research.

6 Computational results
We now computationally explore ideas presented in Sections 4 and 5 and report computational
results. We start by giving information about considered instances in Section 6.1. In Section 6.2,
we study the effects of imposing different values of the penalization parameter β in combination
with the proposed post-processing procedure outlined in Algorithm 1. Finally, in Section 6.3,

17
we employ the simple CH-partitioning method combined with the post-processing procedure as
presented in Algorithm 2.
All computations presented in this work were conducted on an Intel(R) Core(TM) i7-9750H with
16GB of RAM. Additionally, we used two cloud solvers from the D-Wave Leap platform: the QPU
solver Advantage_system4.1 and the hybrid solver hybrid_binary_quadratic_model_version2.
We also utilized a classical, locally run simulated annealing solver, which is part of the D-Wave’s
Python library we employed for interacting with the QPU. Finally, we note that the computations
presented in this paper were conducted at the end of 2023 and the beginning of 2024. For these
computations, the only hyperparameter we adjusted in the D-Wave solvers was the number of runs;
all other hyperparameters were left at their default settings.

6.1 Benchmark set

We consider several classes of instances from the literature: DIMACS instances, Paley graphs, and
several evil instances.
• DIMACS instances: We perform experiments on instances from the Second DIMACS Imple-
mentation Challenge [17], which took place in 1992 and 1993 and which dealt with NP-hard
problems maximum clique, graph coloring, and satisfiability. We consider benchmarks for
the maximum clique problem. Additionally, we perform experiments on some of the dsjc
graphs. These graphs are contained in the part of the challenge dealing with graph coloring
but are also interesting from the perspective of the maximum clique problem. Since we study
the stable set problem, we always consider complements of the mentioned instances.
• Paley graphs: The maximum clique problem in Paley graphs has been considered by several
authors; see, for instance, [5] and [13]. We perform experiments on some small Paley graphs
that can be embedded on QPU. Since Paley graphs are self-complementary, their clique
numbers equal their stability numbers. Therefore, we do not complement these instances.
• Evil instances: Extremely hard and versatile (evil) instances for the maximum clique problem
were recently introduced in [34]. As noted in [23], these instances stand out for their ability to
provide a wide range of difficulties, making them a valuable resource in algorithmic research
and development. The benchmark is composed of altogether 40 graphs. In this work, we
consider the complements of graphs with at most 125 vertices.

6.2 Results for the post-processing procedure

In this section, we assess how the post-processing procedure presented in Section 4.3 improves
the initial results from D-Wave’s solvers and explore the relationship between result quality and
different values of the parameter β.
For this purpose, we perform two sets of experiments. In the first set of experiments, we
consider 18 instances with up to 125 vertices that can be embedded on QPU. In the second set
of experiments, we deal with 7 large instances with up to 1500 vertices that cannot be embedded
on QPU and use the hybrid solver. In this case, we obtain only one solution from the solver.
Hence, to fully analyze the potential of the post-processing procedure, we solve these instances
with D-Wave’s simulated annealing solver and post-process all returned samples.
We conduct computations as described in Section 4.3 and outlined in Algorithm 1. For the
results presented in Section 6.2.1, we use QPU as solver S, while for the results presented in
Section 6.2.2, we use hybrid solver as well as simulated annealing as initial solvers S. Additionally,
we note that for the QPU and simulated annealing computations, we run 1000 iterations. Simulated
annealing is employed also as Spost with 100 iterations. We vary the parameter β, including lowering
1
it to 10 . Note that this contradicts the assumption in Lemma 2 requiring β ≥ 21 , but we make this
adjustment for exploratory reasons, aiming to understand the behavior of the QPU and evaluate
its capability to generate valuable samples for post-processing.

18
6.2.1 Results for smaller instances
The results for the first set of experiments are shown in Table 2. Left of the vertical line, we
provide general information about the considered instances: name of the graph, number of nodes
n, number of edges m, edge density d, and the stability number of the graph α(G). Right of
the vertical line, we provide the raw results and results with post-processing. The first two lines
provide the raw results returned by QPU solver. The α̂ represents the highest value of the QUBO
function, and the “# vertices, edges“ represents the number of vertices and the number of edges
in the solution, which yielded this highest value. The last two lines provide the results we got
using post-processing of raw results. The α̂post again represents the value of the QUBO function,
which is computed on the solution we got back from post-processing. Since post-processing always
returns a feasible solution, this number always represents the cardinality of the largest stable set
found. The “# recalculations“ denotes the number of samples for which we have recomputed the
results. If the obtained solution is a stable set and the solution value corresponds to α(G), we
write the value in bold.
From the results presented in Table 2, we can see that post-processing did manage to improve
the results in 5 cases when β = 12 , 8 cases when β = 1, 2 cases when β = 10 and 6 cases
when β = 100. When β was lower than 12 , solutions obtained from QPU had many edges, so
post-processing was essential to extract solutions from the samples.
When β = 12 is used with post-processing, it outperforms larger β values in two cases and
matches the performance of larger β values in the rest. While this may appear insignificant, in
situations where performance equals that of larger β values, the optimal value has already been
reached, so adjusting the parameter cannot further improve it. There was one exception where
the maximum value was not attained, and in this case, β = 21 did not outperform higher β values.
Despite this, we can still confirm that our intuition in β = 12 being the most suitable parameter
aligns with the outcomes, as it performed equally well, and sometimes even better, than other
larger β values. Furthermore, we note that parameters β = 10 and β = 100 never outperformed
β = 1, and in 6 instances, they yielded lower solutions.
We observed that decreasing β < 21 and utilizing post-processing with βpost = 12 can produce
results equal to or better than those obtained with β = 12 . Nevertheless, it might be that this
enhancement is due to the graph size, as smaller graphs with lower β values result in post-processed
samples containing more vertices than higher β values. For instance, for graphs C125.9 and
dsjc125.9, superior solutions are achieved with lower β values. When we examine the number
1
of vertices in the solutions being post-processed, such as C125.9 with β = 10 , the initial solution
contains 62 nodes, half of all vertices in the graph. Furthermore, the initial solution may not
always be the largest post-processed solution; even larger solutions may exist. Considering this, it
is reasonable to expect that lower β values may perform better for these smaller graphs by allowing
larger solutions to be post-processed.
A potential drawback of our post-processing method when using β < 12 is the increased compu-
tational expense compared to β = 21 and β > 12 . This higher cost arises from the need to process a
1
larger quantity of samples. For example, with C125.9 and β = 10 , we had to recompute stability
1
numbers on all 1000 samples, while with β = 2 , recomputation was needed on only one sample.
Additionally, the computational effort varies between β = 12 and β > 21 , with β > 12 generally
requiring less effort, as seen in instances like dsjc125.5. However, this trend reverses for instances
such as paley89 and paley101, where β = 1 required more recalculations than β = 12 .
Recall that we recalculate the stability numbers of samples by considering their connected
components. To explore the structure of the samples and evaluate the complexity of these recal-
culations, the cardinalities of the largest components considered are presented in Table 3.
1 1
Data presented in Table 3 indicate that when the calculations are performed with β ∈ { 10 , 8 },
the components we need to consider are quite large compared to the size of the graph. For example,
for the instance MANN_a9, the components encompassed nearly all vertices of the graph. The largest
components contained 13 vertices when the calculations were executed with β = 16 . For all other

19
Table 2: Numerical results for the post-processing procedure for QUBO formulation with different values of penalty
term β, where the QPU solver is used as the initial solver S in Algorithm 1

Instance Data Value Result β = 1/10 β = 1/8 β = 1/6 β = 1/4 β = 1/2 β=1 β = 10 β = 100
C125.9 n 125 α̂ 46.8 43.2 40.6 37 31 29 24 21
m 787 # vertices, edges 62, 76 57, 55 49, 25 41, 8 35, 4 29, 0 24, 0 21, 0
d 0.10 α̂post 34 34 34 34 32 29 24 22
α(G) 34 # recalculations 1000 1000 973 155 1 0 0 1
dsjc125.5 n 125 α̂ 6.8 9 6.3 4.5 5 4 6 4
m 3859 # vertices, edges 14, 36 16, 28 11, 14 10, 11 5, 0 6, 1 6, 0 4, 0
d 0.50 α̂post 7 9 7 7 7 7 6 6
α(G) 10 # recalculations 1000 692 495 696 280 5 0 37
dsjc125.9 n 125 α̂ 45.2 41.2 39 35 32 26 23 21
m 789 # vertices, edges 62, 84 55, 55 46, 21 40, 10 34, 2 28, 1 23, 0 21, 0
d 0.10 α̂post 34 34 34 33 32 27 23 22
α(G) 34 # recalculations 1000 993 552 80 0 0 0 1
evil chv12x10 n 120 α̂ 45.8 40.8 35.3 30 20 20 20 20
m 545 # vertices, edges 69, 116 62, 85 51, 47 41, 22 28, 8 20, 0 20, 0 20, 0
d 0.08 α̂post 20 20 20 20 20 20 20 20
α(G) 20 # recalculations 1000 999 1000 984 105 1 0 0
evil myc5x24 n 120 α̂ 75.8 70 62.3 55 48 48 44 43
m 236 # vertices, edges 100, 121 97, 108 80, 53 67, 24 51, 3 48, 0 44, 0 43, 0
d 0.03 α̂post 48 48 48 48 48 48 44 43
α(G) 48 # recalculations 748 260 1000 698 1 0 0 0
evil myc11x11 n 121 α̂ 50 43.8 36.7 33 22 22 22 22
m 508 # vertices, edges 75, 130 6, 89 57, 61 44, 22 32, 10 22, 0 22, 0 22, 0
d 0.07 α̂post 22 22 22 22 22 22 22 22
α(G) 22 # recalculations 1000 1000 1000 958 109 2 0 0
evil s3m25x5 n 125 α̂ 38.6 35.8 31.3 25 20 19 19 17
m 873 # vertices, edges 53, 72 49, 53 45, 41 36, 22 23, 3 19, 0 19, 0 17, 0
d 0.11 α̂post 20 20 20 20 20 20 19 18
α(G) 20 # recalculations 1000 999 1000 997 139 2 0 1
hamming6 2 n 64 α̂ 32 32 32 32 32 32 32 32
m 192 # vertices, edges 32, 0 32, 0 32, 0 32, 0 32, 0 32, 0 32, 0 32, 0
d 0.10 α̂post 32 32 32 32 32 32 32 32
α(G) 32 # recalculations 0 0 0 0 0 0 0 0
hamming6 4 n 64 α̂ 6.6 5.5 4 4 4 2 4 4
m 1312 # vertices, edges 12, 27 11, 22 8, 12 7, 6 4, 0 4, 1 4, 0 4, 0
d 0.65 α̂post 4 4 4 4 4 4 4 4
α(G) 4 # recalculations 994 989 923 78 88 74 11 43
johnson8 2 4 n 28 α̂ 7.2 6 5.3 4 4 4 4 4
m 168 # vertices, edges 12, 24 10, 16 8, 8 7, 6 4, 0 4, 0 4, 0 4, 0
d 0.44 α̂post 4 4 4 4 4 4 4 4
α(G) 4 # recalculations 955 998 560 51 0 0 0 0
johnson8 4 4 n 70 α̂ 16.8 14 14 14 14 14 12 11
m 560 # vertices, edges 22, 56 19, 20 14, 0 14, 0 14, 0 14, 0 12, 0 12, 0
d 0.23 α̂post 14 14 14 14 14 14 12 11
α(G) 14 # recalculations 379 7 0 0 0 0 0 0
johnson16 2 4 n 120 α̂ 14.2 12 10.33 8 7 7 7 8
m 1680 # vertices, edges 25, 54 20, 32 17, 20 14, 12 9, 2 7, 0 7, 0 8, 0
d 0.24 α̂post 8 8 8 8 8 8 7 8
α(G) 8 # recalculations 1000 1000 989 558 15 2 2 0
MANNa 9 n 45 α̂ 30.6 27 24 20 16 16 16 16
m 72 # vertices, edges 45, 72 39, 48 36, 36 27, 14 17, 1 16, 0 16, 0 16, 0
d 0.07 α̂post 16 16 14 15 16 16 16 16
α(G) 16 # recalculations 12 311 58 454 0 0 0 0
paley61 n 61 α̂ 8.4 7.5 6.7 6 5 5 5 5
m 915 # vertices, edges 14, 28 12, 18 9, 7 8, 4 6, 1 5, 0 5, 0 5, 0
d 0.50 α̂post 5 5 5 5 5 5 5 5
α(G) 5 # recalculations 1000 991 950 361 230 39 5 15
paley73 n 73 α̂ 8.2 8 6.3 6 5 4 5 5
m 1314 # vertices, edges 13, 24 18, 16 11, 14 9, 6 6, 1 6, 1 5, 0 5, 0
d 0.50 α̂post 5 5 5 5 5 5 5 5
α(G) 5 # recalculations 1000 1000 1000 724 151 152 55 58
paley89 n 89 α̂ 7.4 5 4.3 4.5 3 0 5 0
m 1958 # vertices, edges 13, 28 14, 36 11, 20 11, 13 7, 4 0, 0 5, 0 0, 0
d 0.50 α̂post 5 5 5 5 5 5 5 5
α(G) 5 # recalculations 1000 1000 1000 1000 881 999 13 512
paley97 n 97 α̂ 8.6 7 6.3 6 2 6 4 0
m 2328 # vertices, edges 13, 22 13, 24 10, 11 9, 6 8, 6 6, 0 4, 0 0, 0
d 0.50 α̂post 6 6 6 6 6 6 5 6
α(G) 6 # recalculations 920 999 616 20 777 11 29 362
paley101 n 101 α̂ 7.4 7.5 4 3 5 0 0 5
m 2525 # vertices, edges 16, 40 11, 14 13, 27 11, 16 6, 1 0, 0 0, 0 5, 0
d 0.50 α̂post 5 5 5 5 5 5 5 5
α(G) 5 # recalculations 1000 977 1000 1000 33 964 454 0

values of the parameters, we observe that the component sizes were relatively small, suggesting
that the recomputation can be carried out efficiently.

20
Table 3: Cardinalities of the largest components considered in the post-processing of results presented in Table 2

Instance n β = 1/10 β = 1/8 β = 1/6 β = 1/4 β = 1/2 β=1 β = 10 β = 100

C125.9 125 67 60 47 18 3 1 1 2
dsjc125.5 125 26 26 19 19 21 14 1 15
dsjc125.9 125 66 59 45 24 1 1 1 1
evil chv12x10 120 71 50 31 12 6 4 1 1
evil myc5x24 120 108 95 50 14 4 1 1 1
evil myc11x11 121 78 44 23 10 6 4 1 1
evil s3m25x5 125 59 51 45 22 10 4 1 2
hamming6 2 64 1 1 1 1 1 1 1 1
hamming6 4 64 15 14 16 10 10 11 10 9
johnson8 2 4 28 14 12 10 9 1 1 1 1
johnson8 4 4 70 29 24 1 1 1 1 1 1
johnson16 2 4 120 31 25 8 19 12 8 4 1
MANNa 9 45 45 43 13 6 1 1 1 1
paley61 61 20 15 15 12 12 10 8 9
paley73 73 19 20 16 14 11 11 10 9
paley89 89 20 22 22 19 16 16 9 14
paley97 97 18 22 17 12 18 12 11 16
paley101 101 26 18 22 19 12 18 14 1

6.2.2 Results for larger instances

We now investigate how different β values, in combination with the post-processing procedure,
perform on larger graphs. Since we could not do those computations on QPU, we use the hybrid
solver and simulated annealing as initial solvers S in Algorithm 1, while the post-processing is
done with simulated annealing, as explained at the beginning of Section 6.2. Note that although
the hybrid solver returns only one solution, we can still post-process it. The results for the hybrid
solver are shown in Table 4 and the results for the simulated annealing in Table 5. These tables
contain the same information as Table 2.
From the results presented in Table 4, we observe that using lower β values with the hybrid
solver generally led to worse results compared to β = 21 , with an exception being the graph
brock800_2 when β = 41 . The results for simulated annealing shown in Table 5 are slightly better
for lower β values, but still, in none of the cases did lower β values yield superior results, even
though the optimal value has not been reached yet. Interestingly, in graphs p_hat1500_3 and
p_hat1500_2 not a single lower β has matched the result of β = 12 . This again supports the
interpretation that the reason why lower values of β performed better than larger β values on
instances shown in Table 2 is mainly the graph size (in Table 2 the instances are smaller, so we
can afford re-computations of many relatively larger samples), and not because the lower β values
are a more appropriate choice for this problem.
When we compare results for β = 12 and β = 1, we note that β = 21 gave better results for
2 instances when the hybrid solver was used, and 4 instances when the simulated annealing was
employed. Results for β = 10 and β = 100 show that the hybrid solver still performs well, while
simulated annealing demonstrates much worse performance, i.e., the choice of penalty term in the
QUBO formulation significantly affects the performance of simulated annealing.
Regarding the complexity of the post-processing procedure, when using the hybrid solver, only
one solution is obtained, making post-processing a less intensive task. For computations done with
simulated annealing, we analyze the sizes of the largest connected components of post-processed
samples and present this information in Table 6.
From Table 6, we can see that the sizes of connected components are larger when lower values
of β are used. However, for β ∈ { 61 , 14 }, the sizes of components are relatively small. This

21
Table 4: Numerical results for the post-processing procedure for QUBO formulations with different values of
penalty term β, where the hybrid solver is used as the initial solver S in Algorithm 1

Instance Data Value Result β = 1/10 β = 1/8 β = 1/6 β = 1/4 β = 1/2 β=1 β = 10 β = 100
brock800 1 n 800 α̂ 26.8 25 23.3 22 21 21 21 21
m 112095 # vertices, edges 36, 46 32, 28 29, 17 25, 6 22, 1 21 0 21, 0 21, 0
d 0.35 α̂post 18 18 18 19 21 21 21 21
α(G) 23 # recalculations 1 1 1 0 0 0 0 0
brock800 2 n 800 α̂ 26.8 25.25 23.33 22 21 21 21 21
m 111434 # vertices, edges 35, 41 33, 31 26, 8 23, 2 21, 0 21, 0 21, 0 21, 0
d 0.35 α̂post 20 20 20 21 21 21 21 21
α(G) 24 # recalculations 1 1 1 0 0 0 0 0
brock800 3 n 800 α̂ 27 25.75 24.33 21.5 22 22 21 21
m 112267 # vertices, edges 33, 30 31, 21 28, 11 24, 5 22, 0 22, 0 21, 0 21, 0
d 0.35 α̂post 22 22 22 20 22 22 21 21
α(G) 25 # recalculations 1 1 1 1 0 0 0 0
brock800 4 n 800 α̂ 26.6 24.75 23 22.5 21 20 21 21
m 111957 # vertices, edges 36, 47 32, 29 27, 12 25, 5 22, 1 20, 0 21, 0 21, 0
d 0.35 α̂post 18 18 19 20 21 20 21 21
α(G) 26 # recalculations 1 1 1 0 0 0 0 0
p hat1500 1 n 1500 α̂ 14.8 13.75 13 12.5 12 11 11 11
m 839327 # vertices, edges 20, 26 18, 17 15, 6 14, 3 12, 0 11, 0 11, 0 11, 0
d 0.74 α̂post 10 10 11 11 12 11 11 11
α(G) 12 # recalculations 1 1 1 0 0 0 0 0
p hat1500 2 n 1500 α̂ 86.2 80.5 74.67 68.5 65 65 65 65
m 555290 # vertices, edges 113, 134 105, 98 91, 49 78, 19 68, 3 65, 0 65, 0 65, 0
d 0.49 α̂post 63 62 63 63 65 65 65 65
α(G) 65 # recalculations 1 1 1 1 0 0 0 0
p hat1500 3 n 1500 α̂ 122.4 114.75 107 99.5 94 94 94 94
m 277006 # vertices, edges 162, 198 146, 125 128, 63 112, 25 97, 3 94, 0 94, 0 94, 0
d 0.25 α̂post 89 89 88 92 94 94 94 94
α(G) 94 # recalculations 1 1 1 1 0 0 0 0

Table 5: Numerical results for the post-processing procedure for QUBO formulations with different values of
penalty term β, where the simulated annealing is used as the initial solver S in Algorithm 1

Instance Information Value Result β = 1/10 β = 1/8 β = 1/6 β = 1/4 β = 1/2 β=1 β = 10 β = 100
brock800 1 n 800 α̂ 26.8 25 23 21.5 21 20 17 15
m 112095 # vertices, edges 35, 41 31, 24 25, 6 25, 7 21, 0 20, 0 17, 0 15, 0
d 0.35 α̂post 21 21 21 21 21 20 17 15
α(G) 23 # recalculations 919 318 69 2 0 0 0 0
brock800 2 n 800 α̂ 26.8 25.25 23.33 22 21 20 17 15
m 111434 # vertices, edges 33, 31 33, 31 27, 11 24, 4 22, 1 20, 0 17, 0 15, 0
d 0.35 α̂post 20 21 21 21 21 20 17 15
α(G) 24 # recalculations 995 349 68 1 0 0 0 0
brock800 3 n 800 α̂ 27 25.75 24.33 22.5 22 22 17 15
m 112267 # vertices, edges 32, 25 32, 25 28, 11 25, 5 23, 1 22, 0 17, 0 15, 0
d 0.35 α̂post 22 22 22 22 22 22 17 15
α(G) 25 # recalculations 465 29 4 1 0 0 0 0
brock800 4 n 800 α̂ 26.4 24.75 23.3 22 21 20 17 15
m 111957 # vertices, edges 34, 38 32, 29 25, 5 23, 2 21, 0 20, 21 17, 0 15, 0
d 0.35 α̂post 21 21 21 21 21 20 17 15
α(G) 26 # recalculations 870 362 58 0 0 0 0 0
p hat1500 1 n 1500 α̂ 14.8 13.75 13 12.5 12 11 9 9
m 839327 # vertices, edges 21, 31 19, 21 16, 9 14, 3 12, 0 11, 0 9, 0 9, 0
d 0.74 α̂post 11 12 11 12 12 11 9 9
α(G) 12 # recalculations 954 480 98 1 0 0 0 0
p hat1500 2 n 1500 α̂ 86.2 80.5 74.67 68.5 65 65 56 43
m 555290 # vertices, edges 116, 149 104, 94 90, 46 76, 15 67, 2 65, 0 56, 0 43, 0
d 0.49 α̂post 63 63 63 64 65 65 56 43
α(G) 65 # recalculations 1000 1000 1000 152 0 0 0 0
p hat1500 3 n 1500 α̂ 122.4 114.75 107 99.5 94 94 76 59
m 277006 # vertices, edges 158, 178 144, 117 134, 81 110, 21 99, 5 94, 0 76, 0 59. 0
d 0.25 α̂post 91 91 91 93 94 94 76 59
α(G) 94 # recalculations 1000 1000 1000 369 0 0 0 0

observation has also been seen in smaller instances, as shown in Table 3. It is interesting to note
this pattern considering that the graphs now are significantly larger compared to those in Table 3.
Despite working with graphs with over 800 vertices, the largest components we recalculated stability
numbers for had a maximum of 34 vertices. Finally, we note that for β ≥ 21 , there were no instances
where improved solutions could be obtained, leading us to skip the recalculation of the stability
numbers for all returned samples.

22
Table 6: Cardinalities of the largest components considered in the post-processing of results presented in Table 5

Instance n β = 1/10 β = 1/8 β = 1/6 β = 1/4 β = 1/2 β=1 β = 10 β = 100

brock800 1 800 38 33 18 3 1 1 1 1
brock800 2 800 38 35 16 2 1 1 1 1
brock800 3 800 38 31 8 5 1 1 1 1
brock800 4 800 37 32 17 1 1 1 1 1
p hat1500 1 500 22 20 14 3 1 1 1 1
p hat1500 2 1500 112 95 34 11 1 1 1 1
p hat1500 3 1500 156 128 34 7 1 1 1 1

6.3 Solving larger instances with partitioning

As the final set of experiments, we consider large graphs that cannot be embedded on QPU
and employ the method of the simple CH-partitioning as explained in Section 5 and outlined in
Algorithm 2. Hence, we first partition the graph into subproblems that can be embedded on QPU,
run 100 iterations on QPU, and then post-process the samples with simulated annealing, where
the number of runs is also set to 100. Since our previous computational investigation suggests that
the best choice for the penalty parameter is 21 , we set β = βpost = 21 . The vertices are ordered
such that d(v1 ) ≤ d(v2 ) ≤ · · · ≤ d(vn ), allowing us to reduce the size of partitions. To evaluate the
results, we compare them with those obtained using the hybrid solver.
The results are presented in Table 7. Columns 1 − 5 contain the basic information about the
considered instances: name of the instance, number of vertices n, number of edges m, edge density
d and the stability number α(G). In columns 6 − 9, the results for the hybrid solver and the
simple partitioning are presented. The results for the hybrid solver contain information about the
solution that was post-processed and the number of vertices and edges in the solution before it
was post-processed. The simple partitioning results contain the best result from all post-processed
partitions and the number of partitions we considered. We write the value in bold if the optimum
was achieved by either the hybrid solver or the simple partitioning method.
From the results presented in Table 7, we note that for instances with densities up to 0.50,
the hybrid solver performed better than the simple partitioning. More precisely, the hybrid solver
gave better solutions for 5 of 8 instances. However, the optimal value was not always attained. In
contrast, both methods yielded optimal results for 7 instances with densities higher than 0.50.
We note that instances san200_0_7_1 and san200_0_7_2 appear to be the most challenging for
both methods. Despite producing identical results, the deviation from the optimal values for these
instances is substantial. Other challenging instances are brock graphs. For 4 considered instances,
the hybrid solver found 2 optimal solutions, while the partitioning method yielded suboptimal
results.
Nevertheless, the simple partitioning method performed extremely well on c-fat instances.
The proposed bounding procedure significantly reduced the number of partitions, and we obtained
optimal solutions for all 6 instances by considering only 3 partitions for each instance.
Altogether, the presented initial results demonstrate the potential of the proposed simple par-
titioning. While the hybrid solver gave better solutions for certain instances, the differences in
results were no more than 2 vertices. Overall, by employing a few simple techniques, we attained
results similar to those obtained by the hybrid solver.

7 Conclusion
This paper presents a detailed analysis of solutions for the stable set problem generated by the
D-Wave’s quantum annealer, providing both theoretical insights and computational findings. We

23
Table 7: Results for the computations with simple graph partitioning method combined with the post-processing
procedure

Instance n m d α(G) Hybrid solver Simple CH-partitioning

keller4 171 5100 0.35 11 α̂post 11 α̂part
post 11
# vertices, edges 13, 2 # partitions 147/171
part
brock200 1 200 5066 0.25 21 α̂post 21 α̂post 19
# vertices, edges 21, 0 # partitions 161/200
brock200 2 200 10024 0.50 12 α̂post 12 α̂part
post 10
# vertices, edges 12, 0 # partitions 170/200
part
brock200 3 200 7852 0.39 15 α̂post 14 α̂post 13
# vertices, edges 14, 0 # partitions 166/200
brock200 4 200 6811 0.34 17 α̂post 16 α̂part
post 14
# vertices, edges 16, 0 # partitions 170/200
part
san200 0 7 1 200 5970 0.30 30 α̂post 16 α̂post 16
# vertices, edges 24, 8 # partitions 174/200
san200 0 7 2 200 5970 0.30 18 α̂post 13 α̂part
post 13
# vertices, edges 20, 7 # partitions 182/200
part
sanr200 0 7 200 6032 0.30 18 α̂post 18 α̂post 17
# vertices, edges 18, 0 # partitions 166/200
c-fat200-1 200 18366 0.92 12 α̂post 12 α̂part
post 12
# vertices, edges 12, 0 # partitions 3/200
c-fat200-2 200 16665 0.84 24 α̂post 24 α̂part
post 24
# vertices, edges 24, 0 # partitions 3/200
part
c-fat200-5 200 11427 0.57 58 α̂post 58 α̂post 58
# vertices, edges 58, 0 # partitions 3/200
c-fat500-1 500 120291 0.96 14 α̂post 14 α̂part
post 14
# vertices, edges 58, 0 # partitions 3/500
part
c-fat500-2 500 115611 0.93 26 α̂post 26 α̂post 26
# vertices, edges 26, 0 # partitions 3/500
c-fat500-5 500 101559 0.81 64 α̂post 64 α̂part
post 64
# vertices, edges 64, 0 # partitions 3/500
part
p hat500 1 500 93181 0.75 9 α̂post 9 α̂post 9
# vertices, edges 9, 0 # partitions 470/500

formulated the stable set problem as a QUBO problem with quadratic constraints weighted by a
penalty parameter β. We showed that with an exact QUBO solver, the optimal value for β ≥ 12
is the stability number of the graph. However, due to the heuristic nature of quantum annealing,
solutions from the D-Wave’s QPU are often far from optimal values and may not even represent
stable sets, as indicated by our computational results for instances with up to 125 vertices. To
address these challenges, we proposed a post-processing procedure that enables us to detect samples
that could lead to improved solutions and to extract solutions that are stable sets. Also, we provided
theoretical guarantees about the quality of the extracted solutions.
We have employed the post-processing procedure on graphs that can be embedded on QPU but
also on larger instances, for which we used the D-Wave hybrid solver and the classical simulated
annealing solver from the D-Wave’s library for interacting with QPU. A comparison of the results
for large instances revealed that the solutions obtained using the hybrid solver and simulated
annealing are very similar. This may partially explain how the hybrid solver is running.
Computational results showed that the post-processing procedure greatly improved solution
quality. Currently, selected samples are post-processed using simulated annealing, but alternative
approaches could further enhance outcomes. Due to the small and sparse nature of the post-
processed samples, an exact method may yield superior results in a shorter time.
Since not all instances can be embedded on the D-Wave’s QPU, we explored methods to ad-
dress this issue. We used the simple CH-partitioning method as an alternative to the D-Wave’s
hybrid solver for certain instances. In this approach, we break down the original problem into
smaller subproblems, solve them using the QPU, and then take the largest stable set across the
subproblems as the final solution. To improve the quality of results, we combined the proposed
partitioning method with the post-processing procedure and obtained promising results. Future

24
research should concentrate on creating techniques to break down partitions further, recognizing
partitions that could lead to optimal solutions, and investigating additional efficient reduction
strategies to decrease computational costs. In particular, it would be valuable to investigate the
impact of different vertex orderings.
Furthermore, in order to assess the impact of different β values on the quality of solutions, we
conducted thorough numerical experiments with various values of the penalty term β ranging from
1 1
10 to 100. Our computational results indicated that β = 2 produced the best quality solutions,
which is in accordance with the given theoretical guarantees. Nevertheless, it would be valuable to
conduct further computational experiments by exploring values of β in the form β = 21 ± ǫ, where
ǫ is small.
Finally, the only hyperparameter we adjusted in the D-Wave solvers for the computations
presented in this work was the number of runs, while all other hyperparameters were left at their
default settings. Future research should explore varying additional parameters of the QPU, such as
annealing time, spin reversal transforms, and chain strength. Optimizing these parameters could
enhance the performance of the QPU before applying the post-processing procedure.

Disclosure statement
The authors report there are no competing interests to declare.

Acknowledgments
We thank the two anonymous reviewers for their insightful comments and suggestions, which have
substantially improved this paper.

Data availability statement

The program code associated with this paper is available as ancillary files from the arXiv page of
this paper: arXiv:2405.12845. Additionally, the source code and data are available upon request
from the authors.

Funding
The research of the first and second authors was funded by the Slovenian Research and Innovation
Agency (ARIS) through the annual work program of Rudolfovo. The second author was also
partially funded by research program P2-0162. The research of the third author was funded by the
Austrian Science Fund (FWF) [10.55776/DOC78]. For the purposes of open access, the authors
have applied a CC BY public copyright license to all author-accepted manuscript versions resulting
from this submission.

References
[1] Suresh Bolusani, Mathieu Besançon, Ksenia Bestuzheva, Antonia Chmiela, João Dionı́sio, Tim
Donkiewicz, Jasper van Doornmalen, Leon Eifler, Mohammed Ghannam, Ambros Gleixner,
Christoph Graczyk, Katrin Halbig, Ivo Hedtke, Alexander Hoen, Christopher Hojny, Rolf
van der Hulst, Dominik Kamp, Thorsten Koch, Kevin Kofler, Jurgen Lentz, Julian Manns,
Gioni Mexi, Erik Mühmer, Marc E. Pfetsch, Franziska Schlösser, Felipe Serrano, Yuji Shinano,
Mark Turner, Stefan Vigerske, Dieter Weninger, and Lixing Xu. The SCIP Optimization Suite
9.0. Technical report, Optimization Online, 2024.

25
 [2] Kelly Boothby, Paul Bunyk, Jack Raymond, and Aidan Roy. Next-Generation Topology of
D-Wave Quantum Processors. arXiv:2003.00133, 2020.
[3] Guillaume Chapuis, Hristo Djidjev, Georg Hahn, and Guillaume Rizk. Finding Maximum
Cliques on a Quantum Annealer. Journal of Signal Processing Systems, 91, 2019.
[4] Vicky Choi. The effects of the problem hamiltonian parameters on the minimum spectral gap
in adiabatic quantum optimization. Quantum Information Processing, 19, 2020.
[5] Stephen Cohen. Clique numbers of Paley graphs. Quaestiones Mathematicae, 11:225–231,
1988.
[6] Matjaž Depolli, Janez Konc, Kati Rozman, Roman Trobec, and Dusanka Janezic. Exact
Parallel Maximum Clique Algorithm for General and Protein Graphs. Journal of chemical
information and modeling, 53, 2013.
[7] Hristo N. Djidjev, Georg Hahn, Susan M. Mniszewski, Christian F. A. Negre, Anders M. N.
Niklasson, and Vivek Sardeshmukh. Graph Partitioning Methods for Fast Parallel Quantum
Molecular Dynamics. In International Conference on Scientific Computing, 2016.
[8] D-Wave Solver Docs. Auto scaling and chain strength, Getting started, D-
Wave solver Docs. [Link]
and [Link] (accessed:
14.04.2024).
[9] D-Wave Solver Docs. What is Quantum Annealing?, Getting started, D-Wave Solver Docs.
[Link]
(accessed: 29.04.2024).
[10] Tuvi Etzion and Patric Ostergard. Greedy and heuristic algorithms for codes and colorings.
IEEE Transactions on Information Theory, 44:382 – 388, 1998.
[11] Gurobi Optimization, LLC. Gurobi Optimizer Reference Manual, 2023.
[12] Nicolò Gusmeroli, Timotej Hrga, Borut Lužar, Janez Povh, Melanie Siebenhofer, and Angelika
Wiegele. BiqBin: A Parallel Branch-and-bound Solver for Binary Quadratic Problems with
Linear Constraints. ACM Transactions on Mathematical Software, 48(2):1–31, 2022.
[13] Brandon Hanson and Giorgis Petridis. Refined estimates concerning sumsets contained in the
roots of unity. Proceedings of the London Mathematical Society, 122(3):353–358, 2021.
[14] Timotej Hrga, Borut Lužar, Janez Povh, and Angelika Wiegele. BiqBin: Moving boundaries
for NP-hard problems by HPC. In Advances in High Performance Computing: Results of
the International Conference on “High Performance Computing” Borovets, Bulgaria, 2019.
Springer, 327–339, 2021.
[15] IBM. IBM CPLEX. Software, 2022.
[16] Yan Jin and Jin-Kao Hao. General swap-based multiple neighborhood tabu search for the
maximum independent set problem. Eng. Appl. Artif. Intell., 37:20–33, 2015.
[17] David J. Johnson and Michael A. Trick. Cliques, Coloring, and Satisfiability: Second DI-
MACS Implementation Challenge, October 11-13, 1993. Center for Discrete Mathematics and
Theoretical Computer Science New Brunswick, NJ: DIMACS series in discrete mathematics
and theoretical computer science. American Mathematical Society, 1996.
[18] Richard Karp. Reducibility Among Combinatorial Problems. Complexity of Computer Com-
putations, 40:85–103, 1972.

26
[19] Aljaž Krpan. Reševanje problema največje neodvisne množice s kvantnimi žarilniki. Bachelor’s
thesis, University of Ljubljana, Slovenia, 2023.
[20] Sebastian Lamm, Peter Sanders, Christian Schulz, Darren Strash, and Renato F. Werneck.
Finding near-optimal independent sets at scale. Journal of Heuristics, 23:207 – 229, 2015.
[21] Andrew Lucas. Ising formulations of many NP problems. Frontiers in Physics, 2:5, 2014.
[22] Noël Malod-Dognin, Rumen Andonov, and Nicola Yanev. Maximum Cliques in Protein Struc-
ture Comparison. In Experimental Algorithms, 106–117, 2010.
[23] Raffaele Marino, Lorenzo Buffoni, and Bogdan Zavalnij. A Short Review on Novel Approaches
for Maximum Clique Problem: from Classical algorithms to Graph Neural Networks and
Quantum algorithms. arXiv:2403.09742, 2024.
[24] Catherine McGeoch, Pau Farre, and William Bernoudy. D-Wave hybrid solver service +
Advantage: Technology update. Technical Report, 2020.
[25] Satoshi Morita and Hidetoshi Nishimori. Mathematical Foundation of Quantum Annealing.
Journal of Mathematical Physics, 49, 2008.
[26] Ojas Parekh, Jeremy Wendt, Luke Shulenburger, Andrew Landahl, Jonathan Moussa, and
John Aidun. Benchmarking Adiabatic Quantum Optimization for Complex network Analysis,
2016.
[27] Elijah Pelofske. Comparing Three Generations of D-Wave Quantum Annealers for Minor
Embedded Combinatorial Optimization Problems. arXiv:2301.03009, 2023.
[28] Elijah Pelofske, Georg Hahn, and Hristo Djidjev. Solving Large Maximum Clique Problems on
a Quantum Annealer. In Quantum Technology and Optimization Problems, Cham, 123–135,
2019. Springer International Publishing.
[29] Elijah Pelofske, Georg Hahn, and Hristo N. Djidjev. Solving larger maximum clique problems
using parallel quantum annealing. Quantum Information Processing, 22(5):219, 2023.
[30] Ryan Pepper. On the Annihilation Number of a Graph. Proceedings of the 15th American
Conference on Applied Mathematics, World Scientific and Engineering Academy and Society,
217-220, 2009.

[31] Janez Povh and Dunja Pucher. Advancing stable set problem solutions through quantum
annealers. arXiv:2308.13041, 2023.
[32] Christoph Roch, Daniel Ratke, Jonas Nüßlein, Thomas Gabor, and Sebastian Feld. The Effect
of Penalty Factors of Constrained Hamiltonians on the Eigenspectrum in Quantum Annealing.
ACM Transactions on Quantum Computing, 4(2), 2023.
[33] Pablo San Segundo, Fernando Matia, Diego Rodrı́guez-Losada, and Miguel Hernando. An
improved bit parallel exact maximum clique algorithm. Optimization Letters, 7:467–479,
2011.
[34] Sandor Szabo and Bogdán Zaválnij. Benchmark problems for exhaustive exact maximum
clique search algorithms. Informatica, 43, 177–186, 2019.
[35] Oliver Weide, David Ryan, and Matthias Ehrgott. An iterative approach to robust and
integrated aircraft routing and crew scheduling. Computers & Operations Research, 37, 833-
844, 2010.

27
[36] Qinghua Wu and Jin-Kao Hao. A review on algorithms for maximum clique problems. Euro-
pean Journal of Operational Research, 242:693–709, 2015.
[37] Sheir Yarkoni, Aske Plaat, and Thomas Back. First Results Solving Arbitrarily Structured
Maximum Independent Set Problems Using Quantum Annealing. In 2018 IEEE Congress on
Evolutionary Computation (CEC), 1-6, 2018.
[38] Sheir Yarkoni, Elena Raponi, Thomas Bäck, and Sebastian Schmitt. Quantum Annealing for
Industry Applications: Introduction and Review. Reports on Progress in Physics, 85, 2022.
[39] Bogdán Zaválnij and Sandor Szabo. Estimating clique size via discarding subgraphs. Infor-
matica, 45, 06 2021.

28