betaFeedback

WorksPhysics and Astronomy

Efficient simulation of variational quantum circuits: representation, accuracy and CPU/GPU allocation

Abstract

Classical circuit simulation supports quantum software development and verification and provides a baseline for assessing quantum advantage. We compare gate-based statevector simulation, direct Pauli evolution and matrix product states for molecular and spin Variational Hamiltonian Ansatze and hardware-efficient ansatze on CPU/GPU systems, varying width, depth, precision and resource allocation. In the tested implementations, direct Pauli evolution benefits complex molecular VHA, whereas GPUs accelerate wider spin and hardware efficient circuits. Matrix product state is useful when limited entanglement permits accurate compression; corrected CPU FP32 can meet the tested tolerance while costing more than FP64. Workload size, startup, worker memory and task-specific profiling can change the preferred allocation. Matched NumPy Pauli updates accelerate two-layer full LiH by 3.45-fold; the GPU gives approximately 30-fold acceleration over 18-thread Aer for 28-qubit, four-layer TFIM, both in FP64. We provide a procedure for choosing representation, precision and worker allocation jointly, comparing the cost of complete energy evaluations under accuracy, memory and core constraints.

Introduction

Classical circuit simulation supports the development and verification of quantum software and provides a performance baseline for assessing quantum advantage [1]. Variational quantum algorithms repeatedly evaluate parameterized circuits for energies and other observables in electronic structure, spin models and machine learning [2, 3, 4]. Their classical cost includes both producing a state and evaluating the requested output. We ask how to choose a simulation method and computational resources for a circuit and evaluation stream, considering execution cost, numerical accuracy and memory.

Gate-based dense simulation stores the full statevector and updates it using a sequence of gates. Qiskit Statevector and Aer share this representation but use different execution paths [5]. Expanding a long Pauli rotation into basis changes and entangling gates creates many state updates. Direct Pauli evolution [6] applies the whole string rotation without that ladder; the NumPy [7] and Lightning paths studied here use this primitive. MPS [8] instead factorizes the state into local tensors and can be economical when intermediate entanglement permits small bonds. Bond caps and truncation cutoffs can introduce errors that must be checked for the requested observable [9, 10].

Hardware adds another decision. The CUDA-Q [11, 12] GPU adapter in this study executes a gate-expanded statevector path. Device execution can accelerate state operations, while compilation, startup and the interface also contribute to complete calls [13]. Resource allocation can parallelize one state or assign independent evaluations to workers. These choices have different memory and communication requirements. A low steady-state latency therefore answers only part of the question posed by a finite workload.

Qubit count sets the number of dense state amplitudes, but does not specify how much work an evaluation requires. Molecular VHA [4, 14, 15] layers can contain many long Hamiltonian-derived rotations; spin circuits offer local commuting blocks; HEA uses short rotation–entangler patterns [3, 4, 16, 17]. Hamiltonian term count also changes readout cost. For MPS, useful compression additionally depends on entanglement and the tolerance [18]. Figure 1 makes these structural differences explicit.

Circuit structure showing (a) HEA local rotations and CNOT brickwork, (b) VHA blocks, and (c) Pauli rotation basis changes and parity ladder

Figure 1. Circuit structure and the meaning of a variational layer. (a) A four-wire excerpt of RY/CNOT HEA, with local rotations and even/odd entanglers. (b) A VHA layer contains BB blocks of internally commuting Pauli terms; rotations within a block share one parameter. The numerical examples refer to the actual stated widths/layers, not matched-size circuits. Recorded Aer depths include scalar save and no hardware routing. (c) Exact elementary decomposition of one weight-four Pauli rotation. A weight-ww rotation uses 2(w−1)2(w-1) canonical CNOTs; applying hundreds of these rotations makes molecular VHA deep. Direct Pauli kernels implement the same rotation without these ladders.

Repeated evaluations arise as VQE parameter candidates, shifted circuits for suitable gradient rules [19], or data samples in variational classifiers and data re-uploading models [20, 21, 22]. Such applications can expose independently ready calls sharing a circuit pattern. Exact statevector gradients also admit adjoint differentiation [23]; the allocation unit studied here is an independently requested scalar evaluation. A QML application would calibrate its own encoding and readout.

Existing benchmarks cover multicore simulators [24], GPU acceleration and fusion [25], just-in-time kernels [26], and VQE/QAOA on HPC platforms [27]. Vallero et al. relate circuit characteristics to statevector/tensor-network strategy [28]; phase2 develops distributed native-Pauli simulation across CPUs and GPUs [29]. These establish structure-dependent selection and native operations. Building on them, our contribution is to demonstrate how the preferred configuration changes when representation, numerical output and parallel allocation are judged together by the cost of a finite stream of complete scalar-energy calls. The executable procedure takes a circuit/Hamiltonian, evaluation count, error tolerance and core/memory limits; checks candidate outputs and resource use; and ranks eligible measured configurations by startup plus execution cost. Task-specific profiling and broader latency-model data collection are accounted for separately.

The study spans molecular/spin VHA, HEA and structural controls across widths and depths (Table 1). Matched implementation comparisons, accuracy checks and resource-allocation measurements support the procedure. § 3.8 translates this evidence into a practical shortlist for the tested circuit regimes, qualified by numerical references and measured configuration coverage.

Problem / circuitHamiltonian or purposeCPU widths and layersGPU subset
Problem-inspired VHA
Transverse-field IsingOpen-chain − ∑ZZ−h∑X\sum ZZ - h\sum X; h=1h = 1, selected 0.25, 2n=8,12,…,28n = 8, 12, \ldots, 28; p=1,2,4,8p = 1, 2, 4, 8n=20,28n = 20, 28; p=4p = 4; n=24n = 24 throughput†
HeisenbergOpen-chain ∑(XX+YY+ZZ)\sum(XX + YY + ZZ)n=8,12,…,24n = 8, 12, \ldots, 24; p=1,2,4,8p = 1, 2, 4, 8n=24n = 24, p=4p = 4
H2STO-3G/Jordan–Wigner; bond 0.74 Ån=4n = 4; p=1,2,4,8p = 1, 2, 4, 8—
H4 chains, two geometriesSpacing 1.0 and 1.8 Ån=8n = 8; p=1,2,4,8p = 1, 2, 4, 8—
H6 chains, two geometriesSpacing 1.0 and 1.8 Ån=12n = 12; p=1,2,4,8p = 1, 2, 4, 8—
H8 chainSpacing 1.0 Ån=16n = 16; p=1,2,4,8p = 1, 2, 4, 8—
LiH, full spaceBond 1.6 Å; 4 electrons / 6 spatial orbitalsn=12n = 12; p=1,2,4,8p = 1, 2, 4, 8n=12n = 12, p=1,4p = 1, 4
LiH, frozen coreSame bond; 2 active electrons / 5 spatial orbitalsn=10n = 10; p=1,2,4,8p = 1, 2, 4, 8—
LiH, smaller active spaceSame bond; 2 active electrons / 4 spatial orbitalsn=8n = 8; p=1,2,4,8p = 1, 2, 4, 8—
Hardware-efficient and controlled-entanglement circuits
RY/CNOT HEALocal rotations + brickwork CNOTs; signed ZZ+Z readoutMain n=10,18,24,28n = 10, 18, 24, 28; L=1,4L = 1, 4, selected 16n=10,24,28n = 10, 24, 28, L=4L = 4; n=28n = 28, L=16L = 16
RY/RZ/CNOT HEAComplex-amplitude counterpart; same readoutn=10,18,24,28n = 10, 18, 24, 28; L=1,4L = 1, 4—
Controlled HEARY/RZ + RZZ(λ\lambda); TFIM energy, λ=0,0.05,0.25,1\lambda= 0, 0.05, 0.25, 1n=12,16,20,28n = 12, 16, 20, 28; selected L=2,4,8,16L = 2, 4, 8, 16n=24n = 24, L=4L = 4; λ=0.05,1\lambda= 0.05, 1
Supplementary structural and output controls
Signed-Ising QAOADiagonal Ising evolution + X mixingn=18,24n = 18, 24; p=3p = 3—
Product / GHZ / easy HEAAnalytic, real-amplitude and low-entanglement limitsn=16,28,64n = 16, 28, 64; shallow circuits—
Output / interface controlsLocal observables, amplitude, terminal shots; reuse, batching and affinitySelected HEA n=8n = 8–28 and spin/molecular casesLocal CPU baselines; independent / distributed GPU states

Table 1. Study overview. nn is qubit count; pp counts VHA/QAOA layers and LL HEA repetitions. The CPU study varies representation, FP32/FP64 precision, 1–36 threads and 1–36 workers on 36-core nodes; the GPU subset uses one/two RTX PRO 6000 Blackwell cards. The grids contain 1,087 CPU and 36 workstation configurations, each with three paired parameter seeds. Entries describe the study grid, with selected combinations rather than a Cartesian product; resource limits and reference coverage are documented in Appendix § 6; separate CPU validation is specified in § 2.6. All molecules use the same basis/mapping convention. The nine fixtures comprise H2, two H4, two H6, H8 and three LiH active spaces. Output controls supplement the main HEA widths with n=8,16,20,22n = 8, 16, 20, 22. † The 24-qubit TFIM GPU throughput control uses FP32 only. Terminal-shot controls use 128, 1,024 and 8,192 shots.

Methods

Energy evaluation and problem-inspired VHA

The primary task is a fixed-parameter scalar energy,

E(θ)=⟨ψ(θ)∣H∣ψ(θ)⟩,H=∑jhjPj,(1)E(\theta) = \langle\psi(\theta)|H|\psi(\theta)\rangle,\qquad H = \sum_j h_jP_j, \tag*{(1)}

with Pauli strings PjP_j. We study the cost and accuracy of this evaluation, rather than optimizer trajectories or ground-state convergence. Molecular active spaces and geometries are distinct physical models; timing differences between them are not matched-unitary speedups.

For VHA, the Hamiltonian is partitioned into blocks HbH_b whose terms commute internally. One layer applies the ordered product

Uℓ=e−iθℓBHB⋯e−iθℓ1H1,∣ψ⟩=Up⋯U1∣ϕ0⟩.(2)U_\ell= e^{-i\theta_{\ell B}H_B}\cdots e^{-i\theta_{\ell1}H_1},\qquad|\psi\rangle= U_p\cdots U_1|\phi_0\rangle. \tag*{(2)}

If Hb=∑j∈bhjPjH_b = \sum_{j\in b}h_jP_j, its exponential is implemented by the product of rotations RPj(2hjθℓb)R_{P_j}(2h_j\theta_{\ell b}). Internal commutation makes that block factorization exact. The ordered layer is not an exact exponential of the sum of noncommuting blocks. Grouping and order are fixed across implementations [30]. The identity coefficient contributes to energy but adds only an omitted global phase to evolution.

Spin circuits use

HTFIM=−∑j=0n−2ZjZj+1−h∑j=0n−1Xj,(3)H_{\mathrm{TFIM}} = -\sum_{j=0}^{n-2} Z_jZ_{j+1} - h\sum_{j=0}^{n-1}X_j, \tag*{(3)}
HH=∑j=0n−2(XjXj+1+YjYj+1+ZjZj+1).(4)H_{\mathrm{H}} = \sum_{j=0}^{n-2}\left(X_jX_{j+1}+Y_jY_{j+1}+Z_jZ_{j+1}\right). \tag*{(4)}

TFIM starts in the plus state and uses ZZ and X blocks. Heisenberg starts in a Néel state and uses even/odd edge blocks. Their local interactions permit shorter Pauli strings and, for TFIM, a specialized commuting-block update.

Molecular Hamiltonians use the STO-3G basis and Jordan–Wigner mapping, with Hartree–Fock occupation reference states.

The stored terms are grouped by X/Y flip mask; each block is checked for commutation and particle-number preservation. Long Pauli strings and many Hamiltonian terms make these circuits substantially deeper than the HEA examples. Figure 1 illustrates the distinction. Full LiH has 631 Pauli terms, 84 blocks and 6,516 canonical CNOTs per VHA layer. At p=2p=2, 168 block parameters control 1,260 Pauli rotations and a decomposition with 13,032 CNOTs. The 24-qubit, L=4L=4 RY/CNOT HEA instead has 120 rotation parameters and 92 CNOTs. A variational-layer count is therefore not a circuit-depth measure. Detailed molecular resources are given in Table A.1.

HEA and structural controls

The RY/CNOT HEA alternates a layer of independent RY rotations with nearest-neighbour even/odd CNOT brickwork, followed by a final rotation layer. Its complex counterpart adds RZ rotations. The energy operator is a fixed-seed signed ZZ+Z Hamiltonian on a ring with opposite-qubit matching, couplings ±1\pm1 and local fields in [−0.2,0.2][-0.2, 0.2]. Thus HEA and VHA timings include their specified observables, rather than timing state preparation alone.

The controlled HEA replaces the CNOT entanglers with RZZ(λ)R_{ZZ}(\lambda) and uses RY/RZ rotations with paired angles. Varying λ\lambda changes entanglement while preserving the symbolic gate pattern. Its readout is TFIM energy at h=1h=1. The product-state boundary at λ=0\lambda=0 and the deeper circuits test the useful range of MPS approximation. The QAOA, product, GHZ and local-observable controls in Table 1 test structural reductions and output choices; further details are in Appendix § 6.§ 5.

Implementations, hardware and timing

We compare Qiskit Statevector, Aer, PennyLane Lightning, matrix-free NumPy, and CUDA-Q. NumPy implements elementary gates, direct Pauli rotations, and a specialized TFIM block method. The direct update is

RP(ϕ)ψ=cos⁡(ϕ/2)ψ−isin⁡(ϕ/2)Pψ,(5)R_P(\phi)\psi= \cos(\phi/2)\psi- i\sin(\phi/2)P\psi, \tag*{(5)}

using a bit permutation and phases rather than a dense operator. Lightning uses native Pauli operations; Aer uses compiled elementary-gate circuits, with molecular optimization levels 0 and 2. CUDA-Q’s nvidia statevector target evaluates the same logical circuits after elementary-gate expansion [12]. Its timed output is a blocking scalar expectation, without full-state transfer. Consequently, CPU/GPU comparisons include both hardware and software representation; they do not isolate architecture alone.

The CPU platform is a dual-socket Intel Xeon Gold 6240 node with 36 physical cores and approximately 192 GB RAM. The main physical Aer/Lightning comparisons request 18 threads; the single-state and worker studies vary the allocation explicitly. NumPy gates and BLAS use one thread. The GPU workstation has an Intel Core i9-14900KS host and two NVIDIA RTX PRO 6000 Blackwell Workstation Edition cards, each reporting 97,887 MiB VRAM. The primary GPU execution sets GPU 0/GPU 1 power limits to 600/400 W. The cards use x8 PCIe links and a host-bridge path. Independent GPU workers receive separate devices; a two-rank CUDA-Q/MPI mode distributes one state. Software versions and implementation details are collected in Appendix § 6.

Setup, first invocation, warm-up and steady evaluation are measured separately. Unless stated otherwise, timings report steady full-energy calls with reuse of the circuit, not cached objective values. Each physical instance uses three parameter-seed blocks, with the same circuit, Hamiltonian and parameter stream across implementations. We report the median across seeds and the full seed range. Benchmark speedups are geometric means of paired seed ratios; executed-stream speedups are ratios of medians across independent launches. Nested timing rounds are not independent samples. Most physical calls use two vectors, while CPU/GPU throughput panels divide a fixed global list of 36/eight vectors among workers. Local workstation CPU controls use one NumPy thread or four Aer threads.

Numerical figures and the allocation table are regenerated from recorded case-level data by the archived Python analysis, whose preparation was assisted by ChatGPT/Codex (OpenAI).

Accuracy and resource metrics

The primary numerical-acceptance condition is

ΔE=max⁡k∈I∣Ek−Ekref∣≤10−6,(6)\Delta E = \max_{k \in\mathcal{I}} \lvert E_k - E_k^{\mathrm{ref}} \rvert\le10^{-6}, \tag*{(6)}

where I\mathcal{I} contains available matched parameter indices and the reference is dense FP64. All available seed blocks must pass for an operating point to be recommended. Tolerance frontiers compare the recorded outputs with several specified error limits. The tolerance is in Hartree for molecules and model energy units for spins. It concerns simulation output, not VQE or chemical accuracy. The primary benchmark records raw SDK outputs. MPS uses bond caps 16, 64 and 256 with cutoff 10−1010^{-10} [31]; separate checks vary the cutoff and numerical readout as specified below. Reference coverage and independent small-state fidelity/entropy diagnostics are specified in Appendix § 6.§ 4.

For ww workers with tt threads each, wt≤36wt \le36. Aggregate throughput QQ divides the fixed number of evaluations by their collective makespan. Its inverse is the completion interval per evaluation, rather than an individual request’s response latency. For a finite workload on a fully reserved node, we estimate

T^w,t(N)=Sw,t+N/Qw,t,NH^w,t=T^w,t/3600,(7)\widehat{T}_{w,t}(N) = S_{w,t} + N/Q_{w,t}, \qquad\widehat{\mathrm{NH}}_{w,t} = \widehat{T}_{w,t}/3600, \tag*{(7)}

where SS is measured startup through warm-up. We evaluate this model within each seed, then take the median. The selected sizes are multiples of the measured 36-vector CPU round. Projections assume persistent workers and constant throughput, excluding queueing and supervisory gaps. Full-node charging includes idle cores; other core budgets or charging schemes require new measurements/costs. For an assumed mean whole-node power Pˉ\bar{P} in kW, the corresponding electricity scenario is

E^(N;Pˉ)=PˉNH^(N)[kWh].(8)\widehat{\mathcal{E}}(N; \bar{P}) = \bar{P}\widehat{\mathrm{NH}}(N) \quad[\mathrm{kWh}]. \tag*{(8)}

We use Pˉ=0.30\bar{P} = 0.30 kW only as an illustrative constant-power scenario. Actual average power may differ between allocations;

CPU-package RAPL and GPU-board telemetry are not whole-node electricity measurements.

Finite-stream selection procedure

Inputs are a circuit/Hamiltonian/output task, NN independently ready parameter vectors, error limit ϵ\epsilon, core budget CC, sampled-memory allowance MM, and optional indifference fraction η\eta. Candidates specify backend, representation, state/readout precision, MPS cap/cutoff and w×tw \times t; unmeasured combinations are excluded.

Retain candidates with wt≤Cwt \le C, w≤Nw \le N, sampled memory ≤M\le M and all available matched outputs within ϵ\epsilon. Profile startup SS and throughput QQ with objective caching disabled; rank using Eq. (7). The tested streams divide evenly among workers; the implementation uses a final-wave ceiling otherwise. Return the least-cost configuration, reference counts/records, and configurations within (1+η)(1+\eta) of its cost, choosing lower sampled memory within this user-defined band. Pool throughput applies only to independently ready calls.

For one workload, task-specific profiling measures SS and QQ for a configuration shortlist. Its cost is TtaskT_{\mathrm{task}}, giving Ttask+T^(N)T_{\mathrm{task}} + \widehat{T}(N) for profiling and one deployment; reuse amortizes this sweep. Latency-model data collection spans the training workloads for the optional latency fit t^c=ac+bc2n−20(Gc+K)\widehat{t}_c = a_c + b_c 2^{n-20}(G_c+K), ac,bc≥0a_c,b_c \ge0, uses relative-error weighted nonnegative least squares. Coefficients group hardware, backend, family, precision, threads and representation settings; GcG_c counts updates and KK Hamiltonian terms. The holdout concerns fixed-precision single-state latency. The cost of collecting this broader training dataset is accounted separately from each task-specific profiling sweep.

Targeted numerical and stream validation

Targeted validation uses a 36-core Xeon Gold 6240 Barbora node and the same pinned software as the benchmark. Each of three independent launches performs task-specific profiling of NumPy and Aer at 36×136 \times1 and Lightning at 1×181 \times18, 4×94 \times9, 12×312 \times3 and 36×136 \times1, using 36 profiling vectors per launch. Profiling pools are destroyed before new pools execute 3,600 held-out vectors for NumPy, Aer and the profiling-selected Lightning allocation. Identical deployment vectors across backends and launches isolate launch variation. One-thread accuracy checks use 24 additional vectors per molecular backend or MPS setting.

For an FP32 state ψ~\tilde{\psi}, we compare the raw SDK scalar, that scalar divided by ν=⟨ψ~∣ψ~⟩\nu=\langle\tilde{\psi}|\tilde{\psi}\rangle, and

Enorm=⟨ψ~∣H∣ψ~⟩FP64ν.(9)E_{\mathrm{norm}}=\frac{\langle\tilde{\psi}|H|\tilde{\psi}\rangle_{\mathrm{FP64}}}{\nu}. \tag*{(9)}

An identity shift cIcI adds c(ν−1)c(\nu-1) to the raw numerator’s error and leaves normalized-energy error unchanged. The SDK scalar can additionally contain reduction error. Normalized-path timings include state export, conversion, norm computation and the specified observable reduction. MPS checks vary cutoffs 10−1010^{-10}, 10−1210^{-12}, 10−1410^{-14} against dense FP64 on every validation vector.

Results

Molecular VHA: native Pauli kernels outperform gate decompositions

For two-layer, 12-qubit full LiH, Lightning’s native Pauli path takes 68.76 ms per FP64 energy call, versus 562.15 ms with 18thread Aer at optimization level 2: a paired 8.14-fold gain. Aer optimization reduces its time from 760.05 ms and its compiled depth from 16,839 to 13,602, but does not close this gap. Within single-thread NumPy, changing only the rotation implementation from elementary gates to direct Pauli updates lowers the median from 609.29 to 176.50 ms, a paired 3.45-fold gain. H4 improves from 58.71 to 19.18 ms. These matched comparisons remove the basis changes and parity ladders in Figure 1(c), without changing the variational circuit or energy readout.

At one layer, 16-qubit H8 contains 2,913 Hamiltonian terms and 41,600 canonical CNOTs. Its energy call takes 0.894 s with Lightning, 1.751 s with Aer level 2 and 16.535 s with direct NumPy (Figure 2). These include evolution and full energy readout. For native NumPy LiH at four layers, the recorded mean call splits into 251.6 ms evolution and 51.5 ms observable evaluation (Table A.2); the archive has no corresponding Lightning/GPU phase split.

Figure 2. Molecular VHA, FP64. Left: one-layer hydrogen chains at the 0.74/1.0 Å geometries in Table 1; width and Hamiltonian complexity grow together. Right: full LiH at fixed width. CPU Lightning/NumPy Pauli use direct rotations, whereas Aer and the single-GPU adapter use elementary gates. Points show three-seed medians and ranges of full-energy calls, excluding setup. The shaded eight-layer position exceeds the shared canonical-gate cap.

The tested GPU gate path is slower than native CPU Lightning for full LiH: 79.97 versus 42.58 ms at one layer, and 347.80 versus 147.94 ms at four layers, giving paired CPU advantages of 1.87 and 2.35. This compares complete implementations; a native-Pauli GPU path was not measured. Startup further penalizes short GPU workloads: the one- and four-layer paths require 6.00 and 63.42 s through warm-up. For four layers, startup equals about 182 steady calls and remains over 10% of the modeled total until approximately 1,642 subsequent calls.

Spin VHA: GPU gains increase with state width

For four-layer TFIM, the GPU lowers the 20-qubit FP64 call from 64.26 ms with 18-thread Aer to 4.482 ms, a paired 14.33-fold gain. At 28 qubits, 21.412 s becomes 0.7131 s, a 29.98-fold gain. The 24-qubit Heisenberg call falls from 1.386 s to 43.88 ms, a 31.31-fold gain (Figure 3).

Figure 3. Spin VHA, four layers, FP64. CPU curves distinguish elementary gates, direct Pauli rotations and the TFIM block method, with thread counts shown. Stars are matched single-GPU timings. Points show three-seed medians and ranges of full-energy calls, excluding setup. A point is omitted when three successful seed values are unavailable.

The specialized single-thread NumPy TFIM block update takes 1.952 s at 20 qubits, compared with 3.894 s for elementary NumPy gates. It remains 30.41 times slower than 18-thread Aer. Thus avoiding a decomposition helps within the Python implementation but does not match the tested compiled path for this spin circuit. The workstation controls preserve the molecular/spin reversal: four-thread local Aer needs 90.62 ms for 20-qubit TFIM versus 4.482 ms on its GPU, whereas local direct NumPy needs only 48.47 ms for one-layer LiH versus 79.97 ms on the GPU.

HEA: independent GPU workers outperform a distributed fitting state

The ten-qubit RY/CNOT HEA takes 1.186 ms with single-thread server NumPy, 0.409 ms with local workstation NumPy and 2.334 ms on the GPU in FP64. At 24 qubits and four layers, the fastest completed dense CPU configuration in the scaling panel is 36-thread Aer at 733.24 ms; GPU FP64 takes 34.44 ms, a paired 21.33-fold gain. At 28 qubits, the CPU/GPU times are 13.139/0.6171 s for four layers and 38.856/2.100 s for 16 layers (Figure 4).

Figure 4. HEA latency and GPU allocation. Left: matched full-energy calls; CPU bars use the fastest completed dense FP64 candidate in the scaling panel, named below each group. All four GPU FP32 cells pass the primary tolerance on the available compared outputs. Bars show medians and full seed ranges. Right: paired throughput ratios for two independent workers sharing eight vectors, or two GPUs distributing a state with two vectors. These use their corresponding one-GPU workloads as baselines. Lines mark equal and twice one-device throughput. Setup is excluded. Labels on the placement bars give compared/executed unique reference outputs; the independent-worker throughput point is partially checked.

For the 24-qubit HEA in FP32, two independent GPU workers complete 312.48 evaluations/s, compared with 154.79 for one worker, a paired 2.01-fold gain. The inverse aggregate throughput is 3.200 ms per completed evaluation; individual response latency remains approximately 6.5 ms. Distributing one state over both cards instead takes 11.943 ms, yielding 83.73 evaluations/s. Independent placement therefore gives 3.72 times the throughput of the distributed placement on the same pair. At 28 qubits, distribution takes 167.49 ms versus 107.45 ms on one GPU. The compared outputs pass the primary tolerance, and both states fit one card: a 28-qubit FP32 state occupies 2 GiB before workspace. These results concern fitting states on the tested PCIe topology.

CPU allocation: executed costs and task-specific profiling

For 3,600 full-LiH evaluations at n=12n = 12, p=2p = 2, Lightning 36×136 \times1 completes in 18.94 s median across three independent Barbora deployments, versus 22.68 s for native-Pauli NumPy and 92.07 s for Aer (Table 3). All three task-specific profiling sweeps select Lightning 36×136 \times1. Its executed makespan gives a 4.86-fold gain over Aer and 1.20-fold over NumPy, at 0.00526 versus 0.00630/0.02557 node-hours. Every deployment compares all 3,600 scalar outputs; circuit, Hamiltonian and parameter hashes match, and maximum NumPy/Lightning disagreement with Aer is 2.48 ×10−12\times10^{-12}.

Table 3: Executed two-layer LiH streams on Barbora, all 36 × 1. Times include deployment startup and result receipt, excluding task-specific profiling and worker teardown. Predicted and executed medians summarize three launches; the executed range spans all three. RSS is the maximum sampled sum of child-process RSS across launches, excluding the supervisor and potentially double-counting shared pages. Every deployment has 3,600/3,600 matched reference outputs.

BackendPred. (s)Executed (s)RSS (GiB)
NumPy23.6622.6821.83–23.392.78
Aer96.0692.0791.99–96.386.89
Lightning16.7018.9418.94–18.967.49

Table 3.

Contemporaneous 36-vector forecasts differ from executed NumPy/Aer times by at most 4.8%, but underestimate Lightning by 11.8–12.1%. The independent 36-vector catalogue’s 23.00/90.36 s NumPy/Aer forecasts agree with executed medians within 1.9%. The model thus selects a useful allocation without predicting every backend’s makespan equally well.

Lightning’s maximum sampled worker RSS is 7.49 GiB versus NumPy’s 2.78 GiB and Aer’s 6.89 GiB. Applying a 4 GiB sampled-memory allowance to this shortlist selects NumPy 36×136 \times1. Task-specific profiling intervals cost 35.66 s median, so this sweep plus Lightning deployment costs at least 54.61 s for one batch, exceeding direct NumPy’s 22.68 s. Reuse of task-specific profiling and the strength of the starting allocation therefore matter to this finite-workload decision.

The 36-vector catalogue spans more NumPy/Aer allocations (Figure 5). One 36-thread Aer worker supplies 1.315 evaluations/s; 36×136 \times1 Aer supplies 42.459 and native-Pauli NumPy 164.249, a paired 3.86-fold gain over the Aer pool. For 36 calls, NumPy 12×112 \times1 projects 1.18 s and the best listed Aer choice is 18×218 \times2 at 5.34 s (Table 2). These short-workload choices and the other table rows remain projections; the 3,600-call LiH deployments above are executed workloads.

Workload / backendw×tw \times t, 36Time (s)w×tw \times t, 3,600NHSavedRSSWh{sup}†
LiH / Aer18×218 \times25.3436×136 \times10.0251096.7%5.107.53
LiH / NumPy Pauli12×112 \times11.1836×136 \times10.0063999.2%1.361.92
TFIM / Aer2×182 \times181.499×49 \times40.0186230.4%0.955.59
HEA, 18q / Aer4×94 \times91.099×49 \times40.0083246.4%0.872.50
HEA, 22q / Aer1×361 \times367.1536×136 \times10.1519412.1%5.3945.58

Table 2. Projected finite-workload choices within the 36-vector FP64 worker catalogue; executed LiH results including Lightning are in Table 3. LiH uses 12 qubits/p=2p = 2, TFIM 20 qubits/p=2p = 2 and HEA L=4L = 4. Each w×tw \times t minimizes projected time within its listed backend. NH and the energy scenario concern 3,600 calls; savings compare with one 36-thread Aer worker for the same task. RSS is maximum sampled process-tree memory in GiB. †Wh assumes a constant 300 W whole-node power for every allocation; it is modeled electricity, not a meter reading.

Plots of LiH CPU allocation cost and TFIM throughput versus sampled process-tree RSS

Figure 5. CPU allocation on a reserved 36-core node. Left: LiH cost including startup. Solid/dashed curves and shading are medians/ranges of 36-vector projections; the Lightning curve uses the independent task-specific profiling shortlist. Diamonds show executed 3,600-vector medians and full launch ranges. Other workload sizes remain projections, excluding task-specific profiling. Right: TFIM throughput and maximum sampled process-tree RSS. Nine four-thread workers retain 99.8% of the 36-worker throughput at 0.95 rather than 3.68 GiB. Throughput on the right excludes startup.

TFIM has a flatter allocation response. At 20 qubits and two layers, 9×49 \times4 supplies 54.72 evaluations/s against 54.81 for 36×136 \times1, retaining 99.8% with 74% less sampled memory and shorter startup. Its median 3,600-call projection is 0.01862 NH; the evidence supports a low-memory plateau rather than a statistically resolved unique worker count. For 22-qubit HEA, the short workload favors 1×361 \times36; 36 workers reduce the long-workload projection by only 12.1%. Internal threading also differs: 24-qubit HEA falls from 19.847 to 0.734 s in Aer from one to 36 threads. Lightning slows from 6.501 s at nine threads to 8.038 s at 36, while sampled memory grows from 5.45 to 18.95 GiB.

Latency-model selection: 33/41 fastest-candidate matches

The affine rule trains on seeds 0/1 at n≤22n \le22, depth ≤4\le4, and assesses seed 2 at n≥24n \ge24 or depth >4> 4. Table 4 compares its 33/41 fastest-candidate matches with fixed ordering and a zero-intercept fit. Fixed rules prefer an available 18-thread configuration and use deterministic fallbacks. Regret divides selected observed latency by the fastest candidate’s observed latency. On the 24 binary choices, the affine fit and Aer-first rule both score 19/24; on the 17 cases with three to five candidates, they score 14/17 and 8/17, respectively.

Table 4: CPU single-state selection on 41 held-out cases, with precision fixed per case. All rules use identical available configurations: 24 cases have two candidates, three have three, five have four, and nine have five. Counts include the chosen configuration and reflect eligible, successful options with fitted models. Geometric and worst regret cover all 41 cases.

RuleCorrect/41Geo. regretWorst
Affine fit331.103.28
Zero-intercept fit301.225.54
Aer first271.509.03
Lightning first152.7522.32

Table 4.

All eight affine errors occur at depth eight: worst regret is 3.28 for 12-qubit TFIM, selecting 18-thread Aer over specialized NumPy; Heisenberg regret is 2.74. The 38 latency models use

765 successful fitting records whose collection intervals total 1.37 node-hours. The latency-model data-collection cost over all 972 training-domain attempts, including 20 unsuccessful executions, is 1.63 recorded node-hours, excluding allocation gaps. This broader dataset-construction expense is separate from the 35.66 s task-specific profiling sweep for the LiH shortlist. The test validates conditional latency selection, not accuracy or worker-scaling prediction.

Controlled HEA: cutoff and validation change eligibility

For 20 qubits, four layers and entangler strength λ=1\lambda= 1, dense Aer takes 84.20 ms while MPS with cap 16 takes 30.23 ms, a paired 2.73-fold gain. Its error on the six recorded reference outputs is 9.94×10−79.94 \times10^{-7}, narrowly below the primary tolerance. Caps 64 and 256 give similar times and errors (Figure 6).

Figure 6. Controlled HEA, FP64. Top and bottom left: Barbora timings and errors at cutoff 10−1010^{-10}, with three-seed timing medians/ranges and a 10−610^{-6} error line. Bottom right: maximum errors over 24 additional vectors per setting on Barbora as the cutoff is tightened; cap-16 and cap-64 weak-entanglement results coincide. Every validation output has a dense FP64 counterpart. The panel tests cutoff sensitivity, rather than inferring it from small-state entropy.

At 16 layers and λ=1\lambda= 1, cap 16 takes 0.207 s versus 0.264 s for dense Aer but leaves error 6.15×10−26.15 \times10^{-2}. Caps 64/256 cost 2.426/9.594 s and leave errors 1.81×10−5/1.26×10−51.81 \times10^{-5}/1.26 \times10^{-5}. At λ=0.05\lambda= 0.05, the default cutoff leaves 1.46×10−61.46 \times10^{-6} error at every cap; the recorded 4.06-fold gain is eligible at 10−510^{-5} (Figure 7).

Figure 7. Accuracy-dependent choices among the recorded raw-output candidates at the primary settings. GPU curves compare FP32 with FP64; the CPU curve compares fixed-cutoff MPS with dense Aer. Each legend gives compared/executed unique outputs, pooled across three seeds: 6/6 for each displayed frontier. Gains are paired geometric ratios with setup excluded. These curves do not include the normalized CPU readout or tighter-cutoff validation, and do not certify unseen parameter vectors.

On 24 additional vectors, L=4L = 4, λ=1\lambda= 1, cap 16 reaches 3.08×10−63.08 \times10^{-6} error at cutoff 10−1010^{-10}; cutoff 10−1210^{-12} reduces it to 1.76×10−71.76 \times10^{-7}. For L=16L = 16, λ=0.05\lambda= 0.05, errors are 1.55×10−6/1.08×10−71.55 \times10^{-6}/1.08 \times10^{-7}. Observed bond is 16 throughout; cap 64 leaves matched errors unchanged. In the one-thread check, cap-16 medians at cutoffs 10−10/10−1210^{-10}/10^{-12} are 68.6/71.9 ms for four layers and 428.2/426.4 ms for weakly entangling 16-layer circuits. Tightening cutoff therefore restores 10−610^{-6} eligibility at fixed observed bond.

Precision: raw GPU errors and normalized CPU readout

All four generic single-GPU HEA FP32 cells meet 10−610^{-6} on recorded raw outputs (Figure 4). For 28-qubit TFIM, FP32 lowers 0.7131 to 0.08885 s, a 1.7-fold paired gain with 3.17×10−43.17 \times10^{-4} error. Heisenberg gains 3.56-fold at 4.46×10−44.46 \times10^{-4}. Both pass 10−310^{-3} on six paired outputs each (Figure 7); normalized GPU paths are unmeasured.

LiH GPU FP32 errors reach 2.02×10−3/8.01×10−32.02 \times10^{-3}/8.01 \times10^{-3} at one/four layers, with time ratios 0.97/1.02, providing no useful precision-performance tradeoff at these settings.

CPU chemistry shows why raw-output rejection is insufficient to characterize a precision. On 24 validation vectors per backend, NumPy LiH FP32 error falls from 3.03×10−53.03 \times10^{-5} to 2.25×10−72.25 \times10^{-7} with normalized FP64 readout (Table 5). Lightning’s SDK scalar divided by the same-template norm still reaches 1.10×10−51.10 \times10^{-5}; FP64 observable accumulation reduces this to 5.64×10−75.64 \times10^{-7}. Aer retains 1.15×10−61.15 \times10^{-6} after that correction. The corrected paths reclassify NumPy/Lightning accuracy on these vectors. For LiH, these complete paths require approximately 3% and 24% more runtime than their matched FP64 SDK paths; Aer requires 12% more runtime and still fails the tolerance. State export and readout costs prevent treating correction as a free scalar division.

SystemFP32 backendRaw SDK errorSDK/∣ψ∣2|\psi|^2 errorFP64 readout/∣ψ∣2|\psi|^2 errorTime / FP64
H4NumPy3.12×10−63.12 \times10^{-6}4.46×10−74.46 \times10^{-7}4.46×10−74.46 \times10^{-7}1.03
H4Aer1.45×10−41.45 \times10^{-4}1.87×10−61.87 \times10^{-6}1.89×10−61.89 \times10^{-6}1.05
H4Lightning9.84×10−69.84 \times10^{-6}1.01×10−61.01 \times10^{-6}5.30×10−75.30 \times10^{-7}1.04
LiHNumPy3.03×10−53.03 \times10^{-5}2.25×10−72.25 \times10^{-7}2.25×10−72.25 \times10^{-7}1.03
LiHAer2.35×10−32.35 \times10^{-3}1.32×10−61.32 \times10^{-6}1.15×10−61.15 \times10^{-6}1.12
LiHLightning6.98×10−56.98 \times10^{-5}1.10×10−51.10 \times10^{-5}5.64×10−75.64 \times10^{-7}1.24

Table 5. Two-layer CPU chemistry on Barbora, 24 vectors per backend. Maximum absolute error against a common dense FP64 reference. The last column is the paired geometric mean time of FP32 state evolution with normalized FP64 readout divided by the same backend’s FP64 SDK time; it includes host state export and readout. A ratio above one is slower. All calls use one thread.

Cross-method comparison and implications for simulation selection

Table 6 translates the cross-method results into an initial shortlist. For molecular VHA with many long Pauli rotations, test native-Pauli implementations first: the matched NumPy comparison isolates the representation gain, while Lightning shows the value of its compiled implementation. For wider dense spin/HEA circuits, include GPU statevector execution alongside threaded Aer; the tested crossover depends on circuit family and implementation, so width alone cannot set a universal GPU threshold. For weakly entangling circuits, include MPS, choosing its cutoff using reference errors rather than bond cap alone.

Simulation approachMain findingImportant qualification
NumPy direct Pauli [7]Avoiding elementary-gate ladders improves matched molecular VHA calls (Figure 2).The specialized NumPy spin update still trails compiled Aer; avoiding decomposition alone does not establish the fastest implementation.
PennyLane Lightning [27]Strong native-Pauli molecular performance; the selected pool wins the executed LiH comparison (Figure 2, Table 3).The selected LiH pool uses more sampled RSS than NumPy. Task-specific profiling adds a separate cost.
Qiskit Aer [5]Compiled dense execution performs strongly on spin/HEA cases; threading and worker pools serve different workloads (Figure 3, Figure 5).Elementary-gate molecular execution remains slower than the tested native-Pauli competitors, even with the reported compilation optimization.
CUDA-Q GPU [11]Large gains for wider spin/HEA cases; independent workers favor fitting states (Figure 3, Figure 4).The gate-expanded GPU path loses to native CPU LiH. Startup and the tested PCIe topology delimit the allocation result.
Aer MPS [8, 9]Selected shallow or weakly entangling HEA permits economical approximation (Figure 6).Bond cap, cutoff and reference-vector coverage determine eligibility; increasing the cap alone need not meet the tolerance.

Table 6. Cross-method synthesis for constructing a simulation shortlist. Findings concern the implemented paths and tested circuit families; qualifications delimit their use.

For large batches of independently ready evaluations whose states fit per worker, compare worker pools with internally parallel execution. The measured CPU/GPU placement cases favor concurrency for such workloads, whereas short streams can favor lower startup costs. Validate each candidate’s complete energy-output path, including any precision correction, then rank feasible configurations for the required evaluation count and memory budget. Reuse suitable profiling where possible; a fresh task-specific sweep is useful when its expected savings justify its cost. The CPU procedure ranks measured host configurations; the GPU controls compare uses of the same device pair.

Discussion

Representation sets the hardware workload

Direct Pauli evolution removes basis changes and parity ladders while preserving the rotation and scalar-energy task. The matched NumPy comparisons therefore identify a representation benefit without changing hardware. Lightning supplies another native-Pauli CPU implementation with strong molecular performance. This does not make direct updates sufficient for every family: the specialized NumPy TFIM block path still trails compiled Aer. The primitive operations and their implementation both matter.

The molecular CPU/GPU reversal follows the same reasoning. Native CPU Pauli operations are compared with a GPU elementary-gate path, so the result selects a complete implementation. The large GPU gains for wider spin and HEA circuits show a different operating regime. A native-Pauli GPU comparison would be needed to separate architecture from representation in the molecular case; the available component timings do not isolate GPU or Lightning kernel costs.

Width and layer count do not specify evaluation complexity

At fixed precision, width determines dense statevector storage, but gate structure and observable complexity determine the work performed on that state. The circuit schematic contrasts a 12-qubit, two-layer LiH circuit with 13,032 canonical CNOTs against a 24-qubit, four-layer HEA with 92. Molecular energies also require many Pauli terms, whereas the HEA readout is comparatively sparse. These are different tasks, not matched-unitary speedups. Their resource counts explain why a smaller register can still present a costly evaluation. For MPS, intermediate bond growth adds another dimension: nominal width or depth alone does not establish c…

The workload determines the useful allocation

Allocation should follow the application’s dependence structure. Single-call latency measures how soon one requested value is available; aggregate throughput measures completed values per second when several are ready. The independent-GPU control increases throughput while individual response latency remains approximately unchanged. An optimization step that must wait for the next energy value can therefore favor a different allocation from a batch of ready parameter vectors. Internal threading helps wide Aer HEA calls, while independent CPU workers exploit ready LiH evaluations. TFIM’s near-equal-throughput allocations make memory and startup useful selection criteria within the measured plateau. Distributing one state addresses a different capacity/allocation objective and is slower for the tested fitting states.

For a finite stream, compare startup plus execution time and include task-specific profiling when a fresh sweep is required. LiH illustrates the trade-off: Lightning has the shortest executed batch time, but the sweep costs more than its gain over an already-native NumPy pool for one batch, and its worker memory is higher. Repeated workloads can amortize that expense; a memory allowance can instead select NumPy. Latency-model data collection builds a broader reusable timing catalogue and remains a separate cost. Selection therefore needs the evaluation count, available independent calls and opportunities to reuse startup and profiling, in addition to per-call timing. Conditional electricity scenarios follow the same accounting (Appendix § 6.7).

Accuracy is part of the configuration

MPS truncation and FP32 readout show how numerical settings change the eligible comparison set. The selected HEA checks recover the target accuracy by tightening the cutoff at the same observed bond dimension, while deeper strongly entangling cases remain inaccurate at the tested settings. A larger bond cap alone therefore need not remove the error floor. Raw FP32 chemistry errors also combine state evolution, norm drift and observable reduction. Normalized FP64 readout qualifies the tested NumPy/Lightning FP32 LiH paths, but requires approximately 3% and 24% more runtime than their FP64 paths. The relevant cost includes every operation needed to meet the tolerance.

These interpretations concern the tested circuits, implementations and available references. Three LiH deployment launches share one Barbora node and the same held-out stream. Native-Pauli GPU execution and normalized GPU readout remain unmeasured, and the canonical-CNOT cap limits the circuit grid. Fixed-parameter agreement assesses simulation output; optimizer convergence and ground-state accuracy require separate evidence.

Conclusion

The tested circuit families favor different simulation pipelines. Direct Pauli implementations benefit molecular VHA, compiled dense and GPU paths perform strongly on wider spin/HEA cases, and MPS is useful where entanglement and validated truncation permit compression. These changes in ranking support selection by circuit structure, observable and implementation, rather than by backend name or qubit count alone.

Representation, precision and parallel allocation must be considered jointly: numerical corrections change evaluation cost, and worker choices change memory and throughput. Single-circuit latency consequently does not determine the reserved cost of repeated evaluations; startup, workload size and task-specific profiling also enter the decision.

For HPC deployment, validate the complete energy-evaluation path first, then compare worker/thread allocations for the available independent calls and memory budget. Reuse task-specific profiling where suitable and charge any new sweep to the planned stream. The practical target is the total reserved cost of delivering the required accurate evaluations.

Declaration of generative AI and AI-assisted technologies in the manuscript preparation process

OpenAI ChatGPT/Codex was used for programming and coding: implementing and debugging the analysis code. All code, computations and results were rigorously reviewed by the authors, who take full responsibility for the content of this article.

Data and Code Availability

The benchmark data and original study code are openly available in the Zenodo repository at https://doi.org/10.5281/zenodo.23857800.

Acknowledgements

This project has received funding from the Research Council of Lithuania (LMTLT), agreement No.: S-ITP-25-7. This work was supported by the European Union under the REFRESH – Research Excellence For REgion Sustainability and High-tech Industries project, project number CZ.10.03.01/00/22_003/0000048, via the Operational Programme Just Transition. This research was also supported by research grants SGS No. SP2026/063 of VSB-Technical University of Ostrava, Czech Republic. The CPU calculations used the Barbora system at IT4Innovations National Supercomputing Center under project FTA-26-86. This work was supported by the Ministry of Education, Youth and Sports of the Czech Republic through the e-INFRA CZ (ID:90254 ).

Reproducibility and supplementary details

Circuit parameters and implementation settings

Independent angles are uniform in [−π,π][-\pi,\pi] with seeds 1729+1009r1729 + 1009r, r=0,1,2r = 0, 1, 2; selected generic controls additionally use nearby trajectories and single-rotation shifts. A two-shift rule is not assumed for tied VHA block parameters. Qubit zero is the least significant statevector bit. Matched comparisons check the circuit, Hamiltonian, output task and identical parameter prefixes. Molecular fixtures omit coefficients with magnitude at most 10−1010^{-10} and record an omitted-coefficient L1 bound. They were generated before timing with PennyLane’s differentiable restricted Hartree–Fock implementation.

CPU software is Python 3.11.4, NumPy 2.2.6, SciPy 1.15.3, Qiskit 2.6.1, Aer 0.18.2, PennyLane 0.45.1 and Lightning 0.45.0.

SystemnnKKBBCNOTs/p
H2415236
H4, two spacings8185271,328
H6, two spacings129191489,972
H8162,91350141,600
LiH full12631846,516
LiH frozen core10276352,362
LiH active 2e/4o810513472

Table A.1. Molecular VHA resources per canonical layer. KK includes the identity; BB counts stored blocks. Each H4/H6 row represents both chain spacings.

The workstation uses Python 3.12.3 and the same NumPy/Aer versions, with CUDA-Q’s amd64–cu13–0.16.0 build, CUDA 13.0 container environment and driver 595.99.02. Affinity and thread limits are applied before SDK import; Lightning numerical binding disables objective memoization. CPU workloads use independent single-node execution, with paired problem/seed blocks on the same node.

Most physical cells evaluate two vectors over three to eight steady rounds, targeting 0.5 s of work within fixed caps. The common 50,000-CNOT canonical limit applies to every representation, including direct Pauli methods. H8 at p≥2p \ge2, H6 at p=8p = 8 and full LiH at p=8p = 8 exceed that bound. Preparation has a 120 s deadline; most physical cells have a 300 s total limit, selected worker cells 600 s. A sampled process-tree memory guard uses 128 GiB or 80% of available memory, whichever is smaller. Such cases are censored, not plotted as measured slow times. Memory sampling may miss short peaks or double-count shared pages.

Molecular resources

Table A.1 details the seven resource patterns across the nine molecular fixtures. Counts refer to the canonical elementary decomposition before optimization. The compiled-depth examples in Figure 1 are the recorded Aer template depths, including the scalar-save instruction and without hardware routing; they are not physical device depths.

Coverage and computational accounting

The CPU grid records 3,261 outcomes: 2,823 executions, 318 time limits, 90 gate exclusions, 21 memory stops and nine software errors. The GPU extension records 108 outcomes per execution of its plan, comprising 84 GPU cases and 24 local CPU controls; 105 execute, and the three time limits are local NumPy controls. CPU production uses 53.93 node-hours across eight single-node allocations, including 33.76 node-hours in timed-out case intervals. The targeted validation driver records another 839.7 s (0.233 node-hours), covering preflight, task-specific profiling, deployments and accuracy checks. These accounting totals describe the benchmark campaign rather than a simulation kernel. Large Lightning allocations trigger the memory stops; the software errors are 64-qubit easy-state MPS controls rejected by the reported 63-qubit transpilation target.

Reference coverage and state diagnostics

Reference comparisons use common outputs rather than assuming that a self reference establishes agreement. The native-Pauli/Aer LiH worker comparison additionally matches all 36 outputs per seed and verifies their circuit, Hamiltonian and parameter hashes; all 108 agree within 2.30×10−122.30 \times10^{-12}. Thirty of the 33 single-GPU FP64 cells have independent CPU-backend comparisons, with maximum scalar difference 1.43×10−111.43 \times10^{-11}. The three controlled-HEA cells at n=24n = 24, λ=0.05\lambda= 0.05 lack an independent FP64 counterpart; their FP32 errors are compared with the same adapter’s FP64 output. The eight-output GPU throughput cells have independent references for four HEA outputs or two TFIM outputs per seed. Acceptance applies to that available subset; it does not certify unobserved vectors. A failing subset is sufficient to reject an operating point. Across the declared grids, 370 of 659 compared CPU FP32 cells and 26 of 51 GPU FP32 cells exceed tolerance; related placements are not independent circuit samples.

The largest CPU FP64 cross-reference discrepancy is 1.95×10−111.95 \times10^{-11}. Selected n≤16n \le16 first-vector diagnostics report normalized fidelity, norm and particle-number moments. Schmidt entropy/effective rank are sampled only at selected cuts and layer boundaries; they do not certify every intermediate bond.

For two-layer H4, capped MPS reaches the physical maximum bond 16 but still has a worst error of 2.89×10−52.89 \times10^{-5} at the fixed cutoff. Full LiH with cap 64 reaches 3.30×10−63.30 \times10^{-6}. Larger controlled-HEA MPS cases without dense counterparts remain unverified. Selected benchmark CPU FP32 chemistry states have normalized fidelity errors below 3.82×10−123.82 \times10^{-12}, yet full LiH Aer norm drift reaches 2.54×10−42.54 \times10^{-4}. The separate numerical-readout check in Table 5 obtains the norm from the same gate template and includes its timing cost.

Reuse and supplementary controls

Reuse/batching timings are retained in the deposited workflow tables. For the 28-qubit local-observable control, exact backwards-cone reduction uses eight effective qubits: 0.399 ms versus 8.782 s for dense Aer, with 2.52×10−142.52 \times10^{-14} worst compared difference. This concerns the local output; computational-basis terminal shots likewise do not estimate non-diagonal molecular energies.

Validation inputs and recorded timing components

The molecular readout check uses seeds 72001–72003 and eight vectors per seed for H4 at 1.0 Å and full LiH, both at two layers. Dense FP64 reference discrepancies across the tested SDKs are at most 2.19×10−122.19 \times10^{-12}. MPS validation uses seeds 73001–73003, eight vectors each, with dense references. Saved task-specific profiling records retain 8/36 scalars per candidate; each deployment records and compares all 3,600. LiH profiling/deployment seeds are 74001/75001; all launches reuse the same held-out stream to measure launch variation. Startup includes parameter generation and hashing; cold means new worker processes, without flushing OS caches. Median last/first full 20-call chunk-time ratios across workers and launches are 0.999/1.003/0.992 for NumPy/Aer/Lightning. The three deployments repeat 3,600 unique held-out vectors, rather than providing 10,800 independent vectors. Task-specific profiling costs sum startup and parent-observed rounds, excluding teardown and gaps; deployment RSS sums sampled child processes and excludes the supervisor.

WorkloadEvolutionObservableOther
LiH, 12q, p=4p = 4251.6151.540.020
TFIM block, 20q, p=4p = 41285.62665.450.041
HEA, 18q, L=4L = 4229.171.000.022

Table A.2. NumPy FP64 call components on Barbora, one thread, in milliseconds. Mean of per-seed mean matched last-vector calls across timing rounds. Other includes Python adapter/batch and timer overhead. These are CPU component measurements, not GPU or Lightning kernel profiles.

Table A.2 reports the available NumPy timing decomposition. LiH’s native NumPy path spends 251.6 ms in evolution and 51.5 ms in its observable, whereas the 18-qubit HEA observable costs 1.0 ms. These are matched recorded CPU calls. Lightning and CUDA-Q expose no corresponding phase split in the archive, so this decomposition cannot assign the CPU/GPU reversal to a particular phase.

Auxiliary power and energy evidence

An auxiliary sequential check changed GPU 0/GPU 1 limits from 400/400 to 600/400 W and reused the same three seeds: the pooled paired FP64 ratio T400/T600=1.0007T_{400}/T_{600} = 1.0007 showed no material timing benefit. The main figures use the 600/400 W execution; the two executions are not treated as six independent seeds. Board-power telemetry and CPU RAPL counters have different scopes, include setup and unequal call counts, and do not establish whole-system energy per evaluation; a power ceiling is not consumed power [32].

At assumed constant 300 W, the executed Aer/NumPy/Lightning LiH deployments correspond to 7.67/1.89/1.58 Wh, excluding task-specific profiling. Task-specific profiling adds another 2.97 Wh under that assumption. Lightning’s runtime advantage over NumPy implies lower deployment electricity only if its mean whole-node power is less than 1.20 times NumPy’s. These are conditional runtime conversions; measured whole-system power and site overhead are required for an electricity comparison.

References

  1. [1]J. Preskill, Quantum computing in the NISQ era and beyond, Quantum 2 (2018) 79. doi:10.22331/q-2018-08-06-79.DOI
  2. [2]M. Cerezo, A. Arrasmith, R. Babbush, S. C. Benjamin, S. Endo, K. Fujii, J. R. McClean, K. Mitarai, X. Yuan, L. Cincio, P. J. Coles, Variational quantum algorithms, Nature Reviews Physics 3 (2021) 625–644. doi:10.1038/s42254-021-00348-9.DOI
  3. [3]A. Kandala, A. Mezzacapo, K. Temme, M. Takita, M. Brink, J. M. Chow, J. M. Gambetta, Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets, Nature 549 (2017) 242–246. doi:10.1038/nature23879.DOI
  4. [4]D. Wecker, M. B. Hastings, M. Troyer, Progress towards practical quantum variational algorithms, Physical Review A 92 (2015) 042303. doi:10.1103/PhysRevA.92.042303.DOI
  5. [5]A. Javadi-Abhari, M. Treinish, K. Krulich, C. J. Wood, J. Lishman, J. Gacon, S. Martiel, P. D. Nation, L. S. Bishop, A. W. Cross, B. R. Johnson, J. M. Gambetta, Quantum computing with Qiskit (2024). arXiv:2405.08810, doi:10.48550/arXiv.2405.08810.
  6. [6]M. S. Rudolph, T. Jones, Y. Teng, A. Angrisani, Z. Holmes, Pauli propagation: A computational framework for simulating quantum systems, PRX Quantum 7 (2026) 032001. doi:10.1103/6vd7-l9bn. URL https://link.aps.org/doi/10.1103/6vd7-l9bnDOI
  7. [7]C. R. Harris, K. J. Millman, S. J. van der Walt, R. Gommers, P. Virtanen, D. Cournapeau, E. Wieser, J. Taylor, S. Berg, N. J. Smith, R. Kern, M. Picus, S. Hoyer, M. H. van Kerkwijk, M. Brett, A. Haldane, J. F. del Río, M. Wiebe, P. Peterson, P. Gérard-Marchant, K. Sheppard, T. Reddy, W. Weckesser, H. Abbasi, C. Gohlke, T. E. Oliphant, Array programming with NumPy, Nature 585 (7825) (2020) 357–362. doi:10.1038/s41586-020-2649-2. URL https://doi.org/10.1038/s41586-020-2649-2
  8. [8]U. Schollwöck, The density-matrix renormalization group in the age of matrix product states, Annals of physics 326 (1) (2011) 96–192.DOI
  9. [9]G. Vidal, Efficient classical simulation of slightly entangled quantum computations, Physical Review Letters 91 (2003) 147902. doi:10.1103/PhysRevLett.91.147902.DOI
  10. [10]A. Sander, M. Fröhlich, M. Ali, M. Eigel, J. Eisert, M. Hintermüller, C. B. Mendl, R. M. Milbradt, R. Wille, Quantum circuit simulation with a local time-dependent variational principle, arXiv:2508.10096 (2025). doi:10.48550/arXiv.2508.10096.DOI
  11. [11]T. C.-Q. development team, Cuda quantum: The platform for integrated quantum-classical computing, in: Proceedings of the 60th Annual ACM/IEEE Design Automation Conference (DAC), IEEE, San Francisco, CA, USA, 2023, pp. 1–6. doi:10.1109/DAC56929.2023.10247886.
  12. [12]NVIDIA, CUDA-Q circuit simulation backends, version 0.16.0, Official documentation. URL https://nvidia.github.io/cuda-quantum/0.16.0/using/backends/simulators.html
  13. [13]P. D. Nation, A. A. Saki, S. Brandhofer, L. Bello, S. Garion, M. Treinish, A. Javadi-Abhari, Benchmarking the performance of quantum computing software for quantum circuit creation, manipulation and compilation, Nature Computational Science 5 (2025) 427–435. doi:10.1038/s43588-025-00792-y.DOI
  14. [14]V. Novák, S. Illésová, T. Bezděk, I. Zelinka, M. Beseda, Reliable optimization under noise in quantum variational algorithms, arXiv preprint arXiv:2511.08289 (2025).arxiv.org/abs/2511.08289
  15. [15]S. Illésová, T. Bezděk, V. Novák, B. Senjean, M. Beseda, Statistical benchmarking of optimization methods for a variational quantum eigensolver under quantum noise, Phys. Rev. A (Nov 2026). doi:10.1103/5clr-mhwn. URL https://link.aps.org/doi/10.1103/5clr-mhwnDOI
  16. [16]R. Wiersema, C. Zhou, Y. de Sereville, J. F. Carrasquilla, Y. B. Kim, H. Yuen, Exploring entanglement and optimization within the Hamiltonian Variational Ansatz, PRX Quantum 1 (2020) 020319. doi:10.1103/PRXQuantum.1.020319.
  17. [17]S. Illésová, V. Novák, T. Bezděk, M. Beseda, C. Possel, Numerical optimization strategies for the variational hamiltonian ansatz in noisy quantum environments, arXiv preprint arXiv:2505.22398 (2025).arxiv.org/abs/2505.22398
  18. [18]M. Cerezo, M. Larocca, D. García-Martín, N. L. Diaz, P. Braccia, E. Fontana, M. S. Rudolph, P. Bermejo, A. Ijaz, S. Thanaslip, E. R. Anschuetz, Z. Holmes, Does provable absence of barren plateaus imply classical simulability?, Nature Communications 16 (2025) 7907. doi:10.1038/s41467-025-63099-6.DOI
  19. [19]M. Schuld, V. Bergholm, C. Gogolin, J. Isaac, N. Killoran, Evaluating analytic gradients on quantum hardware, Physical Review A 99 (2019) 032331. doi:10.1103/PhysRevA.99.032331.DOI
  20. [20]M. Schuld, A. Bocharov, K. M. Svore, N. Wiebe, Circuit-centric quantum classifiers, Physical Review A 101 (2020) 032308. doi:10.1103/PhysRevA.101.032308.
  21. [21]A. Pérez-Salinas, A. Cervera-Lierta, E. Gil-Fuster, J. I. Latorre, Data re-uploading for a universal quantum classifier, Quantum 4 (2020) 226. doi:10.22331/q-2020-02-06-226.
  22. [22]S. Illésová, T. Bezděk, V. Novák, I. Zelinka, S. Cacciatore, M. Beseda, From classical to hybrid: A practical framework for quantum-enhanced learning, arXiv preprint arXiv:2511.08205 (2025).arxiv.org/abs/2511.08205
  23. [23]T. Jones, J. Gacon, Efficient calculation of gradients in classical simulations of variational quantum algorithms, arXiv:2009.02823 (2020). doi:10.48550/arXiv.2009.02823.DOI
  24. [24]J. Cerrudo-Herrera, D. Talaván-Vega, P. Rodríguez-Oliver, A. Ziatbat-Ziabat, J. A. Rico-Gallego, Benchmarking quantum computing statevector simulators on high-performance computing, SIMULATION 102 (7) (2026) 493–507. doi:10.1177/00375497261438515.
  25. [25]J. Faj, J. Peng, J. Wahlgren, S. Markidis, Quantum computer simulations at warp speed: Assessing the impact of GPU acceleration, arXiv:2307.14860 (2023). doi:10.48550/arXiv.2307.14860.DOI
  26. [26]S. Efthymiou, M. Lazzarin, A. Pasquale, S. Carrazza, Quantum simulation with just-in-time compilation, Quantum 6 (2022) 814. doi:10.22331/q-2022-09-22-814.DOI
  27. [27]A. Asadi, A. Dusko, C.-Y. Park, V. Michaud-Rioux, I. Schoch, S. Shu, T. Vincent, L. J. O’Riordan, Hybrid quantum programming with PennyLane Lightning on HPC platforms, arXiv:2403.02512 (2024). doi:10.48550/arXiv.2403.02512.DOI
  28. [28]M. Vallero, P. Rech, F. Vella, State of practice: Evaluating GPU performance of state vector and tensor network methods, Future Generation Computer Systems 174 (2026) 107927. doi:10.1016/j.future.2025.107927.DOI
  29. [29]M. Miller, J. Günther, F. Witteveen, M. S. Teynor, M. Erakovic, M. Reiher, G. C. Solomon, M. Christandl, phase2: full-state vector simulation of quantum time evolution at scale, Communications AI & Computing 1 (2026) 5. doi:10.1038/s44488-026-00002-2.DOI
  30. [30]IBM Quantum, Qiskit api: hamiltonian_variational_ansatz, Official documentation. URL https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.circuit.library.hamiltonian_variational_ansatz
  31. [31]Qiskit Aer developers, AerSimulator options, version 0.18.2, Official documentation. URL https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerSimulator.html
  32. [32]NVIDIA, NVIDIA System Management Interface: Gpu attributes and power readings, Official documentation. URL https://docs.nvidia.com/deploy/nvidia-smi/index.html

Paper details

vlnc:W_2h3ub9n6
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents