Authors: Almudena Carrera Vazquez Caroline Tornow Diego Ristè Stefan Woerner Maika Takita Daniel J. Egger Abstract Quantum computers process information with the laws of quantum mechanics. Current quantum hardware is noisy, can only store information for a short time and is limited to a few quantum bits, that is, qubits, typically arranged in a planar connectivity . However, many applications of quantum computing require more connectivity than the planar lattice offered by the hardware on more qubits than is available on a single quantum processing unit (QPU). The community hopes to tackle these limitations by connecting QPUs using classical communication, which has not yet been proven experimentally. Here we experimentally realize error-mitigated dynamic circuits and circuit cutting to create quantum states requiring periodic connectivity using up to 142 qubits spanning two QPUs with 127 qubits each connected in real time with a classical link. In a dynamic circuit, quantum gates can be classically controlled by the outcomes of mid-circuit measurements within run-time, that is, within a fraction of the coherence time of the qubits. Our real-time classical link enables us to apply a quantum gate on one QPU conditioned on the outcome of a measurement on another QPU. Furthermore, the error-mitigated control flow enhances qubit connectivity and the instruction set of the hardware thus increasing the versatility of our quantum computers. Our work demonstrates that we can use several quantum processors as one with error-mitigated dynamic circuits enabled by a real-time classical link. 1 Main Quantum computers process information encoded in quantum bits with unitary operations. However, quantum computers are noisy and most large-scale architectures arrange the physical qubits in a planar lattice. Nevertheless, current processors with error mitigation can already simulate hardware-native Ising models with 127 qubits and measure observables at a scale where brute-force approaches with classical computers begin to struggle . The usefulness of quantum computers hinges on further scaling and overcoming their limited qubit connectivity. A modular approach is important for scaling current noisy quantum processors and for achieving the large numbers of physical qubits needed for fault tolerance . Trapped ion and neutral atom architectures can achieve modularity by physically transporting the qubits , . In the near term, modularity in superconducting qubits is achieved by short-range interconnects that link adjacent chips , . 1 2 3 4 5 6 7 8 In the medium term, long-range gates operating in the microwave regime may be carried out over long conventional cables , , . This would enable non-planar qubit connectivity suitable for efficient error correction . A long-term alternative is to entangle remote QPUs with an optical link leveraging a microwave to optical transduction , which has not yet been demonstrated, to our knowledge. Moreover, dynamic circuits broaden the set of operations of a quantum computer by performing mid-circuit measurements (MCMs) and classically controlling a gate within the coherence time of the qubits. They enhance algorithmic quality and qubit connectivity . As we will show, dynamic circuits also enable modularity by connecting QPUs in real time through a classical link. 9 10 11 3 12 13 14 We take a complementary approach based on virtual gates to implement long-range interactions in a modular architecture. We connect qubits at arbitrary locations and create the statistics of entanglement through a quasi-probability decomposition (QPD) , , . We compare a Local Operations (LO) only scheme to one augmented by Classical Communication (LOCC) . The LO scheme, demonstrated in a two-qubit setting , requires executing multiple quantum circuits with local operations only. By contrast, to implement LOCC, we consume virtual Bell pairs in a teleportation circuit to create two-qubit gates , . On quantum hardware with sparse and planar connectivity, creating a Bell pair between arbitrary qubits requires a long-range controlled-NOT (CNOT) gate. To avoid these gates, we use a QPD over local operations resulting in cut Bell pairs that the teleportation consumes. LO do not need the classical link and is thus simpler to implement than LOCC. However, as LOCC only requires a single parameterized template circuit, it is more efficient to compile than LO and the cost of its QPD is lower than the cost of the LO scheme. 15 16 17 16 17 18 19 20 Our work makes four key contributions. First, we present the quantum circuits and QPD to create multiple cut Bell pairs to realize the virtual gates in ref. . Second, we suppress and mitigate the errors arising from the latency of the classical control hardware in dynamic circuits with a combination of dynamical decoupling and zero-noise extrapolation . Third, we leverage these methods to engineer periodic boundary conditions on a 103-node graph state. Fourth, we demonstrate a real-time classical connection between two separate QPUs thereby demonstrating that a system of distributed QPUs can be operated as one through a classical link . Combined with dynamic circuits, this enables us to operate both chips as a single quantum computer, which we exemplify by engineering a periodic graph state that spans both devices on 142 qubits. We discuss a path forward to create long-range gates and provide our conclusion. 17 21 22 23 Circuit cutting We run large quantum circuits that may not be directly executable on our hardware because of limitations in qubit count or connectivity by cutting gates. Circuit cutting decomposes a complex circuit into subcircuits that can be individually executed , , , , , . However, we must run an increased number of circuits, which we call the sampling overhead. The results from these subcircuits are then classically recombined to yield the result of the original circuit ( ). 15 16 17 24 25 26 Methods As one of the main contributions of our work is implementing virtual gates with LOCC, we show how to create the required cut Bell pairs with local operations. Here, multiple cut Bell pairs are engineered by parameterized quantum circuits, which we call a cut Bell pair factory (Fig. ). Cutting multiple pairs at the same time requires a lower sampling overhead . As the cut Bell pair factory forms two disjoint quantum circuits, we place each subcircuit close to qubits that have long-range gates. The resulting resource is then consumed in a teleportation circuit. For instance, in Fig. , the cut Bell pairs are consumed to create CNOT gates on the qubit pairs (0, 1) and (2, 3) (see section ‘ ’). 1b,c 17 1b Cut Bell pair factories , Depiction of an IBM Quantum System Two architecture. Here, two 127 qubit Eagle QPUs are connected with a real-time classical link. Each QPU is controlled by its electronics in its rack. We tightly synchronize both racks to operate both QPUs as one. , Template quantum circuit to implement virtual CNOT gates on qubit pairs ( 0, 1) and ( 2, 3) with LOCC by consuming cut Bell pairs in a teleportation circuit. The purple double lines correspond to the real-time classical link. , Cut Bell pair factories 2( ) for two simultaneously cut Bell pairs. The QPD has a total of 27 different parameter sets . Here, . a b q q q q c C θ i θ i Periodic boundary conditions We construct a graph state | ⟩ with periodic boundary conditions on ibm_kyiv, an Eagle processor , going beyond the limits imposed by its physical connectivity (see section ‘ ’). Here, has ∣ ∣ = 103 nodes and requires four long-range edges lr = {(1, 95), (2, 98), (6, 102), (7, 97)} between the top and bottom qubits of the Eagle processor (Fig. ). We measure the node stabilizers at each node ∈ and the edge stabilizers formed by the product across each edge ( , ) ∈ . From these stabilizers, we build an entanglement witness , which is negative if there is bipartite entanglement across the edge ( , ) ∈ (ref. ) (see section ‘ ’). We focus on bipartite entanglement because this is the resource we wish to recreate with virtual gates. Measuring witnesses of entanglement between more than two parties will measure only the quality of the non-virtual gates and measurements making the impact of the virtual gates less clear. G 1 Graph states G V E 2a Si i V SiSj i j E i j E 27 Entanglement witness , The heavy-hexagonal graph is folded on itself into a tubular form by the edges (1, 95), (2, 98), (6, 102) and (7, 97) highlighted in blue. We cut these edges. , The node stabilizers (top) and witnesses , (bottom), with 1 standard deviation for the nodes and edges close to the long-range edges. Vertical dashed lines group stabilizers and witnesses by their distance to cut edges. , Cumulative distribution function of the stabilizer errors. The stars indicate node stabilizers that have an edge implemented by a long-range gate. In the dropped edge benchmark (dash-dotted red line), the long-range gates are not implemented and the star-indicated stabilizers thus have unit error. The grey region is the probability mass corresponding to node stabilizers affected by the cuts. – , In the two-dimensional layouts, the green nodes duplicate nodes 95, 98, 102 and 97 to show the cut edges. The blue nodes in are qubit resources to create cut Bell pairs. The colour of node is the absolute error ∣ − 1∣ of the measured stabilizer, as indicated by the colour bar. An edge is black if entanglement statistics are detected at a 99% confidence level and violet if not. In , the long-range gates are implemented with SWAP gates. In , the same gates are implemented with LOCC. In , they are not implemented at all. a b Sj c Sj d f e i Si d e f We prepare | ⟩ using three different methods. The hardware-native edges are always implemented with CNOT gates but the periodic boundary conditions are implemented with (1) SWAP gates, (2) LOCC and (3) LO to connect qubits across the whole lattice. The main difference between LOCC and LO is a feed-forward operation consisting of single-qubit gates conditioned on 2 measurement outcomes, where is the number of cuts. Each of the 22 cases triggers a unique combination of and/or gates on the appropriate qubits. Acquiring the measurement results, determining the corresponding case and acting based on it is performed in real time by the control hardware, at the cost of a fixed added latency. We mitigate and suppress the errors resulting from this latency with zero-noise extrapolation and staggered dynamical decoupling , (see section ‘ ’). G n n n X Z 22 21 28 Error-mitigated quantum circuit switch instructions We benchmark the SWAP, LOCC and LO implementations of | ⟩ with a hardware-native graph state on ′ = ( , ′) obtained by removing the long-range gates, that is, ′ = lr. The circuit preparing | ′⟩ thus requires only 112 CNOT gates arranged in three layers following the heavy-hexagonal topology of the Eagle processor. This circuit will report large errors when measuring the node and edge stabilizers of | ⟩ for nodes on a cut gate because it is designed to implement | ′⟩. We refer to this hardware-native benchmark as the dropped edge benchmark. The swap-based circuit requires an additional 262 CNOT gates to create the long-range edges lr, which drastically reduces the value of the measured stabilizers (Fig. ). By contrast, the LOCC and LO implementation of the edges in lr does not require SWAP gates. The errors of their node and edge stabilizers for nodes not involved in a cut gate closely follow the dropped edge benchmark (Fig. ). Conversely, the stabilizers involving a virtual gate have a lower error than the dropped edge benchmark and the swap implementation (Fig. , star markers). As an overall quality metric, we first report the sum of absolute errors on the node stabilizers, that is, ∑ ∈ ∣ − 1∣ (Extended Data Table ). The large SWAP overhead is responsible for the 44.3 sum absolute error. The 13.1 error on the dropped edge benchmark is dominated by the eight nodes on the four cuts (Fig. , star markers). By contrast, the LO and LOCC errors are affected by MCMs. We attribute the 1.9 additional error of LOCC over LO to the delays and the CNOT gates in the teleportation circuit and cut Bell pairs. In the SWAP-based results, does not detect entanglement across 35 of the 116 edges at the 99% confidence level (Fig. ). For the LO and LOCC implementation, witnesses the statistics of bipartite entanglement across all edges in at the 99% confidence level (Fig. ). These metrics show that virtual long-range gates produce stabilizers with smaller errors than their decomposition into SWAPs. Furthermore, they keep the variance low enough to verify the statistics of entanglement. G G V E E EE G G G E 2b–d E 2b,c 2c i V Si 1 2c 2b,d G 2e Operating two QPUs as one We now combine two Eagle QPUs with 127 qubits each into a single QPU through a real-time classical connection. Operating the devices as a single, larger processor consists of executing quantum circuits spanning the larger qubit register. Apart from unitary gates and measurements running concurrently on the merged QPU, we use dynamic circuits to perform gates that act on qubits on both devices. This is enabled by a tight synchronization and fast classical communication between physically separate instruments required to collect measurement results and determine the control flow across the whole system . 29 We test this real-time classical connection by engineering a graph state on 134 qubits built from heavy-hexagonal rings that wind through both QPUs (Fig. ). These rings were chosen by excluding qubits plagued by two-level systems and readout issues to ensure a high-quality graph state. This graph forms a ring in three dimensions and requires four long-range gates that we implement with LO and LOCC. As before, the LOCC protocol thus requires two additional qubits per cut gate for the cut Bell pairs. As in the previous section, we benchmark our results to a graph that does not implement the edges that span both QPUs. As there is no quantum link between the two devices, a benchmark with SWAP gates is impossible. All edges exhibit the statistics of bipartite entanglement when we implement the graph with LO and LOCC at a 99% confidence level. Furthermore, the LO and LOCC stabilizers have the same quality as the dropped edge benchmark for nodes that are not affected by a long-range gate (Fig. ). Stabilizers affected by long-range gates have a large reduction in error compared with the dropped edge benchmark. The sum of absolute errors on the node stabilizers ∑ ∈ ∣ − 1∣, is 21.0, 19.2 and 12.6 for the dropped edge benchmark, LOCC and LO, respectively. As before, we attribute the 6.6 additional errors of LOCC over LO to the delays and the CNOT gates in the teleportation circuit and cut Bell pairs. The LOCC results demonstrate how a dynamic quantum circuit in which two subcircuits are connected by a real-time classical link can be executed on two otherwise disjoint QPUs. The LO results could be obtained on a single device with 127 qubits at the cost of an additional factor of 2 in run-time as the subcircuits can be run successively. 3 3c i V Si , Graph state with periodic boundaries shown in three dimensions. The blue edges are the cut edges. , Coupling map of two Eagle QPUs operated as a single device with 254 qubits. The purple nodes are the qubits forming the graph state in and the blue nodes are used for cut Bell pairs. , , Absolute error on the stabilizers ( ) and edge witnesses ( ) implemented with LOCC (solid green) and LO (solid orange) and on a dropped edge benchmark graph (dotted-dashed red) for the graph state in . In and , the stars show stabilizers and edge witnesses that are affected by the cuts. In and , the grey region is the probability mass corresponding to node stabilizers and edge witnesses, respectively, affected by the cut. In and , we observe that the LO implementation outperforms the dropped edge benchmark, which we attribute to better device conditions as these data were taken on a different day from the benchmark and LOCC data. a b a c d c d a c d c d c d Discussion and conclusion We implement long-range gates with LO and LOCC. With these gates, we engineer periodic boundary conditions on a 103-node planar lattice and connect two Eagle processors in real time to create a graph state on 134 qubits, going beyond the abilities of a single chip. Here, we chose to implement graph states as an application to highlight the scalable properties of dynamic circuits. Our cut Bell pair factories enable the LOCC scheme presented in ref. . Both the LO and LOCC protocols deliver high-quality results that closely match a hardware-native benchmark. Circuit cutting increases the variance of measured observables. We can keep the variance under control in both the LO and LOCC schemes as indicated by the statistical tests on the witnesses. An in-depth discussion of the measured variance is found in the . 17 Supplementary Information The variance increase from the QPD is why research now focuses on reducing the sampling overhead. It was recently shown that cutting multiple two-qubit gates in parallel results in optimal LO QPDs with the same sampling overhead as LOCC but requires an additional ancilla qubit and possibly reset , . In LOCC, the QPD is required only to cut the Bell pairs. This costly QPD could be removed, that is, no shot overhead, by distributing entanglement across multiple chips , . In the near to medium term, this could be done by operating gates in the microwave regime over conventional cables , , or, in the long term, with an optical-to-microwave transduction , , . Entanglement distribution is typically noisy and may result in non-maximally entangled states. However, gate teleportation requires a maximally entangled resource. Nevertheless, non-maximally entangled states could lower the sampling cost of the QPD and multiple copies of non-maximally entangled states could be distilled into a pure state for teleportation either during the execution of a quantum circuit or possibly during the delays between consecutive shots, which may be as large as 250 μs for resets . Combined with these settings, our error-mitigated and suppressed dynamic circuits would enable a modular quantum computing architecture without the sampling overhead of circuit cutting. 30 31 32 33 10 34 35 36 37 38 39 40 41 In an application setting, circuit cutting could benefit Hamiltonian simulation . Here, the cost of circuit cutting is exponential in the strength of the cut bonds times the evolution time. This cost may thus be reasonable for weak bonds and/or short evolution times. Furthermore, the LO scheme presented in ref. requires ancilla qubits in a Hadamard test, which would require a reset through a dynamic circuit if the same bond is cut multiple times in a Trotterized time evolution. 42 42 Circuit cutting can be applied to both wires and gates. The resulting quantum circuits have a similar structure making our approach applicable to both cases. Our real-time classical link implements long-range gates and classically couples disjoint quantum processors. The cut Bell pairs that we present have values beyond our work. For example, these pairs are directly usable to cut circuits in measurement-based quantum computing, which relies on dynamic circuits . This could also be accomplished with LO; the result would be an execution setting identical to ours with dynamic circuits. Furthermore, the combination of staggered dynamical decoupling with zero-noise extrapolation mitigates the lengthy delays of the feed-forward operations, which enables a high-quality implementation of dynamic circuits. Our work sheds light on the noise sources, such as cross-talk occurring during the latency, that a transpiler for distributed superconducting quantum computers must consider . In summary, we demonstrate that we can use several quantum processors as one with error-mitigated dynamic circuits enabled by a real-time classical link. 14 ZZ 43 Methods Circuit cutting The gates in a quantum circuit are quantum channels acting on density matrices . A single quantum channel is cut by expressing it as a sum over quantum channels resulting in the QPD ρ I The channels are easier to implement than and are built from LO or LOCC (Fig. ). As some of the coefficients are negative, we introduce = ∑ ∣ ∣ and = ∣ ∣/ to recover a valid probability distribution with probabilities over the channels . 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 . However, when using this QPD, we build an unbiased Monte Carlo estimator of as 16 17 1 ai γ i ai Pi ai γ Pi γ O The variance of the QPD estimator ⟨ ⟩QPD is a factor of 2 larger than the variance of the non-cut estimator ⟨ ⟩ (ref. ). When cutting > 1 identical channels, we can build an estimator by taking the product of the QPDs for each individual channel, resulting in a 2 rescaling factor , . This exponential increase in variance is compensated by a corresponding increase in the number of measured shots. Therefore, 2 is called the sampling overhead and indicates that circuit cutting must be used sparingly. Details of the LO and LOCC quantum channels and their coefficients are provided in sections ‘ ’ and ‘ ’, respectively. O γ O 44 n γ n 22 45 γ n ai Virtual gates implemented with LO Virtual gates implemented with LOCC Virtual gates implemented with LO Here, we discuss how to implement virtual CZ gates with LO , . We follow ref. and, therefore, decompose each cut CZ gate into local operations and a sum over six different circuits defined by 16 18 16 where 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. ). The operations ( + )/2 and ( − )/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 ⟨ ⟩ = ∑ ⟨ ⟩ with the LO QPD, we multiply the expectation values ⟨ ⟩ by 1 and −1 when the outcome of an MCM is 0 and 1, respectively. 46 1 I Z I Z O iai O i O i In the experiments that implement graph states with LO in the main text, we implement the CZ gate with six circuits built from gates and MCMs . Cutting four CZ gates with LO thus requires = 64 = 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 = 62 = 36 LO circuits per expectation value. In general, sampling from a QPD results in an overhead of , where is the number of circuits in the QPD and the 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 . Furthermore, as ∣ ∣ = 1/2 ∀ = 0, …, − 1, sampling from the QPD and fully enumerating it both have the same shot overhead. Rz 16 I 47 I I ai 44 ai i I The decomposition in equation ( ) with 2 = 9 is optimal with respect to the sampling overhead for a single gate . Recently, refs. , found a new protocol that achieves the same overhead as LOCC when cutting multiple gates in parallel. The proofs in refs. , are theoretical demonstrating the existence of a decomposition. 3 γ 17 30 31 γ 30 31 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 and gates) to all control instruments. X Z 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. , . 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. 29 48 29 23 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. , red area). Free evolution during this period ( ), often dominated by static cross-talk in the Hamiltonian, typically with a strength ranging from about 103 Hz to 104 Hz, substantially deteriorates results. To cancel this unwanted interaction and any other constant or slowly fluctuating or terms, we precede the conditional gates with a staggered DD – sequence, adding 3 to the switch duration (Extended Data Fig. ). 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 = ( + )/ , where is a variable delay added before each gate in the DD sequence (Extended Data Fig. ). Second, we extrapolate the stabilizer values to the zero-delay limit = 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. ). Without DD, we observe strong oscillations in the measured stabilizers that prevent an accurate ZNE (see the stabilizer in Extended Data Fig. ). As seen in the main text, this error suppression and mitigation reduce the error on the stabilizers affected by virtual gates. 2a τ ZZ IZ ZI X X τ 2a τ 22 c τ δ τ δ X 2a c 1 2 XZ 2c 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. 49 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 cut Bell pairs, we must find a linear combination of circuits with two disjoint partitions with qubits each to reproduce the statistics of Bell pairs. We create the state of the Bell pairs following ref. such that , where = 2 − 1. Here, are mixed states separable with respect to the partitions and . Note that entangles the qubit partitions and , shown in Fig. , but do not. The total cost of this QPD with two states is determined by = 2 + 1. Next, we realize from a probabilistic mixture of pure states , that is, valid probability distributions. The state is easily implemented by a uniform mixture of all basis states that correspond to a 0 entry on the diagonal of the density matrix . The basis states themselves do not appear in . We thus implement as a diagonal density matrix of basis states. The state is harder to engineer. It requires a probabilistic mixture of intricate states with entanglement within each partition and but not between them. To engineer , we thus build a parametric quantum circuit ( ) with parameters in which no two-qubit gate connects qubits between and . Following ref. , we need pure states to realize . The exact form of , omitted here for brevity, is given in Appendix B of ref. . Therefore, the total number of parameter sets required to implement one, two and three cut Bell pairs is 5, 27 and 311, respectively. Finally, the coefficients , of all the circuits in the QPD in equation ( ) that implement are k k ρk 50 tk k A B ρk A B 1c γk tk ρk ρk A B Ck θ i θ i A B 50 50 ai k 1 For = 2, the resulting weights, ∣ , ∣/ are approximately all equal. There is thus no practical difference between sampling and enumerating the = 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 and the cost of fully enumerating the QPD is , where 2 = 7. k ai k γk k γ We construct all pure states from the same template variational quantum circuit ( ) with parameters , where the index = 0, …, − 1 runs over the elements of the probabilistic mixtures defining . The parameters in the template circuits ( ) are optimized by the SLSQP classical optimizer by minimizing the 2-norm with respect to the pure target states needed to represent , where the norm is evaluated with a classical state vector simulation. After testing various approaches, we find that those provided in Fig. and Extended Data Fig. enable us to achieve an error, based on the 2 norm, of less than 10−8 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 rotations (Fig. ). As is built from basis states, we analytically derive the parameters. Therefore, we could also significantly simplify the ansatz ( ), for example, by cancelling CNOT gates. However, we keep the same template for compilation and execution efficiency. On first inspection, the parameters entering 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. Ck θ i θ i i I I θ i Ck θ i 51 L I 1c 3 L Z 46 1c Ck θ i A single-cut Bell pair is engineered by applying the gates ( 0, 1) and ( 2, 3) on qubits 0 and 1. Here, and in the figures, the gate ( , ) corresponds to . 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. and Extended Data Fig. , respectively. The circuits and the values of the parameters as obtained by the optimizer are available on GitHub ( ). U θ θ U θ θ U θ ϕ 1c 3 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 = 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. I 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 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 or 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 and which require two different measurement bases. The resulting circuit, shown in Extended Data Fig. , is structurally equivalent to half of the circuit that consumes two cut Bell pairs, for example, Fig. . 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, [(⟨ ⟩ − 1)2 + (⟨ ⟩ − 1)2]/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. ). ZZ 52 X Z ZX XZ 4a 1c ZX XZ 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 | ⟩ and second based on the MSE of the Bell pair quality test. G Graph states A graph state | ⟩ is created from a graph = ( , ) with nodes and edges by applying an initial Hadamard gate to each qubit, corresponding to a node in , and then CZ gates to each pair of qubits ( , ) ∈ (refs. , ). The resulting state | ⟩ has ∣ ∣ first-order stabilizers, one for each node ∈ , defined by = ∏ ∈ ( ) . Here, ( ) is the neighbourhood of node defined by . These stabilizers satisfy | ⟩ = | ⟩. By construction, any product of stabilizers is also a stabilizer. If an edge ( , ) ∈ is not implemented by a CZ gate, the corresponding stabilizers drop to zero, that is, ⟨ ⟩ = ⟨ ⟩ = 0. This effect can be seen in the dropped edge benchmark, see, for example, Fig. . G G V E V E V i j E 53 54 G V i V Si Xi k N i Zk N i i E Si G G i j E Si Sj 2b Entanglement witness We now define a success criterion for the implementation of a graph state with entanglement witnesses . A witness is designed to detect a certain form of entanglement. As we cut edges in the graph state, we focus on witnesses over two nodes and connected by an edge in . An edge ( , ) of our graph state | ⟩ presents entanglement if the expectation value . The witness does not detect entanglement if . The first-order stabilizers of nodes and with ( , ) ∈ are 55 i j E i j G i j i j E Here, ( ) is the neighbourhood of node , which includes because ( , ) ∈ . Thus, ( )\ is the neighbourhood of node excluding . Following refs. , , we build an entanglement witness for edge ( , ) ∈ as N i i j i j E N i j i j 55 56 i j E This witness is zero or positive if the states are separable. Alternatively, as in ref. , a witness for bi-separability is also given by 27 Here, we consider both witnesses. The data in the main text are presented for . As discussed in ref. , is more robust to noise than . However, requires more experimental effort to measure than because of the stabilizer . 56 SiSj For completeness, we now show how a witness can detect entanglement by focusing on . A separable state satisfies , where are single-qubit Pauli operators. Therefore, we can show, using the Cauchy–Schwarz inequality, that and that for separable states. Pi The step from equation ( ) to equation ( ) relies on ∏ ≤ ∏ ∣ ∣ and that , where the product runs over nodes that do not contain or . The step from equation ( ) to equation ( ) is based on the Cauchy–Schwarz inequality. The final step relies on the fact that with pure states equal to one. Therefore, the witness will be negative if the state is not separable. 10 11 iai i ai i j 11 12 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 and shown in Fig. , 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 ( , ) is bi-partite entangled if Supplementary Information 2b i j Similarly, we form a success criterion based on as This criterion penalizes any deviation from −1, that is, the most negative value that can have. Here, 99% = 2.326 is the -score of a Gaussian distribution at a 99% confidence level and is the standard deviation of edge witness . 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 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 ( , ) ∈ fails the criteria if equation ( ) or equation ( ) is not satisfied. All edges in , including the cut edges, pass the test based on when implemented with LO and LOCC (Extended Data Table ). However, some edges fail the test based on because of the lower noise robustness of compared with . z z i j E 14 15 E 2 Circuit count for stabilizer measurements Obtaining the bipartite entanglement witnesses requires measuring the expectation values of ⟨ ⟩, ⟨ ⟩ and ⟨ ⟩ of each edge ( , ) ∈ . 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 S = 7 groups of commuting observables. To mitigate final measurement readout errors, we use twirled readout error extinction (TREX) with TREX samples . When virtual gates are used with LO and LOCC, we require LO and 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 ZNE stretch factors. Therefore, the four types of experiments are executed with the following number of circuits. Si Sj SiSj i j E N N 57 I I N Swaps: S TREX N N Dropped edge: S TREX N N LO: S TREX LO N N I LOCC: S TREX LOCC ZNE N N I N In the experiments for the 103- and 134-node graph states, we use TREX = 5 and 3 TREX samples, respectively. Therefore, measuring the stabilizers without a QPD requires S × TREX = 35 circuits for the 103-node graph. For LO and LOCC, measuring the stabilizers for the graphs in the main text requires 64 and 272 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 LO = 62 and 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 S × TREX × LO = 1,260 circuits. For LOCC, we further perform error mitigation of the switch with ZNE = 5 stretch factors. We, therefore, execute S × TREX × LOCC × ZNE = 4,725 circuits to measure the error-mitigated stabilizers needed to compute . Each circuit is executed with a total of 1,024 shots. N N N I I N N I N N N I N 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 gate. These processed bit strings are then aggregated in a count dictionary with 1,024 × TREX counts. Next, to obtain the value of a stabilizer, we identify which of the 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 × 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. . 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 ZNE = 5 switch stretch factors. This fit, shown in Extended Data Fig. , enables us to report the stabilizer at the extrapolated zero-delay switch. X N N N 2b N 2d Data availability The code to analyse the counts, reproduce the plots in this paper and produce the circuits for the cut Bell pairs are available on GitHub ( ). The raw counts are unavailable on GitHub because of size constraints but are available upon reasonable request. https://github.com/eggerdj/cut_graph_state_data References Kim, Y. et al. Evidence for the utility of quantum computing before fault tolerance. , 500–505 (2023). Nature 618 Bravyi, S., Dial, O., Gambetta, J. M., Gil, D. & Nazario, Z. The future of quantum computing with superconducting qubits. , 160902 (2022). J. Appl. Phys. 132 Bravyi, S. et al. High-threshold and low-overhead fault-tolerant quantum memory. , 778–782 (2024). Nature 627 Akhtar, M. et al. A high-fidelity quantum matter-link between ion-trap microchip modules. , 531 (2023). Nat. Commun. 14 Bluvstein, D. et al. A quantum processor based on coherent transport of entangled atom arrays. , 451–456 (2022). Nature 604 Krantz, P. et al. A quantum engineer’s guide to superconducting qubits. , 021318 (2019). Appl. Phys. Rev. 6 Conner, C. R. et al. Superconducting qubits in a flip-chip architecture. , 232602 (2021). Appl. Phys. Lett. 118 Gold, A. et al. Entanglement across separate silicon dies in a modular superconducting qubit device. , 142 (2021). npj Quantum Inf. 7 Zhong, Y. et al. Violating Bell’s inequality with remotely connected superconducting qubits. , 741–744 (2019). Nat. Phys. 15 Zhong, Y. et al. Deterministic multi-qubit entanglement in a quantum network. , 571–575 (2021). Nature 590 Malekakhlagh, M. et al. Enhanced quantum state transfer and Bell-state generation over long-range multimode interconnects via superadiabatic transitionless driving. , 024006 (2024). Phys. Rev. Appl. 22 Ang, J. et al. ARQUIN: architectures for multinode superconducting quantum computers. , 19 (2024). ACM Trans. Quantum Comput. 5 Córcoles, A. D. et al. Exploiting dynamic quantum circuits in a quantum algorithm with superconducting qubits. , 100501 (2021). Phys. Rev. Lett. 127 Bäumer, E. et al. Efficient long-range entanglement using dynamic circuits. , 030339 (2024). PRX Quantum 5 Hofmann, H. F. How to simulate a universal quantum computer using negative probabilities. , 275304 (2009). J. Phys. A Math. Theor. 42 Mitarai, K. & Fujii, K. Constructing a virtual two-qubit gate by sampling single-qubit operations. , 023021 (2021). New J. Phys. 23 Piveteau, C. & Sutter, D. Circuit knitting with classical communication. , 2734–2745 (2023). IEEE Trans. Inf. Theor. 1 Singh, A. P. et al. Experimental demonstration of a high-fidelity virtual two-qubit gate. , 013235 (2024). Phys. Rev. Res. 6 Gottesman, D. & Chuang, I. L. Demonstrating the viability of universal quantum computation using teleportation and single-qubit operations. , 390–393 (1999). Nature 402 Wan, Y. et al. Quantum gate teleportation between separated qubits in a trapped-ion processor. , 875 (2019). Science 364 Viola, L., Knill, E. & Lloyd, S. Dynamical decoupling of open quantum systems. , 2417–2421 (1999). Phys. Rev. Lett. 82 Temme, K., Bravyi, S. & Gambetta, J. M. Error mitigation for short-depth quantum circuits. , 180509 (2017). Phys. Rev. Lett. 119 Reilly, D. J. Challenges in scaling-up the control interface of a quantum computer. Preprint at (2019). arxiv.org/abs/1912.05114 Peng, T., Harrow, A. W., Ozols, M. & Wu, X. Simulating large quantum circuits on a small quantum computer. , 150504 (2020). Phys. Rev. Lett. 125 Brenner, L., Piveteau, C. & Sutter, D. Optimal wire cutting with classical communication. Preprint at (2023). arxiv.org/abs/2302.03366 Pednault, E. An alternative approach to optimal wire cutting without ancilla qubits. Preprint at (2023). arxiv.org/abs/2303.08287 Zander, R. & Becker, C. K.-U. Benchmarking multipartite entanglement generation with graph states. Preprint at (2024). arxiv.org/abs/2402.00766 Mundada, P. S. et al. Experimental benchmarking of an automated deterministic error-suppression workflow for quantum algorithms. , 024034 (2023). Phys. Rev. Appl. 20 Gupta, R. S. et al. Encoding a magic state with beyond break-even fidelity. , 259–263 (2024). Nature 625 Ufrecht, C. et al. Optimal joint cutting of two-qubit rotation gates. , 052440 (2024). Phys. Rev. A 109 Schmitt, L., Piveteau, C. & Sutter, D. Cutting circuits with multiple two-qubit unitaries. Preprint at (2023). arxiv.org/abs/2312.11638 Cirac, J. I., Zoller, P., Kimble, H. J. & Mabuchi, H. Quantum state transfer and entanglement distribution among distant nodes in a quantum network. , 3221–3224 (1997). Phys. Rev. Lett. 78 Duan, L.-M., Lukin, M. D., Cirac, J. I. & Zoller, P. Long-distance quantum communication with atomic ensembles and linear optics. , 413–418 (2001). Nature 414 Magnard, P. et al. Microwave quantum link between superconducting circuits housed in spatially separated cryogenic systems. , 260502 (2020). Phys. Rev. Lett. 125 Niu, J. et al. Low-loss interconnects for modular superconducting quantum processors. , 235–241 (2023). Nat. Electron. 6 Orcutt, J. et al. Engineering electro-optics in SiGe/Si waveguides for quantum transduction. , 034006 (2020). Quantum Sci. Technol. 5 Lauk, N. et al. Perspectives on quantum transduction. , 020501 (2020). Quantum Sci. Technol. 5 Krastanov, S. et al. Optically heralded entanglement of superconducting systems in quantum networks. , 040503 (2021). Phys. Rev. Lett. 127 Bechtold, M., Barzen, J., Leymann, F. & Mandl, A. Circuit cutting with non-maximally entangled states. Preprint at (2023). arxiv.org/abs/2306.12084 Bennett, C. H. et al. Purification of noisy entanglement and faithful teleportation via noisy channels. , 722–725 (1996). Phys. Rev. Lett. 76 Tornow, C., Kanazawa, N., Shanks, W. E. & Egger, D. J. Minimum quantum run-time characterization and calibration via restless measurements with dynamic repetition rates. , 064061 (2022). Phys. Rev. Appl. 17 Harrow, A. W. & Lowe, A. Optimal quantum circuit cuts with application to clustered Hamiltonian simulation. Preprint at (2024). arxiv.org/abs/2403.01018 Caleffi, M. et al. Distributed quantum computing: a survey. Preprint at (2022). arxiv.org/abs/2212.10609 Cai, Z. et al. Quantum error mitigation. , 045005 (2023). Rev. Mod. Phys. 95 Endo, S., Benjamin, S. C. & Li, Y. Practical quantum error mitigation for near-future applications. , 031027 (2018). Phys. Rev. X 8 McKay, D. C., Wood, C. J., Sheldon, S., Chow, J. M. & Gambetta, J. M. Efficient gates for quantum computing. , 022330 (2017). Z Phys. Rev. A 96 Tran, M. C. et al. Hierarchy of linear light cones with long-range interactions. , 031009 (2020). Phys. Rev. X 10 Zettles, G., Willenborg, S., Johnson, B. R., Wack, A. & Allison, B. 26.2 Design considerations for superconducting quantum systems. In , Vol. 65, pp. 1–3 (IEEE, 2022). 2022 IEEE International Solid-State Circuits Conference (ISSCC) Cross, A. et al. OpenQASM 3: a broader and deeper quantum assembly language. , 1–50 (2022). ACM Trans. Quantum Comput. 3 Vidal, G. & Tarrach, R. Robustness of entanglement. , 141–155 (1999). Phys. Rev. A 59 Kraft, D. (DFVLR, 1988). A Software Package for Sequential Quadratic Programming Gupta, R. S. et al. Probabilistic error cancellation for dynamic quantum circuits. , 062617 (2024). Phys. Rev. A 109 Briegel, H. J. & Raussendorf, R. Persistent entanglement in arrays of interacting particles. , 910–913 (2001). Phys. Rev. Lett. 86 Hein, M., Eisert, J. & Briegel, H. J. Multiparty entanglement in graph states. , 062311 (2004). Phys. Rev. A 69 Jungnitsch, B., Moroder, T. & Gühne, O. Entanglement witnesses for graph states: general theory and examples. , 032310 (2011). Phys. Rev. A 84 Tóth, G. & Gühne, O. Entanglement detection in the stabilizer formalism. , 022340 (2005). Phys. Rev. A 72 van den Berg, E., Minev, Z. K. & Temme, K. Model-free readout-error mitigation for quantum expectation values. , 032620 (2022). Phys. Rev. A 105 Acknowledgements We acknowledge the use of IBM Quantum services for this work. The views expressed are those of the authors and do not reflect the official policy or position of IBM or the IBM Quantum team. We acknowledge B. Donovan, I. Hincks and K. Barton for circuit compilation and execution. We also thank D. Sutter, J. Orcutt, E. van den Berg, K. Temme, L. Bishop and P. Seidler for their discussions. This paper is under CC by 4.0 Deed (Attribution 4.0 International) license. available on nature
