A Comparison Between Heuristic and Automatic Design in Variational Quantum Circuits for the MaxCut Problem Under Noise Effects

Abstract

The selection of the right topology (ansatz) for a Variational Quantum Algorithm (VQA) is a complex task that usually involves deep knowledge of a particular problem. The importance of the selection is greater when we consider the current state of quantum hardware, particularly the noise associated with the complexity of Variational Quantum Circuits (VQCs) that implement VQAs. Here, a comparison is presented between two confronted approaches for solving the MaxCut problem: QAOA, which has a theoretical proof of convergence, and the automatic design proposal (QNAS), which relies on evolutionary algorithms (NSGA-II) to discover efficient circuits. The comparison was made across 490 graph instances from different graph topologies and sizes ($n=4$ to $n=16$), accounting for noise models such as depolarizing noise, gate errors, and readout noise. The results show that QAOA achieves an approximation ratio ($r_A$) $\approx 1$ on complete graphs at the cost of being almost 12 times more complex than QNAS in ideal conditions while approaching the random noise floor ($r_A\approx 0.5)$. QNAS was capable of finding circuits less complex while maintaining $69\%$ of the fidelity at a cost of having an $r_A$ on the interval $0.7\le r_A\le 0.8$. However, when the comparison is made across sparse graphs, performance is comparable, while QNAS is less complex.

1. Introduction

The current state of Quantum Computing (QC) is mainly limited by the state-of-the-art Noisy Intermediate-Scale Quantum (NISQ) [1,2] devices which consist of quantum computers primarily based on ultra-cold atoms and superconducting qubits that can only offer processors with 50–1000 qubits that suffer from real world limitations mainly due to physical processes such as decoherence, a process that induces noise that destroys the superposition of a quantum state and consequently alters the measurement of the result of VQAs. These QCs have short coherence times, which translate into a small operational window, limited connectivity between qubits, and gate error rates ranging from ${10}^{-3}$ to ${10}^{-2}$. This is a clear difference with classical computers, where errors may seem, in essence, non-existent, while QCs accumulate noise that affects the measurement of information.

Due to the presence of this inherent noise that is caused by experimental limitations, several approaches are being explored to take value from the QC, in particular, the use of Variational Quantum Eigensolvers (VQEs) [3].

The Quantum Approximate Optimization Algorithm (QAOA) is a VQA focused on combinatorial optimization. This kind of VQA uses a classical computer to repeatedly adjust the parameters of a Variational Quantum Circuit (VQC) called an ansatz to minimize a specified cost function that depends on the problem. Finally, the quantum computer (or the simulation) measures the results to evaluate the cost function.

An important point is that the process relies on the selection of the ansatz, which depends entirely on the choice of architecture. Some of the problems that may arise from choosing the wrong ansatz are as follows:

• The VQC cannot reach the part of the optimization landscape where the solution lives. Recent work has formalized this through measures like Kullback–Leibler (KL) divergence from the Haar measure [4].
• Barren Plateaus: In this case, the optimization landscape becomes flat as the system grows, making gradient-based methods useless in the search for the parameters in the VQC [5,6].
• Decoherence occurs before the algorithm finishes, making the solution provided by the VQC useless due to the random behavior [7].

Our proposal (See Figure 1) is based on a direct comparison between the previously mentioned QAOA and the Quantum Neural Architecture Search (QNAS), which relies on evolutionary computing strategies to discover solutions to a specific problem. Several works, such as those presented in [8,9,10], employ different evolutionary techniques, as well as other approaches, such as reinforcement learning [3,11], for the automatic design of ansatzes.

However, a direct comparison of the functioning of heuristic approaches, such as QAOA, and automatic design strategies, such as QNAS, remains unexplored for well-defined problems, such as the MaxCut problem presented here.

An important remark is that, even though this study is related to the MaxCut problem, it can itself be viewed as part of a more general approach, since QNAS is well known for creating the search for potential Quantum Neural Network (QNN) architectures. A QNN can be represented as a VQC, which is itself a VQA.

This paper is organized as follows. Section 2 presents the theoretical framework, including the MaxCut problem formulation, the QAOA algorithm and its complexity analysis, and the QNAS approach based on NSGA-II. Section 3 details the experimental methodology, including the deployment environment, graph dataset construction, noise model specification, and performance metrics. Section 4 reports the results across ideal and noisy conditions, stratified by graph topology. Finally, Section 5 summarizes the findings and provides directions for future work.

2. Theoretical Background

2.1. Formulation of MaxCut Problem

The formal definition of the MaxCut problem [12] can be summarized by taking into account an undirected graph $G=(V,E)$ with a set of vertices V and edges E. The objective is to find a partition of V into two disjoint sets, S and $S^c=V\setminus S$, that maximizes the number of edges between them. The cut value is defined as follows:

$$\mathrm{Cut}\left(S\right)=\left|\right\{(i,j)\in E:i\in S,j\in S^c\left\}\right|$$

(1)

This problem can be mapped to find the ground-state in an Ising Hamiltonian (see Figure 2), since the two are isomorphic. We assign a spin variable $s_i\in \{+1,-1\}$ to each vertex i, where $s_i=+1$ indicates $i\in S$ and $s_i=-1$ indicates $i\in S^c$. The cost function becomes:

$$C\left(s\right)={\displaystyle \frac{1}{2}}\sum _{(i,j)\in E}(1-s_i{s}_j)$$

(2)

This formulation relies on the fact that $s_i{s}_j=-1$ when vertices i and j are in different partitions, and $s_i{s}_j=+1$ when they are in the same partition. By mapping $s_i\to {\sigma }_i^z$, where ${\sigma }_z$ is the Pauli z–matrix, we obtain the Hamiltonian $H_C$:

$$H_C={\displaystyle \frac{1}{2}}\sum _{(i,j)\in E}(I-{\sigma }_i^z{\sigma }_j^z)$$

(3)

The ground state of $-H_C$ corresponds to the maximum cut. The measurement outcome $z\in {\{0,1\}}^n$ in the computational basis is interpreted as a bit-string, where qubit i in state $|0\rangle$ corresponds to $i\in S$ and $|1\rangle$ to $i\in S^c$.

An auxiliary metric called approximation ratio can be defined as:

$$r_{\mathcal{A}}={\displaystyle \frac{C\left(z_{\mathrm{measured}}\right)}{C^{\ast }}}$$

(4)

where $C^{\ast }$ is the value of the optimal cut, and $r_A$ is a standard metric used to evaluate the quality of a solution provided by an optimization algorithm relative to the best possible (optimal) solution.

2.2. Quantum Approximate Optimization Algorithm (QAOA)

QAOA is a heuristic algorithm inspired by the adiabatic theorem [13] that, as stated previously, was handcrafted to provide solutions to combinatorial optimization problems [14]. This solution method consists of two elementary components of an ansatz, a cost Hamiltonian $U_C\left({\gamma }_k\right)=e^{-i{\gamma }_k{H}_c}$ and a mixer operator $U_M\left({\beta }_k\right)=e^{-i{\beta }_k{H}_M}$. The cost part of the Hamiltonian ensures that the max-cut is evaluated; the mixer part, instead, ensures that the state being evaluated changes and that the algorithm does not fall into a local minimum. The proposed solution takes the following form:

$$\left|\psi \right(\overrightarrow{\gamma },\overrightarrow{\beta })\rangle =U_M\left({\beta }_p\right)U_C\left({\gamma }_p\right)\cdots U_M\left({\beta }_1\right)U_C\left({\gamma }_1\right){|+\rangle }^{\otimes n},$$

(5)

where $\overrightarrow{\gamma }=({\gamma }_1,\dots ,{\gamma }_p)$ and $\overrightarrow{\beta }=({\beta }_1,\dots ,{\beta }_p)$ are variational parameters (rotation angles), and $|+\rangle ={\displaystyle \frac{1}{\sqrt{2}}}\left(\right|0\rangle +|1\rangle )$ is the uniform superposition state. The notation ${|+\rangle }^{\otimes n}$ represents the tensor product of n qubits, each in the $|+\rangle$ state.

The operators are applied sequentially from right to left, beginning with state preparation and then alternating p layers of cost and mixer unitaries. Each $U_C\left({\gamma }_k\right)$ encodes the problem Hamiltonian (Equation (3)), while $U_M\left({\beta }_k\right)={\prod }_{i=1}^{n_q}{e}^{-i{\beta }_k{X}_i}$ implements the mixing part, where $X_i$ is the Pauli-X operator on qubit i.

The mixer operator $U_M$ acts by applying single-qubit Pauli-X rotations to each qubit, $U_M$ induces transitions between computational basis states, ensuring that the algorithm can escape local minima. This property guarantees that, as the number of layers p increases, the algorithm can, in principle, approximate the global optimum. $U_M$ also corresponds to the initial Hamiltonian $H_M=-{\sum }_i{X}_i$, whose ground state is the uniform superposition ${|+\rangle }^{\otimes n}$, the starting point from which the system evolves toward the ground state of the cost Hamiltonian $H_C$.

From Equation (5), it is possible to note that the function depends on a parameter p, which is usually referred to as the number of layers of the ansatz. However, it can be seen that all layers have a cost part and a mixer part; therefore, the number of layers is $2p$. A more visual representation of the structure of each layer in QAOA is shown in Figure 3.

Complexity Analysis of QAOA

The implementation cost of QAOA is dominated by the unitary cost $U_C$. Since $H_C$ contains terms of the form $Z_i{Z}_j$, implementing $U_C$ requires one to realize the unitary $e^{-i\gamma Z_i{Z}_j}$ for every edge $(i,j)\in E$. Standard decomposition requires two CNOT gates and one $R_z$ rotation [15]:

$$e^{-i\gamma Z_i{Z}_j}\equiv {\mathrm{CNOT}}_{ij}·R_z{\left(2\gamma \right)}_j·{\mathrm{CNOT}}_{ij}$$

(6)

Consequently, a single layer ($p=1$) requires $2\left|E\right|$ CNOT gates plus n single-qubit gates for the mixer. For a complete graph $K_n$, where $\left|E\right|=n(n-1)/2$, the total CNOT count for depth p is

$$N_{\mathrm{CNOT}}\approx p·n(n-1)\in \Theta \left(p{n}^2\right)$$

(7)

This quadratic scaling with system size n is the primary limitation of QAOA in the NISQ era, as error rates on CNOT gates ($2q$-gates) (${ϵ}_{2q}\approx {10}^{-2}$) are approximately one order of magnitude higher than single-qubit gates (${ϵ}_{1q}\approx {10}^{-3}$) on current superconducting platforms.

For any graph G with determined depth p, QAOA provides a polynomial-time approximation algorithm for MaxCut. While the approximation ratio depends on p and graph topology, work by [16] proved that for $p=1$, QAOA achieves an approximation ratio of at least $r_A=0.6924$ for any 3-regular graph. Numerical evidence suggests that as p increases, QAOA can approach or exceed the Goemans–Williamson bound ($\alpha \approx 0.878$) for specific graph families [17,18], though this remains an open theoretical question. However, this guarantee comes with the restriction that the parameters $\overrightarrow{\gamma },\overrightarrow{\beta }$ must be optimally chosen [19].

2.3. Quantum Neural Architecture Search (QNAS)

On the other side of our proposal, QNAS optimizes the architecture A (topology and gate selection), and it also optimizes the variational parameters (see Figure 4) $\theta$ for that specific architecture.

We can think of this as a Multi-Objective Optimization (MOO) problem:

$$\underset{A\in \mathcal{S}}{min}\mathbf{F}\left(A\right)=\left[\langle {\psi }_A\left({\theta }^{\ast }\right)\left|H_C\right|{\psi }_A\left({\theta }^{\ast }\right)\rangle ,\mathcal{C}\left(A\right)\right]$$

(8)

where:

• $\mathcal{S}$ is the search space of possible circuits. In this approach, it is described as an integer list.
• $\mathcal{C}\left(A\right)$ is the complexity cost referred to the potential hardware implementation.
• ${\theta }^{\ast }$ denotes the parameters obtained via classical optimization (in our experimentation, we used (L-BFGS-B) [20] with 100 iterations).

The objectives are conflicting (see Figure 5): increasing circuit depth generally improves expressibility (reducing the first objective) but increases complexity (increasing the second objective). The solution to this MOO problem is not a single architecture but a Pareto Front, a set of architectures where no objective can be improved without degrading another.

Evolutionary Search via NSGA-II

We employ the NSGA-II proposed by [21] to conduct the optimization of the architectures/topologies. NSGA-II works by creating a population of candidate architectures and evolving them through variational operators (selection, crossover, and mutation).

The functioning of NSGA-II under our proposal is defined in Algorithm 1, and illustrated in Figure 6 as a direct extrapolation of the original [21] reference.

Algorithm 1 NSGA-II for QNAS. A direct translation of the original algorithm [21] using the notation for the examined problem.

1: Initialize population $P_0$ of N random architectures 2: for generation $g=1$ to $G_{max}$ do 3:     for each architecture $A\in P_g$ do 4:        Train parameters ${\theta }^{\ast }\left(A\right)$ via L-BFGS-B (inner loop) 5:        Evaluate objectives: $f_1\left(A\right)={\langle H_C\rangle }_A$, $f_2\left(A\right)=\mathcal{C}\left(A\right)$ 6:     end for 7:     Perform non-dominated sorting on $P_g$ to assign ranks 8:     Calculate crowding distance for each architecture 9:     Generate offspring $Q_g$ via tournament selection, crossover, mutation 10:   Combine $P_g\cup Q_g$ and select best N for $P_{g+1}$ 11: end for 12: return Pareto front from final population $P_{G_{max}}$

Selection is based on two criteria:

• Pareto front rank: Solutions that are not dominated by any other solution receive Rank 1, and so forth. This stratification ensures convergence toward the true Pareto front.
• Crowding distance: To preserve diversity, the algorithm prefers solutions that are in less crowded regions of the objective space. The crowding distance $d_i$ for individual i is calculated as:

  $$d_i=\sum _{m=1}^M{\displaystyle \frac{f_m^{(i+1)}-f_m^{(i-1)}}{f_m^{max}-f_m^{min}}}$$

  (9)

  where M is the number of objectives, and $(i-1),(i+1)$ denote the neighboring solutions in objective space sorted by $f_m$. This prevents convergence to a single point on the front and ensures exploration of the entire trade-off surface.

3. Methodology

To create a fair benchmark for the proposed approaches, we developed a framework using Qiskit, a state-of-the-art Python (3.11.14) library for conducting real and simulated quantum executions. However, it is also important to illustrate the process that is being made in the execution of a VQA in a QC where the evaluation of the algorithm is being made (see Figure 7 and Figure 8).

3.1. Deployment Details

All quantum circuits were constructed, transpiled, and simulated using the IBM Qiskit SDK (version 0.44.0) with Qiskit Aer (version 0.12.2). Noiseless expectation values were obtained from statevector simulation, while the effect of noise was incorporated through the analytical fidelity model described in Section 3.4 (Equation (13)), which combines $r_{A,\mathrm{ideal}}$ with an estimated circuit fidelity $F_{\mathrm{est}}$ derived from the gate counts and per-gate error rates of Table 1.

To ensure reproducibility, we fixed the following environment parameters:

• All circuits were transpiled (an important remark is that transpilation, which is commonly known as an optimization method for the circuits to be more efficient does not interfere with the QNAS approach since transpilation relies on the logic, while QNAS relies on the architecture of the circuit) to a standard basis gate set $\{R_z,\sqrt{X},X,\mathrm{CNOT}\}$ using optimization level 3 (optimization_level = 3) to minimize swap gates excessive presence before noise injection.
• For QAOA, we employed the L-BFGS optimizer (100 iterations). For the QNAS evolutionary loop, we implemented a custom NSGA-II genetic algorithm.
• Fixed seeds were used for both graph generation (networkx) and quantum circuit initialization.

3.2. Structure of the Proposed Graphs for MaxCut Problem

We generated a dataset composed of 490 graphs from different distributions that may represent different physical phenomena. Our proposed graph distributions can be summarized as follows:

• Random network graphs: We used the Erdös–Rényi model as a baseline to tackle problems without apparent structure.
• Complex networks: In this case, we used Barabási–Albert and Watts–Strogatz models. The former is known for generating scale-free networks. All of them are common in real-world network analysis.
• Regular graph distributions: We used a cycle graph, which models only local connectivity; a grid, which simulates problems with strong locality; a complete graph, which represents the case where the graph has maximum interaction density; and a star, which is a centralized graph.

QNAS Encoding Scheme

To codificate each candidate circuit, a variable-length chromosome was proposed (Figure 9a):

$$\mathrm{Individual}=[l_1,l_2,\dots ,l_k]$$

where each gene $l_i\in \{0,1,\dots ,|S|-1\}$ indexes. The search space S is composed of atomic layers that include single-qubit rotation gates $\{R_x,R_y,R_z,H\}$ and two-qubit entangling gates $\left\{CNOT\right\}$, which are applied across all feasible qubit combinations. This representation facilitates the evolution of circuit topology and depth within the NSGA-II framework.

It is important to note that the list codification depends on the initial configuration used to generate the search space; that is, for a particular quantum computer, restrictions can be added to the search space, allowing a custom design for that hardware. This is particularly relevant since one of the capabilities we need to fight back is the lack of complete connectivity in real QCs.

An important clarification is that NSGA-II was executed independently for each graph instance, meaning that the architecture optimization was made to each specific problem. We acknowledge that this introduces additional computational overhead relative to QAOA, which uses a fixed ansatz structure across all instances. The cost of the evolutionary search is discussed in terms of the total number of circuit evaluations in Section 4.

The search space $\mathcal{S}$ consists of $\left|\mathcal{S}\right|=7$ atomic operations: parameterized single-qubit rotations ($R_x$, $R_y$, $R_z$), the fixed Hadamard gate (H), linear nearest-neighbor CNOTs, circular CNOTs, and problem-specific $ZZ$ interaction layers.

Experiment Hyperparameters: The NSGA-II algorithm was executed with a population size of $N=30$ over a maximum of $G_{max}=50$ generations. The variational operators employed a single-point crossover with probability $p_c=0.7$ and random mutation with probability $p_m=0.3$.

3.3. Noise Models and Their Importance in the Search

As previously stated, QCs tend to have more errors due to coherence issues and other physical factors. In this paper, we analyze the VQCs under varying noise conditions. To achieve this, we avoided simple depolarizing models in favor of a physically motivated noise model applied via Qiskit Aer simulator. The evolution of the density matrix $\rho$, which is a generalization of the state-vector approach and a representation of a VQC/VQA, is then governed by the operator-sum representation $\mathcal{E}\left(\rho \right)={\sum }_k{E}_k\rho E_k^{†}$, where $E_k$ corresponds to the basis (in this scenario, the computational basis) where the state is described. We modeled three distinct error channels applied sequentially to every operation in the circuit:

3.3.1. Gate Error Model

Gate errors were modeled using the depolarizing channel formalism, which approximates the complex error processes in physical devices. Under this model, a quantum state $\rho$ subjected to a depolarizing channel with error probability p evolves as follows:

$$\mathcal{E}\left(\rho \right)=(1-p)\rho +{\displaystyle \frac{p}{d^2-1}}\sum _{P\ne I}P\rho P^{†}$$

(10)

where d is the Hilbert space dimension, and P ranges over the Pauli group excluding identity. (We use the convention where p represents the total depolarizing probability, distributed uniformly across $d^2-1$ non-identity Pauli operators, consistent with Qiskit Aer v0.12.2’s depolarizing_error(p, num_qubits) implementation. Note that for single-qubit gates, e.g., ($d=2$), each Pauli error has a probability of $p/3$; for two-qubit gates, e.g, ($d=4$), it is $p/15$.) The error rates employed in this study are summarized in Table 1.

Table 1. Noise Model Parameters. Error rates calibrated against IBM Eagle/Heron processor specifications. The depolarizing model provides an estimate of gate-fidelity loss by distributing errors uniformly across Pauli channels.

Error Source	Symbol	Value	Physical Mechanism
Single-qubit gate error	$p_{1q}$	$1.0\times {10}^{-3}$	Depolarizing channel applied after each $R_x$, $R_y$, $R_z$ rotation; models pulse calibration drift and decoherence during gate execution.
Two-qubit gate error	$p_{2q}$	$1.0\times {10}^{-2}$	Depolarizing channel on both qubits post-CNOT/CZ; captures crosstalk, residual ZZ coupling, and extended gate duration effects.
Readout error	$p_{\mathrm{ro}}$	$2.0\times {10}^{-2}$	Classical bit-flip confusion matrix; models resonator thermal population, insufficient integration time, and state relaxation during measurement.

Table 1. Noise Model Parameters. Error rates calibrated against IBM Eagle/Heron processor specifications. The depolarizing model provides an estimate of gate-fidelity loss by distributing errors uniformly across Pauli channels.

Error Source	Symbol	Value	Physical Mechanism
Single-qubit gate error	$p_{1q}$	$1.0\times {10}^{-3}$	Depolarizing channel applied after each $R_x$, $R_y$, $R_z$ rotation; models pulse calibration drift and decoherence during gate execution.
Two-qubit gate error	$p_{2q}$	$1.0\times {10}^{-2}$	Depolarizing channel on both qubits post-CNOT/CZ; captures crosstalk, residual ZZ coupling, and extended gate duration effects.
Readout error	$p_{\mathrm{ro}}$	$2.0\times {10}^{-2}$	Classical bit-flip confusion matrix; models resonator thermal population, insufficient integration time, and state relaxation during measurement.

The order-of-magnitude disparity between $p_{1q}$ and $p_{2q}$ reflects the fundamental difficulty of implementing high-fidelity entangling operations, which require precise control of inter-qubit coupling while suppressing parasitic interactions. This asymmetry motivates the complexity weighting scheme introduced in Section 3.4.

An important remark is that the depolarizing channel does not improve the performance of VQAs directly. However, QNAS benefits indirectly from noise through two mechanisms. First, during the NSGA-II search, decoherence penalizes complex circuits in the fitness evaluation via the fidelity term in $r_{\mathrm{eff}}$ (Equation (13)). The Pareto-based selection pressure in NSGA-II implicitly suppresses deep architectures during evolution, since circuits exceeding a complexity threshold where fidelity decay dominates any marginal improvement in expressibility are outperformed on both objectives by more compact alternatives.

3.3.2. Readout Error Model

Measurement errors were implemented using a classical confusion matrix M applied to the ideal measurement outcome distribution:

$${\overrightarrow{p}}_{\mathrm{noisy}}=M·{\overrightarrow{p}}_{\mathrm{ideal}},M=\left(\begin{array}{cc}1-p_{\mathrm{ro}}& p_{\mathrm{ro}}\\ p_{\mathrm{ro}}& 1-p_{\mathrm{ro}}\end{array}\right)$$

(11)

where $p_{\mathrm{ro}}=0.02$ represents the probability of a bit-flip error during the measurement process (see Figure 10). This symmetric error model assumes equal misclassification rates for $|0\rangle \to |1\rangle$ and $|1\rangle \to |0\rangle$ transitions.

3.3.3. Discussion: Impact of Different Noise Channels

The depolarizing channel employed in this study distributes errors uniformly across all Pauli operators, constituting the worst-case scenario for a given error probability p.

Phase damping (dephasing) is a unital channel characterized by Kraus operators $E_0=\left(\begin{array}{cc}1& 0\\ 0& \sqrt{1-\lambda }\end{array}\right)$ and $E_1=\left(\begin{array}{cc}0& 0\\ 0& \sqrt{\lambda }\end{array}\right)$, where $\lambda$ is related to the $T_2$ coherence time. This channel destroys off-diagonal coherences while preserving diagonal populations. Since the MaxCut cost Hamiltonian $H_C={\displaystyle \frac{1}{2}}\sum (I-Z_i{Z}_j)$ depends exclusively on diagonal elements of the density matrix in the computational basis, phase damping has a reduced impact on the expectation value $\langle H_C\rangle$ compared to depolarizing noise.

Amplitude damping models energy relaxation ($T_1$ decay) and is described by Kraus operators $E_0=|0\rangle \langle 0|+\sqrt{1-\gamma }|1\rangle \langle 1|$ and $E_1=\sqrt{\gamma }|0\rangle \langle 1|$, where $\gamma =1-exp(-t_{\mathrm{gate}}/T_1)$. Unlike the depolarizing and dephasing channels, amplitude damping is non-unital: it does not preserve the maximally mixed state, instead driving the system asymptotically toward ${|0\rangle }^{\otimes n}$. For the MaxCut problem, we define an initial setup which corresponds to placing all vertices in the same partition (a trivial cut with $C=0$).

For equivalent error probabilities, the expected degradation hierarchy is depolarizing ≥ amplitude damping > phase damping. The crossover point identified at $n\sim 12$ (discussed in detail in Section 4) thus represents a pessimistic estimate under the depolarizing model; alternative channels would shift this threshold to equal or larger system sizes while preserving the qualitative advantage of QNAS over QAOA.

3.4. Performance Metrics

As described earlier, different types of gates correspond to different problems; in particular, assuming equal complexity is a mistake. To correct this, we define a weighted complexity metric that accounts for the different set of quantum gates:

$$C=N_{1q}+w·N_{2q},w={\displaystyle \frac{p_{2q}}{p_{1q}}}=10$$

(12)

where $N_{1q}$ and $N_{2q}$ denote the total number of single-qubit and two-qubit gates, respectively. The weighting factor w is derived directly from the error rate ratio.

Noise-Adjusted Approximation Ratio

Standard approximation ratios $r_A$$=\langle C\rangle /C_{\max }$ are not effective for evaluating algorithms in high-noise regimes. In a physical system dominated by maximal decoherence (white noise), the quantum state becomes the maximally mixed state $I/2^n$. For unweighted MaxCut, measuring this state yields a random cut, which corresponds to an expected approximation ratio of $0.5$.

To quantify the utility of a quantum circuit relative to this physical baseline, we define $r_{eff}$ as the Noise-Adjusted Approximation Ratio:

$$r_{\mathrm{eff}}=r_{A,\mathrm{ideal}}·F_{\mathrm{est}}+0.5·(1-F_{\mathrm{est}})$$

(13)

where $r_{A,\mathrm{ideal}}$ is the noiseless approximation ratio derived from ideal simulation. $F_{\mathrm{est}}\approx exp[-(p_{1q}{N}_{1q}+p_{2q}{N}_{2q})]$ corresponds to the estimated circuit fidelity, calculated using the gate error rates ($p_{2q}\approx {10}^{-2}$) and gate counts (N) specific to each ansatz. This constitutes a pessimistic bound on circuit fidelity, as it assumes independent depolarizing errors with no error cancellation or coherent recombination.

In the limit of perfect hardware ($F\to 1$), $r_{\mathrm{eff}}\to r_{A,\mathrm{ideal}}$. As the circuit depth exceeds the coherence time ($F\to 0$), the performance converges to the random guessing value of $0.5$. This allows us to identify the point where the algorithm becomes indistinguishable from noise.

The balance between C and $r_{\mathrm{eff}}$ defines a Pareto frontier in the complexity–performance space. Circuits lying on this frontier represent optimal configurations where no improvement in $r_{\mathrm{eff}}$ is achievable without increasing C, and vice-versa. In order to create fair comparisons the knee point of PF was taken into account.

We note that $r_{\mathrm{eff}}$ is an estimate that combines the ideal approximation ratio from noiseless simulation with an analytical fidelity model. Another approach would be to report the directly simulated noisy approximation ratio obtained from Qiskit Aer.

4. Results

We benchmarked the standard QAOA with $p=5$ against the adaptive QNAS. The choice of $p=5$ was due to the fact that, theoretically, this depth provides sufficient expressibility to achieve approximation ratios $r_A>0.90$, minimizing the underfitting errors typical of shallow circuits.

We selected $p=5$ as a representative deep-circuit regime because it lies above the theoretical threshold for high approximation ratios on the tested graph sizes while remaining computationally tractable for full simulation across 490 instances. We acknowledge that intermediate depths ($p\in \{1,2,3\}$) may yield different complexity–performance trade-offs; in particular, a lower p would reduce the complexity gap between QAOA and QNAS. A systematic multi-depth analysis constitutes an immediate extension of this work that would strengthen the generalizability of the reported crossover behavior.

Figure 11a validates this theoretical premise. In noiseless simulations, QAOA ($p=5$) consistently delivers superior solution quality ($r_A\approx 0.92$ for $n=16$), outperforming the shallower structures discovered by QNAS. This confirms that, in an ideal fault-tolerant regime, depth is the primary driver of convergence.

However, Figure 11b exposes the implementation barrier. The Complexity of the $p=5$ ansatz scales linearly but with a prohibitive slope. For $n=16$, the circuit requires approximately 2700 weighted operations to enforce the multilayered topology. In contrast, QNAS identifies hardware-efficient circuits with a complexity of ≈370, representing an $86\%$ reduction in gate resources while preserving structural connectivity.

4.1. What Solutions Are Really Feasible?

The discrepancy between theoretical potential and physical realization is quantified by the Noise-Adjusted Approximation Ratio ($r_{\mathrm{eff}}$).

Table 2. Performance Summary ($n=16$). QAOA ($p=5$) maximizes theoretical potential but fails to preserve the result under noise.

Metric	QAOA ($p=5$)	QNAS
Ideal Ratio (${\mathit{r}}_{\mathit{A},\mathrm{ideal}}$)	$0.92$	$0.74$
Complexity Score (C)	2720	370
Est. Fidelity (F)	$0.06$	$0.69$
Effective Ratio ($r_{\mathrm{eff}}$)	$0.53$ (Noise)	$0.67$ (Signal)

presents the metrics for $n=16$. Despite QAOA showing a high ideal ratio, the estimated circuit fidelity drops to $6.6\%$ due to error accumulation. This forces the effective ratio to converge toward the random noise floor ($0.5$).

We observe a crossover at $n\approx 12$. Beyond this point (see Figure 12), the $p=5$ ansatz enters a regime where adding depth destroys more information than it creates. QNAS, by sacrificing theoretical perfection for structural efficiency, maintains a clear optimization signal ($r_{\mathrm{eff}}>0.65$) well into the region where QAOA collapses.

The asymptotic behavior of both approaches can be characterized analytically from Equation (13). For QAOA, ($p=5$), and the estimated fidelity decays as $F_{\mathrm{est}}=exp\left(-p_{2q}·2p·{\displaystyle \frac{n(n-1)}{2}}\right)$, yielding $F_{\mathrm{est}}\sim 0.02$ at $n=18$ and $F_{\mathrm{est}}\sim 0.006$ at $n=20$, which drives $r_{\mathrm{eff}}$. This degradation does not stabilize; it follows an exponential decay governed by the $\mathcal{O}\left(n^2\right)$ gate count scaling. In contrast, QNAS circuits maintain bounded complexity independent of graph connectivity, with empirical values $\mathcal{C}<500$ across all tested system sizes. Extrapolating with $\mathcal{C}\sim 400$ gives $F_{\mathrm{est}}\sim 0.67$ and $r_{\mathrm{eff}}\sim 0.74\times 0.67+0.5\times 0.33\approx 0.66$, suggesting that QNAS performance stabilizes in the interval $[0.60,0.66]$ as n increases beyond the tested range.

To create a fair comparison and test the hypothesis that smaller circuits exhibit greater noise resilience, we expanded our experiments to include QAOA at intermediate depths ($p\in \{1,3\}$). As illustrated in the Complexity–Performance Pareto Front (Figure 13), QAOA ($p=1$) reduces the structural complexity ($\mathcal{C}\approx 156$) compared to the $p=5$ regime ($\mathcal{C}\approx 763$). However, an important remark is that it suffers from severe underfitting, achieving an effective approximation ratio of only $r_{\mathrm{eff}}\approx 0.76$. At the same time, QNAS strictly dominates the Pareto frontier. This suggests that the evolutionary approach consistently discovers more hardware-efficient architectures ($\mathcal{C}\approx 41$) while approaching optimal theoretical values ($r_{\mathrm{eff}}\approx 0.98$). This small validation in a subset suggests that the superiority of QNAS is not merely an artifact of comparing against a deep, noise-sensitive ansatz.

4.2. Structural Analysis

We decomposed performance by a stratified description of the graph topology and density.

Topology Dependence

Figure 14 contrasts performance across three distinct graph classes. While QAOA ($p=5$) exhibits robustness in regular graphs ($\langle d\rangle \approx 2-4$), its effective performance collapses on Scale-Free networks.QNAS excels here by pruning hub connections, preserving the global signal.

Finally, Figure 15 illustrates that, for fixed depth p, the circuit depth of QAOA scales linearly with average degree $\langle d\rangle$. At $\langle d\rangle >4$, error accumulation becomes critical. QNAS maintains a flat performance profile.

5. Conclusions

In this work, we addressed ansatz selection for Variational Quantum Algorithms by comparing a heuristic strategy (QAOA, $p=5$) with an evolutionary architecture search (QNAS). Our research, performed across 490 graph instances under noise models, reveals a serious trade-off between theoretical expressibility and physical implementability in the NISQ era.

While the QAOA ansatz demonstrated better convergence capabilities in noiseless simulations ($r_A>0.90$), confirming that depth is the key element to the characterization of solution quality in ideal systems, its practical utility is strictly bounded by hardware coherence. At system size $n\approx 12$ solutions were comparable. Beyond this threshold, the linear scaling of the standard ansatz imposes a complexity penalty ($C>2700$ for $n=16$) that drives the effective approximation ratio to the random noise floor ($r_{\mathrm{eff}}\approx 0.5$). In contrast, QNAS demonstrated remarkable structural resilience. By decoupling circuit complexity from graph connectivity, the evolutionary approach reduced gate requirements by approximately $86\%$ compared to the $p=5$ baseline. Through the ability to selectively delete non-essential entanglement—QNAS maintained inside a valid optimization ($r_{\mathrm{eff}}>0.65$) regime.

These findings suggest that simply increasing circuit depth to improve theoretical convergence is a counterproductive strategy without error correction. Instead, resources should be directed toward adaptive, hardware-aware ansatz compilation. Future work will extend the benchmark to larger systems ($n>20$) using tensor network simulators to validate the analytical extrapolation presented in Section 4 and further explore the limits of topological pruning. Second, the noise model will be generalized to include amplitude damping ($T_1$ relaxation) and phase damping ($T_2$ dephasing) channels independently and in combination, using device-specific parameters from current IBM quantum processors to quantify how unital versus non-unital noise modifies the Pareto front topology discovered by QNAS and the degradation profile of QAOA.

Furthermore, deep circuits ($p=5$) collapse under decoherence, while shallow circuits ($p=1$) suffer from extreme underfitting. QNAS bypasses this limitation, showing that dynamic, hardware-aware ansatz compilation is an alternative superior to static topologies in the current NISQ era.