Distributing Quantum Computations, Shot-Wise

Abstract

NISQ (Noisy Intermediate-Scale Quantum) era constraints, high sensitivity to noise and limited qubit count, impose significant barriers on the usability of QPUs (Quantum Process Units) capabilities. To overcome these challenges, researchers are exploring methods to maximize the utility of existing QPUs despite their limitations. Building upon the idea that the execution of a quantum circuit’s shots does not need to be treated as a singular monolithic unit, we propose a methodological framework, termed shot-wise, which enables the distribution of shots for a single circuit across multiple QPUs. Our framework features customizable policies to adapt to various scenarios. Additionally, it introduces a calibration method to pre-evaluate the accuracy and reliability of each QPU’s output before the actual distribution process and an incremental execution mechanism for dynamically managing the shot allocation and policy updates. Such an approach enables flexible and fine-grained management of the distribution process, taking into account various user-defined constraints and (contrasting) objectives. Demonstration results show that shot-wise distribution consistently and significantly improves the execution performance, with no significant drawbacks and additional qualitative advantages. Overall, the shot-wise methodology improves result stability and often outperforms single QPU runs, offering a robust and flexible approach to managing variability in quantum computing.

1. Introduction

Advancements in the design and development of Quantum Computers are rapidly accelerating, setting unprecedented milestones and records [1,2,3]. This fast progress brought a plethora of qubit implementations and QPU (Quantum Process Unit) architectures. Currently, no singular technology reigns supreme, fostering substantial diversity and innovation in quantum computing approaches [4,5,6].

However, despite this remarkable technological progress, the capabilities of Quantum Computers remain highly constrained. John Preskill introduced the term NISQ (Noise Intermediate-scale Quantum) devices [7] to highlight their vulnerability to external noise [8] and their limited qubit count, typically ranging from a few dozen to a few hundred [9]. These constraints severely limit the range of computations feasible within present Quantum Computers, predominantly confining them to tasks requiring only a handful of qubits and a limited number of consecutive operations to mitigate the deleterious effects of noise accumulation [10].

In response, computer scientists and quantum software engineers are actively engaged in addressing the challenge of maximizing the utility of available quantum devices despite their severe limitations [7,11,12,13]. Their efforts are dedicated to devising strategies that optimize quantum computations within current technological boundaries. To this end, researchers are designing increasingly sophisticated techniques for quantum error detection [14], mitigation [15], and correction [16]. Moreover, strategies for “cutting” quantum circuits that exceed the capacity of NISQ devices are currently under active investigation [17,18]. Other approaches involve the careful selection of the most appropriate quantum computer for each computation, taking into account performance metrics and limitations of the available options as well as the characteristics of each specific quantum circuit [19,20,21].

In this paper, we introduce an innovative approach to face the constraints of current NISQ devices and to improve the effectiveness of quantum computations. Our methodology diverges from conventional strategies by proposing a shift in perspective regarding the execution of quantum tasks. Traditionally, executing a quantum circuit typically consists of executing it iteratively numerous independent times, referred to as “shots”, due to the inherently probabilistic nature of quantum mechanics and qubits. Consequently, the output of a quantum computation usually does not consist of a single measured state from a single run. Instead, it includes a distribution reflecting the frequency of output states obtained after running the quantum circuit for multiple (usually thousands) shots (i.e., iterations).

In our approach, we propose a departure from viewing the execution of the shots of a quantum circuit as a single, indivisible unit that must be completed in a solitary run. Instead, we advocate for a more flexible and fine-grained perspective, offering various degrees of freedom in the process. Specifically, we suggest that even for a single circuit, its shots can be distributed, or “split”, across multiple heterogeneous Quantum Computers based on specific custom policies. Note that our proposed approach differs from shot-reduction optimization strategies such as the one in [22]. Indeed, our focus is on distributing a particular pre-determined number of shots on multiple, independent Quantum Computers. Still, as we will discuss in Section 3, our framework is also capable of reducing the total amount of shots performed. Subsequently, the results obtained from each Quantum Computer, representing the output distributions of the circuit execution for that particular QPU, are then merged together in a unified output distribution. In the remainder of this paper, we both discuss the general methodological framework and propose several strategies to split and merge the shots of a quantum circuit (e.g., by distributing the shots equally to each Quantum Computer, in a random way or proportionally to the estimated “reliability” of each QPU).

Through this approach, we aim to leverage the limitations of the NISQ era and turn them into advantages. In the demonstration section of this paper, we present findings on the execution of quantum circuits using multiple QPUs, focusing on the impact of split and merge strategies. The demonstrations encompass various circuit types and assess performance against established baselines obtained from single QPU runs. Key findings indicate that while split-merged strategies do not consistently exceed the best baseline performance, they maintain robustness and are generally aligned with average baseline outcomes. Notably, performance disparities arise across different circuits, suggesting that circuit-specific characteristics influence results. These insights lay the groundwork for exploring advanced strategies in quantum computing.

Furthermore, as discussed in our previous work [23] and further elaborated in [21], adopting a shot-wise management approach to quantum computation offers various qualitative advantages. These encompass enhanced fault resilience to QPU failures, finer-grained management, greater customizability to user requirements, and reduction in waiting times. With respect to our preliminary work [21,23], in this article, we define, formalize, and improve the shot-wise distribution methodology with a more general and holistic approach to the problem and perform numerical demonstrations to assess the methodology distributing the shots up to seven QPUs from two different manufacturers and two different qubit implementations. Moreover, we discuss and develop four distribution policies, two of them informed by the expected noise of each QPU.

Demonstration results show that by enabling the distribution of shots across multiple NISQ devices, our proposal makes it possible to reconcile multiple conflicting objectives (such as waiting time, price, and reliability of a quantum computation [21,23,24]). Moreover, distributing and merging the shots of a particular quantum circuit on various noisy QPUs produces final output distributions more reliable than performing the whole computation on a single QPU (as discussed in the demonstration section of this paper, Section 4). As a final advantage, the framework offers high flexibility in the policies and strategies to assess the capabilities of the available QPUs, how to distribute and merge the shots, and how to dynamically optimize such procedures and reduce the number of shots. To the best of our knowledge, ours is the first work proposing a framework that comprehensively enables all the above features and capabilities.

Summarizing, the main contributions of this paper are as follows:

(a)

We introduce a general and innovative framework for shot-wise distribution, enabling the execution of a single quantum circuit across multiple heterogeneous NISQ devices. The framework incorporates a reliability estimation mechanism and supports adaptive shot allocation, making it robust to device variability and noise.

(b)

We define and formalize a set of flexible split and merge policies. These policies determine how shots are distributed among QPUs and how partial results are combined, with strategies that account for QPU-specific reliability and statistical trade-offs between bias and variance.

(c)

We provide a comprehensive empirical evaluation of the framework on multiple circuits, quantum providers, and hardware technologies. Our results demonstrate that shot-wise distribution consistently improves worst-case stability, reduces variability, and delivers performance competitive with or superior to single-QPU execution.

This paper addresses the motivation and discussion surrounding the shot-wise distribution of quantum computations across heterogeneous Quantum Computers. We present a comprehensive methodology framework to implement such a distribution strategy, parameterized by a set of customizable policies. We provide an overview of related work (Section 2), and illustrate the various degrees of freedom and the underlying criteria guiding each possible decision (Section 3.2). Subsequently, we discuss various potential split and merge policies (Section 3.3). We then detail the demonstration protocol devised to evaluate and validate the shot-wise approach, and we analyze the results obtained from these demonstrations (Section 4). Finally, we draw some conclusions, also mentioning potential directions for future research (Section 5).

2. Related Work

Ever since Preskill highlighted the challenges of contemporary Quantum Computers [7], researchers have designed and developed strategies to tackle or mitigate these constraints [25]. Within the scope of this paper—generalizable as “approaches to perform quantum computations on NISQ devices”—we identify, to the best of our knowledge, three primary categories:

• Fighting the Noise: this category encompasses methodologies and techniques aimed at mitigating, or ideally eliminating, the noise inherent in quantum computations. Within this realm, we discern two principal strategies:

  –

  Quantum Strategies: these approaches aim to combat noise during quantum computations by operating on the structure of the circuit to be executed.

  –

  Classical Strategies: these methods target noise before and/or after executing a quantum algorithm through pre- and post-classical processing of quantum algorithms and output distributions.

• Going beyond the Intermediate scale: here, we find methodologies seeking to execute quantum circuits larger than those achievable with NISQ devices.
• Distributing Quantum Computations: this category encompasses methodologies that address the limitations of quantum computations as a whole while considering the presence of multiple heterogeneous QPUs. The objective is to optimize the execution of quantum circuits across a distributed computing environment.

While our work predominantly aligns with the latter group, it introduces, to the best of our knowledge, a novel idea: distributing even the same quantum circuit among multiple QPUs, exploiting the necessity to run multiple shots. The subsequent sections illustrate each of these categories in depth, presenting key related works associated with each domain.

2.1. Fighting the Noise

The history of error correction techniques and, more broadly, strategies for combating the noise inherent in Quantum Computing is nearly as old as Quantum Computing itself.

In the early days of Quantum Computing, the excitement surrounding the field was tempered by the challenge of qubit noise. Shor, renowned for demonstrating the potential of Quantum Computing [26,27], injected new vitality into the field with his proposal of an initial error correction technique. This technique suggested that if the noise remained below a certain threshold, it would be possible to apply the solution and execute quantum computation as if it were devoid of noise [28].

As Quantum Computing progressed, error correction techniques evolved to become more sophisticated [16,29,30]. However, these techniques typically demand a significantly higher number of qubits than are currently available to be effective. Consequently, while researchers continue to refine error correction techniques to be more resource-efficient, efforts have also emerged to mitigate noise while awaiting full error correction [15,31,32,33,34,35].

Another compelling research direction involves the development of noise-aware compilers. These compilers are designed to compile and optimize circuits for a given QPU while considering its topology, performance, and noise characteristics, among the others. They determine crucial factors such as the initial mapping of virtual qubits onto physical qubits and the optimal set of swap operations, particularly in non-all-to-all topologies. Such classical techniques have the potential to mitigate noise and enhance the performance of quantum circuits [36,37,38,39,40].

Error correction and error mitigation techniques, as well as compilation and optimization processes, are all approaches working before and/or after the actual circuit execution. For that reason, they are completely transparent to our shot-wise methodology. Therefore, they are entirely compatible with our shot-by-shot methodology and can be applied in conjunction. Furthermore, our demonstrations provide initial evidence that distributing circuit shots among multiple heterogeneous QPUs can reduce noise compared to executing all shots on a single QPU. Thus, we intend to explore the possibility of employing shot-wise methodologies as error mitigation techniques and compare them with state-of-the-art approaches, potentially integrating them with already existing ones to further enhance noise reduction strategies.

2.2. Going Beyond the Intermediate Scale

Achieving the capability to execute quantum circuits beyond the current hardware constraints, typically limited to a few hundred qubits at most, is essential for unlocking the full potential of quantum computing. While much attention is directed towards scaling the size of current quantum hardware, an alternative approach to circumventing this limitation involves breaking down larger circuits into smaller pieces. These fragments are then executed independently on NISQ devices, with the resulting computations merged to reconstruct the final output.

These techniques are recognized under various names, including circuit cutting, circuit knitting, and Quantum divide and conquer, or Quantum divide and compute, among others. This strategy offers a promising avenue for harnessing the computational power of existing smaller-scale quantum hardware to tackle larger quantum algorithms.

A seminal contribution is presented in [17], where the authors discuss the theoretical foundations and conduct demonstrations on circuit cutting through tensor-network techniques. This work is further expanded upon by [41,42], where the authors test the approach in the presence of noise and observe that recombining noisy fragments can outperform results without fragmentation. They also investigate the impact of different noise sources on the success of the cutting process.

Another seminal work in this field is illustrated in [18], where the authors introduce CutQC, a scalable circuit cutting approach. They propose a method to execute quantum circuits more than twice the size of available quantum computer backends. Moreover, their approach demonstrates significant improvements in fidelity compared to direct executions on large Quantum Computers, along with elevated speedup over classical simulations. They utilize a mixed-integer programming approach to automate the identification of cuts requiring minimal classical postprocessing. Additionally, they discuss two types of postprocessing: full-definition (FD) query and dynamic-definition (DD) query, differing in whether the entire $2^n$ full-state probability output of the uncut circuit is reconstructed.

In a different approach, Ref. [43] introduces maximum-likelihood fragment tomography to find the most likely probability distribution for the output of a quantum circuit based on measurement data obtained from circuit fragments. The core of their idea is to perform the circuit fragments by providing a variety of quantum inputs to and measuring its quantum outputs in a variety of bases. Supported by both theoretical and demonstration findings, they advocate for the use of circuit cutting as a standard tool for running clustered circuits on quantum hardware. Indeed, they found that circuit cutting can estimate the output of a clustered circuit with higher fidelity than full circuit execution.

A recent contribution is presented in [44], where the approach is based on randomized measurements, by randomly inserting measure-and-prepare channels, to express the output state of a large circuit as a separable state across distinct devices. With this approach, they apply circuit cutting to large-scale QAOA problems on clustered graphs, i.e., up to 129-qubit problems, demonstrating the potential of circuit cutting procedures in practical applications.

In contrast to the aforementioned methodologies, our shot-wise approach presents a significantly different perspective and can be viewed as orthogonal. While circuit cutting focuses on the circuit dimension, our focus lies in the shot dimension. Our strategy is agnostic to whether the shots to be distributed originate from a whole circuit or fragments. Moreover, considering that executing smaller fragments may yield better results than performing the whole circuit, we believe that combining the power of fragment cutting with the idea of executing shots from each fragment on multiple heterogeneous QPUs can further enhance performance. We intend to explore this combination in future work. An initial step in this direction is presented in [45], where the authors combine circuit cutting and parallel scheduling algorithms for quantum multicomputing. However, such work still treats shots as a single monolithic entity, unlike our approach.

2.3. Distributing Quantum Computations

Numerous research efforts are dedicated to identifying the most suitable Quantum Processing Unit (QPU) for executing a particular quantum circuit. These approaches typically define various metrics encompassing not only the inherent characteristics of a specific Quantum Computer (e.g., qubit count, coupling map, noise model) and the quantum circuit itself (e.g., gate count, width, depth) but also environmental factors such as queue waiting time, pricing plans, and availability periods.

One notable approach following this principle is the Quantum API Gateway [19]. In this work, the authors devised a service that automatically selects the optimal QPU among available options for each submitted quantum circuit. The selection process takes into account factors such as QPU architecture (gate-based or annealing) and circuit width. Users have the flexibility to customize the selection criteria, specifying preferences for speed or cost efficiency.

Similarly, the NISQ Analyzer [20] employs a comparable workflow to determine the best QPU for a given quantum circuit. However, unlike the Quantum API Gateway, this approach acknowledges that multiple circuit implementations may exist for a single quantum program. The NISQ Analyzer automatically selects the best implementation from a repository of quantum programs and associated circuit implementations through a set of selection rules associated with each circuit implementation, depending on the input data. The best QPU-circuit pair is then determined based on criteria such as circuit width, depth, and the choice of Software Development Kit (SDK).

The NISQ Analyzer authors have also developed several extensions, including tools for comparing compiler outputs [46], optimizing compilation processes using Machine Learning (ML) models to discard potential compilers and Quantum Computers before compilation [47], ranking compiled circuits for various QPUs using Multi-Criteria Decision Analysis methods [48], and optimizing these processes through ML techniques [49].

In contrast to these approaches, Ref. [50] introduces a quantum job scheduler that optimizes QPU selection by balancing estimated fidelity and expected waiting time. Conversely, Ref. [51] addresses the integration of Quantum Computing into classical enterprise cloud systems, selecting the most suitable single QPU based on factors like qubit count and queue length. Additionally, Ref. [52] presents a framework for automatically predicting the optimal combination of Quantum Computers, compilers, and compiler options for a given circuit, with a focus on maximizing fidelity in gate and measurement operations.

While existing approaches aim to identify the best QPU for a given quantum circuit, our proposal diverges from this paradigm by leveraging multiple heterogeneous Quantum Computers simultaneously. We evenly distribute the shots of a single quantum circuit among multiple heterogeneous QPUs. To the best of our knowledge, ours is the first proposal employing a shot-wise distribution approach. Building upon the principles of shot-wise distribution, we have developed a prototype Quantum Service called the Quantum Broker [23], which distributes quantum computations shot-by-shot while considering user runtime requirements submitted through a Domain-Specific Language (DSL). This paper advances and formalizes the concepts introduced in the Quantum Broker prototype into a unified conceptual and parametric framework. Furthermore, demonstration evaluation validates the efficacy of the proposed ideas.

3. General Framework

In this section, we introduce some definitions and fix the notation used in the following discussions. An overview of the main concepts is provided in standard book references such as [53].

3.1. Preliminaries

Let us consider a circuit $U\in SU\left(2^q\right)$ (for which we extensively use the equivalence between ideal circuits and unitary operators) acting on q qubits initialized as $|0\rangle$. In the ideal noiseless case, the output of a single execution is a pure state $|\psi \rangle =U|0\rangle$. A measurement in the computational basis ${\left\{|x\rangle \right\}}_{x\in {\mathbb{Z}}_{2^q}}$, will yield a specific bitstring x with probability $p_x^{\left(\mathrm{ideal}\right)}={|\langle x|U|0\rangle |}^2$. Any other initialization and change in basis for the measurement can be incorporated into the circuits without loss of generality. Moreover, in the presence of quantum noise, the final state can be represented as a density matrix $\rho$, obtained from the application of a noisy quantum channel $\mathcal{E}$ to the initial standard pure state ${\rho }_0=|0\rangle \langle 0|$ as $\rho =\mathcal{E}\left({\rho }_0\right)$. Therefore, the probability of measuring the bitstring x in the computational basis from a single execution is distributed according to a discrete probability $p_x=\mathrm{T}\mathrm{r}\left[\right|x\rangle \langle x\left|\rho \right]$, where $\rho ={\mathcal{E}}_U\left(\right|0\rangle \langle 0\left|\right)$ depends on the quantum channel ${\mathcal{E}}_U$, which only approximates the effect of the ideally unitary circuit that implements U. In the ideal case of a unitary channel, one would have ${\mathcal{E}}_U\left({\rho }_0\right)=U{\rho }_0{U}^{†}$, while in general, one has ${\mathcal{E}}_U\left({\rho }_0\right)={\sum }_{\alpha }{K}_{\alpha }{\rho }_0{K}_{\alpha }^{†}$ in the Kraus representation [53]. Therefore, for any fixed circuit U and QPU m, we expect the biases $p_x-p_x^{\left(\mathrm{ideal}\right)}$ to be in general non-vanishing, signaling a discrepancy in the results, even in the limit of unlimited resources, unless an error correction or mitigation scheme is applied. Repeating the demonstration a number n of times, commonly known as shots, the number of times a specific state labeled x is measured is called counts and denoted by ${\widehat{c}}_x$, and it follows a multinomial distribution based on $p_x$, i.e.,

$$\begin{array}{c}\hfill P\left({\widehat{c}}_x=c_x\forall x=0,\dots ,2^q-1;\sum _x{c}_x=n\right)\equiv n!\prod _{x\in {\mathbb{Z}}_{2^q}}{\displaystyle \frac{{\left(p_x\right)}^{c_x}}{c_x!}}.\end{array}$$

(1)

From the relative counts, it is possible to estimate the underlying probability distribution as ${\widehat{p}}_x\equiv {\displaystyle \frac{{\widehat{c}}_x}{n}}$, which is unbiased ($\mathbb{E}\left[{\widehat{p}}_x\right]=p_x$) and fluctuates with a statistical error, estimated as $\Delta p_x=\sqrt{{\displaystyle \frac{1}{(n-1)}}{\widehat{p}}_x(1-{\widehat{p}}_x)}$.

We define a q-Quantum Processing Unit (q-QPU) as a hardware capable of running a generic quantum circuit with q qubits. Notice that, with this definition, different connected subtopologies of $q<K$ qubits on the same K-QPU are treated as different q-QPUs. This allows to include the possibility of considering disconnected subtopologies of the same QPU (which might make sense only if the crosstalk between the subtopologies involved is negligible).

We define a policy as a set of criteria determining the specific decisions taken at different steps of the heterogeneous quantum computation. This can involve, for example, limitations and prior knowledge about a QPU, different kinds of budget constraints, time constraints, optimization methods, and whatever the arbitrary choices of the user are. In the following discussions, we denote any policy by the symbol $\mathcal{P}$. In the next section, we propose a framework of heterogeneous quantum computation where the set of policies acts as a controller. Different possible policy choices are discussed thoroughly in Section 3.3.

3.2. General Strategy for Heterogeneous Quantum Computation

In this work, the general aim of an optimal heterogeneous computation involves allocating computational resources (split), gathering and merging results (merge), and updating the information on the performance with optimality criteria, according to the policies chosen by the user. Note that the choice of the split strategy and the merge policy are completely independent. However, for a starting set of QPUs, prior information on the performance and accuracy of each QPU are not always available or comparable to each other. This lack of information makes the merge inaccurate in some cases, for example, when the results of the majority of QPUS cluster around some point in probability space, while the most accurate QPUs lie far from the majority and would be treated as outliers.

This situation can be overcome by a Calibration and Ranking stage, which would then guide further updates during the Production (i.e., execution) stages. Anyway, whenever available and comparable, one can also rely directly on external calibration data from quantum providers for specific quantum devices. Otherwise, we propose a calibration scheme tailored to the specific device subtopologies and the class of circuits one aims to execute in production, provided it is possible to compute ideal probability distributions to be used as benchmarks against which one can compare noisy results from real QPUs. Of course, this computation is possible on classical computers through emulation only for a limited number of qubits, indeed, although effective for the scope of this study, this procedure is not directly scalable to circuits with larger qubit counts, since classical computation of the ideal distributions quickly becomes intractable. While this ensures accuracy in the NISQ setting, we plan in future work to design strategies to scale beyond this limitation, for instance by using approximate benchmarks, surrogate models, or adaptive calibration techniques. Note that the calibration procedure proposed shares similarities with error mitigation techniques, as it aims to reduce noise-induced biases. However, unlike error mitigation, our method does not attempt to correct noise directly but to inform distribution decisions. The calibration stage is instrumental for a ranking of the QPUs considered since it allows to associate an unreliability index to each QPU. After these stages, which can be performed with a fraction of the full budget expected for the full run, one can proceed with the production stages, which involve an iterative scheduling of split-merge-update steps, where the basic execution task involves measurements on some target circuits but without any ideal benchmark. The split part on the very first iteration is determined by the calibration and ranking stages, if available, while the merge part depends on all the previous stages, as well as on the results of the last execution. Finally, the unreliable information can be updated at the end of each production stage based on the data accumulated at each iteration. One might also consider embedding the production stage into a pipeline where QPU executions happen asynchronously. In this case, one can continuously update the information, merging data according to the available partial information and proceeding with the next steps. Furthermore, a stopping policy can be considered, which allows an earlier termination of the run in case a stopping criterion is reached.

We remark that in our approach, shot-wise distribution does not involve physically splitting or copying quantum states. Instead, the same quantum circuit is instantiated independently on each QPU, all starting from the standard initial state |0⟩ (or parametrized variants). Therefore, the framework operates at the level of execution replication rather than state duplication, fully consistent with the no-cloning theorem. This also clarifies that the method is not designed for scenarios where the input is the live quantum output of another circuit without classical re-description.

Having outlined the general strategy of heterogeneous computation we propose, here it follows a scheme for a given set $\mathcal{M}$ of $M\equiv \left|\mathcal{M}\right|$q-QPUs, while in Figure 1 we display a diagrammatic depiction of the processes involved.

Calibration and Ranking stages:

(C.1)

${\mathcal{P}}_{\mathrm{prior}-\mathrm{split}}^{\left(\mathrm{calib}\right)}$—initial split: choose an initial shot allocation ${\overrightarrow{n}}^{\left(0\right)}\equiv {\left(n_m\right)}_{m\in \mathcal{M}}$ (for example, fixing the total number of shots $n_{\mathrm{tot}}^{\left(0\right)}={\sum }_m{n}_m^{\left(0\right)}$ and using a uniform allocation $n_m^{\left(0\right)}=n_{\mathrm{tot}}^{\left(0\right)}/M$);

(C.2)

${\mathcal{P}}_{\mathrm{bench}}^{\left(\mathrm{calib}\right)}$—benchmark: choose a “training set” of circuits $\mathcal{C}$, represented ideally by a class of unitary operators ${\left\{U_c\right\}}_{c\in \mathcal{C}}$ acting on q qubits, and compute the ideal probability distribution of measurements in the computational basis, denoted as $p_x^{(\mathrm{ideal},c)}\equiv {\left|x{U}_{c}0\right|}^2$. These will be used as benchmark distributions;

(C.3)

Calibration executions: execute each circuit $U_c$ on each QPU $m\in \mathcal{M}$ (starting conventionally from the pure state $|0\rangle$) with the selected number of shots $n_m^{\left(0\right)}$, obtaining the counts ${\widehat{c}}_{x,c}^{\left(m\right)}$, distributed according to Equation (1) with a generating probability given by the specific noisy (and unknown) realization $p_x^{(m;c)}$;

(R)

${\mathcal{P}}_{\mathrm{rel}}^{\left(\mathrm{calib}\right)}$—unreliability: using the results from the previous step and comparing them with the benchmark distributions, assign an unrealiability coefficient $u_m$ to each QPU m and compute the optimal split policy for the next stage in the form of a proposal for shot split weight $w_m^{\left(1\right)}$;

Production stage (starts with $\mathit{i}=1$, target circuit U):

(P.0)

${\mathcal{P}}_{\mathrm{init}}^{\left(\mathrm{prod}\right)}$—calibrated prior split weights: using the results from the calibration step (C.3), and comparing them with the benchmark distributions, compute the optimal split policy for the next stage in the form of a proposal for shot split weight $w_m^{\left(1\right)}$;

(P.1-i)

${\mathcal{P}}_{\mathrm{split}}^{\left(\mathrm{prod}\right)}$—production split: implements i-th iteration of the production schedule, computing the number of shots to run in this iteration (for example, simply dividing the total number of shots by the maximum number of iterations) and an optimal split according to prior information;

(P.2-i)

Production executions: execute the circuit U on each QPU m, using a given number of shots of the current interaction and the split policy, by allocating shots according to the split weights $w_m^{\left(\mathit{i}\right)}$ computed in the previous iteration of the production stage (P.4-(i-1)), or in the first step of the production stage (P.0) if this was the first iteration (i.e., $\mathit{i}=1$);

(P.3-i)

${\mathcal{P}}_{\mathrm{merge}}^{\left(\mathrm{prod}\right)}$—merge results: perform the merge policy of the partial distributions estimated by the execution after split. This might also include some error-mitigation strategy per-QPU and per-circuit;

(P.4-i)

${\mathcal{P}}_{\mathrm{update}}^{\left(\mathrm{prod}\right)}$—update optimal split: improve the prior split weights for the next step by analyzing the relative performance of different QPUs by accumulating statistics from all previous runs of U and proposing a new split weight $w_m^{(\mathit{i}+1)}$ and the number of shots to perform in the next iteration;

(P.5-i)

${\mathcal{P}}_{\mathrm{stop}}^{\left(\mathrm{prod}\right)}$—check stopping criterion: if the conditions for the chosen stopping policy are not met, proceed with point (P.2-(i+1)), otherwise terminate.

In the next section, we mention some of different possible choices for the policies to be used in the calibration and production stages.

3.3. Policies

3.3.1. Calibration—Initial Split

Deviations from a uniform initial split at calibration can be motivated by various factors: the economic cost per shot for each QPU, different queue and execution times, and some information about the accuracy of each QPU for the task in question. In general, this policy should reflect all the preferences of the user regarding all or some of these aspects (and possibly others), so that the actual split used can be optimized by considering both information about the QPUs and the specific user needs.

3.3.2. Calibration—Benchmarks

Depending on the task considered in production, it might be possible to identify a class of circuits that can be used as a “training” set for the calibration stage, so that one can provide more tailored information for the production stage. Even if the tasks considered are generic, it could be useful, for example, to test the QPUs on a set of random circuits. This gives just a crude estimate of the general performance of the QPU but, as we show in Section 4, the performance at calibration on a fixed set of random circuits does not necessarily reflect the performance observed on specific tasks. Notice also that the results of the executions for each of these benchmarking circuits should be compared with exact results, which means that this step is accessible only for circuits involving a relatively small number of qubits, so that one can perform an exact emulator as a benchmark, or at least with an output distribution that is simple enough to be easily computable.

3.3.3. Calibration—Executions

The benchmark circuits are executed on each QPU with the selected number of shots. Some preprocessing and postprocessing might be involved at this step. For example, the circuit might be decomposed into different primitive gates for each QPU, or one could apply different mitigation strategies (provided this enters the shot budget or other resource criteria). Since the calibration stage is preparatory to the actual production stage, the same techniques are expected to be applied also later during the production stage executions.

3.3.4. Ranking—Unreliability

As a result of the calibration, we want to assign a “goodness” value to each QPU considered, so that the production stage can be guided by it. The specific metric can also depend on different factors, but it should reflect the discrepancy between the results of the QPUs on the set of benchmarking circuits and the exact output distributions. A distance between probability distributions (or density matrices) is, therefore, an essential component of this policy. For example, in Section 4.1, we adopt as the “unreliability” factor the Hellinger distance between the results of QPU executions and the exact one, averaged among all the benchmarking circuits.

3.3.5. Production—Prior Split Weights

For this policy, the same aspects mentioned in Section 3.3.1 can be considered. Furthermore, the results of the calibration stage, if available, can be integrated into the analysis as expected prior accuracy provided by each QPU. We reason here in terms of prior split “weights” because the specific shot allocation might change depending on more information from the production schedule.

3.3.6. Production—Split Strategies

In the single iteration version of the production stage, this step is a trivial application of the prior split weights step mentioned above, applied to the total number of shots. In the case where more iterations of the production stage loop are needed, different shot allocations might be involved based on an update of the prior collective information, depending on former results, and a different number of shots can be considered at each iteration. Apart from schedule-dependent choices, one can test different policies that use the prior information in different ways. In this work, we investigate three specific cases of splitting strategy:

• uniform: the total number of shots for that iteration are allocated uniformly among all the QPUs;
• Hellinger: the shots are allocated depending on the split weights computed using the Hellinger distance (discussed in Section 3.4) between the count distributions and either the exact one, if provided at calibration, or the best expected one estimated from previous observations during the production stage;
• MISE: in this approach, referred to Mean Integrated Square Error (see Section 3.4.2), the shots are allocated in such a way as to minimize not only the relative discrepancy from the exact distribution at calibration (or the best expected one from previous iterations of the production stage), taking into account also the expected statistical error coming from a finite number of shots per QPU.

3.3.7. Production—Executions

The same considerations conducted during calibration executions apply here.

3.3.8. Production—Merge Strategies

In this step, after gathering all counts obtained from the executions on each QPU, one has to merge the results. As for the split strategies discussed above, one can take into consideration different factors involved, but many, such as shot cost or queue time, should not play a role, since the data is already assumed to be fully available after the executions (or, in the case of a pipelined production stage, of the partial information available). The main goal of this step is therefore to maximize the accuracy of the final result with the given information on the executions. In analogy with the split strategies, in this work, we investigate three specific cases:

• uniform: the distributions estimated from each QPU are simply merged (summing all counts for each outcome);
• Hellinger: the target distribution is chosen as the one that minimizes the total squared Hellinger distance (discussed in Section 3.4.1) weighted according to unreliabilities and other supplementary information;
• MISE: in this case, the target distribution is chosen as the optimal convex sum of all the QPU distributions, where optimality is determined as the minimum of the mean integrated square error (MISE), which takes into account both bias and variance of the data, as described in Section 3.4.2.

3.3.9. Production—Update Split

This step is required in the case of a schedule with more than a single iteration since it involves the updating of both the number of shots to split and the prior split weights, which would be used as improved collective information at the beginning of the next iteration of the production loop.

3.3.10. Production—Stopping Criterion

In the cases when one decides to perform more than once the steps in the production stage, different choices of the stopping criterion might be preferred. For example, a straightforward stopping policy might just be the depletion of the total shot, or any other kind of budget cap expected, or the reach of some accuracy and/or precision requirement on the final result (which might result in a lower total budget expense and faster global execution).

3.4. Distance Between Discrete Probability Distributions

For the following discussions, it is useful to introduce a metric of comparison in the form of a distance between probability distributions, which are considered here as the main output of the execution of a quantum circuit, as measurements in the computational basis. In a general quantum setting, one is interested in the distance between density matrices. Nevertheless, for a wide class of quantum algorithms (e.g., Grover searches, some measurements in real-time evolution), the output of a quantum circuit is a collection of measurements on a fixed basis, while a change in basis can usually be incorporated into the circuit, after which measurements in the computational basis follow. Even if multiple changes of basis are needed (for example, for a typical VQE algorithm), one can consider each version as a distinct circuit, to which the whole analysis can be independently applied. Therefore, it is possible to define as a single task a collection of measurements on a fixed circuit in the computational basis, so that a probability distribution of outcomes can be inferred from the relative counts, while more complex algorithms involve more than one of these simple tasks in general.

We consider the Hellinger distance [54] between two discrete distributions $p_x$, $q_x$, defined as

$$\begin{array}{c}\hfill d_H(p,q)\equiv \sqrt{{\displaystyle \frac{1}{2}}\sum _x{(\sqrt{p_x}-\sqrt{q_x})}^2}=\sqrt{1-\sum _x\sqrt{p_x{q}_x}}=\sqrt{1-cos\Delta (p,q)},\end{array}$$

(2)

where in the rightmost term, we introduced the so-called Bhattacharyya angle [55], defined as the angle $\Delta (p,q)=arccos{\sum }_x\sqrt{p_x{q}_x}$ between the vectors $\left(\sqrt{p_x}\right)$ and $\left(\sqrt{q_x}\right)$, both with Euclidean ($l^2$) norm 1 and with positive components. In our case, we do not have direct access to the probability distributions $p_x^{\left(m\right)}$ for each QPU m; only the information about the counts $c_x^{\left(m\right)}$, obtained using a finite number of shots $n^{\left(m\right)}$, is available. Due to the non-linearity of the definition of the Hellinger distance in Equation (2), replacing the best estimate ${\widehat{p}}_x^{\left(m\right)}={\displaystyle \frac{{\widehat{c}}_x^{\left(m\right)}}{n^{\left(m\right)}}}$ typically yields a biased estimate, namely (by Jensen inequality, $\mathbb{E}\left[f\left(\widehat{X}\right)\right]\ge f\left(\mathbb{E}\left[\widehat{X}\right]\right)$ for a convex function f of a random variable $\widehat{X}$; the opposite inequality is true for a concave function such as $x\mapsto \sqrt{x}$. Therefore, $\mathbb{E}\left[{d_H(\widehat{p},q)}^2\right]=1-{\sum }_x\mathbb{E}\left[\sqrt{{\widehat{p}}_x}\right]\sqrt{q_x}\ge 1-{\sum }_x\sqrt{p_x}\sqrt{q_x}={d_H(p,q)}^2$.), $\mathbb{E}\left[d_H^2(\widehat{p},\widehat{q})\right]\ge \mathbb{E}\left[d_H^2(\widehat{p},q)\right]\ge d_H^2(p,q)$. Due to this bias, to properly estimate these distances, one has to apply a statistical technique of bias removal as outlined in Appendix B.

3.4.1. Weighted Average Square Hellinger Distance

Using the distance metric discussed in the previous section, we can estimate the difference between the relative counts for the dataset ${\mathcal{D}}^{\left(m\right)}$ and the ideal target distribution $p_x^{\left(\mathrm{ideal}\right)}$ known at the calibration stage, where the bias and associated errors are estimated with the techniques discussed in Appendix B. These distances can then be used as the unreliability parameter to be associated with each QPU. A pre-ranking of the QPUs can be determined by reordering them from the lowest unreliability to the highest. We consider an optimal probability distribution ${\overline{p}}_x$ as the one that minimizes the weighted average square distance with respect to the distributions estimated from the QPU results, namely

$$\begin{array}{c}\hfill D^2(\overline{p};p^{\left(m\right)},w^{\left(m\right)})=\sum _{m=0}^{M-1}{w}^{\left(m\right)}{d}^2(\overline{p},p^{\left(m\right)}),\end{array}$$

(3)

where $w^{\left(m\right)}$ are the reliability weights associated with each QPU. In the cases where d corresponds to the Hellinger distance, the probability distribution ${\overline{p}}^{*}$ which minimizes $D^2$ is described in Appendix A.1.

3.4.2. Mean Integrated Square Error

Let us consider a single-circuit benchmark with ideal distribution $p_x^{\left(\mathrm{ideal}\right)}$, and collection of M QPUs, with distribution $p_x^{\left(m\right)}$, sampled with a certain number of shots $n_m$, depending on the split policy and compactly denoted by the “split-shot” vector $\overrightarrow{n}=\left(n_m\right)$. Any convex merge policy is defined by a weight vector $\overrightarrow{w}={\left(w_m\right)}_{m=0}^{M-1}$ and a weighted distribution estimator as follows:

$$\begin{array}{c}\hfill {\widehat{p}}_x^{(\overrightarrow{w};\overrightarrow{n})}\equiv \sum _{m=0}^{M-1}{w}_m{\widehat{p}}_x^{(m;n_m)},\mathrm{where}{\widehat{p}}_x^{(m;n_m)}\equiv {\displaystyle \frac{1}{n_m}}\sum _{y\in {\mathcal{D}}^{\left(m\right)}}{\delta }_{x,y}.\end{array}$$

(4)

The variables in Equation (4) are unbiased estimators of $p_x^{\left(\overrightarrow{w}\right)}\equiv {\sum }_{m=0}^{M-1}{w}_m{p}_x^{\left(m\right)}$, which we want to make as close as possible to $p_x^{\left(ideal\right)}$ by optimizing the weight parameters $\overrightarrow{w}$. Since each QPU contributes in general with a different number of shots, a dataset realization $\mathcal{D}$ can be formally decomposed into independent sub-datasets $\mathcal{D}={\cup }_{m=0}^{M-1}{\mathcal{D}}^{\left(m\right)}$ such that $|{\mathcal{D}}^{\left(m\right)}|=n_m$ with ${\mathcal{D}}^{\left(m\right)}$ sampled according to a multinomial distribution with $p_x^{\left(m\right)}$ as probability for each extraction x. In the following discussion, we consider the Mean Integrated Square Error, defined as

$$\begin{array}{c}\hfill \mathrm{MISE}(\overrightarrow{w};\overrightarrow{n})\equiv {\mathbb{E}}_{\mathcal{D}={\cup }_m{\mathcal{D}}^{\left(m\right)}}\left[\sum _x{({\widehat{p}}_x^{(\overrightarrow{w};\overrightarrow{n})}\left[\mathcal{D}\right]-p_x^{\left(\mathrm{ideal}\right)})}^2\right],\end{array}$$

(5)

where the expectation value involves all possible realizations of the full dataset $\mathcal{D}$ with fixed split-shots $\overrightarrow{n}$ and according to their probabilities. More details on the MISE definition and optimization are reported in Appendix A.2.

4. Demonstration Results

In this section, we present a numerical evaluation of a specific instantiation of the general framework. We begin by examining the calibration stage in Section 4.1, and then analyze the split and merge strategies in Section 4.2.

In both cases, compared to the general protocol shown in Figure 1, this initial numerical study focuses on a specialized protocol where most policies are fixed to simple rules, as illustrated in Figure 2. The codebase used for the demonstration evaluation, along with the corresponding demonstration data, is openly available at https://github.com/GBisi/shot-wise, accessed on 26 October 2025. This codebase can be used directly for shot-wise experiments or as a template for further development.

In particular, whereas the general framework includes a production stage with a scheduling policy allowing multiple incremental executions and optional early stopping, here we restrict the schedule to a simpler policy: the total budget of shots across all considered QPUs is consumed in a single iteration. A comprehensive study of scheduled incremental executions—requiring the exploration of various temporal distribution strategies—is left for future work. In this study, our primary focus is on the optimal distribution of computation across different QPUs.

Moreover, we chose not to employ any error mitigation techniques to maintain the data in its most unaltered and authentic form. This decision aligns with the primary goal of this work, which is not to propose new mitigation methods but rather to provide a clear and unbiased observation. Indeed, while it might happen that error mitigation might be more effective on a specific QPU than another, we assume that this would not change the relative unreliabilities in a relevant way.

4.1. Calibration and Ranking

For the calibration stage, according to the diagram of Figure 2, we first proceed with step (C.1) and select a uniform shot allocation for each QPU m in the set of QPUs considered and reported in

Table 1. Table of QPU emulators considered in this work with some statistical information such as the minimum and the $25\%$, $50\%$ (media), and $75\%$ percentiles of their unreliability.

	Unreliability
QPU Name	min	25% qt	Median (50% qt)	75% qt
ibm_kyoto	0.00071	0.0018	0.0029	0.0035
ibm_brisbane	0.0014	0.0022	0.011	0.016
ibm_osaka	0.0033	0.0062	0.0079	0.071
ibm_sherbrooke	0.00044	0.00084	0.0013	0.0055
simulator_harmony	0.108	0.113	0.114	0.116
simulator_aria-1	0.107	0.112	0.113	0.114
simulator_forte-1	0.093	0.098	0.099	0.100

; then, for step (C.2), we select a set of 10 random circuits $\left\{U_c\right\}$ acting on five qubits which we use as benchmark circuits [56]. The OPENQAMS2 representations of the circuits are available at https://zenodo.org/records/14056270, accessed on 26 October 2025. The random circuits are sampled from the unitary Haar measure. After execution, we choose to assign as an unreliability coefficient the Mean Squared Hellinger distance of the results of each QPU (see Section 3.4.1, where the performance is averaged among the set of circuits considered). Estimates of the unreliability, defined as the Mean Square Hellinger distance for each QPU, are shown in Figure 3 (and summarized in Table 1), where measurements span a time window of about one month and a half.

It is interesting that even if there are sensible fluctuations in time, the best performance between the QPUs considered seems always represented by ‘ibm_sherbrooke’ followed by ‘ibm_kyoto’, while it is not always clear which between ‘ibm_brisbane’ and ‘ibm_osaka’ take the second and third place in the ranking. Furthermore, according to our observation, the performance of IONQ QPUs appears to be one order of magnitude worse. Due to the variability in QPU performances, we stress the importance of a somewhat frequent calibration and assessment of the unreliabilities, at least at the order of the regions of stability (i.e., a few hours).

4.2. Split-Merge Strategies

Here, we follow the right side of Figure 2, where the production stage is simplified as a single iteration and the only variable elements are the split and weight strategies, which we test in three variants for both steps: uniform (all shots are allocated/merged uniformly on the QPUs considered), Hellinger (Section 3.4.1), and MISE (Section 3.4.2). For simplicity, in the split, we are not including other factors that might reweight the resources allocated; for example, different costs per shot in the execution of different QPUs or in the queue and execution times (see Section 3.3 for a more in-depth summary of different situations or [21]).

The main demonstration results of this section are shown in Figure 4. Each panel represents the executions on a different circuit type, among six different cases considered. On the left part of each panel, the ‘baselines’ are shown for each QPU, obtained by running all the shots on single QPUs (the leftmost violins refer to the overall distribution of these results among the QPUs). The specific benchmark circuits have been generated as QASM code for five and eight qubits using the MQT Bench library [56]. On the right part of the panels are shown data with different split and merge strategies for the set of all QPUs (ibm+ionq for the $n_q=5$ data and only IBM for the $n_q=8$ data). We notice that, while the split-merged results never improve the best baseline for each circuit, nevertheless, the former appears to be quite robust and compatible with the average between the different baselines. Furthermore, the performance of each QPU depends heavily on the circuit considered, to the extent that the trends in the performance for some circuits are not always consistent. For example, considering the GHZ circuit, results involving all the seven QPUs considered show the opposite trend instead of the one expected, which results in an improvement from the uniform strategy to the MISE one, as observed in the other cases. This might be due to a high variance between the baselines in this case, which is not well reflected by the calibrated data, which is instead trained from random circuits. In generality, with some exceptions as the one mentioned before, we observe that either splitting or merging using the Hellinger or MISE strategy improves the results of just uniformly splitting and naively merging according to the uniform strategies alone. A complete account of all different combinations of split and merge policies for each of the circuits considered is available at https://zenodo.org/records/14056270, accessed on 26 October 2025.

Figure 5 illustrates the behavior of different split and merge policies as the number of QPUs increases, showing the performance of all policy combinations under varying QPU counts. A key trend is that the maximum error decreases consistently with more QPUs, while the minimum error increases slightly.

This trend reflects the core principle of the shot-wise methodology: it is generally difficult for a quantum programmer to predict which QPU will perform best for a given circuit at a given time. Distributing shots across multiple QPUs may introduce a small error increase compared to using the single best QPU, but since identifying that best QPU in real time is impractical, the distribution provides a safeguard that improves worst-case performance.

Indeed, shot-wise distribution consistently improves the worst-case outcome, while in the average case, the error either decreases or remains comparable to single-QPU execution. Thus, the approach offers a clear advantage: better robustness in the worst case, potential improvements in the average case, and no meaningful degradation overall.

Moreover, we observe that the standard deviation of the results decreases as the number of QPUs grows. This indicates that shot-wise distribution yields more stable outcomes, with reduced variability and a lower upper error bound, albeit at the slight expense of best-case accuracy.

This behavior is, for instance, clearly illustrated in Figure 6 and Figure 7, in which for each circuit we test two different sizes (five and eight qubits) and all split and merge policy combinations. The results of the shot-wise distribution approach are illustrated by distributing the shots from two to seven QPUs, and their results are compared with single and overall (all baselines) QPU executions.

4.3. Discussion

One key advantage of shot-wise distribution in the field of Quantum Software Engineering (QSE) is its robustness to quantum noise. By distributing shots across QPUs with varying noise profiles, the impact of errors is reduced, resulting in more stable outcomes. This is crucial for QSE, as it ensures that quantum applications perform reliably across different hardware platforms. Additionally, shot-wise distribution enhances worst-case performance by mitigating the risk of relying on a single, underperforming QPU, making it useful when the best-performing QPU is uncertain. The method also improves error resilience, as distributing shots across multiple QPUs helps balance the computational load and increases fault tolerance. If one QPU fails, others can continue the computation, ensuring continuity, which is important for long-running algorithms. Furthermore, shot-wise distribution is hardware-agnostic, allowing flexibility across different quantum architectures and making it easier to scale across a variety of platforms. Together with these advantages, shot-wise distribution introduces some challenges. Managing multiple QPUs adds overhead in terms of coordination, scheduling, and result aggregation. This complexity can slow down execution and requires more sophisticated resource management. Additionally, it may dilute best-case performance, as spreading shots can result in lower accuracy than concentrating them on the highest-performing QPU.

We acknowledge that, at a high level, distributing computations across heterogeneous QPUs can be seen as a statistical averaging mechanism. What our study contributes is a systematic framework that operationalizes this intuition into concrete split and merge policies, quantifies their impact, and demonstrates empirically that shot-wise distribution consistently improves worst-case performance without degradation. This goes beyond the intuitive observation by providing a structured, generalizable methodology. Another limitation is the dependency on reliable QPU calibration. For optimal results, accurate and up-to-date information about each QPU’s performance is essential. Without it, the distribution may be inefficient. In [21,23], we present a general multi-service architecture enabling shot-wise distribution and presenting an approach to retrieve up-to-date and reliable QPU calibration data. Interestingly, we observed that even when calibration data were collected at previous time points, the framework delivered consistent results. This robustness can be attributed to two factors: (i) QPU unreliability typically drifts slowly over periods of hours, producing quasi-stable regions (as shown in Figure 3); and (ii) distributing shots across multiple QPUs reduces sensitivity to transient fluctuations of any single device. Thus, although our calibration data were not real-time, the aggregated outcomes remain representative and effective. Future work will address dynamic, real-time calibration to better track QPU performance drift. In conclusion, the shot-wise methodology consistently performs at least as well as the average outcome of a single Quantum Processing Unit (QPU) while often surpassing many individual QPUs in various scenarios. This approach not only reduces variability, leading to more stable and reliable results, but also enhances overall performance when compared to executing all shots on a single QPU. Although it is not yet a complete solution for noise mitigation—a direction we intend to explore further—on average, the shot-wise method improves results and mitigates output variation. Additionally, it offers significant qualitative advantages, such as increased flexibility and customizability tailored to specific requirements. Overall, the shot-wise approach provides a stable and adaptable technique for executing shots across multiple heterogeneous Quantum Computers, combining both qualitative and quantitative benefits.

Beyond these empirical observations, our results invite a more careful theoretical interpretation. Shot-wise distribution can be understood as a statistical variance-reduction mechanism: each QPU samples from a noisy approximation of the ideal output distribution, and merging across QPUs effectively ensembles these estimators. This ensemble averaging suppresses device-specific fluctuations, explaining why our experiments (Figure 4, Figure 5, Figure 6 and Figure 7) show a consistent reduction in error spread and improved worst-case stability.

Moreover, the split and merge policies reveal how error propagation is shaped by allocation choices. For instance, policies weighted by Hellinger distance privilege devices closer to the ideal distribution, thereby reducing bias, while MISE-based policies explicitly balance bias and variance. These observations highlight that shot-wise distribution is not merely a heuristic for spreading work, but a principled optimization problem over probability distributions, where policy design governs the robustness–accuracy trade-off.

Another insight is that distributing shots across heterogeneous QPUs mitigates correlated errors: while a single device may exhibit transient or systematic drifts, their impact is diluted in the merged outcome. This explains the observed narrowing of performance variability as the number of QPUs increases (Figure 5). In practice, the method transforms hardware heterogeneity from a limitation into a resource, converting device variability into statistical robustness.

Taken together, these interpretations clarify why the shot-wise methodology delivers stable performance even without real-time calibration: slow device drifts are absorbed by averaging, while transient anomalies are suppressed. Future research will extend this theoretical foundation by exploring formal error bounds and connecting shot-wise strategies to ensemble learning theory in classical machine learning, where robustness is likewise achieved by aggregating imperfect predictors.

5. Conclusions and Future Work

In summary, our study introduces a novel framework for quantum computation that addresses the limitations of heterogeneous, noisy Quantum Processing Units (QPUs). Unlike the traditional monolithic execution of circuits, our shot-wise approach leverages the probabilistic nature of quantum mechanics to distribute circuit shots across multiple QPUs. This strategy transforms hardware variability from a challenge into an opportunity, improving robustness while maintaining broad applicability.

With that aim, we propose a methodology that advocates for a departure from the traditional monolithic execution of quantum circuits. By capitalizing on the inherent probabilistic nature of quantum mechanics, our shot-wise approach enables distributed execution of quantum tasks across multiple noisy Quantum Computers. We propose a general methodological framework, parameterized by a set of customizable policies, which allows for fine-grained management and distribution of shots across multiple heterogeneous noisy Quantum Computers, even for a single quantum circuit.

At the methodological level, the framework integrates three core elements: (i) shot distribution through customizable split and merge policies that balance accuracy and stability; (ii) calibration to pre-evaluate QPU reliability and guide allocation; and (iii) incremental execution, where feedback from earlier iterations dynamically refines allocation decisions. Together, these mechanisms enable fine-grained, adaptive management of resources without requiring prior knowledge of circuit structure or noise models, ensuring the framework remains hardware-agnostic and operationally realistic.

The term incremental execution refers to the iterative scheduling of circuit runs in multiple stages, where information from earlier executions is used to update shot allocation and merging strategies. It does not necessarily imply that the quality of results improves incrementally at each step, though this may occur in practice depending on noise and policy choices. Rather, the objective of incremental execution is to progressively refine the decision-making process itself: by feeding back empirical evidence from intermediate runs, the framework can adapt policies to the specific characteristics of the circuit, the QPUs involved, and the observed noise conditions. This adaptive loop allows the execution strategy to become increasingly tailored to the scenario at hand, potentially leading to more robust outcomes than a static, one-shot allocation.

Importantly, the proposed framework is entirely black-box with respect to both the structure of the quantum circuits and the underlying noise models of the QPUs. All decisions and computations are grounded solely in empirically obtained data through calibration (and previous iterations), without relying on prior knowledge of circuit structure or internal hardware models. This ensures wide applicability across diverse quantum hardware platforms and circuit classes, and emphasizes operational realism by strictly adhering to observable behavior rather than assumed theoretical characteristics.

Our demonstration evaluation across two major providers and distinct qubit technologies confirms these advantages. Empirical results show that shot-wise distribution consistently improves worst-case stability, narrows variability in results, and produces outcomes that are competitive with or superior to many single-QPU executions. Importantly, this robustness holds even when calibration data are slightly outdated, thanks to the slow drift of QPU reliability and the averaging effect of multi-device execution. The main trade-off is a slight dilution of best-case performance, as distributing shots can limit the benefits of exceptionally well-calibrated devices.

We further note that the shot-wise approach has already been successfully combined with circuit cutting techniques in a separate study [57]. In that work, shot-wise execution was evaluated in scenarios involving up to eight quantum backends and circuits as large as 14 qubits. The results obtained reinforce the conclusions of the present study, confirming the benefits of distributed execution even under realistic and challenging conditions. Notably, the shot-wise strategy demonstrated minimal overhead—only a few milliseconds—even in configurations with eight QPUs and large circuits, with execution latency growing at most linearly with the number of QPUs. That work also provides a deeper analysis of the runtime performance and behavior of shot-wise execution in an application-driven context. Since the focus of this article is on methodological foundations and general-purpose execution strategies, we refer to [57] for a more comprehensive exploration of such application-specific aspects. Currently, our research team is also working on combining shot-wise distribution with state-of-the-art methodologies in which quantum circuits are combined, through multi-programming [58,59], inside the same QPU. Also in this case, combining the two techniques seems to improve the overall performance in terms of noise resistance. These combinations further highlight the benefits, possibility, and potential of adding shot-wise distribution as a transparent step in the quantum execution pipeline, combining multiple QSE solutions (e.g., circuit cutting, multi-programming, noise mitigation).

In conclusion, the shot-wise methodology emerges as a promising approach, yielding results that improve the worst-case performance and are often superior to individual QPUs in diverse scenarios. This method not only reduces variability, enhancing result stability, but also improves overall performance compared to single QPU execution. While it does not fully address noise mitigation, an area for future research, the shot-wise strategy offers substantial qualitative benefits, including increased flexibility and adaptability to specific needs, blending both qualitative and quantitative benefits.

With this work, we aim to contribute to the development of more efficient and reliable quantum computing systems, overcoming current limitations and inspiring further research and innovation in the field.

Several interesting future research directions may emerge from this study:

Shot-wise Error Mitigation: In this paper, our demonstration assessment provides initial evidence that the shot-wise methodology offers promise as an effective approach for managing quantum computations in the presence of diverse heterogeneous QPUs. Additionally, our findings suggest that this strategy may facilitate error cancellation of different Quantum Computers, resulting in a merged final distribution that is more reliable than the average partial distribution obtained from a QPU. However, further studies and an in-depth comparison with state-of-the-art noise mitigation methodologies are warranted to validate these preliminary findings conclusively. If confirmed, future research endeavours could focus on designing and developing robust shot-wise error mitigation techniques to enhance the effectiveness and reliability of quantum computation methodologies.

Design and Development of Additional Split and Merge Policies: This paper introduced and examined four split and merge policies, embedded with and without calibration data. Future research could expand upon these policies, conducting comparative analyses to discern their efficacy. Moreover, exploring scenarios where specific combinations of policies outperform others could offer valuable insights. Currenlty, our approach assumes that the input circuit can be freshly instantiated on each QPU from a classical description. In scenarios where the circuit output of one QPU directly feeds another (without measurement), our methodology would not apply, since shot replication cannot be achieved by quantum state copying. Future research may investigate hybrid models where distributed circuit fragments (via circuit cutting or teleportation-based schemes) are combined with shot-wise execution.

Tailored Calibrations: In this work, we presented a general, customizable framework to perform shot-wise distribution of quantum computations. We have, then, tested the framework in a general setting in which the calibration phase is executed on random circuits to have a calibration that can be suitable in numerous scenarios. However, the shot-wise methodology could be applied even on a specific scenario (e.g., with Variation Quantum Algorithms (VQAs) [60]) and optimize the calibration phase for that specific setting. For instance, the calibration circuits could all have the same parametric quantum circuit with random parameters when working with VQAs. Finally, a key open challenge is the scalability of our calibration approach, since benchmarking against ideal distributions becomes impractical as system sizes grow. Future research will investigate approximate, task-specific calibration methods, and hybrid error mitigation strategies that can extend shot-wise distribution beyond the small- to medium-scale circuits tested here.

Incremental Execution, Scheduling Policies, and Stop Conditions: An intriguing direction for future research involves a more comprehensive exploration of incremental execution and its impact on quantum computation performance. Accompanying this investigation, the study and development of diverse scheduling policies and stop conditions could further optimize the execution process.

Additional demonstrations on More Quantum Providers and Real Quantum Hardware: To further validate and strengthen the findings of this study, conducting additional demonstrations involving multiple quantum providers and utilizing real quantum hardware is essential. By exploring various environments and defining practical benchmark use cases, researchers may gain deeper insights into the robustness and applicability of proposed strategies.