A Variational Qubit-Efficient MaxCut Heuristic Algorithm

Abstract

MaxCut is a key NP-hard combinatorial optimization problem. Quantum computing offers methods to solve such problems potentially better than classical counterparts, with the Quantum Approximate Optimization Algorithm (QAOA) being a state-of-the-art example. However, the performance of quantum methods is currently hindered by hardware noise and limited qubit volumes. We present a variational Qubit-Efficient MaxCut (QEMC) algorithm that requires only $O(\log N)$ qubits to tackle graphs of size N, an exponential reduction compared to QAOA. We demonstrate cutting-edge performance for 32-node graph instances (5 qubits) on real superconducting hardware, and for graphs with up to 2048 nodes (11 qubits) via classical simulations. The QEMC algorithm is based on an innovative encoding scheme, with potentially broad applicability, that empowers it with strong noise resilience, but also enables its efficient classical simulation. As such, the QEMC algorithm provides a challenging benchmark for QAOA on noisy devices and offers a novel quantum-inspired approach.

Introduction

Quantum computing offers promising prospects for achieving highly efficient computation schemes that surpass the capabilities of standard classical approaches¹. Yet, realizing useful quantum computations on noisy intermediate-scale quantum (NISQ) technology is a worldwide challenge². Variational quantum algorithms (VQAs) are a family of hybrid quantum-classical algorithms that provide a heuristic approach for solving different types of optimization problems via an iterative tuning of parameterized quantum circuits. It includes the variational quantum eigensolver (VQE) for finding ground-states of molecular Hamiltonians^3,4, quantum machine-learning algorithms (see Ref. ⁵ and references therein), and more⁶. The quantum approximate optimization algorithm (QAOA)⁷ is a VQA that is used to find approximate solutions for combinatorial optimization problems. It promises an optimal solution in the limit of infinite quantum circuit layers and was studied extensively in the context of the MaxCut problem^8,9,10,11,12.

The MaxCut problem is an NP-hard¹³ combinatorial optimization problem with practical applications in circuit design and statistical physics¹⁴. It is formalized as follows: let G = (V, E) be a (weighted) graph consisting of nodes V and (weighted) edges E, then finding the maximum cut of the graph amounts to partitioning the nodes into two distinct subsets, e.g. “blue” and “white” nodes, such that the total sum (weight) of the edges that connect nodes from different sets is maximized. In unweighted graphs, each edge connecting a blue and a white node simply adds +1 to the cut score, whereas an edge connecting two nodes of the same color does not contribute to the score.

The Goemans-Williamson (GW) algorithm¹⁵ is a well-known classical approximation algorithm for the MaxCut problem. It is a polynomial time semidefinite programming algorithm, which guarantees a minimal approximation ratio of:

$${r}_{A}^{GW}\cong \frac{MaxCu{t}_{GW}}{MaxCu{t}_{OPT}}=0.87856,$$

(1)

where MaxCut_OPT is the optimal cut. It often serves as a benchmark for testing new MaxCut heuristics and is utilized similarly in this paper.

On the quantum side, MaxCut is well suited to be approached by QAOA, which utilizes a basis encoding - meaning that the computational basis state of each qubit ($| 0\rangle$ or $| 1\rangle$) encodes the logical state of the corresponding problem variable - a single graph node in this case. This implies that the number of required qubits for QAOA scales linearly with the problem size. In particular, it requires N qubits for solving the MaxCut problemof an N-node graph, which limits the usage of the QAOA in current quantum computers to very small problem instances^11,12,16,17.

Several attempts have been made towards devising qubit-efficient VQAs for combinatorial problems^{18,19,20,21,22,23,24,25,26,27,28,29,30,31}. Among them, some studies have explored the incorporation of divide-and-conquer techniques to break down the problem into smaller sub-problems, each requiring only a small number of qubits^{18,19,20,21,22}. Another approach, more closely related to our study, develops and utilizes alternative information encoding schemes that result in a reduction in the number of qubits required. For example, in Ref. ²³, the traveling salesman problem (TSP) over N cities was encoded using $N\log N$ qubits, instead of N² qubits in the standard encoding. A different study proposed to divide combinatorial problems to ${2}^{{n}_{r}}$ independent subsystems, each with n_a variables, which can be encoded using n_a + n_r qubits²⁴. This approach relies on the topology of the problem and lies between two extremes: representing the problem with O(N) qubits for N variables, and on the other hand, using $O(\log N)$ qubits but neglecting all interrelations between the variables. Qubit-efficient encoding for solving the k-coloring graph problem²⁵ and the Max k-Cut problem (a generalization of the MaxCut problem to k partitions)²⁶ were also devised, using $N\log k$ qubits instead of Nk qubits. In²⁷, the required number of qubits for solving the MaxCut problem of graphs with N nodes was reduced to $\frac{N}{2}$ qubits using a multibasis graph encoding, which outperformed the QAOA with a comparable circuit Ansatz. A significant generalization of the method proposed in Ref. ²⁷ was recently shown in Ref. ³⁰, while presenting high-quality approximated MaxCut solutions for large graphs. The authors introduced a polynomial (in the number of nodes) encoding scheme, such that N = O(n^k) binary variables (that is, nodes, in the MaxCut case) are encoded using n qubits, where k > 1 is a tunable integer. Each binary variable is mapped to an expectation value of a corresponding Pauli string operator, where the number of non-identity elements in each Pauli string is k. Lastly, a quantum method utilizing $\log N$ qubits was introduced in Refs. ^28,29 for solving the MaxCut problem of graphs with N nodes, based on the graph’s Laplacian matrix.

This paper introduces the variational Qubit-Efficient MaxCut (QEMC) algorithm, designed to find heuristic solutions for the MaxCut problem on an N-node graph using $\lceil \log N\rceil$ qubits, an exponential reduction compared to QAOA. Unlike the work presented in Refs. ^28,29, we do not rely on the Laplacian matrix of the graph. Instead, we achieve this significant qubit reduction via an innovative information encoding scheme based on probability-threshold encoding.

The QEMC algorithm operates outside the QAOA framework. Beyond its unique encoding scheme, it does not embed the graph instance directly into the quantum circuit Ansatz. This approach, combined with the algorithm’s logarithmic qubit scaling, allows for the use of significantly shallower circuits, which are less susceptible to noise. Furthermore, the QEMC’s cost function is phrased as a continuous mean-squared-error estimator, deviating from the conventional VQA technique of expressing cost functions as expectation values of Hamiltonians.

As shown below, the QEMC algorithm does not offer a straightforward quantum advantage. This is not surprising. In general, and without delving into the specific details of the QEMC algorithm, a classical simulation of a $\log N$ qubit circuit requires storage and time that scale approximately linearly with N, while the mere specification of the problem (representing the graph, reading it in and out, etc., see also Ref. ³²) often scales at least linearly with N. This is in contrast to VQAs, which utilize the standard basis encoding, where this issue does not arise.

The significance of this paper lies in several aspects: first, the presentation of the QEMC algorithm, a new, qubit-efficient, variational solver for the MaxCut problem that exhibits high performance in comparison to both the classical Goemans-Williamson (GW) algorithm in classical simulations and the quantum QAOA algorithm on actual quantum devices, as detailed below; second, the introduction of a novel information encoding for the MaxCut problem, which can be utilized in other quantum and classical algorithms; third, the potential role of the proposed QEMC algorithm as a new benchmark for the QAOA algorithm; and last, its potential usage as a classical quantum-inspired algorithm.

Results

The qubit-efficient MaxCut (QEMC) Algorithm

The QEMC algorithm is based on a novel probability-threshold encoding scheme, a suitable cost function, and a parameterized quantum circuit, which we describe below. Here and throughout the paper, we use N = ∣V∣ to denote the number of nodes in the graph and M = ∣E∣ to indicate the number of edges.

The probability-threshold encoding – The QEMC maps each node k into its corresponding computational basis state $| k\rangle$, using the standard decimal to binary mapping. More precisely, given a variational quantum state $| \psi (\theta )\rangle ={\sum }_{k=0}^{N-1}{\alpha }_{k}(\theta )| k\rangle$ of $\log N$ qubits, where θ stands for the circuit’s variational parameters, the logical state of node k (being “blue” or “white”) is encoded onto the probability p_θ(k) = ∣α_k(θ)∣² to measure the computational basis state $| k\rangle$: a low probability indicates w.l.o.g. “white” nodes, whereas a high probability indicates “blue" nodes. For a graph with B blue nodes, a possible but naive qubit-efficient mapping would associate an exact zero-probability with white nodes and an exact $\frac{1}{B}$-probability with blue nodes, to preserve normalization. However, this definitive mapping assigns meaning only to a very small part of the Hilbert-space, leaving the vast majority of it uninterpreted. Instead, to account for all possible states continuously, we set an intermediate probability-threshold of ${p}_{th}=\frac{1}{2B}$ that distinguishes between white and blue nodes, as follows:

$$color(k)=\left\{\begin{array}{l}\begin{array}{cc}white, & \mathrm{if}\,p(k)\le {p}_{th}=\frac{1}{2B}\end{array}\\ \begin{array}{cc}blue, & \mathrm{otherwise}\end{array}\end{array}\right.$$

(2)

This is illustrated in Fig. 1.

Fig. 1: Illustration of the QEMC encoding scheme and optimization process for an N = 4 nodes graph.

Left: An initial random quantum state’s probability distribution, along with the corresponding graph’s state and logical state (partition), resulting in a cut of 2. Right: A final quantum state’s probability distribution, with the corresponding graph’s state and logical state (partition), resulting in a cut of 4. The probability-threshold is determined by setting $B=\frac{N}{2}=2$ blue nodes and is given by $\frac{1}{4}$, as dictated by Eq. (2).

In essence, this procedure maps each graph partition to a volume of quantum states, rather than to just a single state, thereby providing the optimization procedure with a large set of optimal quantum states to search for. We believe that this property of the algorithm plays a central role in its strength and relative noise resilience, as demonstrated below.

The attentive reader would notice that Eq. (2) assumes prior knowledge of the number of blue nodes B, which, however, cannot be obtained in advance. Yet, this does not pose a problem as we can efficiently scan through all possible values of $B=1,...,\lfloor \frac{N}{2}\rfloor$ (it is preferable to designate the smaller set as the blue set because it leads to larger probability-thresholds p_th, which consequently require fewer shots for statistical accuracy). Moreover, in practice, for many cases, such as the regular graphs we examined, it is reasonable to set $B=\frac{N}{2}$, which assumes that half of the nodes are blue and half are white. It should be noted that the value of B we assign does not rigidly constrain the algorithm; instead, it generates solutions where the number of blue nodes is approximately B, due to state normalization. Finally, we note that this encoding scheme works equally well for all graph sizes, including graphs whose number of nodes is not a power of two, through (zero) padding over the non-existing nodes.

The QEMC cost function – The QEMC algorithm searches for quantum states that minimize the following continuous cost function:

$$C(G,B)=\mathop{\sum }\limits_{\begin{array}{l}j < k:\\ \{j,k\}\in E\end{array}}\left[{\left(d(j,k)-\frac{1}{B}\right)}^{2}+{\left(s(j,k)-\frac{1}{B}\right)}^{2}\right]$$

(3)

Where the sum goes over all pairs of neighboring nodes j and k, and where d(j, k) = ∣p(j) − p(k)∣ and s(j, k) = p(j) + p(k) are the absolute difference and sum of the corresponding states probabilities. The idea is that when both d(j, k) and s(j, k) approach $\frac{1}{B}$, we get that the probability of one of the nodes approaches zero (distinctive “white"), whereas the probability of the other node approaches $\frac{1}{B}$ (distinctive “blue"), without imposing which is which. Minimizing the cost function of Eq. (3) drives the quantum circuit to generate quantum states whose probability histogram maximizes the number of neighboring nodes that fulfill this relation, thereby maximizing the cut in the graph.

The QEMC iterative procedure – Throughout the optimization procedure, the QEMC Ansatz circuit (see “The QEMC quantum circuit”) is executed and measured multiple times to obtain a statistically reliable probability histogram of the quantum state. Then, as with all VQAs, the variational parameters of the circuit θ are updated using a classical optimizer to optimize the cost function until convergence. For the exact configuration of the different classical and quantum components of the QEMC algorithm, see “QEMC components configuration and hyperparameters tuning”.

QEMC toy example – In Fig. 1, the QEMC encoding scheme and the optimization process for a graph with N = 4 nodes are demonstrated. Initially, a random distribution is shown on the left, representing a partition with Cut = 2. The QEMC circuit is then iteratively optimized until it converges to the state in the right panel, whose probability distribution encodes an optimal partition, corresponding to Cut^* = 4.

Experimental results: small 3-regular graphs with 4-32 nodes (2-5 qubits) - noiseless simulations and real-hardware calculations

A single graph instance per graph-size - We begin with small to medium-sized 3-regular graphs, consisting of 4–32 nodes (increasing in increments of 2), which we encode using 2–5 qubits. For each graph-size, we focus on a single graph instance. We utilized the exact graph instances from Ref. ¹¹ for graphs with 4–22 nodes, which form a reference point for our results. The remaining graphs, namely 3-regular graphs ranging from 24 to 32 nodes, were randomly generated using the NetworkX package³³. Unless stated otherwise, the hyperparameters, i.e., the step-size α and the number of layers L, were fixed as described in “QEMC components configuration and hyperparameters tuning”, and are detailed in Table 1. Figure 10 in the Methods section presents the corresponding grid-searches performed for each graph instance.

Table 1 QEMC hyperparameters and attained cuts for the set of 3-regular graphs, ranging from 4 to 32 nodes, with one graph instance per size

The 8-node graph instance

As an elaborated example, we focus on the 8-node graph instance, as depicted in Fig. 2a, with an optimal partition yielding Cut^* = 10, found through exhaustive search. Within the QEMC algorithm, this graph is encoded using 3 qubits. Figure 2b displays the QEMC best-so-far cut for this graph as a function of QEMC-iterations for both classical noiseless state-vector simulations (blue) and real-hardware IBMQ calculations (red). The green dashed line represents the optimal cut. The cut values are averaged over 5 executions in both the classical and the real-hardware calculations, each with varying random parameter initializations. Here we used a 2 layered circuit (see Fig. 8) and a step size of α=0.9. As a sanity check, we also plot the best-so-far Random* cut (gray), obtained by randomly sampling graph partitions with $B=\frac{N}{2}=4$ blue nodes, to mimic our partitioning assumption. This sampling method outperforms a naive random sampler in graphs where the optimal partition indeed divides the graph into two equal-sized subsets, as is the case with the graph discussed here, and hence serves as a better and less naive baseline.

Fig. 2: Noiseless and real-hardware results for a 3-regular 8-node graph instance (3 qubits).

a The specific 8-node graph instance we used; b Averaged QEMC best-so-far cut as a function of iterations depicted for noiseless classical simulation (blue) and real-hardware IBMQ calculation (red), along the optimal cut (green) and a random graph partition sampling (grey) with B=4 blue nodes (see text); c Averaged QEMC cost function value as a function of iterations depicted for noiseless (blue) and real-hardware (red) calculations.

It is seen in Fig. 2b that both the noiseless simulations and real-hardware calculations converge rapidly to the optimal cut, with the real-hardware calculations converging even faster. Since these results are averaged, we can infer that in both cases all 5 calculations successfully reached the optimal cut, regardless of the initialization of their circuit parameters. In the noiseless case, a more elaborated numerical analysis with 100 different circuit parameters initializations reached an averaged cut of 9.74 ± 0.59 (std) after 50 iterations, with 82% of the runs reaching the optimal cut. The success of the real-hardware calculations, achieved without any noise mitigation techniques, can be attributed to two factors: first, the utilization of only 3 qubits and 2 layers; and second, to the threshold probability encoding scheme, which allows for a certain degree of variability, thereby enhancing the noise resilience of the scheme.

For completeness, Fig. 2c depicts the average cost function value as a function of QEMC-iterations, as obtained by the noiseless (blue) and real-hardware (red) calculations. It is seen that in both cases the cost decreases rapidly with iterations, as desired. Here, in contrast to the plot in Fig. 2b, the curve does not show monotonic behavior since we plot the actual cost value per QEMC-iteration, rather than the best-so-far one.

The 4-32 nodes graph instances

Figure 3 provides a summary of the results obtained for the 3-regular graph instances with 4-32 nodes. The results are presented for GW (black squares), QEMC noiseless simulations (blue circles), and QEMC real-hardware calculations on IBMQ machines (red stars). Each method is evaluated based on its averaged cut-ratio, i.e., the ratio between the averaged cut and the optimal cut (Cut/Cut^*), obtained through exhaustive search. The optimal cut-ratio (Cut^*/Cut^* = 1) is indicated by a green, dashed line. The average for the GW and QEMC classical simulations was computed based on 10 calculations, while for the QEMC real-hardware results, we averaged over 5 runs (except for the 16-node graph instance, which we ran 3 times). Table 1 provides a summary of these results, along with the corresponding hyperparameters we used.

Fig. 3: Noiseless and real-hardware results for the set of 3-regular graphs with 4 to 32 nodes (2-5 qubits), one graph instance per size.

The average cut-ratio, namely the ratio between the average cut (Cut) and the optimal cut (Cut^*), is depicted for each graph-size in the following scenarios: optimal cut (green), GW (black squares), QEMC noiseless simulation (blue circles), and QEMC real-hardware IBMQ calculations (red stars). The corresponding hyperparameters and exact cuts can be found in Table 1.

The results indicate that the average noiseless QEMC simulations achieved the optimal cut for graphs containing up to 14 nodes, and consistently obtained nearly optimal cuts for all graph instances, where 0.9725 was the lowest recorded average cut-ratio, attained for the 30-node graph instance. Additionally, these simulations surpass the average GW results across all tested graph instances. Note that we report the actual average GW results, not the theoretically guaranteed approximation ratio¹⁵, which is significantly smaller. Moreover, when focusing on the best execution out of 10 trials, detailed in the “Max cut" row in Table 1, it is evident that the top QEMC run consistently reached the optimal exhaustive cut, a feat that was not always met by the GW method. Finally, these simulations also exceed the approximation ratio of 0.9326, guaranteed by the enhanced GW-based algorithm, tailored for 3-regular graphs³⁴.

Figure 3 further illustrates that the real-hardware calculations reached the optimal cut for both the 4- and 8-node graph instances, on average. For the larger graph instances, with 16 and 32 nodes, the average real-hardware calculations experienced a reduction in the achievable cut, primarily attributed to hardware noise. Here, the constrained number of layers and the actual number of iterations also played a role in limiting the achievable cut. First, larger graph instances often require deeper quantum circuits (see second line in Table 1 and “Computational Resources Estimation“ for an empirical evaluation of the scaling of the number of layers L). However, as mentioned earlier, in an effort to lessen the effect of noise, we used at most two layers in our real-hardware executions. Second, due to limited hardware availability, the average number of actual iterations was 98.6 for the 16-node graphs and 62.0 for the 32-node graphs, as also indicated in Table 1. In addition, a large amount of noise can be attributed to additional swap-gates introduced to our circuits during transpilation, in order to make them compatible with the qubit topology of the quantum machines we used. This issue can be mitigated either by using quantum computers with improved qubit connectivity or by opting for slightly less expressive but more hardware-efficient Ansätze.

Despite the real-hardware limitations described above, the QEMC real-hardware calculations were still able to achieve cut-ratios of 0.8857 and 0.76 for the 16- and 32-node instances, respectively. Furthermore, Table 1 outlines the maximum cuts reached (according to the best execution), showing that the real-hardware calculations attained top cut-ratios of 0.9 for the 16-node graph instance and 0.81 for the 32-node graph instance. Accomplishing such outcomes for the MaxCut problem using real quantum devices, and especially with superconducting hardware, is challenging, as evidenced by QAOA calculations on Google’s quantum processor¹¹, and IBMQ machines¹².

Since the QEMC algorithm was tested on the exact same graph instances as those studied in Ref. ¹¹, it allows for a direct comparison. To facilitate this, Fig. 13 in the Methods section replicates the results of Fig. 3, but with a rescaling to align with the evaluation metric applied in Ref. ¹¹. Comparing Fig. 13 with Fig. 4 in Ref. ¹¹, demonstrates that the cuts achieved by the QEMC real-hardware calculations are substantially better than those reported in Ref. ¹¹.

Fig. 4: Noiseless results for the set of 3-regular graphs with 4 to 32 nodes (2–5 qubits), ten graph instances per size.

The average cut-ratio ($\frac{Cut}{Cu{t}^{* }}$) is depicted for each graph-size in the following cases: optimal cut (green), GW (black squares), QEMC simulations with L = 3 circuit-layers (purple circles), and QEMC simulations with L = 1 layer (orange circles). Each data-point represents an average of 100 runs, with 10 trials per graph instance.

Ten graph instances per graph-size – In the following, we examine the robustness of the QEMC algorithm with respect to the choice of hyperparameters. To that end, we evaluated a fresh test set of 3-regular graphs with 4–32 nodes (increasing in increments of 2) using classical state-vector simulations. To ensure a representative sample, we generated 10 graph instances per size category, resulting in a total of 150 graph instances. The evaluation focused on the performance of shallow circuits with L = 1 and L = 3 layers, which may not necessarily be optimal. For each size category of the graph, we set the optimal step-size for a given value of L, as determined previously by our grid-searches on the single graph instances (see Table 1), without fine-tuning it any further for the new set of graphs.

We performed 10 noiseless classical QEMC simulations for each graph instance, using different random initializations of the circuit parameters, as well as 10 GW trials per graph instance. This resulted in a total of 1500 trial runs per method. Fig. 4 presents the average cut-ratios, per graph-size, obtained by: GW (black squares), QEMC 3-layered Ansatz (L = 3, purple circles), and QEMC single-layer Ansatz (L = 1, orange circles). The results show that the cut-ratios for single-layer Ansätze decline rapidly as graph-sizes increase, whereas 3-layered Ansätze demonstrate a gradual decrease while consistently achieving average cut-ratios above 0.96 across the entire scale. Comparing these results with the average GW cut-ratios demonstrates that on average, the QEMC algorithm performed better than GW throughout our graphs test set, even when using shallow 3-layered circuits and without explicitly fine-tuning the step-size hyperparameter.

In comparison to QAOA circuits, Ansätze with 3 layers are considered fairly shallow. For example, noiseless QAOA simulations on Erdős–Rényi graphs with 10 nodes required at least 6 layers to outdo GW performance⁸. Moreover, each layer in the QAOA circuit demands a number of entangling gates that grows linearly with the number of edges in the graph, leading to a quadratic increase with the number of nodes for general graphs and a linear growth for regular ones. Conversely, in the QEMC algorithm, the number of entangling gates per layer depends on the chosen Ansatz. In the case of the “strongly-entangling-layers” Ansatz we utilized, it grows logarithmically with the number of nodes, resulting in circuit layers that are exponentially shallower than in QAOA. This characteristic of shallow circuits in QEMC enhances its resilience to hardware noise.

Numerical results: large 9-regular graphs with 16-2048 nodes (4-11 qubits) - noiseless simulations

The advantages of employing the QEMC encoding scheme become more apparent when examining larger graphs. The logarithmic relationship between the number of required qubits and the size of the graph enables the application of the QEMC method to extensive graphs that would be infeasible to tackle with exhaustive search. In this section, we demonstrate the performance of the QEMC algorithm on 9-regular graphs ranging from 16 to 2048 nodes (increasing in powers of two), which were encoded using 4 to 11 qubits. All QEMC results presented in this section were obtained through classical noiseless state-vector simulations.

A single graph instance per graph-size – We randomly generated a single instance of a 9-regular graph for each graph-size (16-2024 nodes), and then determined the optimal hyperparameters for each graph instance using the grid-search approach described in “QEMC components configuration and hyperparameters tuning”. To that end, we performed 10 QEMC runs for each combination of graph-size, step-size, and number of layers, where each trial utilized different random circuit parameter initialization, and selected the hyperparameters that resulted in the highest average cut for each graph-size. An illustration of the grid-search outcomes for the 256-node graph can be found in Fig. 11 in the Methods section, and the resulting optimal hyperparameters are listed in Table 2.

Table 2 QEMC hyperparameters and attained cuts for the sampled set of 9-regular graphs, ranging from 16 to 2048 nodes, with one graph instance per size

We evaluated the performance of the QEMC algorithm using optimal hyperparameters by comparing its average and maximum cuts to those of the GW method, obtained over 10 different runs for each graph instance. Figure 5 illustrates the relative performance of QEMC compared to GW. In the top panel, the ratio $\frac{Max(QEMC)}{Max(GW)}$ is depicted (red squares). For the 16-node graph instance, both GW and QEMC achieved the same optimal cut. However, for larger graph instances, the maximum cut obtained by QEMC surpassed the maximum cut obtained by GW by ≈ 1−2.5%. The bottom panel displays the relative average performance of QEMC compared to GW, represented by $\frac{Avg.(QEMC)}{Avg.(GW)}$ (blue stars). It is evident that QEMC outperformed GW on average by ≈ 1−4% for these graph instances.

Fig. 5: Relative performance of the QEMC algorithm (noiseless simulations) compared to the GW algorithm for the set of 9-regular random graphs, ranging from 16 to 2048 nodes (4–11 qubits in QEMC).

Each graph-size is represented by a single graph instance, as illustrated at the bottom. Top: The ratio of the best cut found by QEMC to the best cut found by GW, calculated from 10 trials (red squares). Bottom: The ratio of the average QEMC cut to the average GW cut, determined over 10 trials (blue stars).

Fifty graphs with N = 256 nodes (8 qubits) – To further illustrate the strength of the QEMC algorithm and its resilience to hyperparameter selection, we examined its performance on a set of 50 randomly sampled 9-regular graphs, each consisting of N = 256 nodes (8 qubits), with potentially varying maximum cuts. We maintained consistent hyperparameters (step-size and number of layers) across all graph instances, deriving them from the grid-search conducted for the single 256-node graph detailed in “QEMC components configuration and hyperparameters tuning“and illustrated in Fig. 11 in the Methods section. To expedite the calculations, we reduced the number of layers to L = 50 from the optimal value of L = 80 layers, and adjusted the step-size to α = 0.14. While not optimal, this configuration resulted in a nearly optimal average cut (827.2 instead of 828.5) in the previously mentioned grid-search. We executed 10 QEMC runs per graph instance.

Figure 6 shows the performance of the QEMC algorithm as a function of QEMC-iterations. The Max QEMC curve (solid red line) represents the average over the best cuts achieved for each graph instance (a total number of 50 “best cuts"). It converges to the value of Max QEMC = 846.0. The average QEMC curve (solid blue line) is simply the average over all the 500 QEMC calculations (50 graph instances, 10 QEMC-runs for each instance). It converges to the value of Avg. QEMC = 824.1. It is seen that in both cases, the vast majority of the convergence takes place within less than 100 iterations, where the Max QEMC curve converges faster.

Fig. 6: QEMC noiseless simulations vs. GW: 50 different 9-regular graph instances with 256 nodes (8 qubits).

Max. GW (dashed pink line): Average of the maximum 50 GW cuts, one per graph instance. Avg. GW (dashed cyan line): The GW cuts averaged across all 500 trials, 10 trials per graph instance. Max. QEMC (solid red curve): Average of the maximum 50 best-so-far QEMC cuts, one per graph instance, as a function of QEMC-iterations. Avg. QEMC (solid blue curve): The best-so-far QEMC cuts averaged across all 500 trials, 10 trials per graph instance, as a function of QEMC-iterations. We performed 10 trials per graph instance.

For comparison, we also executed the GW algorithm on the same set of graphs, running it 10 times per graph instance. The average of the 50 best GW cuts, one per graph instance, yielded a Max. GW cut value of 829.1 (dashed pink line), and the Avg. GW cut across all trials amounted to 814.9 (dashed cyan line). It is seen that the maximal QEMC curve surpasses the maximal GW cut, crossing it in less than 50 iterations. Moreover, the average QEMC curve outperforms the average GW cut and nearly reaches the maximal GW cut.

Numerical results: Erdős–Rényi graphs of varying densities with 128 nodes (7 qubits) - noiseless simulations

We also tested the QEMC algorithm against GW on non-regular graphs, specifically Erdős–Rényi 128-node graphs with increasing density. To enable comparison with the qubit-efficient scheme of Ref. ²⁹, we selected four graph instances with densities of 0.3, 0.4, 0.5, and 0.6–chosen to closely match those used in Table III of Ref. ²⁹, as they were generated using the same method described in that work. Further implementation details are described in “Computational details for benchmarking Erdős–Rényi 128-node graphs (7 qubits) with varying densities”.

The results of the benchmarks are summarized in Table 3. It can be seen that the QEMC’s average results are 98.5−99.7% of the GW average for the graph instances that we tested. For comparison, the results described in Ref. ²⁹ are ≈92−96% of the corresponding average GW results.

Table 3 QEMC noiseless simulations vs. GW: 128-node Erdős–Rényi graphs with varying densities

Computational Resources Estimation

In what follows, we provide an estimation of the classical and quantum computational resources required for the QEMC algorithm, in terms of the number of nodes (N = ∣V∣) and edges (M = ∣E∣) in the graph.

Depending on the choice of the classical optimizer, updating the tunable parameters requires a different number of cost function evaluations. In the worst-case, which we analyze, at each iteration, each parameter update requires its own cost function evaluation(s), e.g., in gradient-based optimizers.

Within this framework, the time-to-solution (TTS) of the QEMC algorithm is given by

$$TTS={\mathcal{O}}[({T}_{C}+{T}_{Q})\cdot P\cdot I]$$

(4)

where T_C and T_Q are the classical and quantum times required for a single cost function evaluation, while P represents the number of tunable parameters in the circuit, and I represents the number of QEMC-iterations. The actual procedure of the parameters update is considered here to be a constant, subsumed in the ${\mathcal{O}}$ notation.

QEMC analysis – We next analyze the required quantum and classical resources, per cost function evaluation.

Quantum resources analysis

Memory-wise, the number of qubits (n) in the QEMC algorithm is given by $n=\lceil \log N\rceil$, by design. Each cost function evaluation requires the calculation of the N-dimensional probability distribution, constructed from multiple measurements of the quantum state. To that end, the quantum processor executes the quantum circuit S times, which is the number of shots needed to achieve a reliable statistical accuracy; Consequently, the quantum circuit execution time per cost function evaluation is ${T}_{Q}={\mathcal{O}}(mS)$, where m is the number of gates in the circuit (which is an upper bound on the actual circuit-depth). The number of gates m in the quantum circuit is Ansatz-dependent. In the case of the “strongly entangling layers” Ansatz we utilized, m is in the order of ${\mathcal{O}}(L\log N)$, where L denotes the number of layers in the Ansatz circuit. Therefore, we can conclude that ${T}_{Q}={\mathcal{O}}(LS\log N)$, and by neglecting logarithmic terms, we arrive at ${T}_{Q}=\widetilde{{\mathcal{O}}}(LS)$.

Classical resources analysis

At each cost function evaluation, given the N-dimensional probability histogram, the classical processor computes the cost function defined in Eq. (3), which requires classical time and space that scale linearly with the number of edges, namely ${T}_{C}={\mathcal{O}}(M)$. This analysis is summarized in Table 4, under the “QEMC” row.

Table 4 Computational resources estimation of: 1. QEMC; 2. cs-QEMC - the classical simulation counterpart of QEMC; The analysis is done per a single cost function evaluation, performed per a single QEMC-iteration, for a fixed size of graph-partition B

QEMC classical simulation – Let us now focus on the computational resources required for simulating the QEMC algorithm on classical computers. We assume a simple “Schrödinger algorithm"^35,36 as a basis for our analysis (further improvements exist, see e.g.³⁷). Using this algorithm, simulating a quantum circuit comprising n qubits and m gates requires ${\mathcal{O}}(m{2}^{n})$ time and ${\mathcal{O}}({2}^{n})$ memory. As discussed above, we estimate the number of gates m as ${\mathcal{O}}(L\log N)$. Consequently, the estimated time complexity for a classical simulation of the QEMC circuit per cost function evaluation is ${\mathcal{O}}(LN\log N)$, and by neglecting logarithmic terms, we arrive at $\widetilde{{\mathcal{O}}}(LN)$. The space complexity is ${\mathcal{O}}(N)$. Taking into account in addition also the time and memory required for calculating the cost function, which scale linearly with the number of edges M, we get that simulating the QEMC on a classical computer has a time complexity of $\widetilde{{\mathcal{O}}}(M+LN)$ per a single cost function evaluation, and the memory complexity is ${\mathcal{O}}(M)$, see Table 4, under the “cs-QEMC” row.

Empirical resources estimation – To gain a clearer understanding of the overall QEMC time-to-solution, we performed an empirical estimation of how the number of layers (L), shots (S), and iterations (I) scale with respect to N. Our analysis, conducted through classical state-vector noiseless simulations, aims to provide an empirical upper bound on the computational resources required for the average QEMC cut to achieve the average GW cut, assuming optimal fixation of all other resource parameters. We focused on the same sets of 3-regular and 9-regular graphs introduced in “Experimental results: small 3-regular graphs with 4-32 nodes (2-5 qubits) - noiseless simulations and real-hardware calculations” and “Numerical results: large 9-regular graphs with 16-2048 nodes (4-11 qubits) - noiseless simulations“ C, respectively, consisting of one graph instance per size, with 10 randomly-initialized executions per graph instance.

Fig. 7 a shows the minimum number of layers (L) required by the QEMC algorithm to reach the GW cut (on average), as a function of N, on a logarithmic scale. The minimum number of layers was determined through the hyperparameter grid-searches described in the Methods section, using an infinite number of shots and the same total number of iterations reported for the classical simulations. To get an estimation of the scaling, we further plot a ${\log }^{2}N$ curve that upper bounds the results, suggesting a poly-logarithmic scaling of L with respect to N.

Fig. 7: QEMC resource scaling with the size of the graphs (N) required to reach the average GW cut.

a Scaling of the number of layers (L), shown on a logarithmic scale, for the small 4-32 nodes set (in cyan) and the larger 16-2048 nodes set (in blue); b Scaling of the number of shots per a single cost function evaluation (S), for the small 4–32 nodes set; c Scaling of the number of iterations (I), displayed on a logarithmic scale, for the small 4-32 nodes set (in cyan) and the larger 16-2048 nodes set (in blue).

Next, Fig. 7b illustrates the scaling of the number of shots per iteration (S) with respect to N. We conducted QEMC simulations using varying shot quantities per cost function evaluation, namely N, N^3/2, N², 2N², and 3N². Our focus was on the set of 3-regular graphs with smaller sizes ranging from 4 to 32 nodes, as finite shot-number simulations are more resource-intensive. Throughout the simulations, we utilized the optimal hyperparameters (number of layers, step-size) detailed in Table 1 and allowed for the same total number of iterations reported for the classical simulations (I = 300). We marked the minimum shot quantity at which the average GW cut was reached. The results depicted in Fig. 7b suggest an approximated quadratic scaling of S with N.

Finally, Fig. 7c shows the number of QEMC-iterations (I) required in order to reach the GW cut (on average), as a function of N, on a logarithmic scale. We simulated each graph instance with the optimal hyperparameters reported in Tables 1, 2 for the classical simulations, using an infinite number of shots. Here, too, we further plotted a ${\log }^{3}N$ curve that upper bounds the results, suggesting a poly-logarithmic scaling of the number of iterations I with N.

Overall, our empirical estimation indicates that L, and therefore also P, scale as ${\mathcal{O}}(polylog\,N)$, while $S \sim {\mathcal{O}}({N}^{2})$, and $I \sim {\mathcal{O}}(polylog\,N)$. Therefore, it can be deduced, empirically-based, that the QEMC time-to-solution (TTS, Eq. (4)) is governed by the number of required shots (S), and scales quadratically with the number of nodes, i.e. $\widetilde{{\mathcal{O}}}({N}^{2})$ when neglecting logarithmic terms.

Our analysis assumes that the size of the graph-partition, represented by the value of B, can be estimated to a good accuracy in advance. If this isn’t feasible, the scheme would need to be executed $\lfloor \frac{N}{2}\rfloor$ times, leading to a total time-to-solution which scales cubically with the number of nodes N. This positions the QEMC algorithm as a polynomial-time heuristic solver for the MaxCut problem. In comparison, note that the mere specification of the graph scales linearly with the number of edges M, which is, in general, quadratic with the number of nodes N. In addition, the time complexity of the GW algorithm is $\widetilde{{\mathcal{O}}}({N}^{3.5})$ in the most general cases, $\widetilde{{\mathcal{O}}}(NM)$, when all weights are non-negative, and $\widetilde{{\mathcal{O}}}(M)=\widetilde{{\mathcal{O}}}(N)$ for regular graphs, see Ref. ³⁸ and references therein.

Finally, according to our empirical findings, it seems that no speedup is provided by the QEMC algorithm ($\widetilde{{\mathcal{O}}}(M+LS)$), compared to its classical counterpart cs-QEMC ($\widetilde{{\mathcal{O}}}(M+LN)$). This entails that the QEMC algorithm, in its current formulation, does not provide a straightforward quantum advantage. Instead, it offers a quantum-inspired, efficient heuristic for solving the MaxCut problem.

Discussion

To conclude, we presented a novel variational quantum algorithm designed to heuristically address the MaxCut problem for N-node graphs, using $\lceil \log N\rceil$ qubits. The QEMC algorithm utilizes a unique encoding scheme that maps the logical state of a node (either “blue” or “white”) to a range of probability values for measuring the corresponding computational state, by means of probability-threshold encoding. The performance of our algorithm was numerically evaluated using both real-hardware IBMQ calculations and classical simulations, focusing on a set of unweighted, regular-graph instances.

For graph instances with up to 32 nodes, our real-hardware computations attained cuts that were considerably higher compared to previous studies using QAOA¹¹, and also compared to previous studies that suggested methods for logarithmic encoding of the problem^28,29. We achieved approximation ratios of above 97% (75%) for noiseless simulations (real hardware), see Fig. 3, whereas the real hardware QAOA results in Ref. ¹¹ for the exact same graphs were nearly random already for 16 nodes, and where in Ref. ²⁸ the resulted approximation ratios for a similar 3-regular graph with 32 nodes using logarithmic encoding were much worse - 77.6% (54.9%) for noiseless simulations (real hardware). We ascribe QEMC’s enhanced performance on quantum hardware over QAOA to two key factors: first, its employment of significantly smaller circuits, which reduces noise susceptibility; and second, its threshold probability encoding scheme. This encoding approach allows the algorithm to associate each graph partition with a volume of quantum states. This, in turn, grants the variational process a broader optimal state space to explore, potentially enhancing the system’s noise resilience.

In addition, our noiseless QEMC simulations, extended to 9-regular graph instances of up to 2048 nodes, consistently demonstrated an edge over the GW algorithm. High performance was also observed for 128-node Erdős–Rényi graphs with varying densities. Following this, an empirical resources evaluation suggested that the QEMC algorithm is computationally efficient, requiring time and memory resources that scale approximately quadratically with the graph-size (N). While these results are encouraging, it is important to note that they do not challenge the theoretical bounds described by Ref. ³⁹, as they are based on empirical tests over a fixed set of graph instances and do not guarantee a theoretically-proven minimal approximation ratio exceeding that of the GW algorithm.

Based on an empirical analysis of the required computational resources for both QEMC and its classically-simulated counterpart (cs-QEMC), we have shown that, as expected, the QEMC algorithm does not provide a quantum advantage. Demonstrating such an advantage requires an approach that not only surpasses traditional classical schemes but also outperforms the algorithm’s own classical simulation, a merit that is more challenging for qubit-efficient VQAs.

Nevertheless, the QEMC algorithm may serve as a competitive quantum-inspired classical algorithm. This novel paradigm holds potential for numerous applications in classical computing. Moreover, to the best of our knowledge, this is the first quantum-inspired algorithm based on a variational quantum approach. As such, it stands as a challenging benchmark for comparing state-of-the-art variational quantum algorithms, such as QAOA and its derivatives, in terms of computational resources (circuit depth, number of shots, and number of iterations) and overall performance. With respect to circuit depth, we have already made empirical observations that indicate that the QEMC algorithm necessitates circuits that are exponentially shallower than those used in QAOA, in order to surpass the GW algorithm’s performance.

To date, most physically-inspired, classical, and quantum techniques towards combinatorial problems, including simulated annealing, coherent Ising machines, quantum annealing, and the QAOA, formalize the problem naturally in terms of an Ising Hamiltonian⁴⁰. Our formulation is different and phrases the problem as a continuous optimization problem in a form that may be applicable to other types of optimization problems. This highlights the potential significance of exploring new quantum information encoding schemes.

Several open questions remain: (1) Are there any settings under which the QEMC, or variations of it, could also offer quantum advantage? For example, in cases where the reconstruction of the entire probability distribution is not required? (2) What insights can be drawn about the potential quantum advantage of QAOA by comparing it to our QEMC algorithm? (3) While GW is the best-known approximation algorithm for the MaxCut problem, guaranteeing the highest cut in the worst-case scenario, it may not always be the best choice in practice^38,41. How does the QEMC algorithm perform in comparison to state-of-the-art heuristics like simulated annealing⁴², rank-two relaxation heuristic⁴¹, and the coherent Ising machine⁴³? (4) We have tested the QEMC algorithm only on unweighted regular graphs. How does it perform on other families of graphs? These questions are left for future research.

Methods

The QEMC quantum circuit

The QEMC circuit Ansatz does not depend on specific graph instances. This is in contrast to the QAOA, in which the graph-structure is encoded explicitly into the quantum circuit⁷. Instead, the graph is encoded implicitly through the cost function, as described above. Consequently, the QEMC quantum circuit is not constrained to any particular form and should only be expressive enough to approach the optimal states in the Hilbert-space. Such a problem-independent Ansatz approach, denoted as hardware-efficient in Ref. ⁴⁴, offers significant flexibility in the choice of the Ansatz. Moreover, it can be potentially implemented via pulse optimization schemes, such as outlined in Refs. ^45,46,47,48, whose application to problem-dependent Ansätze is not straightforward.

In this study, we employed PennyLane’s “strongly entangling layers” circuit^49,50, depicted in Fig. 8, in which the number of tunable parameters in each layer increases linearly with the number of qubits, resulting in logarithmic scaling with the number of nodes in the graph (N). We did not optimize over this choice. For all calculations, including those conducted on real hardware, we initialized the quantum circuit with random parameters without optimizing over their initialization (see, e.g., Refs. ^51,52 for works on circuit parameters initialization for the QAOA).

Fig. 8: Illustration of PennyLane’s “strongly entangling layers” circuit Ansatz^49,50 used in this study.

The figure depicts the Ansatz for the case of n = 3 qubits and L = 2 layers. After a single (uncounted) layer of Hadamard gates, each subsequent layer consists of 3n single-qubit parameterized rotation gates and n CNOT gates.

Computational details

To demonstrate the performance of the QEMC method, we carried out classical noiseless state-vector simulations, as well as quantum real-hardware IBMQ calculations. We focused on two sets of graphs: small 3-regular graphs with 4–32 nodes (2–5 qubits), and large 9-regular graphs with 16-2048 nodes (4-11 qubits).

To assess the cuts produced by the QEMC algorithm, we compared them to the optimal cuts obtained by exhaustive search (for the smaller 3-regular graphs only) and to GW cuts (for both graph sets). The latter were derived using the public code from Ref. ⁵³ available on GitHub, which we have thoroughly verified independently.

Our classical simulations were conducted using the PennyLane platform⁵⁰. For the real IBMQ executions, we utilized the following machines: ’Jakarta’, ’Perth’, and ’Lagos’, where the specific hardware selection was based on availability. We did not employ any noise-mitigation techniques throughout.

QEMC components configuration and hyperparameters tuning

The Adam optimizer⁵⁴ was used with the default hyperparameters of β₁ = 0.9, β₂ = 0.99, ε = 10⁻⁸ fixed throughout, as implemented in PennyLane. We did not optimize over that choice.

To fix the α step-size in the Adam optimizer and the number of circuit layers L, we ran a grid-search over these two hyperparameters, as depicted in Fig. 9 for a specific graph instance with 22 nodes. For the noiseless simulations, we chose the minimum number of layers that achieved the largest average cut, together with the corresponding step-size. For example, in the case of the 22-node graph, presented in Fig. 9, we set the number of layers to L = 5, and the step-size to α = 0.6. For the real hardware calculations, we utilized a maximum number of L = 2 layers and selected the most suitable corresponding step-size. By doing that, we slightly sacrificed theoretical accuracy, but gained significant practical accuracy, due to the usage of shallower circuits.

Fig. 9

Hyperparameters grid-search on the 22-node graph instance with optimal cut of 28 and average GW cut of 26.7.

Figure 10 presents the hyperparameter grid-searches for the 3-regular graphs set, ranging from 4 to 32 nodes, with one graph instance per graph-size, as described in “Experimental results: small 3-regular graphs with 4–32 nodes (2–5 qubits) - noiseless simulations and real-hardware calculations”. The search was performed for each graph instance. It is observed that utilizing more layers often requires a smaller step-size of the Adam optimizer. Similarly, Fig. 11 shows the parameter grid search for the 256-node graph instance of “Numerical results: large 9-regular graphs with 16–2048 nodes (4–11 qubits) - noiseless simulations”, illustrating the same trend.

Fig. 10: Grid-searches of the number of layers and step-size combinations for the set of 3-regular graphs with 4-32 nodes, with one graph instance per graph-size, described in “Experimental results: small 3-regular graphs with 4–32 nodes (2–5 qubits) - noiseless simulations and real-hardware calculations”.

A grid-search is presented for each graph instance. Each {#Layers, Step-size} entry displays the averaged QEMC cut obtained over 10 trials via noiseless state-vector simulations, where each trial consisted of 300 iterations. The optimal cut, obtained by exhaustive search, is also specified for comparison.

Fig. 11: Grid-search of the number of layers and step-size combinations for the single 9-regular, 256-node graph instance, described in “Numerical results: large 9-regular graphs with 16-2048 nodes (4-11 qubits) - noiseless simulations“.

Each {#Layers, Step-size} entry represents the averaged QEMC cut obtained over 10 trials via noiseless state-vector simulations, where each trial consisted of 200 iterations. The optimal hyperparameters combination is identified as #layers = 80 and step-size=0.08, resulting in an average cut of 828.5. The averaged GW cut of 817 is also specified along the color bar for comparison.

We set $B=\frac{N}{2}$ throughout, namely we assumed that optimal MaxCut partitions would have approximately half of the nodes that are blue, and did not optimize over that choice any further.

Finally, we configured the number of shots for the real-hardware calculations to be S = 3N², based on an empirical estimation described in “Computational Resources Estimation”.

Computational details for benchmarking Erdős–Rényi 128-node graphs (7 qubits) with varying densities

To enable a meaningful comparison with the results reported in Ref. ²⁹, we used the same classical optimizer for the benchmarks reported in “Numerical results: Erdős–Rényi graphs of varying densities with 128 nodes (7 qubits) - noiseless simulations”, namely the gradient-free COBYLA optimizer⁵⁵. This optimizer requires significantly more iterations than the Adam optimizer used elsewhere in this paper. For the 128-node Erdős–Rényi graph instances, we allowed up to 20,000 iterations. Table 5 lists the values of COBYLA’s rhobeg hyperparameter and the number of circuit layers used for each graph instance.

Table 5 Hyperparameter values for rhobeg and the number of circuit layers, selected via grid search for QEMC runs on 128-node graphs (7 qubits) with varying densities, as described in “Numerical results: Erdős–Rényi graphs of varying densities with 128 nodes (7 qubits) - noiseless simulations”

Finally, we note that our implementation for evaluating the Erdős–Rényi 128-node graph instances is based on noiseless simulations using Qiskit⁵⁶, with a “circular” CNOT pattern, as shown in Fig. 12, a choice we did not optimize.

Fig. 12

The “circular” Ansatz scheme used for performing the benchmarks described in “Numerical results: Erdős–Rényi graphs of varying densities with 128 nodes (7 qubits) - noiseless simulations”.

Benchmarking QEMC results against QAOA results

To facilitate a meaningful comparison between the results presented in “Experimental results: small 3-regular graphs with 4-32 nodes (2-5 qubits) - noiseless simulations and real-hardware calculations” and those reported in Ref. ¹¹, Fig. 13 adjusts the y-axis scaling of Fig. 3. This rescaling is performed to align the metric used in Ref. ¹¹, denoted as $\frac{\langle C\rangle }{{C}_{\min }}$, with our metric $\frac{Cut}{Cut* }$, where C = ∑_j<kZ_jZ_k is the cost function utilized in Ref. ¹¹ (for unweighted graphs) and ${C}_{\min }$ is the minimal value it takes, while Cut is the averaged (over multiple QEMC executions) cut and Cut* is the optimal cut. Here, the quantity cut accounts for the number of edges that connect nodes of different colors, as defined earlier. In contrast, according to the definition of C, edges that connect nodes of different colors contribute −1, whereas edges that connect nodes of the same color contribute +1 to C, resulting with 〈C〉 = − Cut + (M−Cut) = M−2Cut and C_min = − Cut^* + (M−Cut^*) = M−2Cut^*, leading to:

$$\frac{\langle C\rangle }{{C}_{min}}=\frac{M-2Cut}{M-2Cu{t}^{* }},$$

(5)

where M = ∣E∣ is the number of edges in the graph.

Fig. 13

The exact same plot of Fig. 3, shown on the y-scale of¹¹.