100,000-Vertex-Scale MAXCUT Instances Derived from Not-All-Equal 3SAT with Certified Optimal Solutions

1. Introduction

The Ising model consists of spins and pairwise interactions between them. Finding the ground state of an Ising model, i.e., the spin configuration that minimizes its energy, is known to be an NP-hard problem [1]. For Ising models without external fields, the ground-state search problem can be reduced to the MAXCUT problem, where spins correspond to vertices and interactions correspond to edges. Since many NP-hard problems can be formulated as Ising models [2], a variety of Ising solvers [3,4,5] have been actively developed, highlighting the importance of benchmark-instance generation. In this paper, we focus on generating large-scale MAXCUT (Ising model) benchmark instances with known exact solutions, a setting that is not sufficiently addressed by existing benchmark suites. To this end, we consider Not-All-Equal 3SAT (NAE3SAT) and exploit state-of-the-art SAT solvers to obtain exact solutions for generated NAE3SAT instances.

NAE3SAT is a variant of 3SAT in which a clause is satisfied only when not all three literals take the same truth value. NAE3SAT instances can be translated almost directly into Ising models and can therefore be efficiently handled by Ising solvers [6,7]. Although dedicated NAE3SAT solvers are uncommon, NAE3SAT instances can be solved by conventional SAT solvers by introducing an additional negated clause for each NAE clause. Consequently, exact solutions of NAE3SAT instances can be used to obtain exact solutions of the corresponding MAXCUT instances. To evaluate the characteristics of the generated benchmarks, we investigate two classes of synthetic instances: random and structured. Random NAE3SAT instances exhibit a phase transition around a clause-to-variable ratio of 2.1 [8,9]. We also generate structured NAE3SAT instances using the modular random SAT generator [10], which was originally designed to mimic the community structure observed in industrial SAT instances [11,12]. The resulting MAXCUT instances possess several distinctive properties: (1) large scale, containing up to approximately 100,000 vertices; (2) availability of exact solutions; and (3) the possibility of indirectly comparing optimization performance against state-of-the-art SAT solvers.

In addition, we investigate equation planting [13], a planted-solution generation technique that guarantees the existence of known optimal solutions. Since the original equation-planting method generates XORSAT instances, we adapt it to the NAE3SAT setting. Experimental results show that the planted instances can be solved optimally by simulated annealing, whereas similarly sized instances derived from random and structured NAE3SAT remain challenging.

The contributions of this paper are summarized as follows:

• We propose a method for generating large-scale MAXCUT (Ising model) instances with exact solutions by leveraging state-of-the-art SAT solvers through NAE3SAT.
• We extend equation planting to generate NAE3SAT-based instances with known optimal solutions.
• We provide a large-scale benchmark suite together with experimental evaluation.

2. Preliminaries

2.1. MAXCUT and Ising Model

The Ising model describes interacting spins in ferromagnetic materials. Finding the ground state of an Ising model, i.e., the spin assignment that minimizes its energy, is known to be an NP-hard problem [1]. The objective is to determine the spin assignment that minimizes the following Ising Hamiltonian $H_{Ising}$:

$$H_{Ising}=\sum _{i<j}{J}_{i,j}{\sigma }_i{\sigma }_j+{\displaystyle \sum _i^n}{h}_i{\sigma }_i$$

(1)

where ${\sigma }_i$($1\le i\le n$) denotes the i-th spin and takes a value of $\pm 1$, $J_{i,j}$ represents the interaction coefficient between spins i and j, and $h_i$ denotes the external magnetic field applied to the i-th spin. When $h_i=0$ for all i, the ground-state search problem can be reduced to the MAXCUT problem. Given a weighted graph $G=(V,E)$, MAXCUT seeks a partition of the vertex set V into two disjoint subsets such that the total weight of edges crossing the partition is maximized. In the corresponding Ising model, assigning a spin value of $+1$ or $-1$ determines the side of the cut to which a vertex belongs. Consequently, minimizing the Ising energy is equivalent to maximizing the cut weight. Various combinatorial problems can be formulated as Ising models [2]: including logistics [14], scheduling problem [15,16,17], online advertisement optimization [18], and engineering design problems such as truss structure analysis [19].

The Ising model is equivalent to the Quadratic Unconstrained Binary Optimization (QUBO) formulation through a simple variable transformation. The objective of a QUBO problem is to minimize the QUBO Hamiltonian $H_{QUBO}$:

$$H_{QUBO}=\sum _i\sum _j{Q}_{i,j}{x}_i{x}_j$$

(2)

where $x_i\in \{0,1\}$ is a binary variable and $Q_{i,j}$ represents the coefficient associated with variables $x_i$ and $x_j$.

A wide variety of solvers for Ising and QUBO problems have been developed [20], including simulated annealing (SA) [21], local search [22], branch-and-cut methods [23,24,25], quantum annealing [26,27], collaborative neurodynamic optimization [28], simulated bifurcation [4], and digital annealers [3]. The performance of these solvers is commonly evaluated using benchmark instances derived from MAXCUT and satisfiability (SAT) problems [6,20,29,30,31,32,33,34,35,36]. As solver capabilities continue to improve, the generation of large-scale benchmark instances with known optimal solutions is becoming increasingly important.

2.2. Not-All-Equal 3SAT

The satisfiability problem (SAT) asks whether there exists an assignment of Boolean variables that evaluates a given Boolean formula to true. A SAT instance in Conjunctive Normal Form (CNF) is defined as follows. A literal is either a Boolean variable or its negation. A clause is a disjunction (logical OR) of literals, and a CNF formula is a conjunction (logical AND) of clauses. A clause is satisfied if at least one of its literals evaluates to true, and a CNF formula is satisfied if all clauses are satisfied. An SAT instance $\varphi =(V,C)$ consists of a set of Boolean variables V and a set of clauses C. When every clause contains exactly k literals, the problem is referred to as k-SAT. For $k\ge 3$, kSAT is NP-complete [37].

Not-All-Equal 3SAT (NAE3SAT) is a variant of 3SAT in which each clause contains exactly three literals and a clause is satisfied only if not all literals take the same value. Equivalently, a clause must contain at least one true literal and at least one false literal. Thus, assignments of the form $(T,T,T)$ and $(F,F,F)$ do not satisfy an NAE clause. Although dedicated NAE3SAT solvers are uncommon, NAE3SAT instances can be solved using conventional SAT solvers. An NAE clause $(a\vee b\vee c)$ can be transformed into the conjunction of two SAT clauses,

$$(a\vee b\vee c)\wedge (\neg a\vee \neg b\vee \neg c),$$

(3)

where the first clause excludes the assignment $(F,F,F)$ and the second excludes $(T,T,T)$. Consequently, exact solutions of NAE3SAT instances can be obtained using state-of-the-art SAT solvers.

NAE3SAT can be converted directly into an Ising model. Let ${\sigma }_x$ denote the spin variable corresponding to Boolean variable x, and let C be the set of NAE clauses. The resulting Ising Hamiltonian is given by

$$H=\sum _{(x_1\vee x_2\vee x_3)\in C}\left({\zeta }_{x_1}{\zeta }_{x_2}{\sigma }_{x_1}{\sigma }_{x_2}+{\zeta }_{x_1}{\zeta }_{x_3}{\sigma }_{x_1}{\sigma }_{x_3}+{\zeta }_{x_2}{\zeta }_{x_3}{\sigma }_{x_2}{\sigma }_{x_3}\right),$$

(4)

where

$${\zeta }_x=\left\{\begin{array}{cc}1\hfill & \mathrm{if}x\mathrm{appears}\mathrm{as}\mathrm{a}\mathrm{positive}\mathrm{literal},\hfill \\ -1\hfill & \mathrm{if}x\mathrm{appears}\mathrm{as}\mathrm{a}\mathrm{negated}\mathrm{literal}.\hfill \end{array}\right.$$

(5)

Each clause contributes minimum energy when its literals are not all assigned the same truth value. Therefore, minimizing the Hamiltonian corresponds to maximizing the number of satisfied NAE clauses, and satisfiable NAE3SAT instances can be mapped to MAXCUT instances with known optimal solutions.

3. Instance Generation

In our experiments, we generate three classes of NAE3SAT instances: random, structured, and planted. For random and structured instances, exact solutions are obtained using the state-of-the-art SAT solver Kissat [38] (version 4.0.3). Each generated instance is solved by Kissat with a time limit of 7,200 seconds, and only satisfiable instances for which Kissat successfully returns a solution are retained. The resulting NAE3SAT instances are then converted into Ising models according to the formulation described in Section 2.2. We use PyQUBO [39,40] to construct the corresponding Ising Hamiltonians.

3.1. Random

Random NAE3SAT instances exhibit a satisfiability phase transition, where the probability that an instance is satisfiable changes abruptly as the clause-to-variable ratio increases. For random NAE3SAT, the phase transition is known to occur at a clause-to-variable ratio of approximately 2.1 [8,9].

To generate random instances, we use CNFgen [41]. For each fixed number of variables $\left|V\right|$, we generate instances with clause-to-variable ratios ranging from 1.9 to 2.1. Each generated instance is solved using Kissat to obtain an exact satisfying assignment, which is subsequently used to derive the corresponding MAXCUT (Ising model) instance with a known optimal solution.

3.2. Community Structure

Many real-world and industrial SAT instances exhibit a pronounced community structure [11,12]. Community structure refers to the tendency of vertices to form densely connected groups, called communities, with relatively sparse connections between groups [42]. Such structural properties are often associated with the practical difficulty of SAT instances and therefore constitute an important characteristic when generating benchmark problems.

A common measure of community structure is modularity [43]. Let $G=(V,w)$ be a weighted graph, where V is the set of vertices and $w:V\times V\to {\mathbb{R}}^{+}$ denotes the edge-weight function. The weighted degree of a vertex $u\in V$ is defined as

$$deg\left(u\right)=\sum _{v\in V}w(u,v).$$

(6)

Given a partition $P=\{P_1,P_2,\dots ,P_k\}$ of V, the modularity value Q is defined as

$$Q(G,P)=\sum _{P_i\in P}{\displaystyle \frac{{\sum }_{x,y\in P_i}w(x,y)}{{\sum }_{u,v\in V}w(u,v)}}-{\left({\displaystyle \frac{{\sum }_{x\in P_i}deg\left(x\right)}{{\sum }_{u\in V}deg\left(u\right)}}\right)}^2$$

(7)

Larger values of Q indicate a stronger community structure.

To generate structured NAE3SAT instances, we employ the modular random SAT generator proposed in [10] 1. The generator allows us to control the number of variables, the number of clauses, the number of communities, and the target modularity value. Using this generator, we create NAE3SAT instances with prescribed community structures and subsequently convert them into MAXCUT (Ising model) instances.

Figure 1 illustrates an Ising graph derived from a modular NAE3SAT instance with $\left|V\right|=10,000$, $\left|E\right|=20,000$, eight communities, and modularity $Q=0.8$. Vertices belonging to the same community are shown in the same color, clearly revealing the underlying community structure.

3.3. Equation Planting

Equation planting [13] is a technique for generating benchmark instances with known optimal solutions. The Chook tool [44] implements this approach for XORSAT by embedding a predetermined solution into randomly generated instances. The same idea can be applied to NAE3SAT.

Algorithm 1 presents the procedure used to generate planted NAE3SAT instances. First, a planted assignment $x^{*}$ is generated uniformly at random. Clauses are then added until the target number of clauses m is reached. For each clause, three distinct variables are selected uniformly at random, and a binary pattern $\mathbf{b}$ is chosen uniformly from $(0,0,1),(0,1,1)$. The entries of $\mathbf{b}$ are randomly permuted before constructing the clause literals.

The literal polarities are determined so that, under the planted assignment $x^{*}$, the resulting clause evaluates according to the selected pattern $\mathbf{b}$. Consequently, each generated clause contains at least one true literal and at least one false literal under $x^{*}$, thereby satisfying the NAE constraint. Therefore, the planted assignment $x^{*}$ is guaranteed to satisfy all generated clauses.

Algorithm 1: Generation of a Planted Random NAE3SAT Instance

Require:  Number of variables n, clause density r Ensure:  Planted assignment ${\mathbf{x}}^{*}$ and clause set $\mathcal{C}$   1: $m\leftarrow \lfloor rn\rfloor$   2: for $i=1$ to n do   3:    $x_i^{*}\leftarrow 0$ or 1 (randomly)   4: end for   5: $\mathcal{C}\leftarrow \varnothing$   6: for $j=1$ to m do   7:    Select three distinct variables $$\{v_1,v_2,v_3\}\subseteq \{1,\dots ,n\}$$ uniformly at random   8:    $\mathbf{b}\leftarrow (0,0,1)$ or $(0,1,1)$ (randomly)   9:    Randomly permute the entries of $\mathbf{b}$ 10:    for $t=1$ to 3 do 11:      if $b_t=x_{v_t}^{*}$ then 12:         ${\ell }_t\leftarrow v_t$ 13:      else 14:         ${\ell }_t\leftarrow -v_t$ 15:      end if 16:    end for 17:    $\mathcal{C}\leftarrow \mathcal{C}\cup \left\{({\ell }_1,{\ell }_2,{\ell }_3)\right\}$ 18: end for 19: .  20: return $({\mathbf{x}}^{*},\mathcal{C})$

4. Experiments

To evaluate the quality of solutions obtained by simulated annealing, we conducted experiments on random, structured, and planted instances generated as described in the previous section. We employed Optimized Simulated Annealing (OSA) [21], which has been reported to provide competitive performance with low computational overhead. Specifically, we used the implementation released by the authors of [36]. Each OSA run consisted of 10,000 sweeps. For a fixed parameter configuration, the solver was executed with 10 different random seeds, and the best solution obtained among the 10 runs was recorded. To select effective OSA parameters, we used a Bayesian optimization library [45]2. For each instance, Bayesian optimization explored 60 parameter configurations. The best solution obtained among these 60 configurations was reported as the final result. Consequently, the processing times reported in the following tables correspond to the runtime of the best-performing configuration rather than the cumulative runtime over all 60 parameter configurations.

For random and structured NAE3SAT instances, we generated instances by varying the clause-to-variable ratio $\left|C\right|/\left|V\right|$ from 1.90 to 2.10 in increments of 0.01. Each generated instance was solved using Kissat (version 4.0.3) with a time limit of 7,200 seconds. If Kissat failed to find a satisfying assignment within the time limit, instance generation for that problem size was terminated. Therefore, all reported random and structured instances were successfully solved by Kissat, and their exact solutions are available. The purpose of the generation process is not to identify the hardest NAE3SAT instances but to construct large-scale MAXCUT benchmarks with certified optimal solutions.

Since random clause generation does not guarantee that every variable appears in at least one clause, some generated CNF formulas may contain unused variables. To avoid this issue, we re-indexed the variables appearing in the CNF and removed variables that did not occur in any clause. As a result, the actual number of variables in an instance may be slightly smaller than the predefined value.

All experiments were conducted on a workstation running Ubuntu 20.04.6, equipped with an Intel Core i9-10980XE CPU and 256 GB of RAM. The source code is available at https://drive.google.com/file/d/17h1hy_i5_fOwHjSlNSo73kTLH-Pn4qe-/view, and the generated benchmark instances is available at https://drive.google.com/file/d/1pOrhRCqUBReH7EH39zbByb71sHrkHFCT/view.

4.1. Random Graphs

We generated random NAE3SAT instances with target numbers of variables equal to 10,000, 50,000, and 100,000. The experimental results are summarized in Table 1, Table 2 and Table 3, respectively. The columns have the following meanings. “V” and “C” denote the numbers of variables and clauses in the generated 3SAT instance converted from NAE3SAT, respectively. “n” and “m” denote the numbers of vertices and edges in the corresponding MAXCUT (Ising model) instance. “exact” represents the optimal MAXCUT value obtained from the satisfying assignment found by Kissat. “OSA” denotes the best cut value obtained by OSA, and “OSA_rate” is the approximation ratio, computed as $OSA/exact$. Finally, “OSA_time” and “Kissat_time” denote the runtimes (in seconds) of OSA and Kissat, respectively.

As the clause-to-variable ratio $\left|C\right|/\left|V\right|$ increases, the runtime of Kissat generally increases, indicating that the corresponding NAE3SAT instances become more difficult to solve exactly. At the same time, the approximation ratio achieved by OSA tends to decrease slightly. However, the degradation is modest: across all tested instances, OSA consistently achieved approximation ratios above 99.845%. An important observation is that the overall trend is largely independent of the problem size. Similar behaviors are observed for instances with 10,000, 50,000, and 100,000 variables. In particular, increasing the number of variables by an order of magnitude does not substantially affect the approximation quality of OSA. Instead, the clause-to-variable ratio appears to have a stronger influence on the solution quality than the absolute problem size. For the instances with approximately 10,000 variables, OSA reached the optimal solution in 9 out of 17 cases while requiring less runtime than Kissat. Furthermore, OSA continued to obtain near-optimal solutions even for the largest instances containing approximately 100,000 vertices. These results provide additional evidence for observations reported in previous studies [6,36]: MAXCUT (Ising model) instances derived from NAE3SAT can be solved very effectively by Ising-based optimization methods, even when the instances contain on the order of 100,000 variables.

4.2. Community Structured Graphs

We generated community-structured NAE3SAT instances with approximately 100,000 variables. Unless otherwise stated, the number of communities was fixed at 8 and the target modularity value was set to 0.9. The experimental results are summarized in Table 4. Overall, OSA achieved solution qualities comparable to those obtained for random instances. OSA found the optimal solution for 5 instances and achieved approximation ratios of at least 99.869% for all remaining instances. These results indicate that OSA continues to perform effectively even when strong community structure is introduced into the underlying NAE3SAT instances. A comparison with the results in Section 4.1 reveals no substantial difference between random and community-structured instances in terms of either the runtime of Kissat or the approximation quality achieved by OSA. In particular, the presence of community structure does not appear to significantly affect the ability of Kissat to obtain exact solutions or the ability of OSA to obtain near-optimal solutions.

We additionally conducted preliminary experiments using different community-structure parameters, with the number of communities selected from $\{8,16,32\}$ and the modularity value selected from $\{0.7,0.8,0.9\}$. Across all tested settings, the observed trends remained largely similar. Therefore, within the range of parameters considered in this study, the influence of community structure on the performance of both Kissat and OSA appears to be limited.

Taken together, these results suggest that the benchmark characteristics observed in the previous subsection are robust with respect to the introduction of community structure. The clause-to-variable ratio appears to have a greater impact on the observed difficulty than the modularity-related parameters considered here.

4.3. Equation Planting for NAE3SAT

We generated planted NAE3SAT instances with approximately 100,000 variables using the procedure described in Algorithm 1. The experimental results are summarized in Table 5. Unlike the random and community-structured instances, all planted instances with clause-to-variable ratios ranging from 1.9 to 2.1 were solved optimally by both Kissat and OSA. Furthermore, the runtime did not exhibit a clear dependence on the clause-to-variable ratio. In contrast to the random and community-structured instances, increasing the clause density did not noticeably increase the difficulty of solving the planted instances. This observation suggests that the planted instances possess structural properties that make them substantially easier for both SAT-based and Ising-based optimization methods.

To further investigate this behavior, we generated a significantly denser planted instance with $\left|V\right|=50,000$ and $\left|C\right|/\left|V\right|=20.0$, corresponding to one million clauses. Due to memory limitations during instance generation, experiments with $\left|V\right|=100,000$ were not feasible for this clause density. Nevertheless, both Kissat and OSA successfully found optimal solutions for the resulting instance. Taken together, these results indicate that the proposed equation-planting approach generates instances that remain relatively easy even at large scales and high clause densities. In contrast to the random and community-structured benchmarks studied in the previous subsections, the planted instances do not appear to provide a challenging testbed for evaluating the approximation quality of OSA. Consequently, while equation planting offers a convenient way to construct instances with certified optimal solutions, additional mechanisms may be necessary to generate planted instances that are difficult for modern optimization solvers.

5. Related Work

5.1. Benchmark Suites for MAXCUT and Ising Models

Several benchmark suites have been proposed for evaluating MAXCUT, Ising, and QUBO solvers.

Gset3 is one of the most widely used benchmark collections for MAXCUT and includes instances ranging from approximately 800 to 20,000 vertices. MQLib [20] provides both a large collection of MAXCUT/QUBO instances and a set of optimization heuristics. The benchmark suite contains 3,506 instances, with the largest graph containing 53,130 vertices. BiqMac Library [46] provides MAXCUT instances with 20 to 500 vertices4.

More recently, MaxCut-Bench [31] was proposed as an open-source benchmark suite for both conventional and machine-learning-based MAXCUT solvers. The included graphs range from 70 to 2,000 vertices. HamLib [47] provides a collection of Hamiltonian optimization problems containing up to 1,000 qubits, including MAXCUT and Max-k-Cut instances.

SATQUBOLIB [48] provides a framework for translating (MAX)3SAT instances into QUBO formulations. In addition to the conversion tools, it introduces a collection of difficult SAT-derived benchmark instances generated using the Balanced SAT [49] and No-Triangle SAT [50] methodologies. These instances are intentionally designed to be difficult for modern SAT solvers.

None of these benchmark suites simultaneously provide (i) around 100,000 vertices and (ii) certified optimal solutions.

5.2. Planted-Solution Instance Generation

Another important research direction is the generation of benchmark instances with known optimal solutions. Planted-solution techniques provide a mechanism for constructing optimization instances whose exact solutions are available by design.

Chook [44] is a Python framework for generating Ising models with planted solutions. It supports several generation methods, including equation planting [13], tile planting [51], and Wishart planting [52]. Similarly, the D-Wave Instance Generator (DWIG) supports planted-solution generation through corrupted biased ferromagnets [53] and frustrated cluster loops [54].

Posiform planting [55] constructs QUBO instances with unique optimal solutions by exploiting MAX2SAT formulations. An improved variant [56] further increases the difficulty of the generated instances by combining random QUBO structures. Experimental evaluations in these studies include instances containing up to 5,627 spins.

5.3. Large-Scale Benchmarking Studies

A number of studies have used MAXCUT instances to evaluate classical, quantum, and quantum-inspired optimization methods.

In [57], several quantum-annealing-inspired algorithms, including SimCIM [58] and discrete simulated bifurcation [4], were evaluated using Gset instances containing up to 20,000 vertices. In [59], weighted MAXCUT instances with 10–250 vertices were used to compare genetic algorithms, graph neural networks, and quantum-inspired solvers. Bucher et al. [60] compared simulated annealing, local search, tabu search, semidefinite programming, and mathematical optimization solvers on MAXCUT instances containing up to 300 vertices.

More recent studies have focused on larger problem sizes. The Digital Annealer was evaluated on more than 2,000 MQLib instances, including graphs with up to 53,130 vertices [61]. Vodeb et al. [62] compared D-Wave quantum and hybrid solvers using 138 MAXCUT instances containing between 100 and 10,000 vertices. Tabu-enhanced simulated bifurcation [63] reported experiments on a physics-derived Ising model containing 109,498 spins. The 100000-spin coherent Ising machine [5] demonstrated optimization on a randomly weighted complete graph with 100,000 vertices generated by Rudy [64].

Compared with these benchmark suites and evaluation studies, our work focuses on generating large-scale MAXCUT instances with certified optimal solutions obtained through state-of-the-art SAT solving. The generated instances contain approximately 100,000 vertices, exceeding the scale of most existing benchmark collections while simultaneously providing exact solutions for performance evaluation.

6. Summary

In this paper, we proposed a method for generating large-scale MAXCUT (Ising model) benchmark instances with certified optimal solutions by leveraging NAE3SAT and state-of-the-art SAT solving technology. The key idea is to generate satisfiable NAE3SAT instances, obtain exact satisfying assignments using Kissat, and convert the resulting formulas into equivalent MAXCUT instances.

Using this approach, we generated random and community-structured benchmark instances containing up to approximately 100,000 vertices. Experimental results demonstrated that Kissat was able to obtain exact solutions for the generated instances near the satisfiability phase-transition region. The availability of exact solutions enables direct evaluation of approximation quality for MAXCUT and Ising solvers.

We further evaluated Optimized Simulated Annealing (OSA) on the generated benchmarks. Under the experimental settings considered in this study, OSA consistently achieved high-quality solutions, obtaining approximation ratios above 99.8% even for the largest instances. Moreover, the observed trends were largely independent of the problem size and the community-structure parameters considered. Instead, the clause-to-variable ratio appeared to have a stronger influence on the observed difficulty than either the number of variables or the modularity-related parameters.

We also investigated a planted-solution generation approach based on equation planting. While the generated instances naturally possessed known optimal solutions, both Kissat and OSA solved them easily, even at substantially higher clause densities. Therefore, the planted instances considered in this study appear less suitable as challenging benchmark instances than those derived from random and community-structured NAE3SAT formulas.

To the best of our knowledge, benchmark suites containing MAXCUT instances with approximately 100,000 vertices and certified optimal solutions are still relatively uncommon. The proposed generation framework provides not only large-scale benchmark instances with known optima but also an opportunity to compare the performance of Ising-based optimization methods against state-of-the-art SAT solvers through a common underlying problem structure.

As future work, it would be interesting to investigate alternative planted-solution generation methods capable of producing harder instances and to evaluate a broader range of MAXCUT and Ising solvers on the generated benchmarks.