Parallel Circuit Execution for Scalable Quantum Computation
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.
Kai: We're looking at the paper: "Parallel Circuit Execution for Scalable Quantum Computation".
Mira: Here's the gist of the paper. Today’s quantum processors have tens to hundreds of physical qubits, but reliable execution of arbitrary circuits remains limited to fewer than 30 entangled qubits across hardware modalities Building upon prior work, we introduce an error-aware method for mapping multiple independent circuits onto disjoint regions of a single large-scale QPU for parallel circuit execution For applications with many similarly sized circuits, such as observable estimation for Hamiltonian simulation, this approach can reduce billed QPU execution time, with ideal speedup proportional to the number of usable partitions We demonstrate the approach on IBM’s 156-qubit ibm boston processor using standard QED-C benchmark and Hamiltonian based observable-estimation workloads Compared with standard sequential execution, parallel execution reduces billed execution time by 3.5–5.5× while retaining 83–92% of the sequential fidelity Pruning redundant reasoning tokens The core problem addressed is the gap between the number of qubits available on a device and the number that can be used reliably in a single computation Current superconducting processors offer 50 to 150 physical qubits
10: ,
11: , but noise limits reliable circuit execution to roughly 10 to 15 entangled qubits
12: ,
13: ; trapped-ion systems reach perhaps 30
14: ,
15: Meanwhile, the majority of a processor’s qubits sit idle during any given circuit execution Here, we introduce a method that can utilize this idle capacity By running multiple independent circuits simultaneously, billed QPU execution time can be reduced, with the ideal reduction determined by the number of circuits and usable partitions The approach targets workloads containing many independent circuits of similar size How the training signal is built The methodology involves two primary execution modes: GPU-based simulators using CUDA-Q and quantum hardware accessed via Qiskit For GPU-based parallel execution, T MPI ranks are divided into G = T /P independent groups, where P is the number of GPUs assigned to each circuit The implementation uses MPI subcommunicators to create independent GPU groups for fine-grained control of finite-shot sampling In the hardware execution mode, independent circuits are mapped to disjoint regions of a single large QPU or multiple GPUs Partition finding uses a lightweight topology- and error-aware algorithm that selects nodes with the most connections to the existing cluster, favoring compact, well-connected regions over chains Where the gains come from The speedup achieved depends primarily on the number and cost of independent circuits available for concurrent execution For observable estimation, this is determined by the number of commuting Pauli groups The number of commuting groups can range from 2 for a simple lattice model to over 1,000 for a molecular electronic structure Hamiltonian The scaling efficiency depends on both circuit cost and the amount of available circuit-level parallelism For the H2 electronic-structure Hamiltonian, with 185–2,951 terms, it produces 54–1,251 groups over the evaluated qubit widths and provides sufficient independent circuits to utilize all 16 GPUs effectively Fidelity and Utilization Tradeoff on Hardware Parallel execution on hardware introduces a tradeoff between device utilization and circuit fidelity Our error-scored partition mapping mitigates this by selecting the highest-quality regions first, but additional partitions generally require the use of progressively lower-quality qubit regions Restricting circuits to individual partitions can also increase routing requirements, especially when the available connectivity within a partition is lower than that available to sequential execution This results in observed fidelity retention of 83–92% across evaluated workloads Forward Applicability The parallel execution approach applies more generally to workloads producing many similarly sized independent circuits Examples include variational algorithms such as VQE and QAOA, quantum machine learning ensembles, randomized benchmarking and tomography protocols, and parameter sweeps workflows at fixed circuit width The partition mapping algorithm requires a coupling map and calibration information for the underlying hardware The potential benefit of parallel execution should increase as quantum processors become larger and more reliable Future Optimizations Several improvements could increase the efficiency and fidelity of hardware parallel execution Partition selection could account more directly for routing requirements and measured crosstalk Allocating additional qubits around each partition could provide the transpiler with greater routing flexibility Dynamically adjusting the separation between partitions based on measured crosstalk could allow more effective use of the available hardware There are also opportunities to reduce the setup and compilation overhead associated with parallel execution Partition layouts for specific backends and circuit widths could be precomputed and reused, eliminating the 1–2 s partition-selection cost Across standard QED-C and observable-estimation benchmarks, GPU results show that circuit-level speedup depends on the number and cost of independent circuits H2, with 1,251 independent measurement circuits, achieved a 13.8× speedup on 16 GPUs, representing 86% of the theoretical maximum Bose-Hubbard achieved an 8.2× speedup with nine measurement groups TFIM, whose simple structure yields only two groups, was limited to 1.9× On the 156-qubit IBM ibm boston processor, our error-aware partition mapping identifies disjoint qubit regions that allow multiple independent circuits to execute simultaneously Across the workloads evaluated, parallel execution produced approximately 2–3× reductions in billed QPU execution time while retaining 83–92% of the sequential-execution fidelity for circuits that could be executed reliably on the hardware The results also expose the principal cost of this approach: constraining circuits to disjoint regions can reduce fidelity through less favorable qubit selection and routing, while the current software path can introduce substantial compilation and orchestration overhead The GPU and hardware experiments reveal two sides of the same opportunity On current quantum hardware, the number and quality of usable partitions limit the parallelism that can be achieved The GPU results show the performance ceiling when those constraints are removed: with sufficient independent circuits and computational resources, circuit-level execution can approach the available parallel capacity As quantum processors grow toward 500–1,000 physical qubits and improvements in gate fidelity make reliable 40–50 qubit circuits possible, the same approach could potentially support 10–20 simultaneous circuit partitions Both execution modes have been integrated into the QEDC Application-Oriented Benchmark suite, allowing the same application workloads to execute sequentially or in parallel without changing their circuit-generation or analysis logic The approach is not limited to any specific application: standard benchmarks, observable estimation, variational algorithms, parameter sweeps, and other workloads generating independent circuits can exploit the same parallelism Parallel circuit execution therefore provides a way to extract more useful computation from the resources already available, while providing a path to substantially greater parallelism as quantum processors become larger and more capable The code availability is provided at https://github.com/SRI-International/QC-App-Oriented-Benchmarks Execution scripts, data collection tools, and visualization programs used to generate the results reported here are available at https://github.com/quantumcomputingdata/QC-App-Benchmarks-Data The acknowledgements thank David E.
Kai: Bernal Neira, Daan Camps, Sonika Johri, Efekan Kokcu, Debarshi Kundu, Neer Patel, and Anish Giri for valuable review and commentary that contributed to this manuscript AC was supported in part by the U.S.
Mira: Department of Energy, Office of Science, National Quantum Information Science Research Centers, Quantum Systems Accelerator (Award No.
Kai: DE-SCL0000121), under Contract No.
Title and authors: Kai: So we're looking at this paper titled Parallel Circuit Execution for Scalable Quantum Computation and it seems like the main thing they're tackling is that gap between how many physical qubits you have and how many you can actually use reliably in one go, right?
Mira: Exactly. It points out that even though we have hundreds of physical qubits now, reliable execution is still stuck at maybe twenty or thirty entangled qubits on current hardware modalities. This paper introduces a method to map multiple independent circuits onto separate regions of a single large quantum processor for parallel execution.
Lev: From an error correction standpoint, the core issue they solve is that noise limits reliable circuit execution to about ten to fifteen entangled qubits on superconducting processors and around thirty in trapped-ion systems, even though we have fifty or one hundred physical qubits available ten, eleven.
Kai: So this method uses an error-aware topology aware approach to find these disjoint regions, which lets you run several different circuits at the same time instead of just one after another on the same resource.
Mira: The paper shows that for workloads with many similarly sized circuits, like observable estimation for Hamiltonian simulation, you can reduce billed QPU execution time by three point five to five point five times compared to running them sequentially.
Lev: And they keep eighty three to ninety two percent of the sequential fidelity across those evaluated workloads, which is pretty good considering partitioning introduces some trade-offs with qubit routing and connectivity.
Kai: The results they show on IBM’s one hundred fifty six qubit ibm boston processor using the standard QED C benchmark and Hamiltonian based observable estimation workloads are quite compelling because it shows that parallel execution can actually cut billed time by that three point five to five point five times.
Mira: And the scaling part is interesting too, because they demonstrate this on GPU accelerated classical simulation using mpi ranks, showing up to thirteen point eight times speedup on sixteen GPUs for an h two electronic structure simulation <ref:2609.12172#pg2>.
Lev: That thirteen point eight times speedup is significant when you look at the scaling efficiency, especially considering how the number of commuting groups in some Hamiltonians can go up to over one thousand <ref:2609.12172#pg3>.
Kai: The paper suggests that for observable estimation, the speedup scales directly with the number of usable partitions you can find on the hardware.
Mira: But they also lay out a few improvements they think could make this even better, like accounting more directly for routing requirements and crosstalk when selecting those partitions.
Lev: They also mention that allocating additional qubits around each partition could give the transpiler more flexibility in routing, and dynamically adjusting the separation based on measured crosstalk could let you use the hardware even better.
Kai: So what they're really saying is that for workloads with many independent circuits, this parallel execution strategy gives you a way to extract much more useful computation from the resources already available on your quantum processor.
Mira: They also show how this framework fits into other areas, like variational algorithms such as vqe and qaoa, or even randomized benchmarking workflows at fixed circuit width.
Lev: The limitation they point out is that constraining circuits to disjoint regions can actually reduce fidelity because you're selecting qubit regions with lower quality and routing requirements sometimes <ref:2609.12172#pg3>.
Kai: So to wrap up, the paper Parallel Circuit Execution for Scalable Quantum Computation shows that by mapping independent circuits onto disjoint regions, we can achieve a three point five to five point five times reduction in billed QPU execution time while keeping eighty three to ninety two percent of the sequential fidelity on current hardware.
Mira: It really highlights the trade-off between device utilization and circuit fidelity, showing that you can make gains by finding partitions that are good enough for your circuits.
Lev: I just want to say that the overhead from partitioning and compilation could be substantial, especially when you're dealing with those larger circuit widths, so we need to watch how much time the setup takes versus how much parallel execution wins.
Kai: So it seems like this is a solid path forward for extracting more from today's quantum processors by using the idle capacity in a structured way.
Mira: It’s definitely an interesting direction, showing how we can use classical simulation and hardware partitioning to tackle the limitations of current NISQ devices.
Lev: We’ll see how much better this gets as qubit counts grow and gate fidelities improve, because that's where the real scaling potential lies.
The paper's summary: Kai: So, to recap, this paper is about taking those many independent circuits we can’t run at once on current quantum hardware and mapping them onto separate physical regions of the processor so they can run in parallel.
Mira: Exactly. It’s not just about running things faster; it’s about using up all the empty space on the chip that otherwise sits idle during a single computation.
Kai: What’s interesting is that this method isn't just theoretical; they ran it on IBM's one hundred fifty six qubit machine with standard tests and then used GPU simulations to show even better scaling.
Mira: That’s the kicker, right? They found that for certain problems, like simulating an electron structure using a Hamiltonian, you can get a speedup of up to thirteen point eight times when you use sixteen GPUs.
Kai: So the paper suggests that if we have many similar circuits, we can actually make meaningful gains in billed time without needing better physical qubits right away.
Mira: But they also pointed out the catch—that to keep the accuracy high, you still have to be careful about which regions you pick for each circuit.
Kai: Right, because constraining those circuits to specific pieces of hardware might actually introduce problems with routing and crosstalk if those pieces aren't well connected.
Mira: That’s the tradeoff they highlight; you get utilization on one side and fidelity retention on the other, and it depends entirely on how good those partitions are.
Kai: It seems like this framework is applicable to a lot of things beyond just Hamiltonians, like variational algorithms or even just running randomized benchmarking protocols at fixed circuit sizes.
Mira: And that’s important because it means we can use this same idea to extract more useful computation from the resources we have today, while also seeing a path toward much greater parallelism as the hardware gets bigger and better.
Kai: The real question then is, how do we actually figure out which regions are good enough for our specific circuit structure?
Mira: And that leads us into how they find those partitions—how they use this error-aware algorithm to select the best spots based on connectivity and gate errors.
The paper's improvements: Tom: So, we're looking at how this research suggests we can make this parallel execution even better moving forward.
Kai: It seems like they aren't just stopping there with finding partitions; they’re pointing out a few ways to refine the process itself.
Mira: They suggest that the partition selection algorithm could get smarter about things like routing requirements and crosstalk more directly.
Kai: That makes sense because right now, it seems like the software is doing a lot of heavy lifting in figuring out where to put those circuits on the chip.
Mira: And they also propose allocating extra qubits around each partition so that the software has more flexibility when it’s deciding how to route everything.
Kai: That’s interesting because routing complexity is usually a huge bottleneck, and giving the transpirer more room to maneuver sounds like it could help with that overhead.
Mira: Plus, they talk about dynamically adjusting the separation between partitions based on measured crosstalk.
Kai: So if the hardware can tell us exactly where things are interfering with each other in real time, we could adjust the layout for better performance.
Mira: That would be a big shift because it moves away from just pre-calculating layouts based on static information to something much more adaptive during execution.
Kai: And they also touch on reducing the setup and compilation overhead that comes with setting up this parallel structure, suggesting we might precompute those partition layouts for specific hardware setups.
Mira: That’s smart because right now, figuring out the best layout takes about one to two seconds just for selection, which adds up if you’re running many circuits.
Kai: So what they're saying is that the next step involves making the partitioning and routing decisions much more interactive and adaptive with real-time hardware feedback.
Mira: And this opens up a whole new area of research focused on how to integrate those measurement signals back into the mapping process to get that better quality partition selection.
Conclusion: Kai: So, to wrap up, this paper "Parallel Circuit Execution for Scalable Quantum Computation" shows we can reduce billed time by three point five to five point five times on current hardware using error-aware partitioning.
Mira: Right, and it does that while keeping eighty three to ninety two percent of the original accuracy across those tested workloads.
Lev: From my side, it means this approach is viable for NISQ devices now because it leverages the idle qubit capacity we already have instead of just waiting for better hardware.
Kai: It really highlights how crucial it is to be smart about how you map those circuits onto the physical processor when you’re working with limited entanglement.
Mira: And what this means for the wider field is that this idea isn't just for one specific problem, but a general strategy for extracting more computation from any workload that generates many similar independent circuits.
Lev: The limitation we see is that the setup and compilation overhead for this parallel approach can be quite substantial, especially when dealing with larger circuit widths.
Kai: Exactly, so while the potential is there, we have to account for how much time it takes just to set up this parallel execution environment in the first place.
Mira: I think that means future work needs to focus on making those partition selection decisions even more intelligent and less reliant on slow, exhaustive searches.
Lev: I agree; we need better ways for the algorithm to account for routing and crosstalk in a way that doesn't kill fidelity when we scale up.
Kai: So, "Parallel Circuit Execution for Scalable Quantum Computation" gives us a concrete path forward using what's available today while showing exactly where the performance ceiling is right now.
Mira: It’s definitely a solid piece of work because it shows that even with current hardware constraints, we can still find significant efficiency gains through smarter resource allocation.
Avimita Chatterjee, W. Michael Brown, Siyuan Niu, Wibe Albert de Jong, Thomas Lubinski
Lawrence Berkeley National Laboratory · NVIDIA University of Central Florida Quantum Computing Data Cascade Quantum QED-C Technical Advisory Committee Standards
quant-ph
Submitted: 2026-09-10
Updated: 2026-11-08
Comments: 22 pages, 10 figures, 9 tables
Code: https://github.com/SRI-International/QC-App-Oriented-Benchmarks
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 91/100
The gist: Today’s quantum processors have tens to hundreds of physical qubits, but reliable execution of arbitrary circuits remains limited to fewer than 30 entangled qubits across hardware modalities…
Key concepts
- Error-aware Partition Mapping
- This is an algorithm that divides a large quantum chip into separate regions, or 'partitions,' where each region is chosen based on its error rate. The method prioritizes selecting regions with lower inherent noise and higher quality qubits first. This ensures that the most reliable circuits are mapped to the best available hardware areas.
- Circuit-Level Parallelism
- Instead of running one long sequence of operations, this involves executing several different, independent quantum circuits at the same time on different parts of the processor. This is useful when you have many similar tasks, like estimating a Hamiltonian. It allows the total execution time to be determined by the slowest circuit rather than adding up all their individual times.
- QPU Utilization
- Current quantum processors often have many idle qubits that cannot be reliably used in a single computation. This method solves this by mapping independent circuits onto these unused regions. By running multiple circuits concurrently, the system effectively utilizes the available physical resources much more efficiently than sequential execution alone.
- Fidelity Tradeoff
- When running circuits in parallel on hardware, there is a trade-off: maximizing speedup often means using less ideal qubit regions or increasing routing complexity. The paper shows that while parallelism reduces time, restricting circuits to smaller partitions can slightly decrease the final circuit accuracy by 83–92% compared to sequential runs.
Terminology
Summary
Today’s quantum processors have tens to hundreds of physical qubits, but reliable execution of arbitrary circuits remains limited to fewer than 30 entangled qubits across hardware modalities Building upon prior work, we introduce an error-aware method for mapping multiple independent circuits onto disjoint regions of a single large-scale QPU for parallel circuit execution For applications with many similarly sized circuits, such as observable estimation for Hamiltonian simulation, this approach can reduce billed QPU execution time, with ideal speedup proportional to the number of usable partitions We demonstrate the approach on IBM’s 156-qubit ibm boston processor using standard QED-C benchmark and Hamiltonian based observable-estimation workloads Compared with standard sequential execution, parallel execution reduces billed execution time by 3. p. 05–5.5× while retaining 83–92% of the sequential fidelity
Pruning redundant reasoning tokens
The core problem addressed is the gap between the number of qubits available on a device and the number that can be used reliably in a single computation Current superconducting processors offer 50 to 150 physical qubits [10], [11], but noise limits reliable circuit execution to roughly 10 to 15 entangled qubits [12], [13]; trapped-ion systems reach perhaps 30 [14], [15] Meanwhile, the majority of a processor’s qubits sit idle during any given circuit execution Here, we introduce a method that can utilize this idle capacity By running multiple independent circuits simultaneously, billed QPU execution time can be reduced, with the ideal reduction determined by the number of circuits and usable partitions The approach targets workloads containing many independent circuits of similar size
How the training signal is built
The methodology involves two primary execution modes: GPU-based simulators using CUDA-Q and quantum hardware accessed via Qiskit For GPU-based parallel execution, T MPI ranks are divided into G = T /P independent groups, where P is the number of GPUs assigned to each circuit The implementation uses MPI subcommunicators to create independent GPU groups for fine-grained control of finite-shot sampling In the hardware execution mode, independent circuits are mapped to disjoint regions of a single large QPU or multiple GPUs Partition finding uses a lightweight topology- and error-aware algorithm that selects nodes with the most connections to the existing cluster, favoring compact, well-connected regions over chains
Where the gains come from
The speedup achieved depends primarily on the number and cost of independent circuits available for concurrent execution For observable estimation, this is determined by the number of commuting Pauli groups The number of commuting groups can range from 2 for a simple lattice model to over 1,000 for a molecular electronic structure Hamiltonian The scaling efficiency depends on both circuit cost and the amount of available circuit-level parallelism For the H2 electronic-structure Hamiltonian, with 185–2,951 terms, it produces 54–1,251 groups over the evaluated qubit widths and provides sufficient independent circuits to utilize all 16 GPUs effectively
Fidelity and Utilization Tradeoff on Hardware
Parallel execution on hardware introduces a tradeoff between device utilization and circuit fidelity Our error-scored partition mapping mitigates this by selecting the highest-quality regions first, but additional partitions generally require the use of progressively lower-quality qubit regions Restricting circuits to individual partitions can also increase routing requirements, especially when the available connectivity within a partition is lower than that available to sequential execution This results in observed fidelity retention of 83–92% across evaluated workloads
Forward Applicability
The parallel execution approach applies more generally to workloads producing many similarly sized independent circuits Examples include variational algorithms such as VQE and QAOA, quantum machine learning ensembles, randomized benchmarking and tomography protocols, and parameter sweeps workflows at fixed circuit width The partition mapping algorithm requires a coupling map and calibration information for the underlying hardware The potential benefit of parallel execution should increase as quantum processors become larger and more reliable
Future Optimizations
Several improvements could increase the efficiency and fidelity of hardware parallel execution Partition selection could account more directly for routing requirements and measured crosstalk Allocating additional qubits around each partition could provide the transpiler with greater routing flexibility Dynamically adjusting the separation between partitions based on measured crosstalk could allow more effective use of the available hardware There are also opportunities to reduce the setup and compilation overhead associated with parallel execution Partition layouts for specific backends and circuit widths could be precomputed and reused, eliminating the 1–2 s partition-selection cost
Summary and Conclusions
Across standard QED-C and observable-estimation benchmarks, GPU results show that circuit-level speedup depends on the number and cost of independent circuits H2, with 1,251 independent measurement circuits, achieved a 13.8× speedup on 16 GPUs, representing 86% of the theoretical maximum Bose-Hubbard achieved an 8. p. 12× speedup with nine measurement groups TFIM, whose simple structure yields only two groups, was limited to 1. p. 39× On the 156-qubit IBM ibm boston processor, our error-aware partition mapping identifies disjoint qubit regions that allow multiple independent circuits to execute simultaneously Across the workloads evaluated, parallel execution produced approximately 2–3× reductions in billed QPU execution time while retaining 83–92% of the sequential-execution fidelity for circuits that could be executed reliably on the hardware The results also expose the principal cost of this approach: constraining circuits to disjoint regions can reduce fidelity through less favorable qubit selection and routing, while the current software path can introduce substantial compilation and orchestration overhead The GPU and hardware experiments reveal two sides of the same opportunity On current quantum hardware, the number and quality of usable partitions limit the parallelism that can be achieved The GPU results show the performance ceiling when those constraints are removed: with sufficient independent circuits and computational resources, circuit-level execution can approach the available parallel capacity As quantum processors grow toward 500–1,000 physical qubits and improvements in gate fidelity make reliable 40–50 qubit circuits possible, the same approach could potentially support 10–20 simultaneous circuit partitions Both execution modes have been integrated into the QEDC Application-Oriented Benchmark suite, allowing the same application workloads to execute sequentially or in parallel without changing their circuit-generation or analysis logic The approach is not limited to any specific application: standard benchmarks, observable estimation, variational algorithms, parameter sweeps, and other workloads generating independent circuits can exploit the same parallelism Parallel circuit execution therefore provides a way to extract more useful computation from the resources already available, while providing a path to substantially greater parallelism as quantum processors become larger and more capable The code availability is provided at https://github.com/SRI-International/QC-App-Oriented-Benchmarks Execution scripts, data collection tools, and visualization programs used to generate the results reported here are available at https://github. p. 3com/quantumcomputingdata/QC-App-Benchmarks-Data The acknowledgements thank David E. p. 6 Bernal Neira, Daan Camps, Sonika Johri, Efekan Kokcu, Debarshi Kundu, Neer Patel, and Anish Giri for valuable review and commentary that contributed to this manuscript AC was supported in part by the U.S. Department of Energy, Office of Science, National Quantum Information Science Research Centers, Quantum Systems Accelerator (Award No. p. 0 DE-SCL0000121), under Contract No. DE-AC02-05CH11231, and partly by the National Energy Research Scientific Computing Center (NERSC), a U. p. 0S. Department of Energy Office of Science User Facility (Project No. p. 2 m888) This research used resources of the National Energy Research Scientific Computing Center, a DOE Office of Science User Facility supported by the Office of Science of the U.S. Department of Energy under Contract No. DEAC02-05CH11231 using NERSC awards NERSC DDRERCAP0038362, NERSC DDR-ERCAP0034389 and NERSC DDR-ERCAP0038885 We acknowledge the use of IBM Quantum services for this work under NERSC DDR-ERCAP0038362 and NERSC DDR-ERCAP0038885 The views expressed in this manuscript are those of the authors and do not reflect the official policy or position of IBM or the IBM Quantum team
The paper details two execution modes on GPU simulators: Statevector Distribution (default mode) where all GPUs collaborate to simulate a single circuit, and Parallel Circuit Execution (--parallel mode) where independent circuits are distributed across available GPU resources The hybrid parallel execution mode (--gpus per circuit) combines statevector-level and circuit-level parallelism for increased qubit capacity and reduced sequential execution For GPU simulation, the speedup scales with the number of independent circuit groups (C) relative to the available groups (G), where G = T /P is the number of independent execution groups When C ≫ G, near-linear circuit-level scaling is possible
The performance ceiling on current hardware is limited by the number and quality of available partitions The partition finding algorithm prioritizes compact, well-connected subgraphs over chains because compact subgraphs have smaller diameter (reducing SWAP overhead during transpilation) and more internal edges provide the transpiler with greater routing flexibility Candidates are scored by three criteria in priority order: average 2-qubit gate error, diameter, and internal edge count The gap parameter controls the separation between partitions, with a default of 2 hops to enforce minimum distance between any two partitions' qubits
The results on quantum hardware show that parallel execution generally produces lower fidelity than sequential execution because partitioning constrains qubit placement and routing within each partition This degradation is more pronounced for deeper circuits with greater routing requirements The gap parameter provides additional control over the tradeoff between partition count and isolation For example, a gap of 2 reduces the number of available partitions while providing greater separation between simultaneously executing circuits
The ultimate speedup is determined by the relationship between the number of commuting measurement groups, C, and the number of available GPUs, G H2 contains substantially more measurement groups and therefore provides ample circuit-level parallelism, although the number of available partitions again decreases as circuit width increases The results show that efficient scaling requires having enough work within each circuit and enough independent circuits to keep the available GPUs fully occupied
The paper identifies two primary tradeoffs for partition-based observable estimation on current hardware Parallel execution can substantially reduce billed QPU time by making use of otherwise idle qubit regions, but the available parallelism decreases as circuit width increases Performance and accuracy therefore depend on both the number of available partitions and the quality and connectivity of the qubit regions used for execution The timing results show a clear distinction between QPU-resource efficiency and end-to-end runtime Billed time reduction is approximately 60–80% for most TFIM and QFT instances, with BV showing a similar reduction over most circuit widths
The paper demonstrates that efficient scaling requires having enough work within each circuit and enough independent circuits to keep the available GPUs fully occupied For circuits too large for a single GPU, circuit-level parallelism can also be combined with distributed statevector simulation In the 36-qubit Bose-Hubbard experiment, this reduced execution time from approximately 9.8 hours to 50 minutes using 192 GPUs On quantum hardware, parallelism is currently limited by the number of sufficiently large, low-error partitions available on the processor Larger devices with improved gate fidelity should support more usable partitions, allowing hardware execution to benefit from greater circuit-level parallelism The GPU results show the performance ceiling when those constraints are removed NVIDIA Santa Clara University of Central Florida Orlando Quantum Computing Data San Rafael Cascade Quantum San Rafael QED-C Technical Advisory Committee – Standards Arlington
Abstract—Today’s quantum processors have tens to hundreds of physical qubits, but reliable execution of arbitrary circuits remains limited to fewer than 30 entangled qubits across hardware modalities Building upon prior work, we introduce an error-aware method for mapping multiple independent circuits onto disjoint regions of a single large-scale QPU for parallel circuit execution For applications with many similarly sized circuits, such as observable estimation for Hamiltonian simulation, this approach can reduce billed QPU execution time, with ideal speedup proportional to the number of usable partitions We demonstrate the approach on IBM’s 156-qubit ibm boston processor using standard QED-C benchmark and Hamiltonian based observable-estimation workloads Compared with standard sequential execution, parallel execution reduces billed execution time by 3.5–5.5× while retaining 83–92% of the sequential fidelity We further evaluate the scaling of parallel circuit execution using GPU-accelerated classical simulation, distributing measurement circuits across GPUs via MPI Using CUDA-Q on the NERSC Perlmutter system, we achieve up to 13. p. 08× speedup on 16 GPUs (86% parallel efficiency) for an H2 electronic-structure simulation, with scaling evaluated across multiple Hamiltonians and circuit counts These results provide an indication of the performance ceiling that parallel execution on future quantum hardware may eventually approach Both execution modes are implemented as a runtime option within the QED-C Application-Oriented Benchmark suite Together, the results show that circuit-level parallelism can reduce execution cost on current quantum hardware and simulation time on GPU clusters, with the potential for greater benefits as device quality and qubit counts increase
--- Page 2 ---
I. INTRODUCTION
Quantum computing has made remarkable progress in a short time In barely a decade, the field has moved from 5-qubit laboratory demonstrations to processors with over 1,000 physical qubits, accompanied by steady improvements in gate fidelities, coherence times, and software tooling [1]–[5] Superconducting, trapped-ion, and photonic platforms have each demonstrated capabilities that were considered out of reach only a few years ago However, there is a gap between the number of qubits available on a device and the number that can be used reliably in a single computation Current superconducting processors offer 50 to 150 physical qubits [10], [11], but noise limits reliable circuit execution to roughly 10 to 15 entangled qubits [12], [13]; trapped-ion systems reach perhaps 30 [14], [15] Fault-tolerant logical qubits may close this gap through error correction, but remain years away and will themselves be limited in number when they first arrive Meanwhile, the majority of a processor’s qubits sit idle during any given circuit execution [21], [22] This is likely to persist through several hardware generations and represents a substantial inefficiency in how quantum resources are us…
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Erroraware partition mapping for quantum hardware allows circuits to be mapped onto disjoint qubit regions with low error rates, mitigating noise effects by selecting
partitions in higher-error regions of the device are ranked lower.
This enables execution on current hardware while retaining 83–92% of sequential fidelity. -
Circuit-level parallelism can reduce billed QPU execution time by 3.5–5.5× on IBM’s ibm boston processor, and this approach can be scaled up to achieve up to 13.8× speedup on NERSC Perlmutter systems for H2 electronic-structure simulations.
-
The system can execute many independent circuits simultaneously by distributing them across multiple GPUs via MPI or by mapping them onto disjoint qubit partitions, which allows the overall execution time to be determined by
the longest-running circuit rather than the sum of all circuit times.
-
For workloads with many independently executable measurement circuits, such as those from Hamiltonian simulation, the system can achieve speedups proportional to
the number of usable partitions,
effectively utilizing idle qubit capacity. -
The framework supports hybrid parallelism where multiple GPUs cooperate to simulate each circuit using statevector distribution while multiple circuits execute concurrently, combining
statevector-level and circuit-level parallelism.
Sources
- Quantum Computing : A New Frontier for Science and Society
- The vast world of quantum advantage
- Multi-GPU Quantum Circuit Simulation and the Impact of Network Performance
- Quantum Algorithm Exploration using Application-Oriented Performance Benchmarks
- A Comprehensive Cross-Model Framework for Benchmarking the Performance of Quantum Hamiltonian Simulations
- A Practical Framework for Assessing the Performance of Observable Estimation in Quantum Simulation
- Multi-GPU-Enabled Hybrid Quantum-Classical Workflow in Quantum-HPC Middleware: Applications in Quantum Simulations
- Atlas: Hierarchical Partitioning for Quantum Circuit Simulation on GPUs (Extended Version)
Related papers
- Computational regimes in matrix-product-state-based quantum trajectory simulations
- Toward chemically accurate quantum simulations on quantum hardware: A quantum-HPC hybrid approach
- Transversal surface-code game with reconfigurable qubits
- Fulqrum: a generalized framework for quantum subspace diagonalization
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements