Modular architectures and entanglement schemes for error-corrected distributed quantum computation

Error-corrected^1,2,3 modular quantum computers^4,5,6,7,8,9 offer a promising route to overcome the noise and scalability challenges of large-scale fault-tolerant quantum computing. A modular quantum computer consists of individual computing modules with separate control, which are linked together by means of quantum entanglement^4,7,9,10,11. Modular architectures have been proposed for several types of quantum computing hardware, such as superconducting qubits^12,13, neutral atoms^14,15, and color centers^16,17,18. However, several fundamental questions remain: What are the optimal ways to generate high-fidelity entanglement between modules? Can modular architectures achieve fault-tolerant thresholds comparable to those of monolithic systems? Previous work has hinted that the performance of a distributed QEC code heavily depends on the degree of modularity¹⁹ and the specific choice of quantum entanglement generation protocol¹⁸. The many suitable protocols for entanglement generation²⁰, as well as specific choice of modular architecture and QEC codes^21,22, amount to a vast and largely unexplored design space. How do different entanglement protocols compare in terms of performance for real hardware? What hardware constraints limit their applicability?

In this article, we explore this space for quantum hardware with efficient spin-photon interfaces such as color centers in diamond or silicon, which is a promising hardware for fully connected, modular quantum computers^{23,24,25,26,27,28,29,30,31,32,33,34}. We investigate the performance of a specific surface code, the toric code^35,36,37,38 across two types of modularized architectures, considering both emission-³⁹ and scattering-based^30,40 entanglement generation schemes.

We go beyond the generic circuit-level noise model and develop hardware-tailored noise models that allow us to link the modular QEC performance directly to the physical parameters of the quantum hardware. From this investigation, we specify the requirements of key parameters such as qubit coherence times, photonic link efficiency, and quality of the spin-photon interface for the existence of a circuit-level noise code threshold and identify the break-even point where the QEC suppresses errors beyond the physical error rates. We perform a comprehensive comparison of multiple GHZ-generation protocols for stabilizer measurements, including several direct GHZ-generation protocols. Crucially, we demonstrate that by avoiding the slow Bell pair combination and distillation process of emission-based (EM) protocols as considered in ref. ¹⁸, one can achieve substantially higher error thresholds and reduce the required coherence times by over an order of magnitude. While we find that near-term experimental parameters are sufficient to realize fault-tolerant quantum computation, modest improvements in hardware performance result in QEC thresholds as high as ~ 0.4%, which is comparable to the thresholds found for monolithic architectures of about half a percent under circuit-level noise³⁸. Our findings provide a road map for designing scalable, fault-tolerant modular quantum computers and answer key questions about their feasibility with near-term and future quantum technology.

Modular architectures

We consider a setup where each module of the computing architecture consists of a single communication qubit (CQ) and a few memory qubits, as shown in Fig. 1(a). The modules are arranged on a square lattice, and the communication qubits can establish entanglement with the nearest-neighboring modules through optical links. We will assign one or two of the memory qubits in a module as data qubits of the code, while additional memory qubits are assigned as auxiliary qubits that can be utilized for stabilizer measurements^12,18,41, as shown in Fig. 1(a).

The alternative text for this image may have been generated using AI.

Full size image

a The structure of a module. It consists of a single communication qubit that allows for optical connection to the other modules and some memory qubits acting as either data qubits of the code or auxiliary qubits for the stabilizer measurements. b Multipartite GHZ states used for measuring the stabilizers that spread among modules. c One round of Z and X type stabilizer measurements, each divided into two subroutines. The four colors of the squares in the toric-code lattice correspond to the four subroutines as shown in the sequence. The toric-code lattice encodes two qubits with logical operators (\({L}_{1,2}^{X,Z}\)). The corresponding blue and orange lines indicate the qubit involved in implementing the logical operators. d Quantum circuits for implementing the distributed Z and X stabilizer measurement. A GHZ state is generated upon demand (star signs) and used to measure the joint parity ZZZZ or XXXX on the stabilizer data qubits via the application of local controlled-Z/X gates. The outcome of the stabilizer measurement is the joint parity outcome from the four measurements, i.e., m_X/Z = m₁ ⋅ m₂ ⋅ m₃ ⋅ m₄. e Time layers of the stabilizer measurement. The stabilizer measurements are repeated d times, the same as the distance of the square toric code. These d layers constitute one full QEC cycle, and all syndrome data is then sent to a decoder. Thereafter, suitable corrections are applied to the qubits.

Two-qubit interactions are allowed only between the communication qubit and a memory qubit within the same node, and only the communication qubit can be directly measured. This model is tailored to a broad range of quantum hardware based on color centers such as Nitrogen-Vacancy (NV)⁴², Silicon-Vacancy (SiV)^{25,26,27,28,30}, Tin-Vacancy (SnV)^31,32,33, and Silicon defect centers¹⁷ where the electronic spin states of the defect are optically addressable and can couple through a dipolar interaction to nearby nuclear memory spins.

We consider the topological non-rotated toric surface code^12,37,38, which requires measurement of four-body stabilizers between neighboring data qubits. The stabilizers are measured by creating multi-qubit GHZ states between the modules, either through direct GHZ state generation or fusion of Bell pairs. For the architecture with one data qubit per module, we require the generation of 4-qubit GHZ states, while 3-qubit GHZ states are sufficient when 2 data qubits are hosted per module. We will refer to these as the weight-4 (WT4)^12,18 and weight-3 (WT3) architectures, respectively. WT4 architecture is a direct translation of monolithic surface code architecture to our modular design, which has been explored in refs. ^12,18,41. We propose WT3 architecture in this work to lower the stringent entanglement generation requirements.

Since each module only contains one communication qubit, it is not possible to measure all the stabilizers simultaneously. This constraint results in a checkerboard pattern of stabilizer measurement sub-rounds (each of X and Z types), which differs for the WT4 and WT3 architectures.

For the WT4 architecture, each X and Z-type stabilizer is divided into two sub-rounds, resulting in a four-sequence QEC cycle (see Fig. 1(c)). For the WT3 architecture, the modules are arranged obliquely on the code background array, such that one module contributes two data qubits on the code and exactly three modules span each stabilizer. We consider the even-distance (for each logical operator) WT3 toric code, as this allows all the modules to have exactly two data qubits. The topology of the WT3 architecture means that four sub-rounds for each stabilizer type (X, Z) are required, resulting in an 8-sequence QEC cycle (see Fig. 2).

The alternative text for this image may have been generated using AI.

Full size image

a One round of stabilizer measurements, consisting of measurements for X and Z type stabilizers, each containing four subroutines. The logical qubits of the code are the same as for the WT4 architecture, as shown in Fig. 1(c). b Quantum circuits for the stabilizer measurement. The notation is the same as in Fig. 1.

GHZ-state generation

We consider emission and scattering-based schemes for generating GHZ states between the modules. Each scheme can be adapted to generate either 4-qubit or 3-qubit GHZ states.

The EM scheme was first proposed in 1999⁴³ and has been well developed to realize long-distance entangled Bell pairs⁴⁴. However, for realizing the multipartite GHZ states, sequential generations of Bell pairs, intra-modular two-qubit gates⁴⁵ on the memory qubits, and multiple-qubit readouts are required. These requirements present a significant time overhead in the QEC cycle with corresponding memory requirements on the data qubits.

Nevertheless, scattering-based entangling schemes⁴⁶ harness spin-dependent reflection/transmission, which is several orders of magnitude faster than the gates based on spin-spin interactions. Based on whether the reflected or transmitted photon is used to generate the heralding signal, we classify the scattering-based schemes into the reflection (RFL) scheme and the carving (CAR) scheme. The RFL scheme is inspired by previous studies of cavity-mediated spin-photon entanglement gates^47,48 used for Bell-state realizations^49,50. On the other hand, the CAR scheme is closely related to carving schemes for Bell-state generation⁵¹. While the RFL scheme requires optical circulators and a delay line to guide and manipulate the photons, which raises challenges in on-chip integrated photonics, the CAR scheme circumvents these problems. However, the probabilistic-success nature lowers its entanglement generation rates. The principles of these schemes are illustrated below.

Emission-based (EM) scheme: In this scheme, GHZ states are realized by the fusion of multiple Bell pairs¹⁸. For creating the Bell pairs, we consider both the single-click⁴³ and double-click (Barrett-Kok⁵²) protocols, as they are suitable for the near-term parameters and boosted future parameters, respectively.

The single-click protocol works as follows. In each module, the CQ has a four-level structure with two ground states, as shown in Fig. 3(b). Ideally, one ground state can be selectively excited to emit a photon. Through a controlled operation, a photon is created and entangled with the CQ. The two photons from two modules are then sent and meet at a balanced beam splitter in a middle station. Then, after a single photon detection, the successful creation of an entangled state between the two CQs will be heralded, as shown in Fig. 3(a). In the double-click protocol, a second round of photon emission is used to boost the fidelity by eliminating terms that do not contribute to single photon emission after the first round, by applying local operations before the second emission. For the single-click (double-click) protocol, the overall success probability of the protocols depends linearly (quadratically) on the effective photon detection probability η_ph.

The alternative text for this image may have been generated using AI.

Full size image

a An optical setup with two emitters as communication qubits can be initialized in a CQ-photon entangled state. Then, the emitted photons (c_ph) are sent to a middle station where an optical Bell measurement is performed using a balanced beam splitter and single photon detection. The detection of an early and a late photon at the detectors successfully heralds a Bell pair between the two CQs (c_i). b The energy levels of the photon-CQ system. The CQ has two sets of independent transitions: E₀ ↔ E_0e and E₁ ↔ E_1e with transition frequencies Δ₀ and Δ₁, respectively. Here, E₁ refers to the energy level of the bright-state \(\left\vert 1\right\rangle\) that emits a photon upon excitation.

Due to imperfections of both the Bell states and the local gate operations, it is necessary to employ distillation protocols to boost the final fidelity of the GHZ state. Similar to the method illustrated in ref. ¹⁸, we optimize over various distillation protocols where additional Bell pairs are used to increase the final GHZ state fidelity. Notably, we only consider distillation protocols where, at most, two auxiliary memory qubits per module are available to accommodate realistic hardware constraints. Full analytical details of the noisy EM schemes and the distillation protocols can be found in the supplementary material.

Reflection (RFL) scheme: In the RFL scheme, the GHZ state is realized by employing a photon as the flying auxiliary qubit, interacting sequentially with all the CQs involved, and finally being detected, as shown in Fig. 4(a). This procedure realized a quantum circuit as shown in Fig. 4(b). The photon-spin interaction realizes a CNOT gate⁴⁹, where the photon encodes a qubit in its early and late time bins, and two qubit rotations are applied on the CQ, with one at the time between the scattering of the two time bins and the other after the late time-bin scattering, as shown in Fig. 4(c).

The alternative text for this image may have been generated using AI.

Full size image

a System setup of the RFL scheme. It contains a series of atoms, each embedded within a single-side cavity. The fibers and circulators guide the photon to interact with each atom-cavity system successively. The delay loop, beam splitter, and photon detectors are used to detect the photonic qubit in the X basis. b Quantum circuit that the reflecting protocol implements. It contains CNOT gates and a photon measurement in its X basis. c Physical implementation for the CNOT gate. It contains four steps, including scattering the photon of the two time bins and implementing Hadamard gates on the atom. d The energy levels of the photon-atom-cavity system. The spin has two sets of independent transitions coupled to the input photon: E₀ ↔ E_0e and E₁ ↔ E_1e. ω_c: cavity resonance frequency; ω_ph: input photon frequency.

When examining the performance, we include various hardware imperfections in our modeling of the RFL scheme, such as photon loss, finite cavity coupling, and unwanted optical couplings, considering the CQ level structure and photon and cavity frequencies, as shown in Fig. 4(d). We consider both a near-perfect single-photon source and an attenuated coherent light source for the photonic qubit. The details of our model are provided in the supplementary material.

Carving (CAR) scheme: The CAR scheme exploits the spin-dependent reflection or transmission mechanism of a qubit-coupled two-sided cavity or waveguide to realize the GHZ state. For an ideal mechanism, an incoming photon will be reflected (transmitted) when the CQ is in state \(\left\vert 1\right\rangle (\left\vert 0\right\rangle )\). The GHZ state can be probabilistically carved out by means of a single photon scattering at the cavities or waveguides arranged in two routes, and finally getting detected, as shown in Fig. 5(a). The protocol can be repeated with NOT gates between every two successive rounds, as shown in Fig. 5(b), to increase the fidelity of the output GHZ state. Note that the CAR scheme is inherently probabilistic, with a probability of success that decreases exponentially with the number of CQs in the target GHZ state. The maximum success probability for a 3-CQ (4-CQ) GHZ state is 1/16 (1/32). For this scheme, we consider both a cavity (CAV) implementation and a waveguide (WG) implementation, where the cavity (waveguide) is of a finite (infinite) bandwidth. The level structure and the frequencies of the incoming photon and cavity are the same as those with the EM and RFL protocols. We include hardware imperfections, such as finite coupling strengths and unwanted transmission/reflection, in our modeling. The performance analysis for the CAR scheme with a perfect single photon source (SPS) and an attenuated coherent light (COH) source is presented in the supplementary material.

The alternative text for this image may have been generated using AI.

Full size image

a System setup of the CAR protocol. It consists of spins embedded inside a two-sided cavity (or waveguide), a light source, beam-splitters, and photon detectors. b The operating sequence of the CAR protocol. All the spins are initialized in \(\left\vert +\right\rangle\) states. The operating sequence consists of scatterings of single photons through the optical circuit and NOT gates implemented on spins between every two sequential scattering rounds.

Hardware parameters to quantum error-correction performance

We consider the physical hardware parameter sets as described in our methods section. For each scheme, we have two sets of parameters: 1) the near-term parameters (NTP), which are based on experimental demonstrations and within the reach of present quantum technology, and 2) the future parameters (FP), where we boost some key parameters in the experiment. Three sets (Set-1, Set-2, and Set-3) of operational and coherence times are also considered, in the increasing order of the ratio between the coherence times and gate times (see the “Methods” section for details). We simulate a square toric surface code of code distance and number of time layers both equal to an even-number d, as shown in Fig. 1(e). Since entanglement generation is probabilistic, we consider a maximum time allowed (GHZ cut-off time t_cut) for GHZ generation for each stabilizer measurement to maintain synchronicity of the error correction sub-rounds.

The code thresholds are calculated for different physical error possibilities p, which account for both the gate and measurement errors, different coherence-time sets, and the NTP and FP scenarios. For each case, t_cut was swept to find the highest threshold p_th via a binary search. We report the optimized code threshold for each case using the weighted-growth version of the Union-Find decoder⁵³, which is used to detect and decode the qubit error.

Based on the numerical investigation with different parameter sets, we, in general, required \({P}_{\,\text{succ}}^{\text{link}\,} > 1{0}^{-4}\) and a GHZ fidelity above 99%, for a threshold p_th to exist. Coherence and operational times of Set-1 also serve as the lower bound for the existence of a threshold. Together, these bounds give a rough guide to determine the necessary hardware requirements.

We report that we do not find any code thresholds using a COH photon source for the CAR scheme. As similar performance for the RFL scheme is expected, we skip the simulation of the RFL scheme with a COH source, considering only a deterministic SPS instead. Note that the performance for a non-deterministic SPS can be estimated from this by absorbing the inefficiency of the photon source into the overall detection efficiency.

Thresholds for modular architectures: We present the WT4 architecture threshold results in Fig. 6 and WT3 thresholds in Fig. 7, where thresholds up to only two decimal places precision are shown. More accurate values can be found in the supplementary material. We found no threshold for the EM scheme for the NTP, which we believe is primarily due to the low success probability (\({P}_{\,\text{succ}}^{\text{link}\,}\)) of Bell pair generation of 10⁻⁴. However, even for future parameters (with \({P}_{\,\text{succ}}^{\text{link}\,}=0.0999\)), we get a threshold for only the best coherence times of Set-3. This threshold was found for the protocol with k = 11(7) Bell pairs for the WT4 (WT3) architecture.

The alternative text for this image may have been generated using AI.

Full size image

For every scheme and hardware parameter set, we report the code threshold for each coherence time set. We also report the optimal GHZ generation fusion-based protocol for the EM scheme via the number of Bell pairs (k) used in that protocol. The reported code thresholds (p_th), followed by a check mark, are the ones that are higher than the corresponding WT3 toric code threshold. NT represents “no threshold exist''.

The alternative text for this image may have been generated using AI.

Full size image

Refer to the caption of Fig. 6 for the explanation.

For the scattering-based (RFL and CAR) schemes with NTP parameters, we observe promising thresholds (~0.3%) for some parameter sets. The RFL scheme supports thresholds for all the examined parameter sets. However, for the WT4 architecture, we only get a threshold value for the highest coherence times (Set-3) for the CAV-CAR and WG-CAR schemes with an SPS. For the WT3 architecture, we find no thresholds for the WG-CAR scheme. This is associated with the low probability of success for the CAR scheme, around an order of magnitude lower than the RFL scheme. This result suggests that the decoherence noise becomes the dominant error source in this regime due to long waiting times.

In contrast, we see higher thresholds for FP. The RFL scheme has the highest success possibilities, \({P}_{\,\text{succ}}^{\text{GHZ}\,}=0.3782\ (0.4823)\) for the WT4 (WT3) architecture, boosting the thresholds. The thresholds for the RFL scheme saturate around ~ 0.35% for WT4, meaning further improvements on the coherence parameters do not increase the threshold due to other noise sources present. However, for the WT3 case, due to the longer QEC cycles, the thresholds improve when the coherence parameters improve. Similarly, for the CAV-CAR protocol, we see a boost in the thresholds, with the highest value of 0.40% for WT4 with Set-3. This happens because the CAV-CAR scheme has higher GHZ state fidelity than the RFL scheme, and with Set-3, the coherence times are high enough for both schemes that the GHZ fidelity becomes the dominant factor in drawing the difference in the performance. Similar trend is seen for WT3. Finally, we get an even lower success probability for the WG-CAR scheme, with no thresholds for coherence times of Set-1. However, rapidly increasing thresholds for Set-2 and Set-3 indicate that the threshold is very sensitive to the coherence times in this regime for both WT4 and WT3 architectures.

Perspective on modular architectures and entangling schemes: The WT4 and WT3 architectures both give rise to competitive code thresholds for all the examined physical parameter sets. When the number of modules is a bottleneck for the experiment, the WT3 architecture can be chosen because it has half the number of modules that are required for the same code distance. However, the QEC cycle times of the WT3 architecture are twice as long for the same distance of the code. The bare WT3 architecture also has an adverse effect due to error propagation within each node, as it has two local data qubits per module that can have hook errors due to local operations within the module. Errors occurring between the stabilizer sub-rounds also affect the decoding of the two modular architectures. These factors become clearer when hardware parameters improve with FP, and the code stabilizer circuit and measurements draw the difference. Numerically, we find that the WT4 architecture generally has about 5% lower logical error rates than the WT3 architecture.

The threshold results show that the scattering-based schemes outperform the EM schemes. Two factors are responsible for this. One is that the EM schemes require two-qubit gates involving the memory qubits for Bell pair fusion operations, while the scattering-based schemes do not. The other factor is the high success possibilities \({P}_{\,\text{succ}}^{\text{GHZ}\,}\) for scattering-based schemes, which reduces the t_cut for the same ratio of GHZ generation rate. This thereby reduces the effect of decoherence noise on the memory qubits.

We conducted a separate investigation to verify the noise impact via the fusion process in the EM scheme. We considered a fictitious set of parameters for WT4 EM Set-3 (FP). We choose the boosted parameters \({P}_{\,\text{succ}}^{\text{link}\,}=0.3782\) and Bell-pair fidelity F_link = 99.75% so that it matches the effective GHZ state fidelity and success probability to the WT4 RFL Set-3 (FP) (with p_th = 0.35%). The new threshold only increased from 0.13% to ≈ 0.16% and saturated around this value despite any further parameter improvements. This lack of improvement in the EM threshold can be explained via the noisy fusion process, which suppresses the performance of the EM scheme.

Sub-threshold performance of the architectures: Most reported thresholds are near p = 10⁻³. We simulated the logical error probability (p_L) for physical error probability as low as p = 10⁻⁵ and found the smallest code distance for NTP and FP, which gives break-even performance.

The logical error rates for code distance d = 8 lattice size are shown in Fig. 8(a) for NTP. It shows that d = 8 is the smallest code distance for which we get p_L ≪ p for at least one combination of architecture and scheme. We show the logical error rates in the FP case in Fig. 8(b). We do this for distance d = 6, for which we get better than break-even performance. For the smallest d = 4, WT4 RFL Set-3 shows just the break-even performance (with p_L ≈ p) near p = 10⁻⁴. A preferred scheme and architecture combination can be chosen for the minimal logical error rates. The plot shows that the logical error rates saturate and do not decrease when going near 10⁻⁵. This is because the system has residual noise beyond the circuit-level noise, which originates from the hardware that remains constant in the plots.

The alternative text for this image may have been generated using AI.

Full size image

For clarity, Set-1, Set-2, and Set-3 are shown with circle, square, and cross markers. All curves are checked for monotonicity, including the error bars. a Logical error probability (p_L) for NTP for the smallest even-sized code distance d = 8 shows better than break-even performance. b p_L with FP, for the smallest even-sized code distance d = 6, which shows better than break-even performance. c p_L for NTP, against varying code distance, with constant p = 10⁻³. For WT4 WG-CAR Set-3 and WT3 CAV-CAR Set-2, we see an increase in p_L for an increase in p because the threshold for these architectures is less than 10⁻³, which is about 0.01%. d p_L with FP, against varying code distance, with constant p = 10⁻⁴. Some curves are discontinued after a certain code distance because no logical failure was recorded beyond this point, even with 10⁶ iterations per data point. More iterations are required for accuracy, but it was beyond our computational resources' ability to estimate.

Additionally, we increase the code distance to see how the logical error rates decrease. Shown in Fig. 8(c) for NTP parameters with p = 10⁻³ and Fig. 8(d) for NF parameters with p = 10⁻⁴, respectively. The logical error rates fall exponentially upon increasing the distance below the code threshold. For the NTP parameters, we see break-even performance for WT4 RFL Set-3 with only d = 8, and a few other schemes catch up with d = 10. We see improved sub-threshold performance for the FP case with a break-even starting lattice size of just d = 6. Most of the FP schemes demonstrate p_L≤p for distance 12 onward.

Our work has outlined several feasible approaches for modular error-corrected quantum computations with solid-state quantum hardware. Our results demonstrate that architectures with either one or two data qubits per module exhibit comparable code thresholds, which are strongly influenced by the choice of GHZ state generation schemes. Besides, we found that scattering-based schemes result in higher thresholds due to the faster and higher quality GHZ state generation for the distributed stabilizer measurements. This is because they circumvent the noisy and slow two-qubit gates and measurements required in the emission-based schemes. Furthermore, we have also provided bounds on the coherence times vs. operation times for the threshold performance of the modular architectures. Architectures with \({T}_{\,\text{link}}^{{\rm{dec}}}/{t}_{{\rm{link}}} < 1{0}^{4}\) will not be a reliable candidate for distributed modular architectures as defined in our framework. A GHZ state success probability \({P}_{\,\text{succ}}^{\text{GHZ}\,} > 1{0}^{-4}\) and GHZ fidelity F_GHZ > 99% are required to achieve a code threshold.

While we investigated the surface code due to its well-studied performance, it will be interesting to consider other codes that might better exploit the GHZ-state-enabled nonlocal stabilizer measurements. In particular, codes that could offer reduced qubit overhead, such as the recently introduced quantum low-density parity check (qLDPC) family known as the Bivariate Bicycle (BB) codes, by IBM⁵⁴. Furthermore, extending the simulations to investigate the performance of logical gates and computation⁵⁵, even for the surface code, would be an interesting future direction.

Cut-off times

The GHZ state generation is probabilistic for the distributed architecture due to the nature of GHZ generation protocols and due to photon loss and imperfect photon measurements. To maintain the stabilizer synchronicity on the code lattice, we consider a cut-off time (t_cut) that caps the maximum time duration allowed for GHZ state generation among the modules before stabilizers are measured. A low t_cut will lead to less syndrome measurement information and affect the detection of errors, and a larger t_cut will lead to more noise accumulation due to decoherence of the qubits while idle. Therefore, we optimize t_cut to find the highest error-correcting threshold of the code.

Operation and coherence times

We consider a broad set of coherence and operation time parameters as shown in Fig. 9. There, \({T}_{\,\text{link}}^{\text{dec}\,}\) and \({T}_{\,\text{idle}}^{\text{dec}\,}\) describe the coherence times applicable to the CQs and memory qubits when entanglement generation is attempted and during idling, respectively. Next, we describe the operational times with t_link as the time for one entanglement generation attempt (either a Bell pair generation or direct GHZ state generation), and t_meas meaning the measurement time duration for the communication qubit. Further, \({t}_{P}^{\,\text{c/m}\,}\) is the time duration of a native single-qubit P gate with P ∈ {X, Y, Z, H} acting on the communication (c)/memory (m) qubit. Lastly, we have the two-qubit gate times for controlled-Z, X, iY rotations t_CZ, t_CX, t_CiY and swap operation t_SWAP.

The alternative text for this image may have been generated using AI.

Full size image

All values are expressed with respect to t_link, which is assumed to take one unit of time.

We express all the parameters with respect to t_link duration times. We consider three parameter sets with varying coherence times for link generation and idling. The first set has the lowest coherence times among the ones for which we find code thresholds. Set-2 has increased link coherence times by one order of magnitude, and finally, we consider Set-3, which has coherence times of 10⁶.

Although our simulation model allows for distinct T₁ and T₂ times, for each communication and memory qubits, we considered \({T}_{\,\text{1, link}}^{{\rm{dec}}}={T}_{{\rm{2,}}\,{\rm{link}}}^{\text{dec}\,}\) and \({T}_{\,\text{1, idle}}^{{\rm{dec}}}={T}_{{\rm{2,}}\,{\rm{idle}}}^{\text{dec}\,}\), where the subscripts 1, 2 denote the T₁ and T₂ decay times. This model describes an effective depolarizing noise on the qubits. We choose this noise model against the optimistic case of pure dephasing where \({T}_{\,\text{1, link}}^{\text{dec}\,}=\infty\) and \({T}_{\,\text{1, idle}}^{\text{dec}\,}=\infty\).

Emission-based scheme parameters

We describe these parameters for the EM scheme in Fig. 10. Here, F_prep^56,57 describes the fidelity of emitter-photon state preparation, p_DE⁵⁸ is the probability of the double excitation error on the emitter caused during emitter-photon state preparation, μ is the Hong-Ou-Mandel visibility of the photon interference^58,59, λ is the standard deviation in the path difference for the interference setup^58,60, and the effective photon detection probability is η_ph⁶¹. Furthermore, we have the probability of successful entanglement generation between two nodes \({p}_{\,\text{succ}}^{\text{link}\,}\) which depends on η_ph and has the approximate value of \({p}_{\,\text{succ}}^{\text{link}\,}\approx 1{0}^{-4}\) and \({p}_{\,\text{succ}}^{\text{link}\,}\approx 0.099\) for NTP and FP, respectively. The FP sets are inspired by potential improvements in the experiments.

The alternative text for this image may have been generated using AI.

Full size image

Parameter sets for the emission-based scheme.

Reflection (RFL) scheme parameters

We simulate the performance of the RFL schemes based on the parameters of the diamond’s silicon-vacancy (SiV) color center. The relevant parameters of the physical setup for the RFL scheme are shown in Fig. 11. The constrained parameters are based on NTP and FP, and the tunable parameters are based on maximizing the final GHZ state fidelity. The near-term parameters are modeled from recent experimental demonstrations in refs. ^29,30,49. κ_c describes the cavity loss rate from the cavity to the coupling fiber. P_dk is the dark count rate of the photon detectors, assuming the dark count happens at 1 Hz and the photon detection window is 1 μs. γ denotes the natural linewidth of the spin, κ_l is the cavity loss rate from the cavity to the environment. Here, Δ = δ₀ − δ₁, with δ₀ = E_0e − E₀ − ω_ph and δ₁ = E_1e − E₁ − ω_ph. σ means the calibration error in δ₁ and δ₀. The cavity cooperativity, C₁, between the spin and the one-side cavity, is defined as \({C}_{1}=\frac{{g}_{1}^{2}}{\gamma \left({\kappa }_{{\rm{c}}}+{\kappa }_{{\rm{l}}}\right)}\), with g₁ the coupling strength of the spin and the one-side cavity. Finally, η_c is the circulator efficiency of preserving a photon and ω is defined as ω = ω_ph − ω_c.

The alternative text for this image may have been generated using AI.

Full size image

System parameters of the reflection scheme (RFL).

Cavity-carving (CAV-CAR) scheme parameters

The parameters for the CAV-CAR scheme are presented in Fig. 12, for both single-photon source (SPS) and coherent photon source (COH). Like the RFL scheme, NTP for the CAV-CAR scheme is also modeled from recent experimental demonstrations in refs. ^29,30,49. Here, C₂ is the cooperativity between the spin and the two-side cavity defined as \({C}_{2}=\frac{{g}_{2}^{2}}{\gamma \left(2{\kappa }_{{\rm{c}}}+{\kappa }_{{\rm{l}}}\right)}\), with g₂ the coupling strength of the spin and the two-side cavity. η_f captures the fiber efficiency of preserving a photon. n_sc indicates the number of total scattering times and α is the parameter of the coherent state \(\left\vert \alpha \right\rangle\) (not to be confused with α as the bright-state parameter in the EM scheme). Other hardware parameters are similar to the RFL scheme. The detailed methods for calculating the final GHZ state with the SPS and COH are shown in the supplementary material.

The alternative text for this image may have been generated using AI.

Full size image

Hardware parameters of the cavity carving scheme (CAV-CAR).

Waveguide-carving (WG-CAR) scheme parameters

The parameters for the CAV-CAR scheme are shown in Fig. 13, respectively. Here, P = Γ/γ, with Γ being the intensity of the light emitted from the spin and going into the waveguide. Other variables are the same as the CAV-CAR scheme. The NTP sets are inspired by the same recent experiments as the RFL scheme parameters.

The alternative text for this image may have been generated using AI.

Full size image

Hardware parameters of waveguide-carving (WG-CAR) scheme.

Logical error rates and thresholds

To calculate the logical error rates, we start with the noisy GHZ state (on the communication qubits) generated by the entangling schemes parameterized by all the input hardware parameters for that architecture. We simulate the X and Z stabilizer unit cell for the architecture’s lattice using our source code https://github.com/Poeloe/oop_surface_code/tree/auto_generated_GHZ_prots CIRCUITSIMULATOR. This is done by executing circuits in Figs. 1(d), 2(b). It results in the density matrix of all the qubits involved in the stabilizer measurement, including all communication and memory qubits. All the qubits, except the data qubits of the code, are measured at the end. This projects the data qubits in the desired stabilizer state. We find this effective projector acting on the data qubits of the code, similar to ref. ¹². The Pauli-twirled representation of this superoperator is

where ρ_D is the data qubits’ density matrix, and Π_M denotes the projector due to the measurement, acting on the state. E_e are all the possible Pauli errors acting on the data qubits in the unit cell of the code lattice, and the bar denotes a measurement error. Coefficients a_e and b_e are estimated by calculating the overlap of a given Pauli error string with the superoperator. This superoperator object is then represented as a table with all possible error configurations. Errors are then sampled from the superoperator onto the unit cells of a given code lattice of distance d. This task is done via our software package https://github.com/siddhantphy/qsurface QSURFACE that samples errors from the superoperator and then decodes for the errors using the UnionFind decoder to calculate the logical error rates. The logical error rates are then fitted to the curve p_L = A + Bγ + Cγ², where p_L is the logical error rate, \(\gamma =(p-{p}_{{\rm{th}}}){L}^{1/{\nu }_{0}}\), where L is the lattice size of the code, p is the physical error probability and A, B, C, p_th, ν₀ are the fitting parameters. We estimate the threshold p_th using this fit.