paper Review Profile

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

approvedby Adam MurphyCreated 3/19/2026Reviewed under Calibration v1.3· 1 review

3.3/ 5

AI Rating

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 \emph{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 \emph{Quantum Utility Ratio} $\QUR(n, d, S, \tau, \varepsilon)$ over the…

Read the Full Breakdown

This work presents a mathematically structured analytical framework for predicting when hybrid quantum-classical computation achieves advantage over purely classical methods. The submission develops the Quantum Utility Ratio (QUR) as a function of five physical parameters and derives boundary surfaces for different classical baselines. While the conceptual framework is coherent and the mathematical approach generally sound, several critical derivations are compressed or inadequately justified. The Math/Logic specialists identified significant gaps in the derivation of the central existence condition εd < ln(2)/2 (Result 1) and the solution for the critical entanglement threshold S*. These compressed derivations undermine the mathematical validity despite the framework's internally consistent structure. The Sources/Evidence specialist found the work well-organized with systematic mathematical development, though some hardware prefactors remain uncalibrated. The Science/Novelty specialist noted strong falsifiability through quantitative predictions and substantial novelty in synthesizing known cost models into a unified decision framework, though clarity is affected by notation inconsistencies and overclaims in the abstract about 'closed-form' expressions.

Internal Consistency

4/5

The framework’s objects are defined once and used largely consistently: QUR in Eq. (qur), boundary surface Σ in Eq. (boundary), and the decomposition of hybrid cost in Eq. (chyb) are coherent. The sequential regime partition is logically consistent as a decision procedure, provided the underlying thresholds (notably Step 1 and S*) are valid. Main internal issues are local: (i) the latency-dominated approximation Eq. (qur_latency) is used without stating the dominance conditions, creating a potential mismatch between regime definitions and the full cost model; (ii) in the QAOA application, the latency inequality appears to use a TN-like cost expression rather than the previously derived τ* form, which looks like a baseline/notation slip. These do not constitute central definition drift but do undermine some application-level numerical claims.

Mathematical Validity

3/5

Most equations are standard and dimensionally consistent. The PEC scaling, MPS cost, and latency expressions follow established forms. However, several load-bearing derivations are compressed: Result 1's noise-gate threshold compares only leading exponents and assumes T_QPU and T_GPU are subdominant without rigorous justification (T_GPU is asserted to scale exponentially but then ignored). The factor-of-2 ambiguity between C_PEC and N_PEC exponents is handled inconsistently across sections. The S* derivation in Eq. (s_approx) uses an R=0 assumption that conflicts with the iterative-algorithm framing. The unverified_central_derivation flag triggers the cap at 3: the noise-gate threshold (Step 1 of the entire phase diagram, used to dismiss the Kim et al. experiment) rests on a comparison-of-exponents argument that does not formally rule out subdominant terms changing the conclusion. The math is plausible and likely correct in spirit, but the paper does not establish it rigorously enough for 4/5.

Falsifiability

4/5

The work is meaningfully falsifiable because it proposes explicit inequalities and crossover conditions that can be checked against benchmark runtime studies on hybrid QPU-GPU systems. The strongest testable claims are the PEC-based noise-depth threshold epsilon*d < 0.347 for existence of advantage against a state-vector baseline, the entanglement threshold S* for beating tensor-network methods, and latency thresholds in the microsecond-to-millisecond regime for iterative algorithms. These are quantitative and differentiate the framework from other narratives about 'quantum utility.' A comparative benchmarking campaign on VQE/QAOA-like workloads could directly confirm or refute whether the proposed regime classification predicts observed wall-clock advantage boundaries. The main limitation is that several predictions depend on poorly calibrated prefactors (alpha_SV, alpha_TN, T_GPU), on entanglement entropy S treated as an input rather than an output of problem structure, and on the assumption that PEC is the relevant mitigation strategy. This means some predictions are testable only after substantial modeling choices and may not be sharp discriminators across platforms. Still, the paper does provide clear, quantitative conditions that could be proven wrong by experiment or simulation, so it merits a high but not maximal falsifiability score.

Clarity

3/5

The paper is generally readable, well sectioned, and written in a style accessible to a graduate-level reader. Definitions are usually introduced before use, the main narrative arc is easy to follow, and the sequential regime-classification procedure is a strong communicative device. The applications section is also helpful in showing how the framework is intended to be used. However, clarity is held back by several core issues. First, notation and object scope shift over the paper: QUR is initially framed as a five-parameter object but later depends essentially on delta, eta, and B; tau* is derived for one baseline and then used in a way that blurs baseline dependence; and the role of T_GPU alternates between being included formally and ignored in practical estimates. Second, there are internal tensions between the abstract and body, especially around 'closed-form' boundary surfaces and the claim that latency is the primary bottleneck. Third, some application-level decisions (for example, asserting the scale gate is passed because 100-qubit SV simulation is 'intractable') substitute intuition for the stated framework's own numerical crossover criterion. Because the term/symbol consistency and abstract overclaim red flags are material, clarity cannot exceed 3.

Novelty

4/5

The paper's main novelty is in proposing a unified analytical 'advantage boundary' framework that combines qubit count, circuit depth, entanglement entropy, hardware error rate, and communication latency into a single decision procedure for hybrid QPU-GPU utility. The explicit synthesis of classical state-vector cost, tensor-network cost, error-mitigation overhead, and communication latency into a regime map is a genuine conceptual contribution, especially the attempt to elevate latency to a first-class axis of the advantage boundary. The framework also offers a distinctive reinterpretation of quantum advantage claims as location within a parameter-space partition rather than as a binary headline result. That said, most individual ingredients are standard: exponential SV cost, entanglement-controlled TN cost, PEC overhead, and latency penalties in variational algorithms are all known themes. The manuscript's originality lies more in the synthesis and packaging than in a fundamentally new mechanism or mathematical structure. Because some conclusions depend on rough scaling arguments rather than a sharply new formal object with independently validated implications, the novelty is substantial but not clearly at the 'genuinely new mechanism' level.

Completeness

2/5

The manuscript is well organized and provides a clear high-level structure: variables are mostly introduced, assumptions such as fully batched execution are stated, and limitations are explicitly discussed. The main argument is followable, and the paper does address its intended topic by proposing a utility ratio, defining regimes, and applying the framework to example tasks. However, the central analytical development is incomplete in ways that affect the core claims. The paper's headline results are presented as 'closed-form expressions' and quantitative thresholds, but several decisive quantities are not fully derived from the full cost model. The state-vector advantage condition is obtained by comparing asymptotic exponents after dropping important additive terms; n*_SV, which is essential to the regime partition, is never actually solved in the examples; T_GPU and R are used in central formulas without sufficiently precise definition; and the applications frequently classify regimes using partial checks rather than full boundary evaluation. There is also an internal inconsistency in the QAOA application, where the latency bound is suddenly written with a TN classical cost after the general latency section had derived τ* using the SV baseline. Because these gaps directly affect the paper's main claimed result—the analytical characterization of advantage boundaries—the completeness score cannot be higher than 2 under the stated rubric.

26 derivation flags— equations with compressed or unverified steps identified by math specialist

Strengths

+Introduces a mathematically rigorous framework (QUR) that unifies multiple cost drivers—classical simulation, error mitigation, and communication latency—into a single comparative picture
+Provides quantitative, testable predictions including the noise-depth threshold εd < 0.347, latency thresholds in the microsecond regime, and entanglement entropy crossovers
+Establishes a proper partition of parameter space through a sequential five-regime decision procedure that avoids overlapping classifications
+Demonstrates practical utility through retrospective analysis of contested quantum utility claims (Kim et al. experiment)
+Maintains internal consistency in definitions and notation throughout most of the framework development

Areas for Improvement

-The derivation from Eq. 12 to Result 1 needs complete mathematical steps showing the dominant balance analysis comparing 2^n vs e^(2εnd) growth rates to establish the εd < ln(2)/2 threshold
-The algebraic solution for S* in Eq. 14 from the TN boundary condition should include intermediate derivation steps
-Hardware prefactors (α_SV, α_TN) require systematic calibration rather than literature estimates to support quantitative threshold predictions
-The PEC cost model central to Result 1 needs rigorous derivation rather than assertion, including justification of the exponential form and gate-count approximation
-Clarify when the small-ε approximation ln(1+2ε)≈2ε remains valid and propagate approximation uncertainties into regime boundaries

Converted from LaTeX43 sections, 297 equations, 2 tables

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. Application of the framework to molecular ground-state energy estimation and variational optimization yields quantitative predictions for minimum hardware specifications required to achieve quantum utility. Our analysis reveals that communication latency---rather than qubit count or gate fidelity alone---constitutes the primary bottleneck for near-term quantum advantage in iterative hybrid algorithms, establishing a sub- $100\,\mu\mathrm{s}$ latency threshold for practical utility in variational quantum eigensolver workflows at moderate qubit counts.

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:discussion] discusses implications for hardware development. Section [ref:sec:conclusion] concludes.

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 capturing the cost per gate application in floating-point operations per second (FLOPS). On current GPU hardware, $\alpha_{\mathrm{SV}} \approx 10^{-9}\,\mathrm{s}$ per gate-amplitude operation 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 holds to within 1% for $\varepsilon < 5 \times 10^{-3}$ , the regime of primary interest for near-term hardware. At $\varepsilon = 5 \times 10^{-2}$ (e.g., the Kim et al. experiment), the relative error of the approximation is $\sim$ 5%, which remains acceptable for order-of-magnitude analysis but should be noted.

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 and scales as $\Ocal(e^{2\varepsilon n d} \cdot n)$ .

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, which through Eqs. (eq:eq:pec) and (eq:eq:cpec) scales as:

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

The existence of a finite crossover $n^{\ast}_{\mathrm{SV}}$ at which the classical cost overtakes the hybrid cost requires that the classical exponential $2^n = e^{n \ln 2}$ grow faster than the PEC exponential $e^{2\varepsilon(n-1)d} \approx e^{2\varepsilon n d}$ . Since both are exponential in $n$ , the dominant balance reduces to a comparison of exponents:

\label{eq:noise_condition} n \ln 2 > 2\varepsilon n d \quad\Longleftrightarrow\quad \varepsilon \cdot d < \frac{\ln 2}{2} \approx 0.347

This yields a fundamental existence condition for quantum advantage against the state-vector baseline:

Result 1. For probabilistic error cancellation, the state-vector advantage boundary exists only when the noise-depth product satisfies $\varepsilon \cdot d < (\ln 2)/2 \approx 0.347$ . Above this threshold, the PEC sampling overhead grows faster than the exponential classical cost at every qubit count, and no quantum advantage is achievable.

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}})$ . For a given hardware configuration, $n^{\ast}_{\mathrm{SV}}$ is the solution to:

\label{eq:sv_crossover} \alpha_{\mathrm{SV}} \cdot d \cdot 2^n = \frac{e^{2\varepsilon(n-1)d}}{\delta^2}\ln\!\left(\frac{2}{\eta}\right)(d\tau_{\mathrm{gate}} + \tau_{\mathrm{read}}) + R\tau + T_{\mathrm{GPU}}

which must be solved numerically for each parameter set. 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}$ :

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

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

\label{eq:s_approx} S^{\ast} \;\approx\; \frac{2\varepsilon(n-1)d}{3\ln 2} + \frac{1}{3\ln 2}\ln\!\left(\frac{d \cdot \tau_{\mathrm{gate}} + \tau_{\mathrm{read}}}{\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 and the accuracy target $\delta$ . 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$ .

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}

For the state-vector baseline, the latency-limited advantage condition is:

\label{eq:latency_sv} \tau < \frac{\alpha_{\mathrm{SV}} \cdot d \cdot 2^n}{R} \;\equiv\; \tau^{\ast}_{\mathrm{SV}}

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}} = \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\,\mu\mathrm{s}$ ---latency-constrained; sub- $100\,\mu\mathrm{s}$ round trips required.
$n = 20$ : $\tau^{\ast} \approx 52\,\mathrm{ns}$ ---severely latency-constrained; 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 falls in the nanosecond-to-microsecond range, making communication latency the dominant bottleneck for hybrid advantage. Non-ideal batching ( $B < N_{\mathrm{PEC}}$ ) further tightens this constraint.

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$ .

[leftmargin=*]

If $\varepsilon \cdot d \geq (\ln 2)/2 \approx 0.347$ : 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.

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):

\begin{aligned} C_{\mathrm{PEC}} &= e^{5 \times 10^{-3} \cdot 19 \cdot 100} \approx 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}$ :

\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 < \frac{\alpha_{\mathrm{TN}} \cdot 50 \cdot 20 \cdot 2^{3 \cdot 3}}{R}

With $\alpha_{\mathrm{TN}} \approx 10^{-6}\,\mathrm{s}$ on GPU hardware: $\tau < 10^{-6} \cdot 50 \cdot 20 \cdot 512 / 500 \approx 1\,\mathrm{ms}$ .

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:

\begin{aligned} \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln n} &\approx 2\varepsilon n d \approx 5.0 \\ \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln d} &\approx 2\varepsilon n d + 1 \approx 6.0 \\ \frac{\partial \ln \Ccal_{\mathrm{hyb}}}{\partial \ln \varepsilon} &\approx 2\varepsilon n d \approx 5.0 \end{aligned}

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.

lcr@{}} Parameter	Symbol	Elasticity $\mathcal{E}_i$
Entanglement entropy	$S$	$+10.4$
Qubit count	$n$	$-4.0$
Circuit depth	$d$	$-5.0$
Error rate	$\varepsilon$	$-5.0$
Communication latency	$\tau$	$-1.0$

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 ( $\sim -5$ ), reflecting their joint role in the PEC overhead. Communication latency ( $-1.0$ ) has the weakest individual effect under fully batched execution but becomes dominant in the latency-limited regime (Regime V).

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 circuits of depth $d = 100$ (relevant for quantum chemistry), the requirement is $\varepsilon < 3.5 \times 10^{-3}$ , which is at the boundary of current superconducting hardware capabilities [Krinner2022]. For deeper circuits ( $d = 1000$ ), the requirement tightens to $\varepsilon < 3.5 \times 10^{-4}$ , necessitating either significant hardware improvement or the transition to error-corrected logical qubits.

The latency analysis (Result 3) provides quantitative motivation for the tight QPU-GPU integration pursued by IBM's QCSC architecture [IBMroadmap2022] and NVIDIA's CUDA-Q platform. The sub-millisecond latency requirement for QAOA and sub- $100\,\mu\mathrm{s}$ requirement for VQE at moderate qubit counts cannot be met by cloud-based QPU access with network round trips; co-located or on-chip classical processing is essential. The introduction of Regime V (latency-limited) in the QCAB phase diagram provides a formal basis for this engineering requirement.

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 QCAB decision procedure:

Step 1 (noise gate): $\varepsilon \approx 2 \times 10^{-2}$ , $d = 60$ , giving $\varepsilon d = 1.2 \gg 0.347$ . The system falls immediately into Regime IV (noise-limited).

This single evaluation suffices: the PEC overhead at $\varepsilon = 0.02$ renders the hybrid approach uncompetitive regardless of entanglement entropy, qubit count, or latency. Classical TN methods should be competitive—precisely what Tindall et al. [Tindall2024] and Begu\v{s}i'{c} et al. [Begusic2024] subsequently demonstrated.

The clarity of this retrospective prediction illustrates the value of the QCAB framework: rather than debating whether a particular experiment demonstrates “quantum utility,” one evaluates where it falls in the decision procedure.

Limitations

Several limitations of the current analysis 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.

The five-regime phase diagram—organized as a sequential decision procedure through noise, entanglement, scale, and latency gates—provides a unified language for evaluating claims of quantum utility, hardware roadmap targets, and algorithmic design choices. The retrospective application to the Kim et al. experiment demonstrates the framework's explanatory power: a single evaluation of the noise gate ( $\varepsilon d = 1.2 \gg 0.347$ ) immediately classifies the experiment as noise-limited, consistent with subsequent classical simulation results.

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).

Share this Review

Post your AI review credential to social media, or copy the link to share anywhere.

LinkedIn X / Twitter Facebook

theoryofeverything.ai/review-profile/paper/75d44b5e-0bd8-4c67-b16c-c12b5bc7c684

Embed a live badge

Paste into a GitHub README, preprint page, or personal site. It reads the current review, so it updates on its own if the score changes or the work is withdrawn.

Preview of the embeddable TOE-Share review badge

[![TOE-Share AI review: 3.3 / 5](https://theoryofeverything.ai/api/badge/paper/75d44b5e-0bd8-4c67-b16c-c12b5bc7c684)](https://theoryofeverything.ai/review-profile/paper/75d44b5e-0bd8-4c67-b16c-c12b5bc7c684?utm_source=toeshare_badge)

How to use it: Markdown goes in a GitHub README or any Markdown page. HTML goes in your own web page, wherever you want the badge to appear. Both show the live badge and link back to this review profile.

Zenodo descriptions strip images; there, link the text TOE-Share 3.3 / 5 to your review profile instead. Show us you shared your work on social media — tag @TOE_Share in your post, or reply to our newsletter with the link. Either works — we’ll add one free review credit to your account.

Share by Email

Email clients cannot render the full review profile page. We send a branded HTML summary plus a link to the live credential.

Recipient emailRecipient name (optional)

Personal note (optional)

Open in Email App

Sign in as the submission owner to send a branded HTML email from TOE-Share. Anyone can still copy the text or open their email app.

This review was conducted by TOE-Share's multi-agent AI specialist pipeline. Each dimension is independently evaluated by specialist agents (Math/Logic, Sources/Evidence, Science/Novelty), then synthesized by a coordinator agent. This methodology is aligned with the multi-model AI feedback approach validated in Thakkar et al., Nature Machine Intelligence 2026.

TOE-Share — theoryofeverything.ai