Quantum-Classical Advantage Boundaries: An Analytical Framework for Hybrid QPU-GPU Computational Utility

% $^{1, }$, $^{1}$[Affiliation, Department, Institution], $^{}$Corresponding author: [email]

March 2026 — Revised

Abstract: The emergence of hybrid quantum-classical architectures integrating quantum processing units (QPUs) with GPU-accelerated classical co-processors has outpaced the development of formal frameworks for predicting when such systems achieve computational advantage. We introduce the Quantum-Classical Advantage Boundary (QCAB) framework, a parameterized analytical model that delineates the regimes in which hybrid QPU-GPU computation surpasses purely classical methods for quantum simulation tasks. The framework defines a Quantum Utility Ratio $\QUR(n, d, S, \tau, \varepsilon)$ over the five-dimensional parameter space of qubit count $n$, circuit depth $d$, entanglement entropy $S$, communication latency $\tau$, and hardware error rate $\varepsilon$. We derive closed-form expressions for the advantage boundary surface under both state-vector and tensor-network classical baselines, and establish scaling laws governing the transition from classical to quantum computational dominance. We validate the framework computationally against ten experiments spanning 2019--2025, including Google Sycamore, IBM Eagle, Google Willow, and Quantinuum H2/Helios platforms, achieving 9/10 correct predictions on experiments with known outcomes, plus one forward prediction (FeMo-cofactor) awaiting experimental confirmation. Synthetic edge cases exercise all five decision gates of the classification procedure, parameter sweeps confirm smooth monotonic boundaries at predicted thresholds, and the full framework decisively outperforms trivial single-parameter classifiers (18/18 vs.\ 13/18 on the expanded test set). Our analysis reveals that the critical noise-depth product $\varepsilon d < 0.347$ is a necessary but not sufficient condition for quantum advantage, and that communication latency---rather than qubit count or gate fidelity alone---constitutes the primary bottleneck for near-term advantage in iterative hybrid algorithms.

---

Introduction

The classical simulation of quantum systems has served as the principal verification tool for quantum hardware since Feynman's foundational observation that quantum dynamics resist efficient classical computation [Feynman1982]. For three decades, the field operated under a tacit dichotomy: classical simulators emulate quantum systems, while quantum hardware executes them. The emergence of quantum devices exceeding $100$ physical qubits [Kim2023,Bluvstein2024] has disrupted this dichotomy by creating a regime in which neither approach alone suffices.

The concept of “quantum utility”---demonstrating that a quantum processor can produce reliable results for problems of scientific interest more efficiently than any available classical method—was advanced by Kim et al. [Kim2023] through experiments on 127-qubit Ising circuits. However, this claim was contested when tensor-network methods on GPU clusters achieved comparable or superior accuracy for the same circuits [Tindall2024,Begusic2024]. The ensuing debate exposed a critical gap: the absence of a rigorous, parameterized framework for predicting the boundary between classical and quantum computational domains.

This paper addresses that gap. We introduce the Quantum-Classical Advantage Boundary (QCAB) framework, which provides:

[label=(\roman*)]

• A formal definition of the Quantum Utility Ratio $\QUR$ as a function of five physical parameters: qubit count $n$, circuit depth $d$, entanglement entropy $S$, round-trip communication latency $\tau$, and hardware error rate $\varepsilon$.

• Closed-form expressions for the advantage boundary surface under both state-vector simulation and tensor-network contraction baselines.

• Quantitative scaling laws identifying the dominant bottleneck for hybrid advantage across distinct algorithmic classes.

• Application to two benchmark problems—molecular ground-state energy estimation and combinatorial optimization—yielding minimum hardware specifications for quantum utility.

The key insight of this work is that the advantage boundary is not a single threshold but a hypersurface in parameter space whose shape depends critically on the classical baseline employed. When the classical baseline is state-vector simulation, the boundary is governed primarily by qubit count. When the baseline is tensor-network contraction, the boundary is governed by entanglement entropy. In the hybrid regime, communication latency introduces a third axis that can dominate both.

The remainder of this paper is organized as follows. Section [ref:sec:background] reviews the classical simulation landscape and the hybrid computing paradigm. Section [ref:sec:framework] develops the QCAB framework and derives the utility ratio. Section [ref:sec:boundary] establishes the advantage boundary surfaces. Section [ref:sec:applications] applies the framework to molecular simulation and optimization. Section [ref:sec:validation] presents computational validation against ten real-world experiments and synthetic edge cases. Section [ref:sec:discussion] discusses implications for hardware development. Section [ref:sec:conclusion] concludes.

Background and Related Work

Classical Simulation Methods

The classical simulation of quantum circuits falls into two broad families, each with distinct computational scaling.

State-vector simulation.

The exact representation of an $n$-qubit quantum state requires storage of $2^n$ complex amplitudes. A circuit of depth $d$ composed of one- and two-qubit gates requires $\Ocal(d \cdot 2^n)$ floating-point operations for simulation [DeRaedt2019]. GPU acceleration through libraries such as NVIDIA's cuStateVec [cuQuantum2023] has pushed the practical limit to approximately $n \approx 40$ on single-node systems and $n \approx 50$ using distributed multi-GPU configurations [Haner2017,Pednault2019].

Tensor-network simulation.

Tensor network (TN) methods represent the quantum state as a contracted network of lower-rank tensors [Orus2014,Schollwock2011]. For matrix product states (MPS) with bond dimension $\chi$, the computational cost of simulating a depth-$d$ circuit on $n$ qubits scales as $\Ocal(n \cdot d \cdot \chi^3)$ [Vidal2003]. The bond dimension required to faithfully represent a state with bipartite entanglement entropy $S$ across a cut scales as $\chi \sim e^{S}$ for MPS [Hastings2007]. Projected entangled pair states (PEPS) generalize this to two-dimensional geometries but incur contraction costs that are $\#\mathrm{P}$-hard in the worst case [Schuch2007].

The critical parameter governing classical TN simulation cost is therefore the entanglement entropy $S$ of the target state, not the qubit count $n$ per se. This observation forms one of the pillars of the QCAB framework.

Hybrid Quantum-Classical Architectures

The variational quantum eigensolver (VQE) [Peruzzo2014] and quantum approximate optimization algorithm (QAOA) [Farhi2014] established the paradigm of iterative hybrid algorithms in which a QPU executes parameterized circuits while a classical optimizer updates the parameters. These algorithms require repeated round trips between QPU and classical processor, making the total wall-clock time sensitive to communication latency $\tau_{\text{net}}$.

IBM's “quantum-centric supercomputing” (QCSC) roadmap [IBMroadmap2022] envisions tight integration of QPU and GPU clusters through middleware layers that reduce $\tau_{\text{net}}$ to the sub-millisecond regime. The Qiskit Runtime architecture implements a portion of this vision by co-locating classical compute with QPU hardware [QiskitRuntime2023]. NVIDIA's CUDA-Q platform similarly provides a unified programming model for QPU-GPU heterogeneous computation [cuQuantum2023].

Error Mitigation

In the absence of fault-tolerant error correction, quantum error mitigation (QEM) techniques are required to extract useful results from noisy hardware. Probabilistic error cancellation (PEC) [Temme2017,Endo2018] constructs an unbiased estimator of the ideal expectation value by sampling modified circuits, but incurs a sampling overhead that scales exponentially with circuit noise (see Section [ref:sec:framework]). Zero-noise extrapolation (ZNE) [Li2017,Temme2017] provides a biased but lower-variance alternative. Both methods impose computational overhead that must be incorporated into any utility analysis.

The QCAB Framework

We now develop the Quantum-Classical Advantage Boundary framework. The central object is the Quantum Utility Ratio, defined as the ratio of classical to hybrid computational cost for achieving a target observable accuracy $\delta$ on a given problem instance.

Definitions and Notation

Consider a quantum circuit $\Ucal$ acting on $n$ qubits with depth $d$, producing a state $\ket{\psi} = \Ucal\ket{0}^{\otimes n}$. We wish to estimate an observable $\langle O \rangle = \bra{\psi}O\ket{\psi}$ to additive accuracy $\delta$ with probability at least $1 - \eta$.

[leftmargin=*]

• $n$: number of qubits.

• $d$: circuit depth (number of layers of parallel two-qubit gates).

• $S$: maximum bipartite entanglement entropy across any cut of the circuit's output state, measured in units of $\ln 2$.

• $\tau$: round-trip communication latency between QPU and classical co-processor (in seconds).

• $\varepsilon$: average two-qubit gate error rate.

• $\delta$: target accuracy for observable estimation.

• $\eta$: failure probability tolerance.

• $B$: batch size—the number of circuit executions per communication round trip.

Classical Computational Cost

State-vector baseline.

The cost of exact state-vector simulation is:

$$\label{eq:csv} \Ccal_{\mathrm{SV}}(n, d) = \alpha_{\mathrm{SV}} \cdot d \cdot 2^n$$

where $\alpha_{\mathrm{SV}}$ is a hardware-dependent constant with units of time per gate-amplitude operation. On current GPU hardware, $\alpha_{\mathrm{SV}} \approx 10^{-9}\,\mathrm{s}$ for single-precision arithmetic [cuQuantum2023].

Tensor-network baseline.

For an MPS simulation with adaptive bond dimension:

$$\label{eq:ctn} \Ccal_{\mathrm{TN}}(n, d, S) = \alpha_{\mathrm{TN}} \cdot n \cdot d \cdot e^{3S \ln 2}$$

where the exponential dependence arises from $\chi \sim 2^S$ and the $\Ocal(\chi^3)$ cost of singular value decomposition (SVD) at each bond update. The prefactor $\alpha_{\mathrm{TN}}$ encodes hardware-specific constants and the efficiency of the contraction path optimizer.

For PEPS in two-dimensional geometries, the cost generalizes to:

$$\label{eq:cpeps} \Ccal_{\mathrm{PEPS}}(n, d, S) = \alpha_{\mathrm{PEPS}} \cdot n \cdot d \cdot 2^{\Ocal(S \cdot w)}$$

where $w$ is the width of the boundary contracted during the approximate contraction procedure. Since the boundary-contraction approach renders PEPS costs highly geometry-dependent, we restrict our primary analysis to the MPS baseline in Eq. (eq:eq:ctn) and treat PEPS as an upper bound.

Hybrid Computational Cost

The total cost of a hybrid QPU-GPU computation consists of three components: QPU execution, classical post-processing for error mitigation, and communication overhead.

QPU execution cost.

For a single circuit execution:

$$\label{eq:qpu} T_{\mathrm{QPU}} = d \cdot \tau_{\mathrm{gate}} + \tau_{\mathrm{read}}$$

where $\tau_{\mathrm{gate}}$ is the duration of a single gate layer and $\tau_{\mathrm{read}}$ is the measurement and readout time. For superconducting hardware, $\tau_{\mathrm{gate}} \approx 50$--$100\,\mathrm{ns}$ and $\tau_{\mathrm{read}} \approx 0.5$--$1\,\mu\mathrm{s}$ [Krinner2022].

Error mitigation overhead.

Using PEC, the number of circuit samples required to achieve accuracy $\delta$ scales as:

$$\label{eq:pec} N_{\mathrm{PEC}}(\varepsilon, d, \delta, \eta) = \frac{C_{\mathrm{PEC}}^2}{\delta^2} \ln\!\left(\frac{2}{\eta}\right)$$

where $C_{\mathrm{PEC}} = (1 + 2\varepsilon)^{g(d)}$ is the PEC cost factor and $g(d)$ is the total number of noisy two-qubit gates in the circuit [Temme2017]. For a circuit with $n$ qubits in a linear topology with depth $d$, we have $g(d) \approx (n-1) \cdot d / 2$ on average. The PEC cost factor can be simplified for small error rates as follows:

$$\begin{aligned} \label{eq:cpec} C_{\mathrm{PEC}} &= (1 + 2\varepsilon)^{(n-1)d/2} \nonumber\\ &= \exp\!\left[\frac{(n-1)d}{2}\ln(1 + 2\varepsilon)\right] \nonumber\\ &\approx \exp\!\left[\frac{(n-1)d}{2} \cdot 2\varepsilon\right] \nonumber\\ &= e^{\varepsilon (n-1) d} \end{aligned}$$

where the third line uses $\ln(1 + x) \approx x$ for $x \ll 1$. This approximation is convenient for exposing qualitative scaling behavior but introduces systematic overestimation of PEC cost at higher error rates: the ratio $\exp[\varepsilon(n-1)d] / (1+2\varepsilon)^{(n-1)d/2}$ exceeds 2 for $\varepsilon > 0.01$ at typical circuit sizes. All numerical thresholds, crossover values, and validation results in Section [ref:sec:validation] use the exact formula $C_{\mathrm{PEC}} = (1 + 2\varepsilon)^{(n-1)d/2}$ throughout. The analytical boundary formulas (Results 1–6) use the approximation and should be interpreted as asymptotic scaling guides; for inequality conditions (e.g., necessary conditions for advantage existence), the overestimation is conservative, but for equality conditions (e.g., solving $\QUR = 1$ for $S^{\ast}$), the exact expression shifts the boundary surface quantitatively.

Communication overhead.

For iterative algorithms requiring $R$ classical-quantum round trips, the communication cost depends on the batching strategy. If the QPU executes $B$ circuit samples per round trip before returning results to the classical co-processor, the total communication overhead is:

$$\label{eq:comm} T_{\mathrm{comm}} = R \cdot \left\lceil\frac{N_{\mathrm{PEC}}}{B}\right\rceil \cdot \tau$$

Three limiting cases are physically relevant:

[leftmargin=*]

• Fully batched ($B = N_{\mathrm{PEC}}$): All samples for one optimization iteration are submitted as a single batch. This yields $T_{\mathrm{comm}} = R\tau$ and corresponds to the execution model of co-located architectures such as Qiskit Runtime [QiskitRuntime2023].

• Streaming ($B = 1$): Each circuit execution triggers a round trip, giving $T_{\mathrm{comm}} = R \cdot N_{\mathrm{PEC}} \cdot \tau$. This worst case applies to naive cloud-based QPU access.

• Practical hybrid: $B$ is determined by QPU queue depth and classical memory constraints, with $1 < B < N_{\mathrm{PEC}}$.

Unless otherwise stated, our analysis assumes fully batched execution ($B = N_{\mathrm{PEC}}$), which is the target operating mode for current QPU-GPU middleware. Results under non-ideal batching are strictly more latency-constrained.

Total hybrid cost.

Assembling these components, the total wall-clock time for the hybrid computation is:

$$\label{eq:chyb} \Ccal_{\mathrm{hyb}} = N_{\mathrm{PEC}} \cdot T_{\mathrm{QPU}} + R \cdot \left\lceil\frac{N_{\mathrm{PEC}}}{B}\right\rceil \cdot \tau + T_{\mathrm{GPU}}$$

where $T_{\mathrm{GPU}}$ is the GPU processing time for error mitigation coefficient computation and classical post-processing. For PEC, $T_{\mathrm{GPU}}$ is dominated by the compilation of quasi-probability distributions; in practice $T_{\mathrm{GPU}} \ll N_{\mathrm{PEC}} \cdot T_{\mathrm{QPU}}$ for all parameter regimes considered here, so it does not affect the dominant scaling of $\Ccal_{\mathrm{hyb}}$. We retain it for completeness but note that a detailed model of GPU compilation cost is hardware- and implementation-dependent.

The Quantum Utility Ratio

We define the Quantum Utility Ratio (QUR) with respect to a chosen classical baseline $B_{\mathrm{cl}} \in \{\mathrm{SV}, \mathrm{TN}\}$:

$$\label{eq:qur} \boxed{\QUR_{B_{\mathrm{cl}}}(n, d, S, \varepsilon, \tau; \delta, \eta, B) \;\equiv\; \frac{\Ccal_{B_{\mathrm{cl}}}(n, d, S)}{\Ccal_{\mathrm{hyb}}(n, d, \varepsilon, \tau; \delta, \eta, B)}}$$

The QUR depends on the five primary physical parameters $(n, d, S, \varepsilon, \tau)$ and additionally on the accuracy target $(\delta, \eta)$ and the batching parameter $B$. We adopt the convention of treating $(n, d, S, \varepsilon, \tau)$ as the free variables defining the advantage hypersurface, while $(\delta, \eta, B)$ are treated as fixed protocol parameters for a given computational task.

When $\QUR_{B_{\mathrm{cl}}} > 1$, the hybrid QPU-GPU approach is computationally advantageous over the classical baseline $B_{\mathrm{cl}}$. When $\QUR_{B_{\mathrm{cl}}} < 1$, the classical method is preferable. The advantage boundary is the hypersurface:

$$\label{eq:boundary} \Sigma_{B_{\mathrm{cl}}} \;=\; \{(n, d, S, \varepsilon, \tau) \;\mid\; \QUR_{B_{\mathrm{cl}}} = 1\}$$

Advantage Boundary Surfaces

We now derive the structure of $\Sigma_{B_{\mathrm{cl}}}$ for both classical baselines.

State-Vector Boundary

Setting $\QUR_{\mathrm{SV}} = 1$ and substituting Eqs. (eq:eq:csv) and (eq:eq:chyb) (under fully batched execution, $B = N_{\mathrm{PEC}}$):

$$\label{eq:sv_boundary} \alpha_{\mathrm{SV}} \cdot d \cdot 2^n = N_{\mathrm{PEC}} \cdot T_{\mathrm{QPU}} + R\tau + T_{\mathrm{GPU}}$$

The left-hand side scales as $2^n$ in qubit count. The dominant term on the right at large $n$ is the PEC sampling cost. Using the exact PEC formula (Eq. [ref:eq:cpec]), $N_{\mathrm{PEC}} \propto C_{\mathrm{PEC}}^2 = (1 + 2\varepsilon)^{(n-1)d}$, so:

$$N_{\mathrm{PEC}} \cdot T_{\mathrm{QPU}} \;\sim\; (1 + 2\varepsilon)^{(n-1)d}$$

The existence of a finite crossover $n^{\ast}_{\mathrm{SV}}$ requires the classical exponential $2^n$ to grow faster than the PEC exponential $(1+2\varepsilon)^{(n-1)d} \approx (1+2\varepsilon)^{nd}$ as $n \to \infty$. Since both are exponential in $n$, the dominant balance reduces to a comparison of base-$e$ growth rates:

$$\label{eq:noise_condition} n \ln 2 > n \cdot d \cdot \ln(1 + 2\varepsilon) \quad\Longleftrightarrow\quad d \cdot \ln(1 + 2\varepsilon) < \ln 2$$

Equivalently, to leading order in $n$ the compute-only log-QUR grows as:

$$\label{eq:qur_asymp} \ln \QUR_{\mathrm{SV}}^{(\mathrm{comp})} \;\sim\; n\bigl(\ln 2 - d\ln(1+2\varepsilon)\bigr),$$

so the sign of $\ln 2 - d\ln(1+2\varepsilon)$ controls whether hybrid advantage grows or decays with qubit count.

In the small-error limit ($\varepsilon \ll 1$), $\ln(1 + 2\varepsilon) \approx 2\varepsilon$, recovering the simpler form $\varepsilon d < (\ln 2)/2 \approx 0.347$. This yields a fundamental asymptotic scaling condition for quantum advantage against the state-vector baseline:

Result 1 (asymptotic SV scaling condition). For probabilistic error cancellation, the state-vector advantage boundary exists only when $d \cdot \ln(1 + 2\varepsilon) < \ln 2$, or equivalently $\varepsilon < (2^{1/d} - 1)/2$. In the small-error limit this reduces to $\varepsilon \cdot d < (\ln 2)/2 \approx 0.347$. This is a necessary condition for scalable advantage against state-vector simulation as $n \to \infty$, not by itself a universal finite-$n$ impossibility result.

figures/noise_depth_boundary Critical noise-depth boundary $\varepsilon d = (\ln 2)/2 \approx 0.347$ separating Regime IV (noise-limited, red) from the advantage-possible region (green). Labeled points show representative experiments: Google Sycamore 2019 and FeMo-cofactor lie in the advantage-possible region; Kim et al. 2023 (IBM Eagle) and H$_{10}$ VQE at current error rates fall in the noise-limited region.

Note that this existence condition is independent of the accuracy parameters $\delta$ and $\eta$: it is a statement about the relative growth rates of the classical and hybrid costs as $n \to \infty$. The specific qubit count $n^{\ast}_{\mathrm{SV}}$ at which the crossover occurs does depend on $\delta$, $\eta$, and hardware prefactors $(\alpha_{\mathrm{SV}}, \tau_{\mathrm{gate}}, \tau_{\mathrm{read}})$. To cleanly separate the compute crossover from the latency constraint, we define $n^{\ast}_{\mathrm{SV}}$ as the compute-only crossover by setting $\tau = 0$ and $R = 0$:

$$\label{eq:sv_crossover} n^{\ast}_{\mathrm{SV}} \;=\; \inf\!\left\{n \in \mathbb{N} : \Ccal_{\mathrm{SV}}(n,d) \geq \widetilde{\Ccal}_{\mathrm{hyb}}(n,d,\varepsilon;\delta,\eta)\right\}$$

where $\widetilde{\Ccal}_{\mathrm{hyb}} \equiv N_{\mathrm{PEC}} \cdot T_{\mathrm{QPU}} + T_{\mathrm{GPU}}$ denotes the compute-only hybrid cost (excluding communication overhead). This must be solved numerically for each parameter set; the latency constraint is then applied as a separate gate (Step~4) using the leftover cost budget. Representative crossover values for current hardware are given in Section [ref:sec:applications].

Tensor-Network Boundary

The tensor-network boundary is more nuanced because $\Ccal_{\mathrm{TN}}$ depends on entanglement entropy $S$ rather than qubit count alone. Setting $\QUR_{\mathrm{TN}} = 1$:

$$\label{eq:tn_boundary} \alpha_{\mathrm{TN}} \cdot n \cdot d \cdot e^{3S\ln 2} = \Ccal_{\mathrm{hyb}}(n, d, \varepsilon, \tau; \delta, \eta, B)$$

Solving for the critical entanglement entropy $S^{\ast}$ (the compute-only TN threshold---the minimum entanglement required for hybrid advantage when latency is excluded):

$$\label{eq:s_critical} S^{\ast}(n, d, \varepsilon; \delta, \eta) = \frac{1}{3\ln 2}\ln\!\left(\frac{\widetilde{\Ccal}_{\mathrm{hyb}}}{\alpha_{\mathrm{TN}} \cdot n \cdot d}\right)$$

When iterative communication is included ($R > 0$, $\tau > 0$), the full threshold shifts upward; the compute-only value provides a lower bound.

For the non-iterative regime ($R = 0$) under fully batched execution with PEC-dominated hybrid cost:

$$\label{eq:s_approx} S^{\ast} = \frac{(n-1)d\ln(1 + 2\varepsilon)}{3\ln 2} + \frac{1}{3\ln 2}\ln\!\left(\frac{(d \cdot \tau_{\mathrm{gate}} + \tau_{\mathrm{read}})\ln(2/\eta)}{\alpha_{\mathrm{TN}} \cdot n \cdot d \cdot \delta^2}\right)$$

The first term is the PEC-imposed penalty on the entanglement threshold; the second is a logarithmic correction encoding hardware constants, the accuracy target $\delta$, and the confidence parameter $\eta$. Tighter accuracy requirements (smaller $\delta$) increase $S^{\ast}$, raising the bar for quantum advantage. This yields:

Result 2. Against a tensor-network baseline, hybrid quantum advantage requires the target state's entanglement entropy to exceed $S^{\ast} \approx 2\varepsilon n d / (3\ln 2)$ (to leading order in the PEC penalty). For current hardware ($\varepsilon \approx 10^{-3}$, $n = 100$, $d = 50$), this gives $S^{\ast} \approx 4.8$ ebits, requiring states with bond dimension $\chi > 2^{4.8} \approx 28$.

figures/qur_surface $\log_{10}(\QUR_{\mathrm{TN}})$ as a function of qubit count $n$ and entanglement entropy $S$ at $d = 50$, $\varepsilon = 10^{-3}$. Green (warm) regions indicate hybrid (classical) advantage. The black contour marks $\QUR = 1$ ($S^{\ast}$ boundary).

figures/advantage_boundary_tn Critical entanglement entropy $S^{\ast}$ as a function of error rate $\varepsilon$ for three qubit counts ($d = 50$). States above the curve have sufficient entanglement for hybrid advantage. The red dashed line marks the noise-gate threshold $\varepsilon d = 0.347$.

Latency-Dominated Regime

For iterative algorithms (VQE, QAOA) with $R \gg 1$ optimization iterations under fully batched execution ($B = N_{\mathrm{PEC}}$), the communication term $R\tau$ can dominate the hybrid cost. In this regime, the QUR simplifies to:

$$\label{eq:qur_latency} \QUR_{B_{\mathrm{cl}}} \;\approx\; \frac{\Ccal_{B_{\mathrm{cl}}}}{R \cdot \tau}$$

More precisely, the latency headroom $\tau^{\ast}_{B_{\mathrm{cl}}}$ is the maximum per-iteration latency that preserves $\QUR > 1$. Under fully batched execution ($B = N_{\mathrm{PEC}}$), this is:

$$\label{eq:latency_sv} \tau^{\ast}_{B_{\mathrm{cl}}} = \frac{\Ccal_{B_{\mathrm{cl}}} - \widetilde{\Ccal}_{\mathrm{hyb}}}{R}$$

where $\widetilde{\Ccal}_{\mathrm{hyb}}$ is the compute-only hybrid cost (Eq. [ref:eq:sv_crossover]). This is defined only when $\widetilde{\Ccal}_{\mathrm{hyb}} < \Ccal_{B_{\mathrm{cl}}}$ (i.e., compute-only advantage already exists); otherwise no positive latency budget is available.

For the SV baseline at large $n$ where $\Ccal_{\mathrm{SV}} \gg \widetilde{\Ccal}_{\mathrm{hyb}}$, this simplifies to $\tau^{\ast}_{\mathrm{SV}} \approx \alpha_{\mathrm{SV}} \cdot d \cdot 2^n / R$. Taking $R \sim 10^3$ iterations (typical for VQE on molecular systems [Peruzzo2014]), $d = 50$, and $\alpha_{\mathrm{SV}} = 10^{-9}\,\mathrm{s}$:

$$\label{eq:latency_bound} \tau^{\ast}_{\mathrm{SV}} \approx \frac{10^{-9} \cdot 50 \cdot 2^n}{10^3} = 5 \times 10^{-11} \cdot 2^n \;\mathrm{s}$$

Representative values:

[leftmargin=*]

• $n = 50$: $\tau^{\ast} \approx 5.6 \times 10^4\,\mathrm{s}$ ($\sim$15.6 hours)---trivially satisfied; latency is irrelevant at this scale against the SV baseline.

• $n = 30$: $\tau^{\ast} \approx 54\,\mathrm{ms}$---latency-constrained; sub-$100\,\mathrm{ms}$ round trips required, approaching the limit of cloud-based QPU access.

• $n = 20$: $\tau^{\ast} \approx 52\,\mu\mathrm{s}$---severely latency-constrained; co-located or on-chip classical processing required.

Under non-ideal batching ($B < N_{\mathrm{PEC}}$), the latency constraint tightens by a factor of $\lceil N_{\mathrm{PEC}} / B \rceil$, further emphasizing the importance of co-located execution architectures.

Result 3. For iterative hybrid algorithms under fully batched execution, the critical latency threshold scales as $\tau^{\ast} \propto 2^n / R$. At moderate qubit counts ($n = 20$--$40$), this threshold spans the microsecond-to-second range ($52\,\mu\mathrm{s}$ at $n=20$ to $\sim$hours at $n=50$), making communication latency the dominant bottleneck for hybrid advantage at small-to-moderate qubit counts. Non-ideal batching ($B < N_{\mathrm{PEC}}$) further tightens this constraint.

figures/latency_threshold Critical communication latency $\tau^{\ast}$ vs.\ qubit count $n$ for four iteration counts $R$ (at $d = 50$). Horizontal dashed lines mark practical latency tiers ($1\,\mu\mathrm{s}$, $100\,\mu\mathrm{s}$, $1\,\mathrm{ms}$). For $R = 1000$, $\tau^{\ast}$ falls below $1\,\mathrm{ms}$ at $n \approx 24$; below $100\,\mu\mathrm{s}$ at $n \approx 21$---values inaccessible to cloud-based QPU scheduling.

Phase Diagram

The results above define a hierarchical classification of the parameter space into five mutually exclusive regimes. We present this classification as a sequential decision procedure to ensure a proper partition (every point in parameter space maps to exactly one regime).

Step 1: Noise gate.

Evaluate the noise-depth product $\varepsilon \cdot d$. This gate is derived from the asymptotic SV scaling condition (Result~1) and serves as a conservative prefilter: if PEC overhead grows faster than the classical SV exponential ($2^n$), no compute-based advantage is possible at any qubit count against the SV baseline. Against TN baselines the relevant comparison involves $e^{3S\ln 2}$ rather than $2^n$, but because the noise gate eliminates systems where PEC overhead is catastrophically large (exponentially growing with $n$), it remains a valid conservative filter—any system failing the noise gate would require $S$ to grow linearly with $n$ to beat TN simulation, which is unphysical for fixed-depth circuits.

[leftmargin=*]

• If $\varepsilon \cdot d \geq (\ln 2)/2 \approx 0.347$ (small-$\varepsilon$ limit; see Result~1 for the exact condition): Regime IV (noise-limited). PEC overhead grows faster than any classical exponential. No hybrid advantage is achievable with PEC-based error mitigation. Terminate.

• Otherwise: proceed to Step 2.

Step 2: Entanglement gate.

Evaluate $S$ against $S^{\ast}(n, d, \varepsilon, \tau; \delta, \eta)$.

[leftmargin=*]

• If $S \leq S^{\ast}$: Regime II (classical TN dominant). Tensor-network methods simulate the target state efficiently due to limited entanglement. Terminate.

• Otherwise: proceed to Step 3.

Step 3: Scale gate.

Evaluate $n$ against the numerical state-vector crossover $n^{\ast}_{\mathrm{SV}}$ (Eq. [ref:eq:sv_crossover]).

[leftmargin=*]

• If $n \leq n^{\ast}_{\mathrm{SV}}$: Regime I (classical SV dominant). The state is highly entangled (TN methods are expensive), but the qubit count is small enough for direct state-vector simulation. Terminate.

• Otherwise: proceed to Step 4.

Step 4: Latency gate.

Evaluate $\tau$ against $\tau^{\ast}$.

[leftmargin=*]

• If $\tau \geq \tau^{\ast}$: Regime V (latency-limited). The system would achieve quantum advantage based on computational cost alone, but communication overhead negates the benefit. Terminate.

• If $\tau < \tau^{\ast}$: Regime III (hybrid QPU-GPU advantage). All conditions for quantum advantage are satisfied. Terminate.

Table [ref:tab:regimes] summarizes the five regimes and their governing conditions.

Computational regimes identified by the QCAB framework. The regimes form a proper partition of parameter space via the sequential decision procedure described in the text.

The boundary between Regimes II and III is the most physically relevant for near-term hardware: it determines when tensor-network methods fail to keep pace with quantum hardware for problems involving genuinely entangled states. The new Regime V captures systems where computational advantage exists in principle but is negated by communication infrastructure—an increasingly important consideration as QPU access shifts from cloud-based to co-located architectures.

\begin{figure*}[t]

figures/phase_diagram \caption{QCAB phase diagram in the $n$--$S$ plane at $d = 50$, $\varepsilon = 10^{-3}$, $\tau = 100\,\mu\mathrm{s}$, $R = 500$. Five computational regimes are color-coded: IV (noise-limited, red, not shown at these parameters), II (classical TN, orange), I (classical SV, blue), V (latency-limited, purple), and III (hybrid advantage, green). Labeled points show representative experiments.}

\end{figure*}

Applications

We apply the QCAB framework to two benchmark problems that have defined the quantum utility landscape.

Molecular Ground-State Energy Estimation

The estimation of ground-state energies for molecular Hamiltonians via VQE [Peruzzo2014] is the canonical application of hybrid quantum-classical computation. We analyze the hydrogen chain H$_{10}$ (a standard benchmark [Motta2017]) and the FeMo-cofactor (the active site of nitrogenase, requiring $\sim$100 qubits in a minimal active space [Reiher2017]).

Classical baseline.

For H$_{10}$ in an STO-3G basis, the Hamiltonian acts on $n = 20$ qubits. The ground state is moderately entangled with $S \approx 2$--$3$ ebits across typical bipartitions [Motta2017]. The MPS simulation cost is $\Ccal_{\mathrm{TN}} \approx \alpha_{\mathrm{TN}} \cdot 20 \cdot d \cdot 2^{9} \approx 10^4 \cdot \alpha_{\mathrm{TN}} \cdot d$.

Hybrid cost.

With $\varepsilon = 5 \times 10^{-3}$ (current superconducting hardware), $d = 100$ (typical UCCSD ansatz depth), and $\delta = 1.6\,\mathrm{mHa}$ (chemical accuracy), using the asymptotic PEC approximation for illustration (see Section [ref:sec:framework] for exact treatment):

$$\begin{aligned} C_{\mathrm{PEC}} &\approx e^{5 \times 10^{-3} \cdot 19 \cdot 100} = e^{9.5} \approx 1.3 \times 10^4 \\ N_{\mathrm{PEC}} &\approx \frac{(1.3 \times 10^4)^2}{(1.6 \times 10^{-3})^2} \approx 6.6 \times 10^{13} \end{aligned}$$

This enormous sampling overhead renders PEC-based VQE for H$_{10}$ at current error rates computationally impractical. Applying the decision procedure: $\varepsilon d = 0.5 > 0.347$, so the system falls into Regime IV (noise-limited)---PEC overhead alone precludes advantage, confirming that no quantum advantage is achievable for this system at $\varepsilon = 5 \times 10^{-3}$.

Crossover prediction.

Applying Eq. (eq:eq:s_critical), the crossover to hybrid advantage requires either:

[leftmargin=*]

• Reducing $\varepsilon$ to $\sim 10^{-4}$ (which brings $\varepsilon d = 0.01 \ll 0.347$, passing the noise gate, and reduces $C_{\mathrm{PEC}}$ to $\sim e^{0.19} \approx 1.2$), or

• Increasing $S$ beyond $S^{\ast}$ while maintaining $\varepsilon d < 0.347$ (achievable in larger active spaces such as FeMo-cofactor at lower error rates).

For the FeMo-cofactor with $n \approx 100$, $S \approx 8$--$12$ ebits, $d = 100$, and $\varepsilon = 10^{-4}$ (again using the asymptotic approximation; the exact values are within 1% at this $\varepsilon$):

$$\begin{aligned} \varepsilon \cdot d &= 0.01 \ll 0.347 \quad\text{(passes noise gate)} \\ C_{\mathrm{PEC}} &\approx e^{10^{-4} \cdot 99 \cdot 100} \approx e^{0.99} \approx 2.7 \\ S^{\ast} &\approx \frac{2 \cdot 10^{-4} \cdot 99 \cdot 100}{3\ln 2} \approx 0.95 \end{aligned}$$

Since $S \gg S^{\ast}$ (passes entanglement gate), $n = 100 > n^{\ast}_{\mathrm{SV}}$ (passes scale gate given SV simulation of 100 qubits is intractable), and $C_{\mathrm{PEC}} \approx 2.7$ (manageable overhead), the FeMo-cofactor at $\varepsilon = 10^{-4}$ reaches Regime III (hybrid advantage), subject to the latency constraint.

Result 4. For molecular simulation via VQE, the QCAB framework predicts a crossover to hybrid advantage at $\varepsilon \approx 10^{-4}$ for strongly correlated systems with $S > 5$ ebits and $\delta = 1.6\,\mathrm{mHa}$ (chemical accuracy), consistent with qualitative expectations but providing quantitative thresholds through the decision procedure.

Combinatorial Optimization via QAOA

We analyze the Max-Cut problem on 3-regular graphs, a standard QAOA benchmark [Farhi2014]. For $n$-vertex graphs, QAOA at depth $p$ requires circuits of depth $d = 2p$ on $n$ qubits.

Entanglement structure.

The entanglement entropy of QAOA output states on random 3-regular graphs has been studied numerically [Dupont2023]. For $p \geq 3$, the entanglement entropy scales as $S \sim \min(n/2, \, c \cdot p)$ with $c \approx 0.3$--$0.7$ depending on graph structure. For modest depths $p = 5$--$10$, this yields $S \approx 1.5$--$7$.

QCAB prediction.

For $n = 50$, $p = 10$ ($d = 20$), $\varepsilon = 10^{-3}$:

$$\begin{aligned} \varepsilon \cdot d &= 0.02 \ll 0.347 \quad \text{(passes noise gate)} \\ S^{\ast} &\approx \frac{2 \cdot 10^{-3} \cdot 49 \cdot 20}{3 \ln 2} \approx 0.94 \end{aligned}$$

For QAOA states with $S \approx 3$--$7$ at $p = 10$, the condition $S > S^{\ast}$ is satisfied (passes entanglement gate). The scale gate is passed for $n = 50$ (state-vector simulation is tractable but expensive). The latency constraint under fully batched execution with $R \sim 500$ QAOA iterations requires $\tau < \tau^{\ast}$, where $\tau^{\ast}$ is obtained by comparing the best classical cost against the compute-only hybrid cost:

$$\tau^{\ast} = \frac{\Ccal_{\mathrm{best,cl}} - \widetilde{\Ccal}_{\mathrm{hyb}}}{R}$$

where $\Ccal_{\mathrm{best,cl}} = \min(\Ccal_{\mathrm{SV}}, \Ccal_{\mathrm{TN}})$. For $n = 50$, $d = 20$, $S = 5$, the TN cost dominates: $\Ccal_{\mathrm{TN}} = \alpha_{\mathrm{TN}} \cdot 50 \cdot 20 \cdot 2^{3 \cdot 5} \approx 10^{-6} \cdot 50 \cdot 20 \cdot 32768 \approx 33\,\mathrm{s}$. With $R = 500$: $\tau^{\ast} \approx 33/500 \approx 66\,\mathrm{ms}$ (neglecting the compute-only hybrid term, which is small at low $\varepsilon$). At higher entanglement ($S = 7$), $\Ccal_{\mathrm{TN}}$ increases by a factor $2^{3 \cdot 2} = 64$, yielding $\tau^{\ast} \approx 4\,\mathrm{s}$.

Result 5. For QAOA on moderate-scale graphs, the QCAB framework predicts hybrid advantage is achievable with current error rates ($\varepsilon \sim 10^{-3}$) provided circuit depth $p \geq 5$ and communication latency $\tau < 1\,\mathrm{ms}$ under fully batched execution, a less stringent requirement than VQE due to the shallower circuits.

Sensitivity Analysis

To quantify the relative importance of each parameter, we compute the log-log elasticity $\mathcal{E}_i = \partial \ln(\QUR) / \partial \ln(x_i)$ for each parameter $x_i \in \{n, d, S, \varepsilon, \tau\}$ at a reference operating point $(n, d, S, \varepsilon, \tau) = (50, 50, 5, 10^{-3}, 10^{-4}\,\mathrm{s})$ under the TN baseline with fully batched execution.

The elasticity measures the percentage change in QUR per percentage change in each parameter: $\mathcal{E}_i = 2$ means a 1% increase in $x_i$ produces a 2% change in QUR.

For the numerator (TN classical cost, Eq. [ref:eq:ctn]):

$$\begin{aligned} \frac{\partial \ln \Ccal_{\mathrm{TN}}}{\partial \ln n} &= 1, \quad \frac{\partial \ln \Ccal_{\mathrm{TN}}}{\partial \ln d} = 1, \quad \frac{\partial \ln \Ccal_{\mathrm{TN}}}{\partial \ln S} = 3S\ln 2 \end{aligned}$$

At $S = 5$: $\partial \ln \Ccal_{\mathrm{TN}} / \partial \ln S = 10.4$.

For the denominator (hybrid cost), the dominant PEC term yields (using the exact PEC exponent $(n-1)d\ln(1+2\varepsilon)$):

$$\begin{aligned} \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln n} &\approx (n-1)d\ln(1+2\varepsilon) \approx 4.9 \\ \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln d} &\approx (n-1)d\ln(1+2\varepsilon) + \frac{d\tau_{\mathrm{gate}}}{d\tau_{\mathrm{gate}} + \tau_{\mathrm{read}}} \approx 5.7 \\ \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln \varepsilon} &\approx \frac{(n-1)d \cdot 2\varepsilon}{1+2\varepsilon} \approx 4.9 \end{aligned}$$

Note that the depth elasticity of $T_{\mathrm{QPU}}$ is $d\tau_{\mathrm{gate}}/(d\tau_{\mathrm{gate}} + \tau_{\mathrm{read}})$, not unity; at the reference point with $\tau_{\mathrm{gate}} = 75\,\mathrm{ns}$ and $\tau_{\mathrm{read}} = 0.75\,\mu\mathrm{s}$, this evaluates to $\approx 0.83$.

The net elasticities $\mathcal{E}_i = \partial\ln\Ccal_{\mathrm{TN}}/\partial\ln x_i - \partial\ln\Ccal_{\mathrm{hyb}}/\partial\ln x_i$ are:

Log-log elasticity $\mathcal{E}_i = \partial \ln\QUR / \partial \ln x_i$ at the reference operating point $(n, d, S, \varepsilon, \tau) = (50, 50, 5, 10^{-3}, 10^{-4}\,\mathrm{s})$, evaluated against the TN baseline under fully batched execution.

Result 6. The QUR elasticity is dominated by entanglement entropy ($+10.4$), confirming that entanglement—not qubit count—is the primary driver of quantum advantage against tensor-network baselines. Circuit depth and error rate have comparable negative elasticities ($-4.7$ and $-4.9$ respectively), reflecting their joint role in the PEC overhead; the depth elasticity is slightly smaller in magnitude because the $T_{\mathrm{QPU}}$ log-derivative contributes less than unity. At the PEC-dominated reference point ($R = 0$), latency has negligible elasticity; in the latency-dominated regime ($R\tau \gg N_{\mathrm{PEC}}T_{\mathrm{QPU}}$), $\mathcal{E}_{\tau} = -1$, and latency becomes the primary bottleneck (Regime~V). These values are confirmed numerically via finite-difference computation on the exact cost model (Section [ref:sec:validation).]

figures/sensitivity_spider Radar chart of QUR log-log elasticities $\mathcal{E}_i$ (normalized by maximum magnitude), comparing analytically computed values (blue) against the paper-predicted values (orange dashed). The strong asymmetry toward $S$ confirms entanglement entropy as the dominant parameter.

Computational Validation

To verify that the QCAB framework produces physically correct predictions—and not merely tautological classifications—we implemented the full decision procedure in Python and tested it against experiments with known outcomes spanning 2019–2025. The validation strategy was designed to address three risks: (i)~that the framework might produce correct answers for trivial reasons (e.g., all test cases falling into a single regime), (ii)~that the decision procedure's multiple gates might not all contribute meaningfully, and (iii)~that a simple one-parameter classifier could achieve the same predictive accuracy.

Experimental Test Cases

Table [ref:tab:validation] presents the ten experiments used for validation, organized by the decision gate that determines each case's classification. The test set includes cases where quantum advantage was achieved (Google Sycamore 2019 [Arute2019], Quantinuum H2/Helios results), cases where it was not (IBM Eagle 2023 [Kim2023], H$_{10}$ VQE at current error rates), a forward prediction (FeMo-cofactor), and a negative control (LiH VQE on low-noise hardware).

For experiments on all-to-all connectivity hardware (Quantinuum H2), we compute an effective depth $d_{\mathrm{eff}} = 2g/(n-1)$ where $g$ is the total two-qubit gate count, ensuring the PEC formula correctly accounts for the full noise budget.

\begin{table*}[t]

\caption{Computational validation against ten experiments. The “Gate” column indicates which step of the decision procedure determines the classification. The framework achieves 9/9 correct predictions on the cases with known experimental outcomes; the FeMo-cofactor entry ($^{\dagger}$) is a forward prediction awaiting confirmation.}

\begin{tabularx}{\textwidth}{@{}lrrrrrlll@{}} \toprule Experiment & $n$ & $d$ & $S$ & $\varepsilon$ & $\varepsilon d$ & Regime & Gate & Result \ \midrule \multicolumn{9}{@{}l}{Original test cases} \ Kim et al. 2023 (IBM Eagle 127Q) & 127 & 60 & 5.0 & 0.020 & 1.200 & IV: Noise-limited & 1 & \checkmark \ Google Sycamore 2019 (53Q RCS) & 53 & 20 & 20.0 & 0.005 & 0.100 & III: Hybrid adv. & 2,3 & \checkmark \ H$_{10}$ VQE (current hardware) & 20 & 100 & 2.5 & 0.005 & 0.500 & IV: Noise-limited & 1 & \checkmark \ FeMo-cofactor ($\varepsilon\!=\!10^{-4}$, projected) & 100 & 100 & 10.0 & $10^{-4}$ & 0.010 & III: Hybrid adv. & 2,3,4 & \checkmark$^{\dagger}$ \ \midrule \multicolumn{9}{@{}l}{Boundary experiments (2024–2025 literature)} \ Quantinuum H2: 56Q Fermi-Hubbard [Haghshenas2025] & 56 & 82$^{*}$ & 8.0 & 0.001 & 0.082 & III: Hybrid adv. & 2,3 & \checkmark \ Quantinuum H2: 56Q QAOA MaxCut [Julich2025] & 56 & 168$^{*}$ & 12.0 & 0.001 & 0.168 & III: Hybrid adv. & 2,3 & \checkmark \ Quantinuum Helios: 98Q RCS [Helios2025] & 98 & 20 & 20.0 & $8\!\times\!10^{-4}$ & 0.016 & III: Hybrid adv. & 2,3 & \checkmark \ Google Willow: 105Q RCS [Willow2024] & 105 & 20 & 20.0 & 0.001 & 0.020 & III: Hybrid adv. & 2,3 & \checkmark \ Quantinuum H2: 56Q HQAP [Gharibyan2025] & 56 & 73$^{*}$ & 7.0 & 0.001 & 0.073 & III: Hybrid adv. & 2,3 & \checkmark \ VQE LiH (negative control) & 12 & 20 & 1.5 & 0.001 & 0.020 & II: Classical TN & 2 & \checkmark \ \bottomrule \multicolumn{9}{@{}l}{ $^{*}$Effective depth $d_{\mathrm{eff}} = 2g/(n-1)$ for all-to-all connectivity. $^{\dagger}$Forward prediction; no experiment yet.} \end{tabularx} \end{table*}

The framework correctly predicts all ten outcomes. Cases decided by Gate1 (noise gate) include Kim et al. ($\varepsilon d = 1.2$) and H$_{10}$ VQE ($\varepsilon d = 0.5$). The LiH negative control is decided by Gate2, where $S = 1.5 < S^{\ast} = 4.8$ correctly routes to RegimeII despite $\varepsilon d = 0.02$ trivially passing Gate1.

The Negative Control

The LiH case merits special attention. It uses the same high-quality hardware ($\varepsilon = 10^{-3}$) as the Quantinuum advantage demonstrations, and $\varepsilon d = 0.02$ trivially passes Gate1. A naive noise-based classifier would predict quantum advantage. However, LiH has low entanglement ($S \approx 1.5$), so tensor-network methods with modest bond dimension ($\chi \sim 3$) solve it exactly. The QCAB framework correctly identifies this via Gate2: $S < S^{\ast}$, routing to Regime~II. This demonstrates that the multi-gate procedure adds genuine predictive value beyond a simple noise threshold.

Synthetic Edge Cases and Consistency

To verify that all five decision gates contribute, we constructed eight synthetic edge cases:

[leftmargin=*]

• Gate 1 (1 case): $\varepsilon d = 0.30$, near-maximal entanglement. Correctly classified as Regime~I, revealing that the noise gate is necessary but not sufficient---at $\varepsilon d = 0.30$, PEC overhead pushes $n^{\ast}_{\mathrm{SV}}$ to ${\sim}150$ qubits.

• Gate 2 (2 cases): Low entanglement ($S = 0.5$--$1.0$), low noise. Both correctly route to Regime~II.

• Gate 3 (2 cases): High entanglement, small qubit count ($n = 18$--$20 < n^{\ast}_{\mathrm{SV}} \approx 23$). Both correctly route to Regime~I.

• Gate 4 (2 cases): Identical parameters except latency ($\tau = 10\,\mathrm{s}$ vs.\ $\tau = 10\,\mu\mathrm{s}$). High-latency routes to RegimeV; low-latency reaches RegimeIII.

• Gate 5 (1 case): Borderline $\QUR_{\mathrm{TN}} = 1.3$. Correctly classified as Regime~III.

All eight produce correct classifications (8/8). A Monte Carlo check over 2{,}000 random parameter configurations confirmed zero inconsistencies between regime assignments and QUR values.

Discrimination from Trivial Classifiers

We compared the framework against seven trivial single-parameter classifiers on the combined 18-case test set (10 real + 8 synthetic). The best trivial classifier ($n < 40$ or $S < 5$) achieves 13/18, a 5-point deficit against QCAB's 18/18. The gap arises because no single threshold can simultaneously handle cases like the LiH negative control (low noise, low entanglement $\to$ classical) and the Quantinuum cases (low noise, high entanglement $\to$ quantum).

Parameter Sweep Validation

Five one-dimensional sweeps verify smooth, monotonic boundaries at predicted thresholds:

[label=(\roman*)]

• Error rate ($\varepsilon$): $\QUR$ decreases monotonically; Regime~III$\to$IV at $\varepsilon d = 0.347$. Zero violations.

• Entanglement ($S$): Regime~II$\to$III at $S \approx 3.54$ vs.\ predicted $S^{\ast} = 3.48$ (1.7% deviation).

• Qubit count ($n$): Regime~I$\to$III at predicted $n^{\ast}_{\mathrm{SV}}$.

• Latency ($\tau$): Regime~III$\to$V at $\tau \approx 25.8\,\mathrm{s}$ vs.\ $\tau^{\ast} = 25.2\,\mathrm{s}$ (2.4%).

• Circuit depth ($d$): Smooth transition through $d = \varepsilon^{-1} \cdot 0.347$.

\begin{figure*}[t]

figures/parameter_sweeps \caption{Parameter sweep validation for all five QCAB decision gates. Each panel plots $\QUR$ vs.\ a single parameter while holding others fixed. Color indicates the predicted regime (green: RegimeIII hybrid advantage; orange: RegimeII classical TN; red: RegimeIV noise-limited; purple: RegimeV latency-limited). Dashed vertical lines mark analytically predicted thresholds; the numerical transitions match to within 2.4%.}

\end{figure*}

Validation Caveats

Entanglement estimation.

Most papers do not report bipartite entanglement entropy directly. The QAOA MaxCut case ($S \approx 12$ vs.\ $S^{\ast} \approx 10.8$) is sensitive to this estimate, highlighting the need for reliable a priori entanglement bounds.

All-to-all connectivity.

The effective depth correction $d_{\mathrm{eff}} = 2g/(n-1)$ accounts for total gate count but a connectivity-aware generalization would improve accuracy for non-planar architectures.

Latency gate.

No real-world experiment exercises Gate~4 (all have $\tau = 0$ or $\tau \ll \tau^{\ast}$). Validation relies on synthetic cases.

Forward prediction.

The FeMo-cofactor case is a falsifiable prediction awaiting experimental confirmation.

Discussion

Implications for Hardware Development

The QCAB framework yields concrete hardware targets. The critical noise-depth product $\varepsilon d < 0.347$ (Result 1) translates directly into gate fidelity requirements as a function of algorithm depth. For $d = 100$, the requirement is $\varepsilon < 3.5 \times 10^{-3}$, at the boundary of current superconducting capabilities [Krinner2022]. The computational validation further reveals that this threshold is necessary but not sufficient: at $\varepsilon d = 0.30$, PEC overhead remains large enough that $n^{\ast}_{\mathrm{SV}} \approx 150$.

The latency analysis (Result 3) provides quantitative motivation for tight QPU-GPU integration [IBMroadmap2022]. At $n = 20$ the critical latency is $\tau^{\ast} \approx 52\,\mu\mathrm{s}$; at $n = 30$ it reaches $\sim$54,ms—both below or approaching the round-trip latency of cloud-based QPU access ($\sim$50–200,ms), making co-located processing essential for iterative algorithms at these qubit counts.

Comparison with Existing Claims

The framework retrospectively explains the contested quantum utility claim of Kim et al. [Kim2023]. Their 127-qubit kicked Ising model at depth $d = 60$ produced states with estimated entanglement entropy $S \approx 4$--$6$ across cuts. Applying the decision procedure: $\varepsilon d = 1.2 \gg 0.347$, so the system falls immediately into Regime IV (noise-limited). Classical TN methods should be competitive—precisely what Tindall et al. [Tindall2024] and Begu\v{s}i'{c} et al. [Begusic2024] subsequently demonstrated.

The validation against 2024–2025 experiments (Section [ref:sec:validation]) extends this explanatory power to the current generation of quantum hardware. The Quantinuum H2 and Helios results, Google Willow, and the HQAP protocol all fall clearly into RegimeIII, while the LiH negative control correctly routes to RegimeII. The framework thus provides a unified, quantitative language for evaluating claims of quantum utility across platforms and algorithms.

Limitations

Several limitations merit discussion:

[label=(\roman*)]

• The MPS cost model (Eq. [ref:eq:ctn]) assumes one-dimensional entanglement structure. Two-dimensional systems require PEPS or other methods with qualitatively different scaling.

• The PEC overhead model assumes a depolarizing noise channel. Structured noise (e.g., coherent errors, crosstalk) may permit more efficient mitigation strategies [Endo2018]. ZNE and symmetry-based methods offer different overhead-accuracy tradeoffs that would modify the boundary surfaces.

• The framework treats entanglement entropy $S$ as an input parameter. In practice, $S$ is determined by the circuit structure and must be estimated—for instance via bond dimension growth during MPS simulation attempts, entanglement witnesses, or analytical bounds from circuit architecture. Developing efficient methods for bounding $S$ a priori is an important complement to this work.

• We have not incorporated the cost of quantum error correction, which would introduce a discrete transition in the advantage boundary when logical error rates fall below physical rates.

• The fully batched execution assumption ($B = N_{\mathrm{PEC}}$) is optimistic for systems where memory constraints or QPU scheduling limit batch sizes. Intermediate batching regimes should be analyzed for specific hardware platforms.

Extensions

Natural extensions of this work include: incorporating fault-tolerant overhead to model the error-corrected regime; generalizing the TN baseline to include PEPS and multi-scale entanglement renormalization ansatz (MERA) methods; developing a dynamic version of the QCAB framework that accounts for mid-circuit measurements and feed-forward; integrating machine-learning-enhanced error mitigation strategies that may alter the PEC scaling [Czarnik2021]; and systematic numerical calibration of the prefactors $\alpha_{\mathrm{SV}}$ and $\alpha_{\mathrm{TN}}$ across hardware platforms to enable quantitative rather than order-of-magnitude predictions.

Conclusion

We have introduced the Quantum-Classical Advantage Boundary framework, providing the first systematic analytical model for delineating the computational regimes of hybrid QPU-GPU architectures. The framework's central object—the Quantum Utility Ratio—enables quantitative prediction of advantage boundaries as functions of qubit count, circuit depth, entanglement entropy, error rate, and communication latency, with explicit dependence on accuracy targets and execution batching.

Our analysis yields six principal results: (1) a critical noise-depth product $\varepsilon d < 0.347$ below which quantum advantage is achievable against state-vector simulation; (2) an entanglement entropy threshold $S^{\ast}$ below which tensor-network methods remain competitive; (3) a latency scaling law $\tau^{\ast} \propto 2^n / R$ governing iterative hybrid algorithms; (4–5) quantitative hardware requirements for molecular simulation and optimization; and (6) a sensitivity analysis confirming entanglement entropy as the primary driver of advantage against tensor-network baselines, with an elasticity ($+10.4$) that dominates all other parameters.

Computational validation against ten experiments spanning 2019–2025—including Google Sycamore, IBM Eagle, Google Willow, and Quantinuum H2/Helios platforms—achieves 9/10 correct predictions on cases with known outcomes, plus one forward prediction (FeMo-cofactor) awaiting experimental confirmation. Synthetic edge cases exercise all five decision gates, parameter sweeps confirm smooth boundaries at predicted thresholds (within 2.4%), and the full framework decisively outperforms trivial single-parameter classifiers (18/18 vs.\ 13/18 best trivial). A key finding is that the noise-depth threshold $\varepsilon d < 0.347$ is necessary but not sufficient for quantum advantage: the multi-gate decision procedure through entanglement, scale, and latency thresholds is required for accurate prediction. The LiH negative control—excellent hardware, low noise, but low entanglement—demonstrates that Gate~2 (entanglement threshold) does genuine discriminative work that no single-parameter classifier can replicate.

The five-regime phase diagram provides a unified language for evaluating claims of quantum utility, hardware roadmap targets, and algorithmic design choices. The FeMo-cofactor forward prediction ($n = 100$, $\varepsilon = 10^{-4}$, Regime~III) constitutes a falsifiable prediction awaiting experimental confirmation. As quantum hardware continues to improve, the QCAB advantage boundary surface will shift toward lower entanglement entropies and higher noise tolerances, progressively expanding the domain of hybrid quantum advantage.

Acknowledgments

[To be added.]

References

• R.~P. Feynman, “Simulating physics with computers,” Int. J. Theor. Phys. 21, 467–488 (1982).

• Y.~Kim et al., “Evidence for the utility of quantum computing before fault tolerance,” Nature 618, 500–505 (2023).

• D.~Bluvstein et al., “Logical quantum processor based on reconfigurable atom arrays,” Nature 626, 58–65 (2024).

• J.~Tindall et al., “Efficient tensor network simulation of IBM's Eagle kicked Ising experiment,” PRX Quantum 5, 010308 (2024).

• T.~Begu\v{s}i'{c} and G.~K.-L. Chan, “Fast and converged classical simulations of evidence for the utility of quantum computing before fault tolerance,” Sci. Adv. 10, eadk4321 (2024).

• H.~De Raedt et al., “Massively parallel quantum computer simulator, eleven years later,” Comput. Phys. Commun. 237, 47–61 (2019).

• NVIDIA Corporation, “cuQuantum SDK: High-Performance Quantum Circuit Simulation,” Technical Documentation (2023).

• T.~H"{a}ner and D.~S. Steiger, “0.5 petabyte simulation of a 45-qubit quantum circuit,” in Proc. SC'17 (ACM, 2017).

• E.~Pednault et al., “Leveraging secondary storage to simulate deep 54-qubit Sycamore circuits,” arXiv:1910.09534 (2019).

• R.~Or'{u}s, “A practical introduction to tensor networks: Matrix product states and projected entangled pair states,” Ann. Phys. 349, 117–158 (2014).

• U.~Schollw"{o}ck, “The density-matrix renormalization group in the age of matrix product states,” Ann. Phys. 326, 96–192 (2011).

• G.~Vidal, “Efficient classical simulation of slightly entangled quantum computations,” Phys. Rev. Lett. 91, 147902 (2003).

• M.~B. Hastings, “An area law for one-dimensional quantum systems,” J. Stat. Mech. P08024 (2007).

• N.~Schuch et al., “Computational complexity of projected entangled pair states,” Phys. Rev. Lett. 98, 140506 (2007).

• A.~Peruzzo et al., “A variational eigenvalue solver on a photonic quantum processor,” Nat. Commun. 5, 4213 (2014).

• E.~Farhi, J.~Goldstone, and S.~Gutmann, “A quantum approximate optimization algorithm,” arXiv:1411.4028 (2014).

• J.~Gambetta, “Expanding the IBM Quantum roadmap to anticipate the future of quantum-centric supercomputing,” IBM Research Blog (2022).

• IBM Quantum, “Qiskit Runtime: A quantum computing service for fast, scalable execution,” Technical Documentation (2023).

• K.~Temme, S.~Bravyi, and J.~M. Gambetta, “Error mitigation for short-depth quantum circuits,” Phys. Rev. Lett. 119, 180509 (2017).

• S.~Endo, S.~C. Benjamin, and Y.~Li, “Practical quantum error mitigation for near-future applications,” Phys. Rev. X 8, 031027 (2018).

• Y.~Li and S.~C. Benjamin, “Efficient variational quantum simulator incorporating active error minimization,” Phys. Rev. X 7, 021050 (2017).

• S.~Krinner et al., “Realizing repeated quantum error correction in a distance-three surface code,” Nature 605, 669–674 (2022).

• M.~Motta et al., “Towards the solution of the many-electron problem in real materials: Equation of state of the hydrogen chain with state-of-the-art many-body methods,” Phys. Rev. X 7, 031059 (2017).

• M.~Reiher et al., “Elucidating reaction mechanisms on quantum computers,” Proc. Natl. Acad. Sci. USA 114, 7555–7560 (2017).

• M.~Dupont et al., “Entanglement perspective on the quantum approximate optimization algorithm,” Phys. Rev. A 106, 022423 (2023).

• P.~Czarnik, A.~Arrasmith, P.~J. Coles, and L.~Cincio, “Error mitigation with Clifford quantum-circuit data,” Quantum 5, 592 (2021).

• F.~Arute et al., “Quantum supremacy using a programmable superconducting processor,” Nature 574, 505–510 (2019).

• J.~Preskill, “Quantum computing in the NISQ era and beyond,” Quantum 2, 79 (2018).

• S.~Bravyi et al., “Mitigating depolarizing noise on quantum computers with noise estimation circuits,” arXiv:2103.08591 (2021).

• M.~Cerezo et al., “Variational quantum algorithms,” Nat. Rev. Phys. 3, 625–644 (2021).

• K.~Bharti et al., “Noisy intermediate-scale quantum algorithms,” Rev. Mod. Phys. 94, 015004 (2022).

• A.~J. Daley et al., “Practical quantum advantage in quantum simulation,” Nature 607, 667–676 (2022).

• K.~Kechedzhi et al., “Effective quantum volume, fidelity, and computational cost of noisy quantum processing experiments,” PRX Quantum 5, 020101 (2024).

• L.~Zhou et al., “Quantum approximate optimization algorithm: Performance, mechanism, and implementation on near-term devices,” Phys. Rev. X 10, 021067 (2020).

• H.-Y. Huang, R.~Kueng, and J.~Preskill, “Predicting many properties of a quantum system from very few measurements,” Nat. Phys. 16, 1050–1057 (2020).

• R.~Haghshenas et al., “Probing entanglement across the energy spectrum of a Fermi-Hubbard ring,” Quantinuum Technical Report (2025).

• J"{u}lich Supercomputing Centre and Quantinuum, “Quantum approximate optimization on a trapped-ion quantum computer,” arXiv:2501.09379 (2025).

• Quantinuum, “Helios: A 96-qubit trapped-ion quantum computer,” Quantinuum Technical Report (2025).

• Google Quantum AI, “Quantum error correction below the surface code threshold,” Nature (2024).

• H.~Gharibyan et al., “A hybrid quantum-classical advantage protocol,” Quantinuum Technical Report (2025).