1 Introduction↩︎

Effective distributed quantum computing (DQC) depends on developing algorithms tailored to the physical limitations and network architectures of connected quantum processing units (QPUs). Current algorithmic design efforts generally pursue two main strategies. The first is circuit cutting, where a global quantum circuit is partitioned into smaller sub-circuits that can be executed in parallel on separate QPUs, and later classically recombined [1]–[5]. The second is graph state-based design, which constructs large entangled graph states spanning multiple QPUs to support algorithms exceeding the qubit capacity of any single processor [6]. While circuit cutting is easier in the short term, as it only requires classical post processing and can be implemented on one smaller QPU, it requires a sampling overhead that is asymptotically \({O}\left(\gamma^{2n}\right)\), where \(n\) is the number of circuit cuts [7]. In contrast, if multiple QPUs or quantum computers are interconnected through network-distributed entanglement, the graph state approach could execute the entire algorithm simultaneously, eliminating this overhead [7]. However, because practical network-based entanglement distribution has not yet been achieved, it remains difficult to design and evaluate algorithms that depend on such large, distributed graph states.

Carrera Vazquez et al. [7], propose a potential solution to this limitation through the use of cut Bell pairs, discussed in detail in Section 2. In their approach, the density matrix of a Bell pair is decomposed into a set of separable states, each of which can be classically combined in post-processing to reproduce the same measurement statistics as those obtained from an entangled Bell pair. Using a classical-communication-enabled teleportation protocol [3], [7], they demonstrate that these cut Bell pairs can be teleported to create a virtual controlled-Z (CZ) gate across a previously disconnected edge in a graph state, virtually entangling qubits that were initially unentangled [7].

To truly be used as a tool for algorithmic development with the intention of having deployable algorithms for network-enabled distributed quantum computing systems, one must account for the constraints imposed by generation and distribution, namely the fidelity and rate degradation. Here, we focus on the fidelity, leaving investigation of rate to future work. Since we assume a zero-added-loss multiplexed (ZALM) entanglement source [8] with a predicted emission fidelity of 99.6%, we apply three distinct depolarizing channels to the cut Bell pairs which can be tuned to model any realistic input fidelity. These methods are described in depth in [9]. Our performance analysis in simulation and on a quantum computer informs future modeling and design of network-enabled distributed quantum computing.

2 Cut Bell Pair↩︎

Cut Bell pairs consist of a set of carefully chosen separable states whose outputs, when linearly combined with appropriate weights, reproduce the same measurement statistics as an entangled \(\ket{\Phi^+}\) Bell pair [7], using the density matrix decomposition of Vidal et al. [10]: \[\rho_k = (1 + t_k)\rho_k^{+} - t_k\rho_k^{-}, \label{eq:ogQPD}\tag{1}\] where \(k\) is the number of cut Bell pairs, \(t_k = 2^k-1\), and \(\rho_k^{\pm}\) are separable states. The signal term \(\rho_k^{+}\) contains states with arbitrary single-qubit superpositions that remain separable across the bipartition [7], [10], while the corrective term \(\rho_k^{-}\) is composed of basis states orthogonal to the target (e.g., \(|01\rangle\) and \(|10\rangle\) for \(\ket{\Phi^+}\)). The weights \(a_{i,k}\) form a quasi-probability distribution (QPD), meaning they sum to 1 but may take negative values, with sampling overhead \(\gamma_k = 2t_k + 1\). For a single cut Bell pair (\(k{=}1\)), \(I_{\text{LOCC}} = n_k^- + n_k^+ = 5\) independent circuit realizations are required. We use the optimized circuit and parameters of Carrera Vazquez et al. [7], summarized in Table 1. Further details on the QPD construction, depolarization methods applied to the cut Bell pairs, and the entanglement witness formalism used in our evaluation are given in [9].

3 Experiment Setup↩︎

Each of these 12 circuits is executed for every term in the associated QPD decomposition, and subsequently combined using the QPD observable formula given in [7]. Thus, for a single set of input parameters, a total of 60 circuits are executed (or 84 when using QPD-based depolarization [9]). This number could potentially be reduced by measuring commuting stabilizers simultaneously, at the cost of more complex post-processing.

We evaluate the efficacy of each of the three depolarizing methods discussed in [9] in comparison to a cut Bell pair at ideal fidelity, i.e., not affected by a depolarizing channel. Table 2 summarizes the relevant gate, qubit and circuit run differences between each method. Whenever possible, we evaluate using both a simulation based on IBM’s Torino (a 133-qubit Heron r1 device [11]) and IQM’s Emerald (a 54-qubit superconducting processor [12]).

We evaluate the different depolarization methods assuming a ZALM emission fidelity of 99.6% under a 10 ns classical communication delay. Because the simulation environment does not inherently account for classical communication time, we manually impose a fixed 10 ns delay, corresponding to a propagation distance of approximately 2 meters in optical fiber. In addition, we analyze the impact of network-distributed fidelity on the cut graph state by sweeping from 50% to 100%, in increments of 10%, in both simulation and hardware experiments. Finally, we investigate the influence of classical communication delay by varying the simulation delay logarithmically from 0 to 100,000 ns. For each test configuration, we report the individual-qubit stabilizer expectations and the pairwise fidelities corresponding to the six-qubit ring graph state. Each circuit is executed with 1,024 shots.

3.1 Simulation↩︎

In our experiments, we simulate the circuits using a noise model based on IBM Torino, a 133-qubit device built around the Heron r1 processor architecture [11]. The noise model incorporates a snapshot of the gate errors reported for Torino at the start of the program, and this fixed model is held constant for all runs corresponding to the same set of input parameters. However, separate runs for different depolarization methods each retrieve an independent calibration snapshot, so the noise model may differ slightly between methods. Because the standard noise model does not account for classical communication latency, we explicitly insert a variable delay on all graph state qubits following measurement, and prior to the corresponding conditional feed-forward gates.

It is important to note that classical communication delays are the only point where we apply thermal relaxation, as we assume the time is dominated by classical communication.

3.2 Quantum Computing Hardware↩︎

For experiments, we employ IQM’s Emerald, a 54-qubit superconducting processor with a square lattice connectivity [12]. The square lattice connectivity of the quantum computer does not provide needed connectivity to run the unitary depolarization on hardware in its current state.

4 Results and Discussion↩︎

4.1 Simulated Results↩︎

Fig. 3 presents the simulation results assuming a 99.6% ZALM-generated fidelity and a classical communication delay of 10 ns. We evaluate each of the depolarizing channels described in [9], along with the ideal case where no depolarization is applied. Consistent with the findings of Carrera Vazquez et al. [7], the lowest stabilizer values, shown in Fig. 3 (a), occur at the qubits connected by the cut edge, namely qubits 0 and 5. We hypothesize that the lower fidelity observed on qubit 0 relative to qubit 5 arises from the virtual cz gate implemented during the teleportation process [3], [7]. In this configuration, qubit 5 functions as the control and qubit 0 as the target. Thus, any errors affecting qubit 5 propagate to qubit 0 but not vice versa.

Fig. 3 (b) further illustrates that the lower-bounded fidelity across the cut edge (0,5) is the smallest, while the lower-bounded fidelities of neighboring edges (0,1) and (4,5) exhibit more moderate degradation. This behavior is again consistent with the results of Carrera Vazquez et al. [7]. Mirroring the stabilizer behavior, edge (0,1) exhibits a lower fidelity than its counterpart edge (4,5), which we similarly attribute to the directionality of the cz operation.

Depolarization differences are most pronounced near the cut edge, where unitary depolarization performs notably worse due to its additional gate overhead. QPD and Pauli perform close to ideal, with Pauli slightly lower due to increased gate errors. All methods maintain fidelities above 0.5, confirming entanglement across the cut. Occasional instances where a depolarized run outperforms the ideal case arise because each method is executed as a separate run, each retrieving a fresh calibration snapshot from the hardware backend, so the effective noise model differs slightly between methods.

4.2 Hardware Run Results↩︎

Fig. 4 presents the hardware results for the output stabilizers and lower-bounded fidelities when the depolarized runs are configured to emulate a 99.6% ZALM-generated fidelity. The error bars indicate shot-based statistical uncertainty. We evaluate both the QPD and Pauli depolarizing channels described in [9], along with the ideal case in which no depolarization is applied. As discussed in Section 3.2, the unitary depolarization method requires greater qubit connectivity than is available on current hardware, and is, therefore, not included here.

Fig. 4 (a) shows that the Pauli stabilizers are inconsistent with both expected behavior and simulation. This discrepancy arises because transpiling the Pauli depolarizing channel to IQM Emerald’s native gates requires additional Hadamard operations for the \(Y\) and \(Z\) implementations, resulting in unequal gate counts and accumulated error across Pauli operators. The implemented operation therefore no longer represents a true depolarizing channel, as confirmed by Fig. 4 (b), where many Pauli-depolarized fidelities fall below 50%.

In contrast, the QPD method performs considerably better, though still below ideal for qubits on the cut (0 and 5), suggesting depolarization impacts teleportation-based protocols more strongly on real hardware than simulations predict. Overall, edge fidelity trends are consistent with Carrera Vazquez et al. [7] and simulation: the cut edge shows the lowest fidelity, with adjacent edges moderately degraded. Hardware stabilizers and fidelities are uniformly lower than simulated values due to additional transpilation gates, noise processes not captured by the noise model, and the architectural mismatch between the simulated IBM Torino processor and the IQM Emerald hardware.

4.3 Network Distributed Fidelity Sweep↩︎

4.3.1 QPD Depolarization↩︎

Consistent with Figs. 3 and 4, qubits along cut edges and adjacent edges show decreased fidelities, with the gap diminishing as network-distributed fidelity increases. This suggests that as the fidelity of the pre-shared entanglement improves, the cut edge becomes more like entanglement generated within a quantum computer.

In the simulated results, shown in Fig. 5 (a), the network distributed fidelity of 0.5 corresponds to a maximally mixed Bell pair, which carries no entanglement; the poor performance at this fidelity is therefore a physical expectation, not a noise artifact.

Stabilizer values and fidelities increase approximately linearly with network-distributed fidelity in both simulation and hardware, though on hardware the rate of increase lessens above 0.9, likely as internal noise becomes dominant. As discussed in [9], [13], entanglement is only detected at graph state fidelities greater than 0.5, which corresponds to a negative witness value. We define the creation of a graph state as successful if all edge pairs are above this value. Fig. 5 (a) shows that, for our simulated results, this occurs at a network distributed fidelity of 0.6, while on the quantum computer shown in Fig. 5 (b), this is only seen at network distributed fidelities of 0.9 and 1. This shows that the more error prone the QPUs, the higher quality the distributed entanglement will have to be.

4.3.2 Pauli Depolarization↩︎

The Pauli depolarization method exhibits similar trends in simulation (Fig. 5 (c)), with graph state fidelities increasing linearly with network-distributed fidelity, and successful graph-state creation at fidelities of 0.6 and above. On hardware, however, the Pauli method fails to implement a true depolarizing channel, as discussed in Section 4.2, and changing the input fidelity has no notable effect on stabilizers or pairwise fidelities.

4.3.3 Unitary Depolarization↩︎

The unitary depolarization method (Fig. 5 (d)), available only in simulation due to hardware connectivity constraints, shows the same linear trend but with lower absolute fidelities, consistent with the additional gate errors shown in Fig. 3. Graph-state creation succeeds at network-distributed fidelities of 0.6 and above.

4.4 Classical Communication Delay Sweep↩︎

Fig. 6 shows the ideal and QPD depolarization cases under varying classical communication delay, simulated at 99.6% ZALM fidelity with thermal relaxation noise proportional to delay over ideal optical fiber. Consistent with previous results, the cut edge (0,5) yields the lowest fidelity, with adjacent edges moderately degraded. The Pauli and unitary methods (not shown) exhibit similar trends with slightly lower absolute fidelities.

Our results show that for classical communication delays between 0 and 100 ns, there is no appreciable loss in stabilizer values or graph state fidelity. This is encouraging for data-center-scale distributed quantum computing, where interconnects are typically on the order of a few meters or less of optical fiber. A small but noticeable decrease in both stabilizer values and fidelities appears around 1,000 ns, corresponding to approximately two hundred meters of transmission distance. Even so, all depolarization methods maintain fidelities above the 50% entanglement threshold up to delays of approximately 10,000 ns, or a few kilometers. Only at 100,000 ns, corresponding to tens of kilometers of fiber, does thermal relaxation noise become dominant, reducing the resulting graph state fidelities below the entanglement threshold.

5 Conclusion↩︎

Overall, this work successfully created and demonstrated a framework for modeling the effects of network-distributed entanglement on creating a virtual entanglement graph state on a quantum computer, an essential step to enabling distributed quantum computing. This is based on the results in Carrera Vazquez et al., where they show that this methodology can be extended across multiple QPUs[7]. We model the decreased fidelity entangled pairs produced by the ZALM entanglement process with three distinct descriptions of depolarizing channels, an extension of the QPD used in Carrera Vazquez et al., randomly applying Pauli error, and a Stinespring dilated unitary operator. These methods are examined in simulation, with the QPD and Pauli methods additionally evaluated on quantum hardware. Throughout the tests we found that the QPD method consistently performed the best of the proposed methods, at the cost of more runs in both simulation and on the quantum computer. This advantage is expected, as QPD introduces no additional gates; the more significant finding is that mathematically equivalent noise implementations diverge substantially on real hardware.

We discovered that to effectively create entanglement, i.e., have a graph state fidelity of greater than 50%, on the quantum hardware the network-distributed entanglement fidelity needs to be quite high, 90% or greater. Finally, we examined the effect of classical communication delay on the creation of graph states. We showed that the increase of thermal relaxation noise due to the extended delay is negligible over tens of meters, a promising result for data centers that often only need a few meters of fiber to connect multiple QPUs. In fact, we find that only at tens of kilometers do the delays prevent the teleportation of entanglement in the resulting graph state.

The results here are influenced by transient hardware noise; future work could improve statistical robustness by averaging over multiple calibration cycles. We also plan to benchmark our virtual Bell pair against a physical Bell pair prepared with a true entangling gate on the same hardware. Error-mitigation techniques such as TREX and optimized qubit mapping [7] could be incorporated to improve hardware results. Extending this framework to two cut Bell pairs connecting distinct graph states, and to algorithms using graph states as computational resources such as the Steane code [14], would provide a more complete picture of network-enabled distributed quantum computing.

References↩︎