What the paper solves
HPC systems have the GPUs quantum simulators need, but their interfaces are scheduler-oriented: users submit batch jobs, wait in queues, run, and exit. Quantum software instead expects a QPU—an interactive device you can submit circuits to, observe, and query, like IBM Quantum or AWS Braket. Worse, HPC compute nodes are internally addressed and ephemeral, with no inbound connectivity allowed. The paper defines this as the "connectivity inversion problem": rather than sending quantum jobs into the HPC, you must export the simulator out.
Two-plane architecture
HPC-vQPU uses a deliberately asymmetric design—all coordination is outbound and agent-initiated:
- Control plane (
vqpu_server): cloud-visible, exposes a REST API and SSE event streams. It speaks in devices, tasks, lifecycle states, and results—never partitions, module stacks, or batch scripts. - Execution plane (
vqpu_agent): an unprivileged process on the HPC login node that polls the control plane, CLAIMs tasks, translates them into scheduler jobs (Slurm/Dask), and reports results. - Directed coupling graph G = (Q, E) with topology constraints
- Native gate set G_native for acceptability validation
- Per-qubit T1/T2 coherence times, single-qubit error ε_1q, readout error r
- Per-edge two-qubit error ε_ij and gate type g_ij, with directionality (ε_ij ≠ ε_ji allowed)
- Experiment A (bounded overhead): 28–32 qubit circuits, 1024 shots. T_exec = 23.77 s at 32 qubits, but service-layer overhead was only 3.7%—the exponential simulation cost stays strictly isolated from constant-time service logic.
- Experiment B (device-aware fidelity): noisy device showed TV = 0.03537 ± 0.00171 vs. the ideal, consistent with readout errors and calibrated two-qubit channels.
- Experiment C: confirmed CLAIM-time binding (8/8 noise-free outputs).
- Experiment D (crash recovery): killing the agent left 3 tasks RUNNING without auto-failure; explicit admin requeues plus an agent restart completed 3/3. The system deliberately avoids automatic requeueing to prevent competing execution lineages.
- Exponential statevector simulation cost is not hidden—only kept out of the service layer; beyond ~32 qubits, simulation time dominates.
- Recovery is conservative; automatic policies post-heartbeat-expiry are future work.
- Only Dask-backed Slurm integration; PBS, LSF, Kubernetes need adapters.
- Only simulators validated; physical QPU integration remains open, though architectural principles carry over.
Between the planes there are only three verbs: CLAIM, HEARTBEAT, REPORT. No callbacks, no RPC. Failure detection is heartbeat-expiry driven; crashed agents leave tasks in ambiguous states pending explicit admin recovery—by design.
Core abstraction: the immutable device snapshot
The key data structure is a device snapshot Δ(𝒟, t) containing:
The snapshot is an execution contract, not metadata. It is bound at CLAIM time—neither at submission (too early; devices drift during queueing) nor at node runtime (too late; would require inbound connectivity).
The paper builds a 156-qubit virtual device ibm-fez-0309 from real IBM Fez calibration data (2026-03-09), alongside ibm-fez-ideal (zero error). A clever experiment zeroes all noise parameters via the admin API 1.2 seconds after submitting 8 tasks; since binding occurs at CLAIM, all 8 returned noise-free results (TV = 0), proving the binding timing.
Nine design invariants (D1–D9)
1. Outbound-only: no inbound path into the HPC 2. Terminal state absorption: COMPLETED/FAILED/CANCELLED are absorbing states 3. Exclusive atomic CLAIM 4. Asymmetric coordination: heartbeat expiry, not server callbacks 5. Snapshot immutability: bound at CLAIM, sealed at execution 6. Topology parameterization: graph-based checks, not string matching 7. TTL caching of snapshots, invalidated on device mutation 8. Sealed execution: compute nodes have no network or control-plane access 9. Server-side observability via SSE event streams
Experimental validation on Pawsey Setonix
Production environment: Setonix, AMD Instinct MI250X GPUs, Qiskit-Aer + cuQuantum.
A subtle but critical detail: the control-plane simulator and compute-node runner use identical noise-model derivation logic, preventing semantic divergence between validation and execution paths.
Limitations
Why it matters
The architecture re-draws the boundary: HPC keeps doing what it is good at (scheduling, isolation, GPU compute), but exposes a "device" rather than a "job script" externally. The principles—two planes, outbound-only, snapshot contracts, sealed execution—generalize to any HPC-internal resource needing interactive external service: ML inference, scientific visualization, data query. External users can now submit circuits via REST, watch progress via SSE, and receive calibration-informed results, all without opening a single inbound port.