Combining quantum processors with real-time classical communication – Nature

Circuit cutting

The gates in a quantum circuit are quantum channels acting on density matrices ρ. A single quantum channel \({\mathcal{E}}(\rho )\) is cut by expressing it as a sum over I quantum channels \({{\mathcal{E}}}_{i}(\rho )\) resulting in the QPD

The channels \({{\mathcal{E}}}_{i}(\rho )\) are easier to implement than \({\mathcal{E}}(\rho )\) and are built from LO¹⁶ or LOCC¹⁷ (Fig. 1). As some of the coefficients a_i are negative, we introduce γ = ∑_i∣a_i∣ and P_i = ∣a_i∣/γ to recover a valid probability distribution with probabilities P_i over the channels \({{\mathcal{E}}}_{i}\). Here, γ can be seen as the amount by which the QPD deviates from a true probability distribution and is thus a cost to pay to implement the QPD. Without a QPD an observable is estimated by \(\langle O\rangle ={\rm{Tr}}\,\{O{\mathcal{E}}(\rho )\}\). However, when using this QPD, we build an unbiased Monte Carlo estimator of O as

The variance of the QPD estimator ⟨O⟩_QPD is a factor of γ² larger than the variance of the non-cut estimator ⟨O⟩ (ref. ⁴⁴). When cutting n > 1 identical channels, we can build an estimator by taking the product of the QPDs for each individual channel, resulting in a γ²ⁿ rescaling factor^22,45. This exponential increase in variance is compensated by a corresponding increase in the number of measured shots. Therefore, γ²ⁿ is called the sampling overhead and indicates that circuit cutting must be used sparingly. Details of the LO and LOCC quantum channels \({{\mathcal{E}}}_{i}\) and their coefficients a_i are provided in sections ‘Virtual gates implemented with LO’ and ‘Virtual gates implemented with LOCC’, respectively.

Virtual gates implemented with LO

Here, we discuss how to implement virtual CZ gates with LO^16,18. We follow ref. ¹⁶ and, therefore, decompose each cut CZ gate into local operations and a sum over six different circuits defined by

where \({R}_{z}(\theta )=\exp \left(-{\rm{i}}\frac{\theta }{2}Z\right)\) are virtual Z rotations⁴⁶. The factor 2 in front of CZ is for readability. Each of the possible six circuits is thus weighted by a 1/6 probability (Extended Data Fig. 1). The operations (I + Z)/2 and (I − Z)/2 correspond to the projectors |0⟩ ⟨0| and |1⟩ ⟨1|, respectively. They are implemented by MCMs and classical post-processing. More specifically, when computing the expectation value of an observable ⟨O⟩ = ∑_ia_i⟨O⟩_i with the LO QPD, we multiply the expectation values ⟨O⟩_i by 1 and −1 when the outcome of an MCM is 0 and 1, respectively.

In the experiments that implement graph states with LO in the main text, we implement the CZ gate with six circuits built from R_z gates and MCMs¹⁶. Cutting four CZ gates with LO thus requires I = 6⁴ = 1,296 circuits. However, as the node and edge stabilizers of the graph states are at most in the light cone⁴⁷ of one virtual gate, we instead implement two QPDs in parallel, which requires I = 6² = 36 LO circuits per expectation value. In general, sampling from a QPD results in an overhead of \({({\sum }_{i=0}^{I-1}| {a}_{i}| )}^{2}\), where I is the number of circuits in the QPD and the a_i are the QPD coefficients⁴⁴. However, as the LO QPDs in our experiments have only 36 circuits, we fully enumerate the QPDs by executing all 36 circuits. The sampling cost of full enumeration is \(I({\sum }_{i=0}^{I-1}| {a}_{i}{| }^{2})\). Furthermore, as ∣a_i∣ = 1/2 ∀ i = 0, …, I − 1, sampling from the QPD and fully enumerating it both have the same shot overhead.

The decomposition in equation (3) with γ² = 9 is optimal with respect to the sampling overhead for a single gate¹⁷. Recently, refs. ^30,31 found a new protocol that achieves the same γ overhead as LOCC when cutting multiple gates in parallel. The proofs in refs. ^30,31 are theoretical demonstrating the existence of a decomposition.

Virtual gates implemented with LOCC

We now discuss the implementation of the dynamic circuits that enable the virtual gates with LOCC. We first present an error suppression and mitigation of dynamic circuits with dynamical decoupling (DD) and zero-noise extrapolation (ZNE). Second, we discuss the methodology to create the cut Bell pairs and present the circuits to implement one, two and three cut Bell pairs. Finally, we propose a simple benchmark experiment to assess the quality of a virtual gate.

Error-mitigated quantum circuit switch instructions

All quantum circuits presented in this work are written in Qiskit. The feed-forward operations of the LOCC circuits are executed with a quantum circuit switch instruction, hereafter referred to as a switch. A switch defines a set of cases in which the quantum circuit can branch depending on the outcome of a corresponding set of measurements. This branching occurs in real time for each experimental shot, with the measurement outcomes being collected by a central processor, which in turn broadcasts the selected case (here corresponding to a combination of X and Z gates) to all control instruments.

As quantum computing scales, the control electronics become tailored to its QPU and are no longer built from off-the-shelf components. Recent IBM devices have a single QPU with a rack of dedicated and tailored control electronics, as shown in refs. ^29,48. The realization of the feed-forward we present builds upon the work in ref. ²⁹ and advances its scalability in two main ways. First, our development enables the synchronization and inter-communication between separate experimental setups. Not only are the control instruments for the two sub-QPUs located in different racks, but they are also configurable in software to operate on them independently for the LO experiments and recombined for LOCC. This architecture is extensible to multiple racks and QPUs. It overcomes several of the challenges in operating a distributed control system as pointed out in ref. ²³. Second, the duration of the conditional operation is independent of the measurement results, of which qubits are measured, and which qubits are subject to the conditional operations (apart from minor differences due to cable lengths). This enables the scheduling and execution of programs equally across the combined QPU as if it were a single one.

The feed-forward process results in a latency of the order of 0.5 μs (independent of the selected case) during which no gates can be applied (Extended Data Fig. 2a, red area). Free evolution during this period (τ), often dominated by static ZZ cross-talk in the Hamiltonian, typically with a strength ranging from about 10³ Hz to 10⁴ Hz, substantially deteriorates results. To cancel this unwanted interaction and any other constant or slowly fluctuating IZ or ZI terms, we precede the conditional gates with a staggered DD X–X sequence, adding 3τ to the switch duration (Extended Data Fig. 2a). The value of τ is determined by the longest latency path from one QPU to the other and is fine-tuned by maximizing the signal on such a DD sequence. Furthermore, we mitigate the effect of the overall delay on the observables of interest with ZNE²². To do this, we first stretch the switch duration by a factor c = (τ + δ)/τ, where δ is a variable delay added before each X gate in the DD sequence (Extended Data Fig. 2a). Second, we extrapolate the stabilizer values to the zero-delay limit c = 0 with a linear fit. In many cases, an exponential fit can be justified¹; however, we observe in our benchmark experiments that a linear fit is appropriate (Extended Data Fig. 2). Without DD, we observe strong oscillations in the measured stabilizers that prevent an accurate ZNE (see the XZ stabilizer in Extended Data Fig. 2c). As seen in the main text, this error suppression and mitigation reduce the error on the stabilizers affected by virtual gates.

The error suppression and mitigation that we implement for the switch also apply to other control flow statements. The switch is not the only instruction capable of representing control flow. For instance, OpenQASM3⁴⁹ supports if/else statements. Our scheme is done by (1) adding DD sequences to the latency (possibly by adding delays if the control electronics cannot emit pulses during the latency); (2) stretching the delay; and (3) extrapolating to the zero-delay limit.

Cut Bell pair factories

Here, we discuss the quantum circuits to prepare the cut Bell pairs needed to realize virtual gates with LOCC. To create a factory for k cut Bell pairs, we must find a linear combination of circuits with two disjoint partitions with k qubits each to reproduce the statistics of Bell pairs. We create the state ρ_k of the Bell pairs following ref. ⁵⁰ such that \({\rho }_{k}=(1+{t}_{k}){\rho }_{k}^{+}-{t}_{k}{\rho }_{k}^{-}\), where t_k = 2^k − 1. Here, \({\rho }_{k}^{\pm }\) are mixed states separable with respect to the partitions A and B. Note that ρ_k entangles the qubit partitions A and B, shown in Fig. 1c, but \({\rho }_{k}^{\pm }\) do not. The total cost of this QPD with two states is determined by γ_k = 2t_k + 1. Next, we realize \({\rho }_{k}^{\pm }\) from a probabilistic mixture of pure states \({\rho }_{k,i}^{\pm }\), that is, valid probability distributions. The state \({\rho }_{k}^{-}\) is easily implemented by a uniform mixture of all basis states that correspond to a 0 entry on the diagonal of the density matrix ρ_k. The basis states themselves do not appear in ρ_k. We thus implement \({\rho }_{k}^{-}\) as a diagonal density matrix of \({n}_{k}^{-}={4}^{k}-{2}^{k}\) basis states. The state \({\rho }_{k}^{+}\) is harder to engineer. It requires a probabilistic mixture of intricate states with entanglement within each partition A and B but not between them. To engineer \({\rho }_{k}^{+}\), we thus build a parametric quantum circuit C_k(θⁱ) with parameters θⁱ in which no two-qubit gate connects qubits between A and B. Following ref. ⁵⁰, we need \({n}_{k}^{+}={2}^{{2}^{k}}-1\) pure states to realize \({\rho }_{k}^{+}\). The exact form of \({\rho }_{k}^{+}\), omitted here for brevity, is given in Appendix B of ref. ⁵⁰. Therefore, the total number of parameter sets \(I={n}_{k}^{+}+{n}_{k}^{-}\) required to implement one, two and three cut Bell pairs is 5, 27 and 311, respectively. Finally, the coefficients a_i,k of all the circuits in the QPD in equation (1) that implement \({\rho }_{k}^{\pm }\) are

For k = 2, the resulting weights, ∣a_i,k∣/γ_k are approximately all equal. There is thus no practical difference between sampling and enumerating the k = 2 QPD when executing it on hardware. More precisely, for the factories with two cut Bell pairs that we run on hardware, the cost of sampling the QPD is \({({\sum }_{i=0}^{I-1}| {a}_{i,2}| )}^{2}={\gamma }_{2}^{2}(1+1.6\times 1{0}^{-7})\) and the cost of fully enumerating the QPD is \(I({\sum }_{i=0}^{I-1}| {a}_{i,2}{| }^{2})={\gamma }_{2}^{2}(1+1.0\times 1{0}^{-3})\), where γ₂ = 7.

We construct all pure states \({\rho }_{k,i}^{\pm }\) from the same template variational quantum circuit C_k(θⁱ) with parameters θⁱ, where the index i = 0, …, I − 1 runs over the I elements of the probabilistic mixtures defining \({\rho }_{k}^{\pm }\). The parameters θⁱ in the template circuits C_k(θⁱ) are optimized by the SLSQP classical optimizer⁵¹ by minimizing the L₂-norm with respect to the I pure target states needed to represent \({\rho }_{k}^{+}\), where the norm is evaluated with a classical state vector simulation. After testing various approaches, we find that those provided in Fig. 1c and Extended Data Fig. 3 enable us to achieve an error, based on the L₂ norm, of less than 10⁻⁸ for each state while having minimal hardware requirements. To enable rapid execution of the QPD with parametric updates, all the parameters are the angles of virtual Z rotations⁴⁶ (Fig. 1c). As \({\rho }_{k}^{-}\) is built from basis states, we analytically derive the parameters. Therefore, we could also significantly simplify the ansatz C_k(θⁱ), for example, by cancelling CNOT gates. However, we keep the same template for compilation and execution efficiency. On first inspection, the parameters entering \({\rho }_{k}^{+}\) do not have any usable structure. We thus leave it up to future research to further investigate whether these parameters have any structure that could be leveraged to simplify the cut Bell pair factories.

A single-cut Bell pair is engineered by applying the gates U(θ₀, θ₁) and U(θ₂, θ₃) on qubits 0 and 1. Here, and in the figures, the gate U(θ, ϕ) corresponds to \(\sqrt{X}{R}_{z}(\theta )\sqrt{X}{R}_{z}(\phi )\). The QPD of a single-cut Bell pair requires five sets of parameters given by {[π/2, 0, π/2, 0], [π/2, −2π/3, π/2, 2π/3], [π/2, 2π/3, π/2, −2π/3], [π, 0, 0, 0], [0, 0, π, 0]} which could also be derived analytically. The circuits to simultaneously create two and three cut Bell pairs are shown in Fig. 1c and Extended Data Fig. 3, respectively. The circuits and the values of the parameters as obtained by the optimizer are available on GitHub (www.github.com/eggerdj/cut_graph_state_data).

In the experiments that implement graph states with LOCC in the main text, we construct two QPDs in parallel with I = 27 circuits, each QPD implementing two long-range CZ gates. This execution is similar to the LO execution in which we also execute two QPDs in parallel.

Benchmarking qubits for LOCC

The quality of a CNOT gate implemented with dynamic circuits depends on hardware properties. For example, qubit relaxation, dephasing and static ZZ cross-talk all negatively affect the qubits during the idle time of the switch. Furthermore, measurement quality also affects virtual gates implemented with LOCC. Errors on MCMs are harder to correct than errors on final measurements as they propagate to the rest of the circuit through the conditional gates⁵². For instance, assignment errors during readout result in an incorrect application of a single-qubit X or Z gate. Given the variability in these qubit properties, care must be taken in selecting those to act as cut Bell pairs. To determine which qubits will perform well as cut Bell pairs, we develop a fast characterization experiment on four qubits that does not require a QPD or error mitigation. This experiment creates a graph state between qubits 0 and 3 by consuming an uncut Bell pair created on qubits 1 and 2 with a Hadamard and a CNOT gate. We measure the stabilizers ZX and XZ which require two different measurement bases. The resulting circuit, shown in Extended Data Fig. 4a, is structurally equivalent to half of the circuit that consumes two cut Bell pairs, for example, Fig. 1c. We execute this experiment on all qubit chains of length four on the devices that we use and report the mean squared error (MSE), that is, [(⟨ZX⟩ − 1)² + (⟨XZ⟩ − 1)²]/2 as a quality metric. The lower the MSE is the better the set of qubits act as cut Bell pairs. With this experiment we benchmark, ibm_kyiv (the device used to create the graph state with 103 nodes), and ibm_pinguino-1a and ibm_pinguino-1b (the two Eagle QPUs combined into a single device, named ibm_pinguino-2a, used to create the graph state with 134 nodes). We observe more than an order of magnitude variation in MSE across each device (Extended Data Fig. 4b).

The qubits we chose to act as cut Bell pairs are a tradeoff between the graph we want to engineer and the quality of the MSE benchmark. For example, the graphs with periodic boundary conditions presented in the main text were designed first based on the desired shape of |G⟩ and second based on the MSE of the Bell pair quality test.

Graph states

A graph state |G⟩ is created from a graph G = (V, E) with nodes V and edges E by applying an initial Hadamard gate to each qubit, corresponding to a node in V, and then CZ gates to each pair of qubits (i, j) ∈ E (refs. ^53,54). The resulting state |G⟩ has ∣V∣ first-order stabilizers, one for each node i ∈ V, defined by S_i = X_i∏_k∈N(i)Z_k. Here, N(i) is the neighbourhood of node i defined by E. These stabilizers satisfy S_i|G⟩ = |G⟩. By construction, any product of stabilizers is also a stabilizer. If an edge (i, j) ∈ E is not implemented by a CZ gate, the corresponding stabilizers drop to zero, that is, ⟨S_i⟩ = ⟨S_j⟩ = 0. This effect can be seen in the dropped edge benchmark, see, for example, Fig. 2b.

Entanglement witness

We now define a success criterion for the implementation of a graph state with entanglement witnesses⁵⁵. A witness \({\mathcal{W}}\) is designed to detect a certain form of entanglement. As we cut edges in the graph state, we focus on witnesses \({{\mathcal{W}}}_{i,j}\) over two nodes i and j connected by an edge in E. An edge (i, j) of our graph state |G⟩ presents entanglement if the expectation value \(\langle {{\mathcal{W}}}_{i,j}\rangle . The witness does not detect entanglement if \(\langle {{\mathcal{W}}}_{i,j}\rangle \ge 0\). The first-order stabilizers of nodes i and j with (i, j) ∈ E are

Here, N(i) is the neighbourhood of node i, which includes j because (i, j) ∈ E. Thus, N(i)\j is the neighbourhood of node i excluding j. Following refs. ^55,56, we build an entanglement witness for edge (i, j) ∈ E as

This witness is zero or positive if the states are separable. Alternatively, as in ref. ²⁷, a witness for bi-separability is also given by

Here, we consider both witnesses. The data in the main text are presented for \({{\mathcal{W}}}_{i,j}\). As discussed in ref. ⁵⁶, \({{\mathcal{W}}}_{i,j}\) is more robust to noise than \({{\mathcal{W}}}_{i,\,j}^{{\prime} }\). However, \({{\mathcal{W}}}_{i,j}\) requires more experimental effort to measure than \({{\mathcal{W}}}_{i,\,j}^{{\prime} }\) because of the stabilizer S_iS_j.

For completeness, we now show how a witness can detect entanglement by focusing on \({{\mathcal{W}}}_{i,j}\). A separable state satisfies \(\langle {P}_{1}…{P}_{n}\rangle ={\prod }_{i}\langle {P}_{i}\rangle \), where P_i are single-qubit Pauli operators. Therefore, we can show, using the Cauchy–Schwarz inequality, that \(\langle {S}_{i}\rangle +\langle {S}_{j}\rangle +\langle {S}_{i}{S}_{j}\rangle \le 1\) and that \({{\mathcal{W}}}_{i,j}\ge 0\) for separable states.

The step from equation (10) to equation (11) relies on ∏_ia_i ≤ ∏_i ∣a_i∣ and that \({\prod }_{k}| \langle {Z}_{k}\rangle | \le 1\), where the product runs over nodes that do not contain i or j. The step from equation (11) to equation (12) is based on the Cauchy–Schwarz inequality. The final step relies on the fact that \({\langle {X}_{i}\rangle }^{2}+{\langle {Y}_{i}\rangle }^{2}+{\langle {Z}_{i}\rangle }^{2}\le 1\) with pure states equal to one. Therefore, the witness \({{\mathcal{W}}}_{i,j}\) will be negative if the state is not separable.

In the graph states presented in the main text, we execute a statistical test at a 99% confidence level to detect entanglement. As discussed in the Supplementary Information and shown in Fig. 2b, some witnesses may go below −1/2 because of readout error mitigation, the QPD and Switch ZNE. We, therefore, consider an edge to have the statistics of entanglement if the deviation from −1/2 is not statistically greater than ±1/2. Based on a one-tailed test, we consider that edge (i, j) is bi-partite entangled if

Similarly, we form a success criterion based on \({{\mathcal{W}}}_{i,j}^{{\prime} }\) as

This criterion penalizes any deviation from −1, that is, the most negative value that \({{\mathcal{W}}}_{i,\,j}^{{\prime} }\) can have. Here, z_99% = 2.326 is the z-score of a Gaussian distribution at a 99% confidence level and \({\sigma }_{{\mathcal{W}},i,j}\) is the standard deviation of edge witness \({{\mathcal{W}}}_{i,j}\). These tests are conservative as they penalize any deviation from the ideal values. Moreover, these tests are most suitable for circuit cutting because the QPD may increase the variance \({\sigma }_{{{\mathcal{W}}}_{i,j}}\) of the measured witnesses. Therefore, the statistics of entanglement are detected only if the mean of a witness is sufficiently negative and its standard deviation is sufficiently small. An edge (i, j) ∈ E fails the criteria if equation (14) or equation (15) is not satisfied. All edges in E, including the cut edges, pass the test based on \({{\mathcal{W}}}_{i,j}\) when implemented with LO and LOCC (Extended Data Table 2). However, some edges fail the test based on \({{\mathcal{W}}}_{i,\,j}^{{\prime} }\) because of the lower noise robustness of \({{\mathcal{W}}}_{i,\,j}^{{\prime} }\) compared with \({{\mathcal{W}}}_{i,j}\).

Circuit count for stabilizer measurements

Obtaining the bipartite entanglement witnesses requires measuring the expectation values of ⟨S_i⟩, ⟨S_j⟩ and ⟨S_iS_j⟩ of each edge (i, j) ∈ E. For the 103- and 134-node graphs presented in the main text, all 219- and 278-node and edge stabilizers, respectively, can be measured in N_S = 7 groups of commuting observables. To mitigate final measurement readout errors, we use twirled readout error extinction (TREX) with N_TREX samples⁵⁷. When virtual gates are used with LO and LOCC, we require I_LO and I_LOCC more circuits, respectively. In this work, we fully enumerate the QPD. Furthermore, for LOCC, we mitigate the delay of the switch instruction with ZNE based on N_ZNE stretch factors. Therefore, the four types of experiments are executed with the following number of circuits.

• Swaps: N_SN_TREX

• Dropped edge: N_SN_TREX

• LO: N_SN_TREXI_LO

• LOCC: N_SN_TREXI_LOCCN_ZNE

In the experiments for the 103- and 134-node graph states, we use N_TREX = 5 and 3 TREX samples, respectively. Therefore, measuring the stabilizers without a QPD requires N_S × N_TREX = 35 circuits for the 103-node graph. For LO and LOCC, measuring the stabilizers for the graphs in the main text requires 6⁴ and 27² circuits, respectively. However, owing to the graph structure, each edge witness is only ever in the light cone of two cut gates at most. We may thus execute a total of I_LO = 6² and I_LOCC = 27 circuits for LO and LOCC, respectively, based on the light cone of the gates. For higher-weight observables, this corresponds to sampling the diagonal terms of a joint QPD. Therefore, measuring the stabilizers with LO requires N_S × N_TREX × I_LO = 1,260 circuits. For LOCC, we further perform error mitigation of the switch with N_ZNE = 5 stretch factors. We, therefore, execute N_S × N_TREX × I_LOCC × N_ZNE = 4,725 circuits to measure the error-mitigated stabilizers needed to compute \({{\mathcal{W}}}_{i,j}\). Each circuit is executed with a total of 1,024 shots.

To reconstruct the value of the measured observables, we first merge the shots from the TREX samples. To do this, we flip the classical bits in the measured bit strings corresponding to measurements for which TREX prepended an X gate. These processed bit strings are then aggregated in a count dictionary with 1,024 × N_TREX counts. Next, to obtain the value of a stabilizer, we identify which of the N_S measurement bases we need to use. The value of a stabilizer and its corresponding standard deviation are then obtained by resampling the corresponding 1,024 × N_TREX counts. Here, we randomly select 10% of the shots to compute an expectation value. Ten such expectation values are averaged and reported as the measured stabilizer value. The standard deviation of these 10 measurements is reported as the standard deviation of the stabilizer, shown as error bars in Fig. 2b. Finally, if the stabilizer is in the light cone of a virtual gate implemented with LOCC, we linearly fit the value of the stabilizer obtained at the N_ZNE = 5 switch stretch factors. This fit, shown in Extended Data Fig. 2d, enables us to report the stabilizer at the extrapolated zero-delay switch.