Parallel Circuit Execution for Scalable Quantum Computation

summary

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…

In short

The paper introduces an error-aware method to map multiple independent quantum circuits onto disjoint regions of a large quantum processor for parallel execution. This technique utilizes idle qubits by running circuits simultaneously, significantly reducing billed QPU time—by 3.5–5.5× on IBM hardware—while maintaining high fidelity (83–92%). It shows that speedup scales with the number of usable partitions.

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 used across episodes

This episode discusses

The paper

Parallel Circuit Execution for Scalable Quantum Computation · Read on arXiv

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

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.

More episodes

← Home