Abstract
Suppressing errors is the central challenge for useful quantum computing^{1}, requiring quantum error correction (QEC)^{2,3,4,5,6} for largescale processing. However, the overhead in the realization of errorcorrected ‘logical’ qubits, in which information is encoded across many physical qubits for redundancy^{2,3,4}, poses substantial challenges to largescale logical quantum computing. Here we report the realization of a programmable quantum processor based on encoded logical qubits operating with up to 280 physical qubits. Using logicallevel control and a zoned architecture in reconfigurable neutralatom arrays^{7}, our system combines high twoqubit gate fidelities^{8}, arbitrary connectivity^{7,9}, as well as fully programmable singlequbit rotations and midcircuit readout^{10,11,12,13,14,15}. Operating this logical processor with various types of encoding, we demonstrate improvement of a twoqubit logic gate by scaling surfacecode^{6} distance from d = 3 to d = 7, preparation of colourcode qubits with breakeven fidelities^{5}, faulttolerant creation of logical Greenberger–Horne–Zeilinger (GHZ) states and feedforward entanglement teleportation, as well as operation of 40 colourcode qubits. Finally, using 3D [[8,3,2]] code blocks^{16,17}, we realize computationally complex sampling circuits^{18} with up to 48 logical qubits entangled with hypercube connectivity^{19} with 228 logical twoqubit gates and 48 logical CCZ gates^{20}. We find that this logical encoding substantially improves algorithmic performance with error detection, outperforming physicalqubit fidelities at both crossentropy benchmarking and quantum simulations of fast scrambling^{21,22}. These results herald the advent of early errorcorrected quantum computation and chart a path towards largescale logical processors.
Similar content being viewed by others
Main
Quantum computers have the potential to substantially outperform their classical counterparts for solving certain problems^{1}. However, executing largescale, useful algorithms on quantum processors requires very low gate error rates (generally below about 10^{−10})^{23}, far below those that will probably ever be achievable with any physical device^{2}. The landmark development of QEC theory provides a conceptual solution to this challenge^{2,3,4}. The key idea is to use entanglement to delocalize a logical qubit degree of freedom across many redundant physical qubits, such that, if any given physical qubit fails, it does not corrupt the underlying logical information. In principle, with sufficiently low physical error rates and sufficiently many qubits, a logical qubit can be made to operate with extremely high fidelity, providing a path to realizing largescale algorithms^{4}. However, in practice, useful QEC poses many challenges, ranging from large overhead in physical qubit numbers^{23} to highly complex gate operations between the delocalized logical degrees of freedom^{24}. Recent experiments have achieved milestone demonstrations of two logical qubits and one entangling gate^{5,6} and explorations of new encodings^{25,26,27,28}.
One specific challenge for realizing largescale logical processors involves efficient control. Unlike modern classical processors that can efficiently access and manipulate many bits of information^{29}, quantum devices are typically built such that each physical qubit requires several classical control lines. Although suitable for the implementation of physical qubit processors, this approach poses a substantial obstacle to the control of logical qubits redundantly encoded over many physical qubits.
Here we describe the realization of a programmable quantum processor based on hardwareefficient control over logical qubits in reconfigurable neutralatom arrays^{7}. We use this logical processor to demonstrate key building blocks of QEC and realize programmable logical algorithms. In particular, we explore important features of logical operations and circuits, including scaling to large codes, fault tolerance and complex nonClifford circuits.
Logical processor based on atom arrays
Our logical processor architecture, illustrated in Fig. 1a, is split into three zones (see also Extended Data Fig. 1). The storage zone is used for dense qubit storage, free from entanglinggate errors and featuring long coherence times. The entangling zone is used for parallel logical qubit encoding, stabilizer measurements and logical gate operations. Finally, the readout zone enables midcircuit readout of desired logical or physical qubits, without disturbing the coherence of the computation qubits still in operation. This architecture is implemented using arrays of individual ^{87}Rb atoms trapped in optical tweezers, which can be dynamically reconfigured in the middle of the computation while preserving qubit coherence^{7,9}.
Our experiments make use of the apparatus described previously in refs. ^{7,8,30}, with key upgrades enabling universal digital operation. Physical qubits are encoded in clock states within the groundstate hyperfine manifold (T_{2} > 1s (ref. ^{7})) and stored in optical tweezer arrays created by a spatial light modulator (SLM)^{30,31}. We use systems of up to 280 atomic qubits, combining highfidelity twoqubit gates^{8}, enabled by fast excitation into atomic Rydberg states interacting through robust Rydberg blockade^{32}, with arbitrary connectivity enabled by atom transport by means of 2D acoustooptic deflectors (AODs)^{7}. Central to our approach of scalable control, AODs^{10,11,12,13,14,15,31,33} use frequency multiplexing to take in just two voltage waveforms (one for each axis) to create large, dynamically programmable grids of light. Fully programmable local singlequbit rotations are realized through qubitspecific, parallel Raman excitation through an additional 2D AOD (ref. ^{34}) (Fig. 1b and Extended Data Fig. 2). Midcircuit readout is enabled by moving selected qubits about 100 μm away to a readout zone and illuminating with a focused imaging beam^{7,35}, resulting in highfidelity imaging, as well as negligible decoherence on stored qubits (Fig. 1c and Extended Data Fig. 3). The midcircuit^{10,11,12,13,14,15} image is collected with a CMOS camera and sent to a fieldprogrammable gate array (FPGA) for realtime decoding and feedforward.
The central aspect of our logical processor is the control of individual logical qubits as the fundamental units, instead of individual physical qubits. To this end, we observe that, during most errorcorrected operations, the physical qubits of a logical block are supposed to realize the same operation, and this instruction can be delivered in parallel with only a few control lines. This approach naturally multiplexes with optical techniques. For example, to realize a logical singlequbit gate^{2}, we use the Raman 2D AOD (Fig. 1b) to create a grid of light beams and simultaneously illuminate the physical qubits of the logical block with the same instruction. Such a gate is transversal^{2}, meaning that operations act on physical qubits of the code block independently. This transversal property further implies that the gate is inherently faulttolerant^{2}, meaning that errors cannot spread within the code block (see Methods), thereby preventing a physical error from spreading into a logical fault. Crucially, a similar approach can realize logical entangling gates^{2,4}. Specifically, we use the grids generated by our moving 2D AOD to pick up two logical qubits, interlace them in the entangling zone and then pulse our single global Rydberg excitation laser to realize a physical entangling gate on each twin pair of the blocks (Figs. 1a and 2a). This process realizes a highfidelity, faulttolerant transversal CNOT in a single parallel step.
Improving entangling gates with code distance
A key property of QEC codes is that, for error rates below some threshold, the performance should improve with system size, associated with a socalled code distance^{4,24}. Recently, this property has been experimentally verified by reducing idling errors of a code^{6}. Neutralatom qubits can be idly stored for long times with low errors, and the central challenge is to improve entangling operations with code distance. Thus motivated, we realize a transversal CNOT gate using logical qubits encoded in two surface codes (Fig. 2). Surface codes have stabilizers that are used for detecting and correcting errors without disrupting the logical state^{4,24}. The stabilizers form a 2D lattice of fourbody plaquettes of X and Z operators, which commute with the X_{L} (Z_{L}) logical operators that run horizontally (vertically) along the lattice (Fig. 2d). By measuring stabilizers, we can detect the presence of physical qubit errors, decode (infer what error occurred) and correct the error simply by applying a software Z_{L}/X_{L} correction^{24}. Such a code can detect and correct a certain number of errors determined by the linear dimension of the system (the code distance d).
To test the performance of our logical entangling gate, we first initialize the logical qubits by preparing physical qubits of two blocks in +⟩ and 0⟩ states, respectively, and performing a single round of stabilizer measurements with parallel operations^{7}. Although this state preparation is nonfaulttolerant (nFT) beyond d = 3, we are still able to study error suppression of the transversal CNOT (Methods). Specifically, we prepare the two logicals in state +_{L}⟩ and 0_{L}⟩, perform the transversal CNOT and then projectively measure to evaluate the logical Bellstate stabilizers \({{\rm{X}}}_{{\rm{L}}}^{1}{{\rm{X}}}_{{\rm{L}}}^{2}\) and \({{\rm{Z}}}_{{\rm{L}}}^{1}{{\rm{Z}}}_{{\rm{L}}}^{2}\) (Fig. 2c). For decoding and correcting the logical state, we observe that there are strong correlations between the stabilizers of the two blocks (Extended Data Figs. 4 and 5) owing to propagation of physical errors between the codes during the transversal CNOT (ref. ^{36}) (Fig. 2b). We use these correlations to improve performance by decoding the logical qubits jointly, realized by a joint decoding graph that includes edges and hyperedges connecting the stabilizers of the two logical qubits (Fig. 2b, Methods). Using this correlated decoding procedure, we measure roughly 0.95 populations in the X_{L}X_{L} and Z_{L}Z_{L} bases (Fig. 2c), showing entanglement between the d = 7 logical qubits.
Studying the performance as a function of code size (Fig. 2d) reveals that the logical Bell pair improves with larger code distance, demonstrating improvement of the entangling operation. By contrast, we note that, when conventional decoding, that is, independent minimumweight perfect matching within both codes^{4}, is used, the fidelity decreases with code distance. This is in part because of the nFT state preparation, whose effect is partially mitigated by the correlated decoding (Methods).
We emphasize that, although these results demonstrate surpassing an effective threshold for the entire circuit (implying that we surpass the threshold of the transversal CNOT), such a threshold is higher owing to projective readout after the transversal CNOT. In practice, the transversal CNOT should be used in combination with many repeated rounds of noisy syndrome extraction^{6}, which is expected to have a lower threshold and is an important goal for future research.
Faulttolerant logical algorithms
All logical algorithms we perform in this work are built from transversal gates, which are intrinsically faulttolerant^{2}. We now also use faulttolerant state preparation to explore programmable logical algorithms. We use 2D d = 3 colour codes^{3,37}, which are topological codes akin to the surface code, but with the useful capability of transversal operations of the full Clifford group: Hadamard (H), π/2 phase (S) gate and CNOT (ref. ^{37}). This transversal gate set can realize any Clifford circuit faulttolerantly. As a test case, here we create a logical GHZ state. Figure 3a shows the implementation of a tenlogicalqubit algorithm, in which all ten qubits are first encoded by a nFT encoding circuit (Methods). Then, five of the codes are used as ancilla logicals, performing parallel transversal CNOTs to faulttolerantly detect errors on the computation logicals^{38}, and are then moved into the storage zone, in which they are safely kept. Subsequently, four computation logicals are used to prepare the GHZ state and logical Clifford rotations are used at the end of the circuit for direct fidelity estimation^{39} and full logical state tomography.
We first benchmark our state initialization^{5,40,41} (Fig. 3b). Averaged over the five computation logicals, we find that, by using the faulttolerant initialization (postselecting on the ancilla logical flag not detecting errors) our 0_{L}⟩ initialization fidelity is \(99.9{1}_{0.09}^{+0.04} \% \), exceeding both our physical qubit 0⟩ initialization fidelity (99.32(4)% (ref. ^{8})) and physical twoqubit gate fidelity (99.5% (ref. ^{8})). Then, Fig. 3c shows that the resulting GHZ state fidelity obtained using the faulttolerant algorithm is 72(2)% (again using correlated decoding), demonstrating genuine multipartite entanglement. Furthermore, we can postselect on all stabilizers of our computation logicals being correct; using this errordetection approach, the GHZ fidelity increases to \(99.8{5}_{1.0}^{+0.1} \% \), at the cost of postselection overhead.
Because not all nontrivial syndromes are equally likely to cause algorithmic failure, we can perform a partial postselection, in which syndrome events most likely to have caused algorithmic failure are discarded, given by the weight of the correlated matching in the whole algorithm. Figure 3d shows the measured GHZ fidelity as a function of this sliding threshold converted into a fraction of accepted experimental repetitions, continuously tuning the tradeoff between the success probability of the algorithm and its fidelity; for example, discarding just 50% of the data improves GHZ fidelity to approximately 90%. (As discussed below, for certain applications, purifying samples can be advantageous in improving algorithmic performance.) Finally, faulttolerantly measuring all 256 logical Pauli strings, we perform full GHZ state tomography (Fig. 3e).
The use of the zoned architecture directly allows scaling circuits to larger numbers, without increasing the number of controls, by encoding and operating on logical qubits, moving them to storage and then accessing storage as appropriate. This process is illustrated in Fig. 4a,b, in which ten colour codes are made and operated on with parallel transversal CNOTs, moved to storage and then more qubits are accessed from storage. Repeating this process four times, we create 40 colour codes with 280 physical qubits, at the cost of slow idling errors of roughly 1% logical decoherence per additional encoding step (Fig. 4c). These storage idling errors primarily originate from global Raman π pulses applied for dynamical decoupling of atoms in the entangling zone, which could be greatly reduced with zonespecific Raman controls.
Because midcircuit readout^{10,11,12,13,14,15} is an important component of logical algorithms, we next demonstrate a faulttolerant entanglement teleportation circuit. We first create a threelogicalqubit GHZ state 0_{L}0_{L}0_{L}⟩ + 1_{L}1_{L}1_{L}⟩ (Fig. 4d,e) from faulttolerantly prepared colour codes. Midcircuit Xbasis measurement of the middle logical creates 0_{L}0_{L}⟩ + 1_{L}1_{L}⟩ if measured as +_{L}⟩ and 0_{L}0_{L}⟩ − 1_{L}1_{L}⟩ if measured as −_{L}⟩. We recover 0_{L}0_{L}⟩ + 1_{L}1_{L}⟩ by applying a logical S gate to the first and third logicals conditioned in real time on the state of the middle logical, akin to the magicstateteleportation circuit^{24}. Measurements in Fig. 4e indicate that, although ⟨X_{L}X_{L}⟩ and ⟨Y_{L}Y_{L}⟩ indeed vanish without the feedforward step, by applying the feedforward correction, we recover a Bellstate fidelity of 77(2)%, limited by imperfections in the original underlying GHZ state. By repeating this experiment without midcircuit readout and instead postselecting on the middle logical being in +_{L}⟩, we find a similar Bell fidelity of 75(2)%, indicating highfidelity performance of the readout and feedforward operations.
Complex logical circuits using 3D codes
One important challenge in realizing complex algorithms with logical qubits is that universal computation cannot be implemented transversally^{42}. For instance, when using 2D codes such as the surface code, nonClifford operations cannot be easily performed^{37}, and relatively expensive techniques are required for nontrivial computation^{24,43}, as Clifford circuits can be easily simulated^{44}. By contrast, 3D codes can transversally realize nonClifford operations, but lose the transversal H (ref. ^{37}). However, these constraints do not imply that classically hard or useful quantum circuits cannot be realized transversally or efficiently. Motivated by these considerations, we explore efficient realization of classically hard algorithms that are codesigned with a particular errorcorrecting code. Specifically, we implement fast scrambling circuits using small 3D codes, which are used for native nonClifford operations (CCZ).
We focus on small 3D [[8,3,2]] codes^{16,17,26,27} (Fig. 5a), which have various appealing features. They encode three logicals per block, feature d = 2 (d = 4) in the Z basis (X basis), implying errordetection (errorcorrection) capabilities for Z (X) errors and can realize a transversal CNOT between blocks. Most importantly, by using physical {T, S} rotations (T is π/4 phase gate), we can realize transversal {CCZ, CZ, Z} gates on the logical qubits encoded within each block, as well as intrablock CNOTs by physical permutation^{26,27} (Methods). This gate set allows us to transversally realize the circuits illustrated in Fig. 5a,c, alternating between layers of {CCZ, CZ, Z} within blocks and layers of CNOTs between blocks. Although transversal H is forbidden, initialization and measurement in either the X or the Z basis effectively allows H at the beginning and end of the circuit.
We use these transversal operations to realize logical algorithms that are difficult to simulate classically^{45,46}. More specifically, these circuits can be mapped to instantaneous quantum polynomial (IQP) circuits^{20,45,46}. Sampling from the output distribution of such circuits is known to be classically hard in certain instances^{20}, implying that a quantum device can be exponentially faster than a classical computer for this task.
Figure 5b shows an example implementation of a 12logicalqubit sampling circuit. Here we prepare all logical blocks in +_{L}⟩, implement a scrambling circuit with 28 logical entangling gates and then measure all logicals in the X basis. Figure 5b shows the probability of observing each of the 2^{12} = 4,096 possible logical bitstring outcomes, showing that, as we progressively apply more error detection (that is, postselection) in postprocessing, the distribution more closely reproduces the ideal theoretical distribution. To characterize the distribution overlap, we use the crossentropy benchmark (XEB)^{18,47}, which is a weighted sum between the measured probability distribution and the ideal calculated distribution, normalized such that XEB = 1 corresponds to perfectly reproducing the ideal distribution and XEB = 0 corresponds to the uniform distribution, which occurs when circuits are overwhelmed by noise. Consistent with Fig. 5b, the 12logicalqubit circuit XEB increases from 0.156(2) to 0.616(7) when applying error detection (Fig. 5e). We note that the XEB should be a good fidelity benchmark for IQP circuits (Methods).
We next explore scaling to larger systems and circuit depths. To ensure high complexity of our logical circuits, we use nonlocal connections to entangle the logical triplets on up to 4D hypercube graphs (Extended Data Fig. 6 and Supplementary Video 3), which results in fast scrambling^{19}. Exploring entangled systems of 3, 6, 12, 24 and 48 logical qubits, in all cases, we find a finite XEB score, which improves with increased error detection (Fig. 5e,f). The finite XEB indicates successful sampling and the improvement with error detection shows the benefit of using logical qubits. Although this improvement comes at the cost of measurement time owing to error detection, improving the sample quality cannot be replaced by simply generating more samples. Thus, improving the XEB score yields substantial practical gains. We obtain an XEB of approximately 0.1 for 48 logical qubits and hundreds of nonlocal logical entangling gates, up to roughly an order of magnitude higher than previous physical qubit implementations of digital circuits of similar complexity^{18,48}, showing the benefits of a logical encoding for this application.
Assuming our best measured physical fidelities, the estimated upper bound for an optimized physical qubit implementation in our system is also greatly below the measured logical XEB (blue line in Fig. 5f; Methods). In attempting to run these complex physical circuits, in practice, we find that realizing nonvanishing XEB is much more challenging; we confirm with small physical instances that we measure values well below this upper bound (Methods). As well as the errordetecting benefits, it seems that the logical circuit is substantially more tolerant to coherent errors, exhibiting operation that is inherently digital, just with imperfect fidelity (see, for example, Extended Data Fig. 7a), consistent with theoretical predictions^{49}. We also note that, for the logical algorithms, we optimize performance by optimizing the stabilizer expectation values (rather than the complex sampling output), providing further advantage for logical implementations.
Our 48logical circuit, corresponding to a physical qubit connectivity of a 7D hypercube, contains up to 228 logical twoqubit gates and 48 logical CCZ gates. Simulation of such logical circuits is challenging because of the high connectivity (rendering tensor networks inefficient) and large numbers of nonCliffords^{50}. To benchmark our circuits, we structure them such that we can use an efficient simulation method (Methods), which takes about 2 s to calculate the probability of each bitstring (Fig. 5d and Extended Data Fig. 8). Modelling noise in our logical circuits is even more complicated, as they are composed of 128 physical qubits and 384 T gates, thereby making experimentation with logical algorithms necessary to understand and optimize performance.
Quantum simulations with logical qubits
Finally, we explore the use of logical qubits as a tool in quantum simulation, probing entanglement properties of our fast scrambling circuits, potentially related to complex systems such as black holes^{19,51}. In particular, we use a Bellbasis measurement made on two copies of the quantum state (Fig. 6a), which is a powerful tool that can efficiently extract many properties of an unknown state^{21,22,52}. With this twocopy technique, in Fig. 6b, we plot the measured entanglement entropy in the scrambled system. We observe a characteristic Page curve^{51} associated with a maximally entangled, highly scrambled, but globally pure state. These measurements also reveal a final state purity of 0.74(3), compared with the measured XEB of 0.616(7) in Fig. 5f, consistent with the XEB being a good proxy for the final state fidelity. Despite postselection overhead, we find that error detection greatly improves signal to noise here, as nearzero entropies are exponentially faster to measure (Extended Data Fig. 9).
Twocopy measurements can also be used to simultaneously extract information about all 4^{N} Pauli strings^{22}. Using this property and an analysis technique known as Bell difference sampling^{53}, we experimentally evaluate and directly verify the amount of additive Bell magic^{53} in our circuits as a function of the number of applied logical CCZs (Fig. 6c). This measurement of magic, associated with nonClifford operations, quantifies the number of T gates (assuming decomposition into T) required to realize the quantum state by observing the probability that sampled Pauli strings commute with each other (see Methods). Moreover, combining encoded qubits and twocopy measurement allows for further errormitigation techniques. As an example, Fig. 6d shows the measured absolute expectation values of all 4^{12} logical Pauli strings with slidingscale error detection. Because in the twocopy measurements for each errordetection threshold we also measure the overall system purity, we can extrapolate our expectation values to the case of unit purity (zero noise)^{54}. This procedure evaluates the averaged Pauli expectation values to about 10% relative precision of the ideal theoretical values spanning several orders of magnitude (Methods).
Outlook
These experiments demonstrate key ingredients of scalable error correction and quantum information processing with logical qubits. As well as implementing the key elements of logical processing, our approach demonstrates practical utility of encoding methods for improving sampling and quantum simulations of complex scrambling circuits. Future work can explore whether these methods can be generalized, for example, to more robust, higherdistance codes and if such highly entangled, nonClifford states could be used in practical algorithms. We note that the demonstrated logical circuits are approaching the edge of exact simulation methods (Fig. 5d) and can readily be used for exploring errorcorrected quantum advantage. These examples demonstrate that the use of new encoding schemes, codesigned with efficient implementations, can allow the implementation of particular logical algorithms at reduced cost.
Our observations open the door for exploration of largescale logical qubit devices. A key future milestone would be to perform repetitive error correction^{6} during a logical quantum algorithm to greatly extend its accessible depth. This repetitive correction can be directly realized using the tools demonstrated here by repeating the stabilizer measurement (Fig. 2) in combination with midcircuit readout (Fig. 4). The use of the zoned architecture and logicallevel control should allow our techniques to be readily scaled to more than 10,000 physical qubits by increasing laser power and optimizing control methods, whereas QEC efficiency can be improved by reducing twoqubit gate errors to 0.1% (ref. ^{8}). Deep computation will further require continuous reloading of atoms from a reservoir source^{11,15}. Continued scaling will benefit from improving encoding efficiency, for example, by using quantum lowdensityparitycheck codes^{55,56}, using erasure conversion^{13,33,57} or noise bias^{35} and optimizing the choice of (possibly several) atomic species^{11,14,47}, as well as advanced optical controls^{34}. Further advances could be enabled by connecting processors together in a modular fashion using photonic links or transport^{10,58} or more powerefficient trapping schemes such as optical lattices^{59}. Although we do not expect clock speed to limit mediumscale logical systems, approaches to speed up processing in hardware^{60} or with nonlocal connectivity^{61} should also be explored. We expect that such experiments with earlygeneration logical devices will enable experimental and theoretical advances that greatly reduce anticipated costs of largescale errorcorrected systems, accelerating the development of practical applications of quantum computers.
Methods
System overview
Our experimental apparatus (Extended Data Fig. 1a) is described previously in refs. ^{7,8,30}. To carry out these experiments, several key upgrades have been made enabling programmable quantum circuits on both physical and logical qubits. A cloud containing millions of cold ^{87}Rb atoms is loaded in a magnetooptical trap inside a glass vacuum cell, which are then loaded stochastically into programmable, static arrangements of 852nm traps generated with a SLM and rearranged with a set of 850nm moving traps generated by a pair of crossed AODs (DTSX400, AA OptoElectronic) to realize defectfree arrays^{30,31,62}. Atoms are imaged with a 0.65NA objective (Special Optics) onto a CMOS camera (Hamamatsu ORCAQuest C1555020UP), chosen for fast electronic readout times. The qubit state is encoded in m_{F} = 0 hyperfine clock states in the ^{87}Rb groundstate manifold, with T_{2} > 1s (ref. ^{7}), and fast, highfidelity singlequbit control is executed by twophoton Raman excitation^{7,63} (Extended Data Fig. 1b). A global Raman path illuminating the entire array is used for global rotations (Rabi frequency roughly 1 MHz, resulting in approximately 1μs rotations with composite pulse techniques^{7}), as well as for dynamical decoupling throughout the entire circuit (typically one global π pulse per movement). Fully programmable local singlequbit rotations are realized with the same Raman light but redirected through a local path, which is focused onto targeted atoms by an additional set of 2D AODs. Entangling gates (270ns duration) between clock qubits are performed with fast twophoton excitation using 420nm and 1,013nm Rydberg beams to n = 53 Rydberg states, using a timeoptimal twoqubit gate pulse^{64,65}, detailed in ref. ^{8}. During the computation, atoms are rearranged with the AOD traps to enable arbitrary connectivity^{7,66,67}. Midcircuit readout is carried out by illuminating from the side with a locally focused 780nm imaging beam, with scattered photons collected on the CMOS camera and processed in real time by a FPGA (Xilinx ZCU102), with feedforward control signal outputs.
The quantum circuits are programmed with a control infrastructure consisting of five arbitrary waveform generators (AWGs) (Spectrum Instrumentation), as illustrated in Extended Data Fig. 1c, synchronized to <10 ns jitter. The twochannel ‘Rearrangement AWG’ is used for rearranging into defectfree arrangements^{30} before the circuit, the one channel of the ‘Rydberg AWG’ is used for entanglinggate pulses, the four channels of the ‘Raman AWG’ are used for IQ (inphase and quadrature) control of a 6.8GHz source^{7,63} (the global phase reference for all qubits) and pulseshaping of the global and local Raman driving, the two channels of the ‘Raman AOD AWG’ are used for generating tones that create the programmable light grids for local singlequbit control and the two channels of the ‘Moving AOD AWG’ are used for controlling the positions of all atoms during the circuit. AODs are central to our methods of efficient control^{62}, in which the two voltage waveforms (one for the x axis and one for the y axis) control many physical or logical qubits in parallel: each row and column of the grid simply corresponds to a single frequency tone, and these tones are then superimposed in the waveform delivered to the AOD (amplified by Mini Circuits ZHL5W1+). The phase relationship between tones is chosen to minimize interference.
Programming circuits
Most of the system parameters used in our approach do not have hard limits but instead result from possible tradeoffs. Next, we detail some design decisions made for the circuits used in this work.
Zone parameter choices
For simplicity, we keep the entangling zone fixed for all experiments. This conveniently allows us to switch between, for example, surface code and [[8,3,2]] code experiments, without further calibrations. We choose our entanglingzone profile, realized by 420nm and 1,013nm Rydberg ‘tophat’ beams generated by SLM phase profiles^{30}, to be homogeneous over a 35μmtall region. As the Rydberg beams propagate longitudinally, the entangling zone is longer than it is tall. We optimize top hats to be homogeneous over roughly 250μm horizontal extent. Taller regions are also achievable, with a tradeoff with reduced laser intensity and greater challenge in homogenization. The 250μm width of the zones used here is set by the bandwidth of our AOD deflection efficiency. We position the readout zone on the other side of the storage zone to further minimize decoherence on entanglingzone atoms.
Our twoqubit gate parameters are similar to our previous work in ref. ^{8}. During twoqubit Rydberg (n = 53) gates, we place atoms ≲2 μm apart within a ‘gate site’, resulting in ≳450 MHz interaction strength between pairs, much larger than the Rabi frequency of 4.6 MHz. Notably, owing to the use of the Rydberg blockade^{32,68}, the gate is largely independent of the exact distance between atoms. Hence, precise interatom positioning is not required. Gate sites are separated such that atoms in different gate sites are no closer than 10 μm during the gate, resulting in negligible longrange interactions. Throughout this work, we use four gate sites vertically (five for the surfacecode experiment) and 20 horizontally, performing gates on as many as 160 qubits simultaneously (see Extended Data Fig. 1d). Under various conditions, with proper calibration, we measure twoqubit gate fidelities in the range F = 99.3–99.5%. We do not observe any error on storagezone atoms when Rydberg gates are executed in the entangling zone. Even though the tail of the tophat Rydberg excitation beams is only suppressed to about 10% intensity, the twophoton drive is far offresonant owing to the approximately 20 MHz 1013 light shift detuning that is present for the entanglingzone atoms^{8}. We natively realize physical CZ gates; when implementing CNOTs, we add physical H gates. We find minimal twoqubit crosstalk between gate sites, as examined with long benchmarking sequences in ref. ^{8}. Although ref. ^{8} seems to find some small crosstalk seemingly originating from decay into Rydberg P states, this should be considerably suppressed in the practical operation here owing to the approximately 200 μs duration between gates, during which time Rydberg atoms should either fly away or decay back to the ground state.
Shuttling and transfers
The SLM tweezers can have arbitrary positions but are static. The AOD tweezers are mobile but have several constraints^{7,69}. In particular, the AOD array creates rectangular grids (but not all sites need to be filled). During the atommoving operations, they are only used for stretches, compressions and translations of the AOD trap array, that is, atoms move in rows and columns, and rows and columns never cross^{7,69}. Arbitrary qubit motions and permutation is achieved by shuttling atoms around in AOD tweezers and then transferring atoms between AOD and SLM tweezers as appropriate. We perform gates on pairs of atoms in both AOD–AOD traps and AOD–SLM traps, with no observed difference for gate performance as measured by randomized benchmarking^{8}.
We find that freespace shuttling of atoms (that is, no transfers) in AOD tweezers comes essentially with no fidelity cost (other than time overhead), consistent with our previous work^{7}. Two further improvements here are the use of a photodiode to calibrate and homogenize the 2D deflection efficiency of our 2D AODs to percentlevel homogeneity across our used region and engineering atomic trajectories and echo sequences to cancel out residualpathdependent inhomogeneities. For example, we move an atom 100 μm away to realize a distant entangling gate and then, before returning the atom, we perform a Raman π pulse, so that differential light shifts accumulated during the return trip cancel with the first trip. Motion is realized with a cubic profile as in ref. ^{7}, the characteristic freespace movement time between gates is roughly 200 μs and acousticlensing effects from the AOD are estimated to be negligible. We pulse the 1013 laser off during motion to remove loss effects from the large light shifts. Note that the 1013induced differential light shift on the hyperfine qubit is only on the kHz scale but we still ensure its effects are properly echoed out.
Transferring atoms between tweezers^{9} presents further challenges. We measure the infidelity of each transfer, encompassing both dephasing and loss, to be ≲0.1%. To achieve this performance, in our transfer from SLM to AOD, we ramp up the intensity of the AOD tones (with quadratic intensity profile when possible) corresponding to the appropriate sites over a time of 100–200 μs to a trap depth about two times larger than the SLM trap depth, and then move the AOD trap 1–2 μm away over a time of 50–100 μs. These timescales can probably be shortened considerably while suppressing errors using optimal control techniques. During subsequent motion, we leave the AOD trap depth at this 2× value. To transfer an atom AOD to SLM, we perform the reversed process. During these transfer processes, the differential light shifts on the transferred atoms are dynamically changing and can result in large unechoed phase shifts. As such, whenever possible, we engineer circuits such that pairs of transfers will echo with appropriately chosen π pulses. When echoing pairs of transfers is not possible, we perform one cycle of XY4 or XY8 dynamical decoupling during the transfer. Finally, we note that lowloss transfer is highly sensitive to alignment of the AOD and SLM grid. We fix small optical distortions between the AOD and SLM tweezer grids by fine adjustment of individual SLM grid tweezers, which can be arbitrarily positioned, to overlap with the AOD traps as seen on an image plane reference camera. It is important to adjust the SLM and not the AOD, as small adjustments of individual AOD tones deviating from a frequency comb causes beating and atom loss.
Dynamical decoupling and local gates
In our circuit design, we engineer our echo sequences to cancel out as many deleterious aspects as possible. We ensure that, in our dynamical decoupling, we have an odd number of π pulses between CZ gates (whenever possible), as this echoes out both systematic and spurious contributions to the singlequbit phase^{7,8}. We apply appropriate X(π) and Z(π) rotations between local addressing with the local Raman to cancel out errors induced by the global π/2 pulses, as well as between pulses of the 420nm laser (when used for entanglingzone singlequbit rotations^{7}) to echo out small crosstalk experienced in the storage zone by the tail of the 420nm beam. For our global decoupling pulses, we use both BB1 pulses^{70} and SCROFULOUS pulses^{71}. To benchmark and optimize coherence during our complex circuits, we perform a Ramsey fringe measurement encompassing the entire movement and singlequbit gate sequence and optimize the observed contrast^{7}. When performing properly, our total singlequbit error is consistent with state preparation and measurement (SPAM)^{8}, an effective coherence time of 1–2 s and the Raman scattering error of all the Raman pulses^{7,63}. We note that these measured coherence times include the movement within and between zones; although we use fewer pulses (typically one per movement) than the XY16128 sequence used to benchmark 1.5 s coherence in ref. ^{7}, the coherence times here are naturally longer because of furtherdetuned tweezers used (852 nm rather than 830 nm).
Local singlequbit gates^{34,72} with the Raman AOD are realized in arbitrary positions in space on both AOD and SLM atoms. Targeted logical qubit blocks are addressed by a grid illumination of the logical block. Arbitrary patterns of rotations on the qubit grid (for example, during colourcode preparation) are realized with rowbyrow serializing, with the targeted x coordinates in each row simultaneously illuminated. The duration of each row is 5–8 μs (corresponding to several tens of μs for an arbitrary pattern of rotations), which can be sped up considerably, as discussed in the next section. For simplicity, we carefully calibrate rotations on 80–160 specific sites across the array, but also perform rotations in arbitrary spots using the nearest calibrated values.
With the local singlequbit gates and entanglingzone twoqubit gates calibrated, the entire circuit is simply defined by the appropriate trapping SLM phase profile and waveforms for our several AWG channels and TTL pulse generator. These several channels then program complex, varied circuits on hundreds of physical qubits. Animations of all of our programmed circuits are attached as Supplementary Videos.
Programmable singlequbit gates
To enable individual singlequbit gates, we use the same Raman laser system as our global rotation scheme and illuminate only chosen atoms using a pair of crossed AODs. The focused beam waist in the plane of the atoms is 1.9 μm, which is large enough to be robust to fluctuations in atomic positions and small enough to prevent crosstalk to neighbouring atoms separated by ≳6 μm. For Raman excitation, polarization needs to be carefully considered. Unlike the global path, the local beampropagation direction is perpendicular to the atomquantization axis (set by the external magnetic field). Therefore, the fictitious magnetic field \({\overrightarrow{B}}_{{\rm{fict}}}\) responsible for driving the transitions, as described in ref. ^{63}, preferentially drives σ^{±} hyperfine transitions rather than the desired π clock transition^{73}. There exist two possible approaches to singlequbit gates, as illustrated in Extended Data Fig. 2a. First, offresonant σ^{±} dressing generates differential light shifts between qubit states, enabling fast local Z(θ) gates. Global π/2 rotations convert these to local X(θ) gates. Second, we can directly apply local X(θ) gates with direct π transitions by slightly rotating the quantization axis towards the local beam direction; this could be achieved with an external field but, conveniently, \({\overrightarrow{B}}_{{\rm{fict}}}\) has a DC component that naturally rotates the axis. Note that, if the local beam is quickly turned on, this same fictitious DC field causes leakage out of the m_{F} = 0 subspace, therefore Gaussiansmoothed pulses are used throughout this work.
Although we realize both the π and σ^{±} versions above, in these experiments, we use the offresonant σ^{±} dressing procedure because of reduced polarization sensitivity, as our polarization homogeneity was affected by the sharp wavelength edge of a dichroic after the AOD. Furthermore, as for most circuits, we perform local rotations row by row (only one Y tone at a time); this enables arbitrary finetuning of X coordinates and powers at each site for homogenizing and calibrating rotations (Extended Data Fig. 2b). We calibrate using the procedure in Extended Data Fig. 2c and find that these calibrations are stable on month timescales.
To quantify the fidelity, we perform randomized benchmarking using 0, 10, 20, 30, 40 and 50 local Z(π/2) rotations (per site) on 16 sites, obtaining \({\mathcal{F}}=99.912(7) \% \), as shown in Extended Data Fig. 2d (note that the singlequbit gates we execute globally have fidelity closer to 99.99% (refs. ^{7,8})). This approaches the Raman scattering limit for our σ^{±} scheme (error of about 7 × 10^{−4} per π/2 pulse), but when not well calibrated is limited by inhomogeneity, in particular, associated with distortions of the y position of the rows. In the future, the performance can be further improved by using X(θ) gates, which enables robust composite sequences such as BB1 (ref. ^{70}), has an improved Raman scattering contribution and is faster (roughly 1 μs duration).
Midcircuit readout and feedforward
To perform midcircuit readout^{10,11,12,13,14,15} of selected qubits without affecting the others, we use a local imaging beam focused on the readout zone that is roughly 100 μm spatially separated from the entangling zone^{7,35}. The local imaging beam consists of 780nm circularly polarized light, with a nearresonant component from F = 2 to F′ = 3 and a small repump component. This beam is sent through the side of our glass vacuum cell, copropagating with the global Raman and 1,013nm Rydberg beams (Extended Data Fig. 1a). We use cylindrical lenses to shape the beam, with focused beam waists of 30 μm in the plane of the atom array and 80 μm out of the plane. After moving some of the atoms to this readout zone, we first perform local pushout of population in the F = 2 groundstate manifold (by turning off the repump laser frequency), followed by local imaging of the remaining F = 1 population.
As depicted in Extended Data Fig. 3a, we collect an average of about 50 photons per imaged atom. To avoid losing the atoms too quickly during midcircuit imaging (which, unlike our global imaging scheme, does not have multiaxis cooling), we use deep (roughly 5mK) traps (helping retain the atoms) and stroboscopically pulse them on and off out of phase of the local imaging light to avoid deleterious effects of the deep traps, such as inhomogeneous light shifts and fluctuating dipole force heating^{74} (Extended Data Fig. 3b). From a doubleGaussian fit to the two distributions in Fig. 3a, we extract an imaging fidelity of more than 99.9%. Because this fit can lead to an overestimate of the imaging fidelity (for example, owing to atom loss during imaging), we compare the total SPAM error (measured by the amplitude of the Ramsey fringe) with local imaging versus with global imaging for the same statepreparation sequence, extracting 0.14(5)% higher error with local imaging; with these considerations, we conservatively estimate a local imaging fidelity of around 99.8%.
Various design considerations facilitate local imaging in the readout zone while preserving coherence of the data qubits in the entangling zone^{35} (Extended Data Fig. 3e–g). The main sources of decoherence are rescattering of photons from the locally imaged atoms, as well as beam reflections and tails of the local imaging beam hitting the data qubits. As shown in Fig. 1c, for the 500μs midcircuit imaging used in this work, we are able to achieve unchanged coherence (identical within the error bars) of the data qubits with the local imaging light on as without it. To understand these effects more quantitatively, we measure the error probability of the data qubits in the entangling zone while the local imaging beam is on in the readout zone for up to 20 ms and with higher intensities than used for local imaging in this work. We suppress decoherence by light shifting the 780nm transition of the data qubits to be different from that of the locally imaged qubits by several tens of MHz, as studied in Extended Data Fig. 3f–g. Data qubit decoherence is further suppressed by the large spatial separation between the readout zone and the entangling zone, in which intensity from the Gaussian tail of the local imaging beam should theoretically fall off rapidly. Even at large separations, we find that stray beam reflections (for example, from the glass cell window and other optical elements) can hit the data qubit region. To mitigate this effect, we displace reflections away from the atom array by angling the local imaging beam as it hits the glass cell window. The estimated effects of rescattered photons from the imaged atoms, especially with the added relative detuning, is negligible. With all these considerations, we find that we are able to suppress data qubit decoherence rates to ≲0.1% per 500 μs of local imaging exposure, as illustrated in Extended Data Fig. 3h.
The full midcircuit readout and feedforward cycle occurs in slightly less than 1 ms, including local pushout, local imaging, readout of the camera pixels, decoding of the logical qubit state on the FPGA and a local Raman pulse, which is gated on or off by a conditional trigger (Extended Data Fig. 3d). In future work, this approach to midcircuit readout and feedforward can be considerably improved to enable midcircuit readout close to the 100μs scale^{75}. This method can be directly extended to perform many rounds of measurement and feedforward, in which groups of ancilla atoms are consecutively brought to the readout zone throughout a deep quantum circuit.
Correlated decoding
During transversal CNOT operations, physical CNOT gates are applied between the corresponding data qubits of two logical qubits. These physical CNOT gates propagate errors between the data qubits in a deterministic way: X errors on the control qubit are copied to the target qubit and Z errors on the target qubit are copied to the control qubit (see Extended Data Fig. 4b). As a result, the syndrome of a particular logical qubit can contain information about the errors that have occurred on another logical qubit, at the point in time in which the pair underwent a transversal CNOT operation. We can use the information about these correlations and improve the circuit fidelity by jointly decoding the logical qubits involved in the algorithm. We note that this is closely related to other recent developments in decoding entire circuits, or socalled spacetime decoding^{76,77,78,79}. It is also related to Steane error correction^{80}, for which errors are intentionally propagated from a data logical qubit onto an ancilla logical qubit, which is then projectively measured to extract the syndrome of the data logical qubit.
To perform correlated decoding, we solve the problem of finding the most likely error given the measured syndrome. We start by constructing a decoding hypergraph based on a description of the logical algorithm, which describes how each physical error mechanism (for example, a Paulierror channel after a twoqubit gate) propagates onto the measured stabilizers^{76,81}. The hypergraph vertices correspond to the stabilizer measurement results. Each edge or hyperedge corresponds to a physical error mechanism that affects the stabilizers it connects, with an edge weight related to the probability of that error. Each hyperedge can connect stabilizers both within and between logical qubit blocks (see Fig. 2b). We then run a decoding algorithm that uses this hypergraph, along with each experimental snapshot, to find the most likely physical error consistent with the measurements. This correction is then applied in software (with the exception of Fig. 4e, which is decoded in real time).
Concretely, to construct the hypergraph for a given logical circuit, we perform the following procedure. For each logical algorithm (in this section, considering only Clifford gates), we identify a set of N detectors (vertices of the hypergraph) D_{i} ∈ {0, 1} for i = 1,…, N, which are sensitive to physical errors occurring during the logical circuit. A detector is either on (1) or off (0) to indicate the presence of an error. For the general case, we let D_{i} = 0 if the ith stabilizer measurement matches the measurement of its backwardspropagated Pauli operator at a previous time and 1 otherwise (the latter indicates that an error has occurred). In particular, for our surfacecode experiments, detectors in the final projective measurement are computed by comparing the final projective measurement of the stabilizers with the value of the ancillabased stabilizer measurement that occurred before the CNOT (note that, owing to our statepreparation procedure, the initial stabilizer measurement is randomly ±1, but the detector is deterministically zero in the absence of noise). For our 2D colourcode experiments, the initial stabilizers are deterministically +1, so each detector is equal to zero if the corresponding stabilizer in the final projective measurement is +1. To construct the concrete hypergraph and hyperedge weights, we then use Stim^{76} to identify the probability p_{j} (j = 1,…, M) of each error mechanism E_{j} in the circuit using a Paulichannel noise model with approximate experimental error rates, along with the detectors that are affected by E_{j}.
To find the most likely physical error, we encode it as the optimal solution of a mixedinteger program, a canonical problem in optimization with commercial solvers readily available^{82}, similar to previous work in ref. ^{83}. We associate each error mechanism E_{j} with a binary variable that is equal to 1 if that error occurred and 0 otherwise. Our goal is then to find the error assignment {0, 1}^{M} with maximum total error probability (alternatively, the error with the minimum total weight, in which the weight of error i is w_{i} = log[(1 − p_{i})/p_{i}]), subject to the constraint that the error is consistent with the measured detectors. To be consistent with the measured detectors, the parity of the error variables for all the hyperedges connected to a given detector should match the parity of that detector. Concretely, let f be a map from each detector D_{i} to the subset of error mechanisms that flip its parity. The most likely error is then the optimal solution to the following mixedinteger program:
The objective function evaluates to the logarithm of the probability of the assigned error configuration, and each variable K_{i} ensures that the sum of the error variables in f(D_{i}) matches D_{i}, modulo 2. Finally, we solve the mixedinteger program to optimality using Gurobi, a stateoftheart solver^{82}, and apply the correction string associated with the error indices j for which E_{j} = 1 in the optimal assignment. We explore this correlated decoding in more detail, including its consequences on errorcorrected circuits and the asymptotic runtimes of different decoders (M.C. et al., manuscript in preparation). See sections ‘Surface code and its implementation’ and ‘Correlated decoding in the surface code’ for further discussion on the surface code in particular.
Direct fidelity estimation and tomography
One challenge with logical qubit circuits is that convenient probes that are accessible with physical qubits may no longer be accessible. The GHZ state studied here provides such an example, as conventional parityoscillation measurements cannot be performed^{84}. Instead, we use a technique known as direct fidelity estimation^{39}, which can be understood as follows. The target state ψ is the simultaneous eigenstate of the N stabilizer generators {S_{i}} and, so, the projector onto the target state is \(\left\psi \right\rangle \left\langle \psi \right={\prod }_{i}^{N}({S}_{i}+1)/2\) (which is 1 if S_{i} = 1 ∀ i and 0 otherwise). Thereby, we can directly measure fidelity by measuring the expectation values of all terms in this product, which—in other words—refers to measuring the expectation values of all elements of the stabilizer group given by the exponentially many products of all the S_{i}. The logical GHZ fidelity is defined as the average expectation value of all measured elements of the stabilizer group. With our fourqubit GHZ state, with four stabilizer generators {XXXX, ZZII, IZZI, IIZZ}, the 16element stabilizer group is given by all possible products: {IIII, ZZII, IZZI, IIZZ, ZIIZ, IZIZ, ZIZI, ZZZZ, XXXX, XYYX, YXXY, XXYY, YYXX, YXYX, XYXY, YYYY}. We measure the expectation values of all 16 of these operators; for each element, we simply rotate each logical qubit into the appropriate logical basis and then calculate the average parity of the four logical qubits in this measurement configuration. We then directly average all 16 elements equally (with appropriate signs, as some of the stabilizer products should have −1 values) and, in this way, compute the logical GHZ state fidelity. This is an exact measurement of the logical state fidelity^{39}. Scaling to larger states can be achieved by measuring elements of the stabilizer group at random^{39}. To perform full tomography in Fig. 3e, we measure in all 3^{4} = 81 bases, thereby measuring the expectation values of all 256 logical Pauli strings, and reconstruct the density matrix by solving the system of equations with optimization methods.
Slidingscale error detection
Here we provide more information about the slidingscale errordetection protocol applied for Figs. 3, 5 and 6. Typically, error detection refers to discarding (or postselecting) measurements in which any stabilizer errors occurred. In the context of an algorithm, however, discarding the result of an entire algorithm if just one physical qubit error occurred may be too wasteful and we may want to only discard measurements in which many physical qubits fail and the probability of algorithm success is greatly reduced. For this reason, for the algorithms here, we explore error detection on a sliding scale, for which we can set a desired ‘confidence threshold’ such that, on the basis of the syndrome outcomes, we determine whether to accept a given measurement. Sliding this confidence threshold enables a continuous tradeoff (in data analysis) between the fidelity of the algorithm and the acceptance probability. When slidingscale error detection is applied, in all applicable cases, we also apply error correction to return to the codespace.
We apply such a slidingscale error detection for the colourcode logical GHZ fidelity measurements in Fig. 3d. One possible method would be to discard measurements based on the number of detected stabilizer errors. However, this is suboptimal, both because on the colour code a single physical qubit error can result from anywhere between 1 and 3 stabilizer errors and also because errors deterministically propagate between codes during the transversal CNOT gates, such that a single physical error on one code can lead to detected errors on all codes, but which are still all correctable errors. As such, we perform the slidingscale error detection using the correlated decoding technique and set the confidence threshold as a threshold weight of the overall correction weight on the decoding hypergraph. For example, in the colour code GHZ experiment, a stabilizer error on all four logical qubits that is just consistent with a single physical qubit error that propagated to all four logical qubits is in fact a lowweight (or highprobability) error, as it corresponds to just a single physical qubit error. If the weight of hypergraph correction (inversely related to the log of the probability that a given error mechanism would have occurred leading to the observed syndrome outcome) is below the cutoff threshold weight, then the measurement is accepted; otherwise, it is rejected. For each threshold, we then calculate the average algorithm result (y axis of Fig. 3d), as well as the fraction of accepted data (x axis of Fig. 3d).
In Fig. 5 with [[8,3,2]] codes, for 3, 6, 24 and 48 logical qubits, we apply our slidingscale detection simply as given by the total number of stabilizer errors detected, although—as illustrated above—this can probably be improved by considering which stabilizer error patterns are more likely to cause an algorithmic failure. For the 12 logical qubits, to have a more finegrained sliding scale, for each of the 2^{4} = 16 possible stabilizer outcomes, we calculate the XEB to rank the likelihood that each of the observed stabilizer outcomes leads to an algorithmic failure and then use this ranking when deciding whether a given measurement is above/below the cutoff threshold. In Fig. 6b, we set the threshold by the number of stabilizer errors and in Fig. 6d, to have more finegrained slidingscale information, we take different subsets of stabilizer outcome events that are all below the threshold of the allowed number of stabilizer errors and calculate the y axis (Pauli expectation value) and x axis (purity) for all of them. Broadly, there are many ways to perform this slidingscale error detection, and this can be useful both as continuous tradeoffs between fidelity and acceptance probability, as well as for use in techniques such as zeronoise extrapolation in data analysis (Fig. 6d).
Overview of QEC methods
Here we provide a brief overview of key QEC methods used in our work.
Code distance, decoding and thresholds
[[n,k,d]] notation describes a code with several physical qubits n, several logical qubits k and a code distance d. The code distance d sets how many errors a code can detect or correct. The code distance is the minimum Hamming distance between valid codewords (logical states), that is, the weight of the smallest logical operator^{85}. In the case of the 2D surface and colour codes studied here, d is equivalent to the linear dimension of the system^{24}.
Following this definition, quantum codes of distance d can detect any arbitrary error of weight up to d − 1. Such errors cause stabilizer violations, indicating that errors occurred. Postselecting on the results with no such stabilizer violations corresponds to performing error detection, which protects the quantum information up to d − 1 errors at the cost of postselection overhead. Conversely, codes can correct fewer errors than they detect (but without any postselection overhead). The correction procedure brings the system back to the closest logical state (codeword); thus, if more than d/2 errors occur, the resulting state may be closer to a codeword different from the initial one, resulting in a logical error^{85}. For this reason, codes of distance d can correct any arbitrary error of weight up to (d − 1)/2 (rounded down if d is even^{24}). The process of decoding refers to analysing the observed pattern of errors and determining what correction to apply to return to the original code state and undo the physical errors created. In many cases, such as with the 2D surface and colour codes, one does not need to apply the correction in hardware (physically flipping the qubits); instead, it is sufficient to undo an unintended X_{L}/Z_{L} operator that was applied by hardware errors by simply applying a ‘software’ X_{L}/Z_{L} operator^{24}, also described as Pauli frame tracking^{86}.
As the size of an error correcting code and the corresponding code distance is increased, so are the opportunities for errors to occur as the number of physical qubits increases. This leads to a threshold behaviour in QEC: if the density of errors p is above a (possibly circuitdependent) characteristic error rate p_{th}, then increasing code distance will worsen performance. However, if p < p_{th}, then increasing code distance will improve performance^{24}. Theoretically, because we require (d + 1)/2 errors to create a logical error, the logical error rate will be exponentially suppressed as ∝(p/p_{th})^{(d+1)/2} at sufficiently low error rates^{24}. The performance improvement with increasing code distance, observed for the preparation and entangling operation in Fig. 2, implies that we surpass the threshold of this circuit. We note that, in this regime, improving fidelities by, for example, a factor of 2× can then lead to an error reduction of 2^{4} = 16× for the distance7 code studied and further exponential suppression with increasing code distance. This rapid suppression of errors with reduced error rate and increased code distance is the theoretical basis for realizing largescale computation. We emphasize that thresholds can be circuitdependent, as discussed in detail in the surfacecode section below.
Fault tolerance and transversal gates
A common definition of fault tolerance in quantum circuits^{85} (which we use in this work) is that a weight1 error (that is, an error affecting one physical qubit) cannot propagate into a weight2 error (now affecting two physical qubits) within a logical block. This property implies that errors cannot spread within a logical block and thereby prevents a single error from growing uncontrollably and causing a logical error.
Distance3 codes, which are of notable historical importance^{3,87}, can correct any weight1 error. Fault tolerance is particularly important for these codes because otherwise a weight1 error can lead to a weight2 error and thereby cause a logical fault. An important characteristic of a faulttolerant circuit that uses distance3 codes^{85} is that (in the lowerrorrate regime) physical errors of probability p lead to logical errors with probability ∝p^{2}. We emphasize that the notion of fault tolerance refers to circuit structuring to control propagation of errors, but a circuit can be faulttolerant with low fidelity or nonfaulttolerant with high fidelity. For example, even if a weight1 error can lead to a weight2 error but the code has high distance, or if this errorpropagation sequence is possible but highly unlikely, then this property may not be of practical importance (for this reason, definitions of fault tolerance may vary). In practice, the goal of QEC is to execute specific algorithms with high fidelity, and faulttolerant structuring of a circuit is one of many tools in the design and execution of highfidelity logical algorithms.
Transversal gates, defined here as being composed of independent gates on the qubits within the code block (that is, entangling gates are not performed between qubits within the same code block)^{42}, constitute a direct approach to ensure faulttolerant structuring of a logical algorithm. Because transversal gates imply performing independent operations on the physical constituents of a code block, errors cannot spread within the block and fault tolerance is guaranteed. In this work, all logical circuits we realize (following the logical state preparation) are faulttolerant, as all logical operations we perform are transversal. Note, in particular, that even though the transversal CNOT allows errors to propagate between code blocks, this is still faulttolerant, as it does not lead to a higherweight error within the block and, thereby, a single physical error can neither lead to a logical failure nor an algorithmic failure. Notably, the large family of codes referred to as Calderbank–Shor–Steane (CSS) codes all have a transversal CNOT (ref. ^{2}), all of which can be implemented with the singlestep, paralleltransport approach here.
Although all the logical circuits we implement are faulttolerant, the logical qubit state preparation is faulttolerant for our d = 3 colour code (Figs. 3 and 4) and d = 3 surface code (part of Fig. 2), but is nonfaulttolerant for the state preparation of our d = 5, 7 surface codes and [[8,3,2]] codes. Thus, all of our experiments with the d = 3 colour codes are faulttolerant from beginning to end, and so the entire algorithm is faulttolerant and theoretically has a failure probability that scales as p^{2}. However, we note that having a faulttolerant algorithm also does not imply that errors do not build up during execution of the circuit. For this reason, deep circuits require repetitive error correction^{6,88} to constantly remove errors and continuously benefit from, for example, the p^{2} suppression.
Our logical GHZ state theoretically has a failure probability scaling as p^{2}. Nevertheless, the error buildup (increasing p) during the operations of the circuit and the spreading of errors through transversal gates limits our logical GHZ fidelity to 72%. This is consistent with numerical modelling. Similar to the surfacecode modelling (Extended Data Fig. 4), we use empirical error rates consistent with 99.4% twoqubit gate fidelity, as well as roughly 4% data qubit decoherence error (including SPAM) over the entire circuit. We simulate the experimental circuit (including the faulttolerant state preparation with the ancilla logical flag) and measurements of all 16 elements of the stabilizer group (see the ‘Direct fidelity estimation and tomography’ section), and extract a simulated logical GHZ fidelity of 79%. This is slightly higher than our measured 72% logical GHZ fidelity, possibly originating from imperfect experimental calibration. This modelling indicates that our logical GHZ fidelity is limited by residual physical errors, which will be reduced quadratically as p^{2} with reduction in physical error rate p, in particular by reducing residual singlequbit errors, which were larger during this measurement and are dominating the error budget here.
Surface code and its implementation
In 2D planar architectures, such as those associated with superconducting qubits^{6,88}, stabilizer measurement is the most important building block of errorcorrected circuits^{24}. In such systems, stabilizers need to be constantly measured to correct qubit dephasing and increase coherence time, as demonstrated recently^{6}. Logic operations are implemented by changing stabilizer measurement patterns, enabling realization of techniques such as braiding^{24} and lattice surgery^{89}. Similar techniques can be used to move logical degrees of freedom to implement nonlocal logical gates^{23}. Owing to this gateexecution strategy, d rounds of stabilizer measurement are required for each entangling gate for ensuring fault tolerance^{24}.
Neutralatom quantum computers feature different challenges and opportunities. Specifically, they feature long qubit coherence times (T_{2} > 1s), which can be further increased to the scale of tens to hundreds of seconds with wellestablished techniques^{72}. By using the storage zone, qubits can be idly and safely stored for long periods without repeated stabilizer measurements. Hence, from a practical perspective, increasing qubit coherence by using a logical encoding does not provide immediate gains in improving quantum algorithms and the gains will be from improving the fidelity of entangling operations. Moreover, logic gates and qubit movement do not have to be performed with stabilizer measurements. Instead, they can be executed with nonlocal atom transport and transversal gates. Because such transversal gates are intrinsically faulttolerant, they do not necessarily require d rounds of correction after each operation. Even syndrome measurement may be better executed in certain cases by techniques such as Steane error correction^{80} (similar to our ancilla logical flag with colour codes as used in Fig. 3), as opposed to repeated stabilizer measurement. For these reasons, the transversal CNOT is among the most important building blocks in errorcorrected circuits. Hence, we focus here on improving the transversal CNOT by scaling code distance.
Specifically, we use the socalled rotated surface code^{6}, which has code parameters [[d^{2},1,d]]. Our distance7 surface codes (as drawn in Fig. 2d) are composed of 49 physical data qubits, with 24 X stabilizers (lightblue squares) and 24 Z stabilizers (darkblue squares), and one encoded logical qubit described by anticommuting weight7 operators, the horizontally oriented X_{L} and the vertically oriented Z_{L}. The X and Z stabilizers commute with the X_{L} and Z_{L} logical operators, allowing the measurement of the stabilizers without disturbing the underlying logical degrees of freedom. In our experiments, we prepare one surface code in +_{L}⟩ and one surface code in 0_{L}⟩. In the first code, this is realized by preparing all physical data qubits in +⟩, thereby preparing an eigenstate of X_{L} and the 24 X stabilizers, and then projectively measuring the 24 Z stabilizers with 24 ancilla qubits (Fig. 2d red dots) using four entanglinggate pulses^{24}. The second code is prepared similarly but with all physical qubits initialized in 0⟩, thus preparing an eigenstate of Z_{L} and the 24 Z stabilizers, and then projectively measuring the 24 X stabilizers with 24 ancillas. The CNOT is directly transversal because these two surfacecode blocks have the same orientation and does not require rotation of the lattice to implement a H. The projective measurement of the ancillas defines the values of the stabilizers. During the transversal CNOT, the values of the stabilizers are copied onto the other code as well and is tracked in software.
Because we only perform a single round of stabilizer measurement, our statepreparation scheme is nFT for the d = 5, 7 codes. Consider, for instance, the case when all stabilizers are defined as +1 and no errors are present in the system, but an ancilla measurement error in the middle of the surfacecode lattice yields a stabilizer measurement of −1. Correction then causes a largeweight pairing of this apparent stabilizer violation to the boundary^{4}. Hence, this single ancilla measurement error can lead to several data qubit errors, resulting in nFT operation. The d = 3 code initialization is a special case that does not suffer from this issue^{38}. Higherorder considerations about fault tolerance given by gate ordering during stabilizer measurement can also be considered^{6}.
The effect of these nFT errors from noisy syndrome extraction is to cause X physical errors on the +_{L}⟩ state and Z physical errors on the 0_{L}⟩ state. Thus, in performing just a SPAM measurement, the presence of these errors would not be directly apparent, as these errors commute with measuring the +_{L}⟩ in the X basis and 0_{L}⟩ in the Z basis. As such, this circuit would not be a good benchmark of surfacecode state preparation. Conversely, the transversal CNOT experiment is sensitive to the various aspects of the circuit and a good indication of performance. Because we measure the Bell state in both the \({{\rm{X}}}_{{\rm{L}}}^{1}{{\rm{X}}}_{{\rm{L}}}^{2}\) and \({{\rm{Z}}}_{{\rm{L}}}^{1}{{\rm{Z}}}_{{\rm{L}}}^{2}\) bases, the nFT errors in both bases will propagate through the logical CNOT and cause errors on both logical qubits in both the X and Z bases. For these reasons, unlike a surfacecode SPAM measurement, this experiment is a good indication of logical performance. In fact, the effect of these nFT errors is such that, if we just apply conventional decoding within each logical block, then we find that the Bell state degrades substantially with increased code distance (Fig. 2d).
The effects of this nFT preparation are suppressed (but not entirely removed) by using the correlated decoding technique. For example, consider a nFTinduced apparent stabilizer violation to the left of the middle line in the lattice of the d = 7 +_{L}⟩ state, corresponding to a chain of three physical X errors to the boundary. These errors will propagate through the logical CNOT onto the second logical qubit and affect the independent measurement of both logical qubits in the Z basis when investigating the \({{\rm{Z}}}_{{\rm{L}}}^{1}{{\rm{Z}}}_{{\rm{L}}}^{2}\) stabilizer. When decoded independently, if another single X error occurs on the first block after the CNOT moving the stabilizer violation to the right of the middle line, becoming a chain of four X physical errors, this will cause an incorrect pairing and lead to an independent \({{\rm{X}}}_{{\rm{L}}}^{1}\) error on this code only and thereby corrupt the \({{\rm{Z}}}_{{\rm{L}}}^{1}{{\rm{Z}}}_{{\rm{L}}}^{2}\) stabilizer and would correspond to a total weight6 correction between the two codes. However, when decoded jointly with correlated decoding, these errors can be effectively decoded, as they will appear on the stabilizers of both logical qubits. In this example, the lowestweight pairing would remove this chain of three X errors from both codes and leave only the one remaining X error on the first block, which can also be decoded successfully (the total pairing weight here is only 2). Our correlated decoding technique is thus essential to our observation of improved Bell performance with code distance.
Finally, we elaborate on our evaluation of Bellpair error. Bellstate fidelity is given by the average of the populations and the coherences, which—for physical qubits—can be measured as the ZZ populations and the amplitude of parity oscillations. In the language of stabilizers, the parity oscillation amplitude is given by the average of ⟨XX⟩ and −⟨YY⟩ (ref. ^{90}). With the surface code, we cannot conveniently measure the Y_{L} operators faulttolerantly (and that is why we use colour codes for programmable Clifford algorithms and full tomography; see next section). For this reason, we estimate the logical coherences as ⟨X_{L}X_{L}⟩, which we then average with the populations for calculating the Bellpair error. To support the validity of this analysis, we can instead calculate a lower bound on the Bellstate fidelity^{90}, which also shows the same improvement in performance as we increase code distance (Extended Data Fig. 4d).
Correlated decoding in the surface code
Following the above discussion, we provide more insights related to the correlated decoding in the case of the surfacecode transversal CNOT. Consider a circuit in which perfect (noiseless) surface codes are initialized, a transversal CNOT is executed and then projective readout is performed. If errors occur before the transversal CNOT, then these errors can propagate; for example, an X physical error on the control logical qubit will propagate onto the target logical qubit and thereby double the density of errors on the target logical qubit. By multiplying the projectively measured Z stabilizers of the target logical qubit with those of the control logical qubit, the propagation is undone. Now the target logical qubit only has to decode its original density of X errors. The same considerations can be made for Z errors originating on the target logical qubit that propagate onto the control logical qubit. However, if there are errors after the transversal CNOT, then multiplying the stabilizers instead doubles the density of such errors. Thus, the optimal decoding strategy if errors are only after the transversal CNOT is to perform independent matching within both codes. The general case in which errors are present both before and after the transversal CNOT corresponds to neither case and is modelled by our decoding hypergraph that has edges and hyperedges connecting the two logical qubits, with edge weights informed by our experimental error model. Extended Data Fig. 5 explores decoding performance with different values of the scaled weights of the edges and hyperedges that connect the stabilizers of the two logical qubits. These results illustrate that the correlated decoding is robust (but not completely insensitive) to the nFT errors associated with ancilla measurement errors. This feature would also be recovered by the simpler multiplication decoder, which would be entirely insensitive to errors from ancilla measurement, but is—however—more sensitive to errors after the CNOT. Specifically, Extended Data Fig. 5c shows that our optimized decoder is not simply a ‘multiplication decoder’, as the ancilla measurement values indeed contribute to the correction procedure and make the correlated decoding more robust to decoder parameters. For a given logical circuit, our correlated decoding procedure generates a decoding hypergraph, which we then solve using most likely error methods, which is done here for both surfacecode and colourcode experiments, and can generically be applied to any stabilizer codes and Clifford circuits^{79}. More theoretical details and discussion of correlated decoding will be presented in M.C. et al, manuscript in preparation.
2D colour codes
2D colour codes are topological codes that are similar to surface codes^{91}. Often portrayed in a triangular geometry, the colour codes used here are a tiling of three colours of weight4 and weight6 stabilizers, with X_{L} and Z_{L} operator strings running along the boundary of the code^{91}. In this work, we study 2D d = 3 colour codes, as portrayed in Fig. 3a, which only contain weight4 stabilizers given by the products of X and Z on the qubits of each coloured plaquette. This d = 3 colour code is identical to the sevenqubit Steane code. However, we emphasize that the techniques used here directly apply to largerdistance colour codes^{92}.
Although the colour codes are similar to surface codes, an important difference is that, in the colour code, the X and Z stabilizers lie directly on top of the same qubits (as opposed to being on dual lattices with respect to each other) and, similarly, the X_{L} and Z_{L} operators lie on top of each other (as opposed to propagating in the orthogonal directions on the surface code). In other words, the operators here are symmetric and related by a global basis transformation. This has important consequences for the allowed transversal gate set^{41,93}. In particular, although the surface code technically has a transversal H that transforms X_{L} ↔ Z_{L}, it requires a physical 90° rotation of the code block. Although such lattice rotations are possible using atommotion techniques, for many circuits, it is inconvenient. Conversely, in the colour code, H is transversal: it directly exchanges X_{L} ↔ Z_{L} as well as the X and Z stabilizers. This difference is even more important for the transversal S gate, which is possible for the colour code. Here transversal S exchanges X_{L} ↔ Y_{L} (for which Y_{L} is given by the product of X_{L} and Z_{L}, which lie on top of each other) as intended, and the X stabilizer of a given plaquette returns to itself by multiplying the Z stabilizer of that same plaquette. (This is in contrast to the surface code, which does not have a transversal S, for which the Y_{L} operator is a product of horizontally propagating X_{L} and vertically propagating Z_{L} (ref. ^{24})). Because the colour code has the entire transversal gate set of {H, S, CNOT} and also does not require tracking any lattice rotations, it is well suited to exploration of programmable logical Clifford algorithms.
For faulttolerant preparation of the d = 3 colour code, we use a modified version of the scheme summarized in ref. ^{38}, in which, instead of the eightgate encoding circuit, we use a ninegate encoding circuit that is more conveniently mapped to specific atom movements in our system (corresponding to graphstate preparation similar to ref. ^{7}), followed by a transversal CNOT with an ancilla logical flag. The logical SPAM fidelity is then calculated as the probability of observing 0_{L}⟩ after decoding. We note that, in Fig. 3, we could also have made a fivequbit GHZ state but instead made a fourqubit GHZ state for simplicity of performing full tomography. In Fig. 4, when Bellstate fidelities with feedforward are reported, we estimate the logical coherences as the average of ⟨X_{L}X_{L}⟩ and −⟨Y_{L}Y_{L}⟩, which we then average with the Z_{L}Z_{L} populations (not plotted) for calculating the Bellpair fidelity. Finally, we note that the feedforward Bell state in Fig. 4e could also be performed with a software Z_{L} rotation on either of the two qubits, allowing correction to the appropriate Bell state, but here we perform the feedforward S on both qubits to test our feedforward capabilities; this technique is directly compatible with performing magicstate teleportation^{24}.
Clifford and nonClifford gates and universality
2D topological codes such as the surface and colour codes have transversal implementation of Clifford gates (for example, {H, S, CNOT}). This gate set is not universal, that is, it cannot alone be used to realize an arbitrary quantum computation and requires a nonClifford gate such as {T, CCZ} for achieving universal computation. Moreover, circuits composed solely of stabilizer states and Clifford gates can be simulated in polynomial time because of the Gottesman–Knill theorem^{44}. This can be understood as stabilizer tracking; for example, consider a threequbit system in which a stabilizer of the state is X ⊗ I ⊗ I, such that X stabilizes the +⟩ state and I is the identity. Applying two CZ entangling gates CZ_{1,2} ⊗ CZ_{1,3} transforms this stabilizer to X ⊗ Z ⊗ Z because an X flip before the CZ simply changes whether a Z flip will be applied to the other qubits. Even though Clifford circuits create superposition and entanglement between qubits, the N initial stabilizers of the state can simply be tracked as they propagate through the circuit (socalled operator spreading^{94}) and thereby simulation of the circuit can be easily accomplished.
The effect of nonClifford gates, however, is far more complex. For example, passing the stabilizer X ⊗ I ⊗ I through a CCZ maps into a superposition of Pauli strings, that is, X ⊗ I ⊗ I → 1/2(X ⊗ I ⊗ I + X ⊗ Z ⊗ I + X ⊗ I ⊗ Z − X ⊗ Z ⊗ Z), as an X flip now changes whether a CZ operator will be applied on the other qubits, resulting in four times more operators to track after the single CCZ. (The CZ operator matrix is simply equal to 1/2[I ⊗ I + Z ⊗ I + I ⊗ Z − Z ⊗ Z]). This causes not only operator spreading but also socalled operator entanglement^{94}. As we apply further nonClifford gates, the number of operators to track will grow exponentially and eventually will become computationally intractable. For example, stateoftheart Clifford + T simulators can handle roughly 16 CCZ gates^{50}. This is the basis behind our complex sampling circuits, in which the 48 CCZs on the 48 logical qubits create a high degree of scrambling and magic (defined below), rendering Clifford + T simulation impractical.
[[8,3,2]] circuit implementation
Here we provide more detail about our [[8,3,2]] circuit implementations. The [[8,3,2]] code blocks are initialized in the −_{L},+_{L},−_{L}⟩ state with the circuit in Extended Data Fig. 6, which can be understood as preparing two fourqubit GHZ states (corresponding to [[4,2,2]] codes^{95}), that is, \({{\rm{GHZ}}}_{{\rm{Z}}}^{1,3,5,7}\otimes {{\rm{GHZ}}}_{{\rm{X}}}^{2,4,6,8}\), and subsequently entangling them as illustrated in Extended Data Fig. 6a (as well as applying Z gates). In our circuit implementations, for system sizes of 3–24 logical qubits for both sampling and twocopy measurements, we prepare eight blocks encoded over 64 physical qubits. For the 48logicalqubit circuit (128 physical qubits in total), we encode eight blocks and entangle them, and then drop them into storage; then, we pick up 64 new physical qubits from storage, encode them into eight blocks in the entangling zone and entangle them. Finally, we bring the original eight blocks from storage and entangle them with the second group of eight blocks in the entangling zone (Extended Data Fig. 6) (see Supplementary Video).
The transversal gate set of the [[8,3,2]] code is enabled as follows (see also refs. ^{16,17,26,27}). The transversal CNOT between blocks immediately follows from the fact that the [[8,3,2]] code is a CSS code. Inblock CZ gates between two logical qubits L_{i} and L_{j} (CZ_{Li,Lj}) can be realized by S, S^{†} gates on the face corresponding to logical qubit L_{k}. For example, consider applying the pattern of S, S^{†} gates to the top face in Fig. 5, that is, \({{\rm{S}}}_{1}{{\rm{S}}}_{3}^{\dagger }{{\rm{S}}}_{5}^{\dagger }{{\rm{S}}}_{7}\), which transforms X_{L1} = X_{1}X_{2}X_{3}X_{4} to \({{\rm{X}}}_{{\rm{L}}1}^{{\prime} }={{\rm{Y}}}_{1}{{\rm{X}}}_{2}{{\rm{Y}}}_{3}{{\rm{X}}}_{4}\), which is equal to \({{\rm{X}}}_{{\rm{L}}1}^{{\prime} }={{\rm{X}}}_{{\rm{L}}1}{{\rm{Z}}}_{{\rm{L}}2}\), and the same applies to give \({{\rm{X}}}_{{\rm{L}}2}^{{\prime} }={{\rm{X}}}_{{\rm{L}}2}{{\rm{Z}}}_{{\rm{L}}1}\), that is, a CZ is realized between logical qubits 1 and 2. This procedure can also be used to understand why the pattern of T, T^{†} realizes a CCZ between the three encoded qubits. CCZ gates should map X_{L3} to X_{L3} ⊗ CZ_{L1,L2}. By applying the pattern of T, T^{†} in Fig. 5a, each X face maps to itself multiplied by a pattern of S, S^{†}, for example, X_{L3} = X_{1}X_{3}X_{5}X_{7} maps to \({{\rm{X}}}_{{\rm{L}}3}^{{\prime} }={{\rm{X}}}_{{\rm{L}}3}{{\rm{S}}}_{1}{{\rm{S}}}_{3}^{\dagger }{{\rm{S}}}_{5}^{\dagger }{{\rm{S}}}_{7}\), or then \({{\rm{X}}}_{{\rm{L}}3}^{{\prime} }={{\rm{X}}}_{{\rm{L}}3}\otimes {{\rm{CZ}}}_{{\rm{L}}2,{\rm{L}}3}\). This happens for all three X_{L} faces, thereby realizing a CCZ gate. Finally, we detail the permutation CNOT, which was also developed in ref. ^{27}. Physically permuting atoms to swap qubits 4 ↔ 8 and 3 ↔ 7 takes X_{L1} = X_{1}X_{2}X_{3}X_{4} to \({{\rm{X}}}_{{\rm{L}}1}^{{\prime} }={{\rm{X}}}_{1}{{\rm{X}}}_{2}{{\rm{X}}}_{7}{{\rm{X}}}_{8}\) or instead \({{\rm{X}}}_{{\rm{L}}1}^{{\prime} }={{\rm{X}}}_{{\rm{L}}1}{{\rm{X}}}_{{\rm{L}}2}\) (also by multiplying the global X stabilizer) and, similarly, it can be seen by tracking the qubit permutations that \({{\rm{Z}}}_{{\rm{L}}2}^{{\prime} }={{\rm{Z}}}_{{\rm{L}}2}{{\rm{Z}}}_{{\rm{L}}1}\), that is, realizing a CNOT. Finally, although these 3D codes do not have a transversal H, because they are CSS codes, they can be initialized and measured in either the X or the Z basis, effectively allowing H gates at the beginning or end of the circuit.
Inblock logical entangling gates are applied block by block and any inblock gate combination can be realized. For conceptual simplicity, we apply only two particular local Raman patterns in layers. The first is the gate combination CCZ_{L1,L2,L3} ⋅ CZ_{L1,L2} ⋅ CZ_{L1,L3} ⋅ CZ_{L2,L3} ⋅ Z_{L1} ⋅ Z_{L2} ⋅ Z_{L3}, given by applying T^{†} on the entire physical qubit block, and the second gate combination we apply is CCZ_{L1,L2,L3} ⋅ CZ_{L2,L3} ⋅ CZ_{L1,L3} ⋅ Z_{L3}, given by applying T on the top row and T^{†} on the bottom row. In our circuits, we alternate layers of inblock transversal entangling gates and outblock transversal CNOTs, entangling logical blocks on up to 4D hypercubes^{19,96,97} (see Extended Data Fig. 6). We keep the control and target qubits the same throughout the circuit for conceptual simplicity, allowing the local physical H gates on the target qubits to be compiled with the inblock gate layers, but the controltarget direction can also be chosen arbitrarily. We ensure that inblock logical entangling gates are applied such that they do not trivially commute through and cancel with earlier entanglinggate applications. As an experimental note, we remark that, for the Clifford states realized in the other parts of this work, stabilizers take on values of either +1 or −1 (owing to, for example, use of physical π/2 rotations instead of H), which is then simply redefined in software. Because, for our [[8,3,2]] circuits, we implement nonCliffords on the physical level, it is important to ensure that all stabilizers are initialized and maintained as +1; for example, if a Z stabilizer is −1, then the logical CCZ implementation sends the X stabilizer expectation value to 0. This can be understood as a physical X on a single site transforming to a superposition \(({\rm{X}}+{\rm{Y}})/\sqrt{2}\) by physical T, going into an equal superposition of X stabilizer being +1 and −1.
Classically hard circuits with [[8,3,2]] codes
Our implemented circuits are equivalent to IQP circuits^{98}, which gives a theoretical basis for understanding why our circuits could be classically hard to simulate, for which we also provide numerical evidence of socalled anticoncentration^{99,100}. IQP circuits are defined as initializing +⟩^{⊗n} on n qubits, applying a diagonal entangling unitary such as those composed by {CCZ, CZ, Z} and then measuring in the X basis^{20,98}. A uniform superposition of 2^{n} bitstrings is created, the diagonal gates apply −1 signs in a complicated fashion to the exponentially many bitstrings and then ‘undoing the superposition’ with the final H before measurement now results in an intricate ‘speckle’ interference pattern^{18}. Sampling from the output distribution of this speckle pattern can be done efficiently on a quantum device that implements the circuit, but is exponentially costly on a classical device for certain choices of IQP circuits^{20}. The transversal gate set of the [[8,3,2]] code, as described above, contains diagonal gates {CCZ, CZ, Z} that apply −1 signs to the bitstrings, but is made nondiagonal by the application of CNOTs, which permute bitstrings. Because this bitstring permutation does not break the IQP framework, these circuits are equivalent to an effective IQP circuit, but which is much more complex: for example, circuits with 48 CCZs and 96 CNOTs map to effective IQP circuits with roughly 1,000 CCZ gates. Nevertheless, because IQP circuits are a wellunderstood framework, we can discuss our circuit properties with this toolset.
We experimentally explore these circuits with the XEB^{18}, defined as \({\rm{XEB}}={2}^{{N}_{{\rm{L}}}}{\Sigma }_{i}p({x}_{{\rm{L}}}^{i})q({x}_{{\rm{L}}}^{i})1\), in which N_{L} is the number of logical qubits, \(q({x}_{{\rm{L}}}^{i})\) is the measured probability distribution for our logical qubits and \(p({x}_{{\rm{L}}}^{i})\) is the calculated probability distribution; here we normalize the XEB by its ideal value such that the XEB for the noiseless circuit is 1. In typical cases, if noise overwhelms the circuit, the measured distribution will be uniform^{18} and the measured XEB will be 0.
The IQP circuits are a good setting for quantumadvantagetype experiments, as the bitstring distribution of IQP circuits with randomly applied {CCZ, CZ, Z} gates (random degree3 polynomials) is known to be classically hard to simulate^{20,101}. In M.K. et al., manuscript in preparation, we show that the ensemble of random hypercube IQP circuits, whose instances are experimentally explored here, converges to the uniform IQP ensemble as the depth and size of the hypercube is increased. In Extended Data Fig. 8a, we show that hypercube IQP circuits with random inblock operations and randomized controltargets on the outblock CNOT layers (realizing the hypercube) anticoncentrate quickly as the dimension of the hypercube is increased, with XEB eventually reaching the uniformIQP value of 2. We also find that the presence of nonClifford CCZ gates, which are critical for the computational hardness here, further improves anticoncentration properties, as we observe that the ideal XEB of experimental circuits approach 2 as well, even without much randomization.
Moreover, the XEB turns out to be a better benchmark for IQP circuits than for generic random circuit sampling settings (such as Haarrandom circuits)^{102,103,104}. For IQP, the XEB is close to the manybody fidelity and the difference can be theoretically bounded under reasonable noise assumptions (M.K. et al., manuscript in preparation). Intuitively, this fact is related to the diagonal structure of the IQP circuits, which allows the XEB to capture errors in a manner closer to fidelity, despite being defined only in the computational basis. In other words, a Z error will always corrupt the Xbasis measurement, and an X error (except one immediately before measurement) will create new Z errors that also corrupt the Xbasis measurement. Thus, in the fully postselected regime, in which errors at the end of the circuit are well described by logical errors, we expect the XEB to be a good measure of fidelity. We further note that, as well as the efficient generation of complex IQP circuits here, the [[8,3,2]] gate set presented here can realize arbitrary IQP circuits composed of {CCZ, CZ, Z} gates^{105}. The inblock {CCZ, CZ, Z} operations can be applied to any groupings of qubits by noting that combining the inblock and outblock CNOTs allow us to compose arbitrary transversal SWAP operations of targeted individual logical qubits between different blocks.
Simulation of bitstring probabilities
To calculate the logical bitstring probabilities necessary for evaluating the XEB and benchmarking our circuits, we use a hybrid simulation approach combining wavefunction and tensornetwork^{106} methods. It works best only when performing all of the entangling gates of the hypercube a single time and relies on the fact that the final round of CNOTs is immediately followed by a measurement, simplifying network contraction. Concretely, for a Ddimensional logical hypercube, the two subsystems consisting of 2^{D−1} blocks are simulated independently and then the final layer of CNOTs and inblock operations is combined with the measurement outcomes (the bitstring of interest), which results in a contraction of two \({8}^{{2}^{D1}}\) tensors (see Extended Data Fig. 8b). This is a squareroot reduction in the memory requirement compared with the full wavefunction simulation, which uses \({\rm{O}}({8}^{{2}^{D}})\) space. The ideal XEB value is calculated by sampling bitstrings from the ideal output distribution and then averaging the corresponding probabilities. The bitstrings are sampled using a marginal sampling algorithm, which uses the same contraction scheme described above.
We next consider whether the finite XEB scores in this problem can be easily ‘spoofed’ by foregoing exact simulation of the implemented circuit and using a classical algorithm with fewer resources, similar in spirit to the algorithm introduced in ref. ^{102}. For the circuits studied in Fig. 5, containing only a single layer of gates on the hypercube, there is only a single round of CNOTs connecting the two 2^{D−1}block partitions; thus, removing them from the circuit and sampling from the two independent halves might not decrease the XEB substantially while reducing the memory requirement to \({8}^{{2}^{D2}}\). In Extended Data Fig. 8c, we study the performance of this spoofing attack and find that the obtained XEB rapidly decreases, once further gate layers are introduced, for a particular extension of our circuit.
The contraction scheme above, used for both the ideal simulation and the XEB spoofing, scales exponentially with the number of qubits. However, the exponent is substantially reduced by using the fact that the hypercube circuits can be naturally partitioned into smaller blocks, with only a single interpartition layer of CNOTs at the end of the circuit. This simulation method therefore becomes less efficient if we introduce extra CNOT layers (within a single partition) after the interpartition layer, as we estimate in Fig. 5d. Applying l = {0,…, D − 1} further intrapartition CNOT layers forces the CNOT tensors in Extended Data Fig. 8b to be blocked into groups of 2^{l}, which results in the execution time to scale roughly as \({\rm{O}}({8}^{{2}^{l}}/{2}^{l})\), in which the numerator comes from the tensor contraction complexity and the denominator accounts for the reduced number of contractions resulting from blocking. The explicit times quoted in Fig. 5d as a function of extra CNOT layers are based on the above matrixmultiplication estimate and fitted such that the depth1 hypercube time matches 1.44 s, which corresponds to our implementation. In practice, the actual runtimes might differ owing to hardware and software optimization and other factors, such as the cost of tensor permutations; however, we expect the general trend to hold. Finally, if the 2^{l}blocked tensors were to be stored directly, the memory requirement of this approach would grow as \({8}^{{2}^{l+1}}\), recovering the full \({8}^{{2}^{D}}\) memory complexity for l = D − 1.
In this work, we use these circuits and XEB results for benchmarking our logical encoding, which requires the ability to simulate these circuits. Future logicalalgorithm experimentation can explore quantumadvantage^{18,48,107,108,109} tests with encoded qubits, as will be detailed in M.K. et al., manuscript in preparation.
Physical qubit circuit implementations
To compare our logicalqubit algorithms with analogous circuits on physical qubits, we work out a concrete implementation of our sampling/scrambling circuits on physical qubits using the same physical gate set, Clifford + T, as used in the logical circuit, which we also then attempt to realize experimentally. We replace each [[8,3,2]] block with a threephysicalqubit block, decomposing the ‘inblock’ CCZ gates into six CNOTs and seven {T, T^{†}} gates and implement ‘transversal’ CNOTs directly between the threequbit blocks. We note that the CZ can be compiled into the CCZ implementation, but this has a minor effect on our analysis and estimates. These physical circuits are complex: 48 qubits with 48 CCZs and 228 twoqubit gates (as realized with our logical qubits) decomposes into an effective 516 twoqubit gates (384 if the CZ gates are compiled into the CCZs). In trying to implement these circuits in practice, the buildup of coherent errors resulted in a vanishing XEB for our physical circuits. These experiments made it clear that the logicalcircuit equivalent was greatly outperforming the physical circuit, thereby providing direct evidence that our logical algorithm outperforms our physical algorithm for this specific sampling circuit.
More quantitatively, with a concrete physical implementation, we calculate an upper bound by assuming optimistic performance. We assume our bestmeasured fidelities: SPAM of 99.4% (ref. ^{8}), local singlequbit gate fidelity of 99.91% (Extended Data Fig. 2), twoqubit gate fidelity of 99.55% (ref. ^{8}) and T_{2} = 2s. We then count the total number of entanglinggate pulses for the CZ gates, the total number of compiled local singlequbit gates and the estimated circuit duration, and use these to calculate the estimate presented in Fig. 5f. We further confirm this analysis for smallscale circuit implementations. For a short threequbit circuit, we benchmark the XEB for the physical circuit as approximately 0.87, which is below the estimated threequbit upper bound of roughly 0.92. We note that, in Fig. 5f, we plot estimates of physicalqubit fidelity and not the XEB, but we expect the XEB and fidelity to be closely related, as discussed previously.
We note several observations made in comparing physical and logical implementations of these complex circuits. First, empirically, it seems that the logical circuit is much more tolerant to coherent errors^{49,110,111}, and understanding the manifestations of this is a subject of continuing investigation. Specifically, it seems that the logical circuit realizes inherently digital operation, for which the small coherent errors do not substantially shift/distort the bitstring distribution but just reduce the overall fidelity^{49,110} (see, for example, the agreement in Extended Data Fig. 7a). This is in contrast to the physical implementation, in which coherent errors are seen to substantially alter the shape of the bitstring distribution, for example, changing relative amplitudes. Second, we note that we optimize our [[8,3,2]] circuits only by optimizing the stabilizer expectation values and not by optimizing the XEB or twocopy result directly. When running complex circuits, the stabilizers serve as useful intermediate fidelity benchmarks, for both optimizing circuit design and ensuring proper execution, especially in regimes in which output distributions or other observables cannot be calculated. Overall, we find that these complex circuits seem to perform much better with logical qubits than physical qubits.
Twocopy measurements
A powerful method to extract various quantities of interest are Bellbasis measurements between two copies of the same state^{21,22,52}. First, we use these measurements to calculate the purity or entanglement entropy of the resulting state^{7,21,52,112,113}. Measuring the occurrences of the singlet state \(\frac{ \,01\rangle \,\, \,10\rangle }{\sqrt{2}}\) (11⟩ outcome for our measurements after applying the final pairwise entangling operations) probes the eigenvalue of the SWAP operator \({\widehat{s}}_{i}\) at a given pair of sites i. This is in turn related to the purity of the state by observing that \({\rm{Tr}}[\,{\rho }_{A}^{2}]\,=\)\({\rm{Tr}}[{\Pi }_{i\in A}{\widehat{s}}_{i}{\rho }_{A}\otimes {\rho }_{A}]\) for any subsystem A. Thus, the average purity can be estimated by the average parity \({\rm{Tr}}[\,{\rho }_{A}^{2}]=\langle {(1)}^{{\rm{no}}.{\rm{of}}{\rm{observed}}{\rm{singlets}}}\rangle \) within A and, thus, also the secondorder Rényi entanglement entropy \({S}_{2}(A)={\log }_{2}{\rm{Tr}}[\,{\rho }_{A}^{2}]\).
The entanglement entropy calculation only involves the singlet outcomes. By making use of the full outcome distribution, we can also evaluate the absolute value of all 4^{N} Pauli strings, from a single dataset, in which N is the number of qubits involved in each copy of the state^{22}. More concretely, consider a given Pauli string O = ∏_{i}P_{i}, in which P_{i} ∈ {X_{i}, Y_{i}, Z_{i}, I_{i}} are individual Pauli operators on site i (and the identity), and a given observed bitstring \(\{\overrightarrow{a},\overrightarrow{b}\}\), in which \(\overrightarrow{a}\), \(\overrightarrow{b}\) label the outcomes in the control and target copy. The rules of reconstructing the Pauli strings through these Bellbasis bitstrings can be worked out through considering the computational states to which the Bell states are mapped and considering which operators of XX, YY and ZZ have +1 or −1 eigenvalue for the various Bell states. We explicitly list the analysis procedure: for Pauli term X_{i}, we assign parity +1 if a_{i} = 0 and −1 otherwise; for Pauli term Y_{i}, we assign parity +1 if a_{i} ≠ b_{i} and −1 otherwise; for Pauli term Z_{i}, we assign parity +1 if b_{i} = 0 and −1 otherwise; for I_{i}, we assign parity +1 always. The contribution of the bitstring \(\{\overrightarrow{a},\overrightarrow{b}\}\) to \( {\rm{tr}}(O\rho ){ }^{2}\) is then given by the product of the individual parities.
We can perform the same analysis as a function of the amount of error detection applied. As shown in Extended Data Fig. 9a, as more error detection is applied, the distribution of Pauli expectation values that are expected to be zero and nonzero separate apart further. This also provides a natural method to perform error mitigation through zeronoise extrapolation: by performing slidingscale error detection, we can extract the Pauli expectation value squared for groups of Pauli strings with the same expected value, as a function of the logical purity. We perform a linear fit of the Pauli expectation value squared versus the logical purity and extrapolate to purity \({\rm{tr}}({\rho }^{2})=1\), corresponding to the case of zero noise, to estimate the errormitigated values. The choice of a linear fit is motivated by the fact that both \( {\rm{tr}}(O\rho ){ }^{2}\) and \( {\rm{tr}}({\rho }^{2}) \) scale with power 2 of the density matrix. We expect that more detailed considerations of the noise model, using knowledge about the weight of each operator, as well as whether detected errors in each shot overlap with a given Pauli operator, can further improve the errormitigation results.
We can also compute measures of distance from stabilizer states, also known as ‘magic’, using the additive Bell magic measure in ref. ^{53}, which only requires O(1) number of samples and O(N) classical postprocessing time. To do so, we randomly sample subsets of four measured Bellbasis bitstrings r, r′, q, q′ and calculate their contribution to the Bell magic using the checkcommute method of ref. ^{53}: \({\mathcal{B}}={\sum }_{\mathop{{\bf{r}},{{\bf{r}}}^{{\prime} },{\bf{q}},{{\bf{q}}}^{{\prime} }}\limits_{\in {\{0,1\}}^{2N}}}P({\bf{r}})P({{\bf{r}}}^{{\prime} })P({\bf{q}})P({{\bf{q}}}^{{\prime} }){\left\Vert \left[{\sigma }_{{\bf{r}}\oplus {{\bf{r}}}^{{\prime} }},{\sigma }_{{\bf{q}}\oplus {{\bf{q}}}^{{\prime} }}\right]\right\Vert }_{\infty }\), with \({\left\Vert \left[{\sigma }_{{\bf{r}}\oplus {{\bf{r}}}^{{\prime} }},{\sigma }_{{\bf{q}}\oplus {{\bf{q}}}^{{\prime} }}\right]\right\Vert }_{\infty }\) being 0 when the two Pauli strings commute and 2 otherwise. \({\bf{r}}\oplus {{\bf{r}}}^{{\prime} }\) denotes bitwise XOR between the two bitstrings. P(r) is the probability of observing bitstring r. The Pauli string σ_{r} is of length N and the i^{th} element is I, X, Z or Y when the target and control qubit at site i read 00, 01, 10 or 11, respectively. We convert this result to additive Bell magic through the formula \({{\mathcal{B}}}_{a}={\log }_{2}(1{\mathcal{B}})\). We use approximately 10^{7} samples to estimate the additive Bell magic for each dataset. The results for the estimated additive Bell magic as a function of the number of nonClifford gates applied (circuits shown in Extended Data Fig. 9f) are shown in Fig. 6c. These results also use the purity estimates in the same dataset, which are used for error mitigation as described in equations (13)–(15) of ref. ^{53}. All additive Bell magic data shown are with full error detection applied.
The same experiments we perform here can also be interpreted as a physical Bellbasis measurement. Using this insight, in Extended Data Fig. 9c,d, we show the entanglement entropy for different subsystem sizes, when analysing the data as physical Bellpair measurements and applying different levels of stabilizerbased postselection. Notably, the fullsystem parity when postselecting on all stabilizers being correct is identical when analysing the outcomes as either a physical or a logical circuit. This is because, in this limit, the results of the physicalcircuit analysis can be viewed as taking the (imperfect) logical state and running a perfect encoding circuit, hence giving identical results.
Data availability
The data that support the findings of this study are available from the corresponding author on request.
References
Preskill, J. Quantum computing in the NISQ era and beyond. Quantum 2, 79 (2018).
Shor, P. W. in Proc. 37th Conference on Foundations of Computer Science 56–65 (IEEE, 1996).
Steane, A. Multipleparticle interference and quantum error correction. Proc. R. Soc. Lond. A Math. Phys. Eng. Sci. 452, 2551–2577 (1996).
Dennis, E., Kitaev, A., Landahl, A. & Preskill, J. Topological quantum memory. J. Math. Phys. 43, 4452–4505 (2002).
RyanAnderson, C. et al. Implementing faulttolerant entangling gates on the fivequbit code and the color code. Preprint at https://arxiv.org/abs/2208.01863 (2022).
Google Quantum AI. Suppressing quantum errors by scaling a surface code logical qubit. Nature 614, 676–681 (2023).
Bluvstein, D. et al. A quantum processor based on coherent transport of entangled atom arrays. Nature 604, 451–456 (2022).
Evered, S. J. et al. Highfidelity parallel entangling gates on a neutralatom quantum computer. Nature 622, 268–272 (2023).
Beugnon, J. et al. Twodimensional transport and transfer of a single atomic qubit in optical tweezers. Nat. Phys. 3, 696–699 (2007).
Deist, E. et al. Midcircuit cavity measurement in a neutral atom array. Phys. Rev. Lett. 129, 203602 (2022).
Singh, K. et al. Midcircuit correction of correlated phase errors using an array of spectator qubits. Science 380, 1265–1269 (2023).
Graham, T. M. et al. Midcircuit measurements on a singlespecies neutral alkali atom quantum processor. Phys. Rev. X 13, 041051 (2023).
Ma, S. et al. Highfidelity gates and midcircuit erasure conversion in an atomic qubit. Nature 622, 279–284 (2023).
Lis, J. W. et al. Midcircuit operations using the omg architecture in neutral atom arrays. Phys. Rev. X 13, 041035 (2023).
Norcia, M. A. et al. Midcircuit qubit measurement and rearrangement in a ^{171}Yb atomic array. Phys. Rev. X 13, 041034 (2023).
Campbell, E. T. The smallest interesting colour code. Earl T. Campbell https://earltcampbell.com/2016/09/26/thesmallestinterestingcolourcode/ (2016).
Vasmer, M. & Kubica, A. Morphing quantum codes. Phys. Rev. Appl. 10, 030319 (2022).
Arute, F. et al. Quantum supremacy using a programmable superconducting processor. Nature 574, 505–510 (2019).
Kuriyattil, S., Hashizume, T., Bentsen, G. & Daley, A. J. Onset of scrambling as a dynamical transition in tunablerange quantum circuits. PRX Quantum 4, 030325 (2023).
Bremner, M. J., Montanaro, A. & Shepherd, D. J. Averagecase complexity versus approximate simulation of commuting quantum computations. Phys. Rev. Lett. 117, 080501 (2016).
Daley, A. J., Pichler, H., Schachenmayer, J. & Zoller, P. Measuring entanglement growth in quench dynamics of bosons in an optical lattice. Phys. Rev. Lett. 109, 020505 (2012).
Huang, H. Y. et al. Quantum advantage in learning from experiments. Science 376, 1182–1186 (2022).
Gidney, C. & Ekerå, M. How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits. Quantum 5, 433 (2021).
Fowler, A. G., Mariantoni, M., Martinis, J. M. & Cleland, A. N. Surface codes: towards practical largescale quantum computation. Phys. Rev. A 86, 032324 (2012).
Self, C. N., Benedetti, M. & Amaro, D. Protecting expressive circuits with a quantum error detection code. Nat. Phys. https://doi.org/10.1038/s41567023022822 (2024).
Honciuc Menendez, D., Ray, A. & Vasmer, M. Implementing faulttolerant nonClifford gates using the [[8,3,2]] color code. Preprint at https://arxiv.org/abs/2309.08663 (2023).
Wang, Y. et al. Faulttolerant onebit addition with the smallest interesting colour code. Preprint at https://arxiv.org/abs/2309.09893 (2023).
Andersen, T. I. et al. NonAbelian braiding of graph vertices in a superconducting processor. Nature 618, 264–269 (2023).
Patterson, D. A. & Hennessy, J. L. Computer Organization and Design: The Hardware/Software Interface. RISCV Edition (Morgan Kaufmann, 2018).
Ebadi, S. et al. Quantum phases of matter on a 256atom programmable quantum simulator. Nature 595, 227–232 (2021).
Scholl, P. et al. Quantum simulation of 2D antiferromagnets with hundreds of Rydberg atoms. Nature 595, 233–238 (2021).
Jaksch, D. et al. Fast quantum gates for neutral atoms. Phys. Rev. Lett. 85, 2208–2211 (2000).
Scholl, P. et al. Erasure conversion in a highfidelity Rydberg quantum simulator. Nature 622, 273–278 (2023).
Graham, T. M. et al. Multiqubit entanglement and algorithms on a neutralatom quantum computer. Nature 604, 457–462 (2022).
Cong, I. et al. Hardwareefficient, faulttolerant quantum computation with Rydberg atoms. Phys. Rev. X 12, 021049 (2022).
Beverland, M. E., Kubica, A. & Svore, K. M. Cost of universality: a comparative study of the overhead of state distillation and code switching with color codes. PRX Quantum 2, 020341 (2021).
Bombín, H. Gauge color codes: optimal transversal gates and gauge fixing in topological stabilizer codes. New J. Phys. 17, 083002 (2015).
Goto, H. Minimizing resource overheads for faulttolerant preparation of encoded states of the Steane code. Sci. Rep. 6, 19578 (2016).
Flammia, S. T. & Liu, Y. K. Direct fidelity estimation from few Pauli measurements. Phys. Rev. Lett. 106, 230501 (2011).
Egan, L. et al. Faulttolerant control of an errorcorrected qubit. Nature 598, 281–286 (2021).
Postler, L. et al. Demonstration of faulttolerant universal quantum gate operations. Nature 605, 675–680 (2022).
Eastin, B. & Knill, E. Restrictions on transversal encoded quantum gate sets. Phys. Rev. Lett. 102, 110502 (2009).
Brown, B. J. A faulttolerant nonClifford gate for the surface code in two dimensions. Sci. Adv. 6, eaay4929 (2020).
Aaronson, S. & Gottesman, D. Improved simulation of stabilizer circuits. Phys. Rev. A 70, 052328 (2004).
Mezher, R., Ghalbouni, J., Dgheim, J. & Markham, D. Faulttolerant quantum speedup from constant depth quantum circuits. Phys. Rev. Res. 2, 033444 (2020).
Paletta, L., Leverrier, A., Sarlette, A., Mirrahimi, M. & Vuillot, C. Robust sparse IQP sampling in constant depth. Preprint at https://arxiv.org/abs/2307.10729 (2023).
Shaw, A. L. et al. Benchmarking highly entangled states on a 60atom analog quantum simulator. Preprint at https://arxiv.org/abs/2308.07914 (2023).
Wu, Y. et al. Strong quantum computational advantage using a superconducting quantum processor. Phys. Rev. Lett. 127, 180501 (2021).
Bravyi, S., Englbrecht, M., König, R. & Peard, N. Correcting coherent errors with surface codes. npj Quantum Inf. 4, 55 (2018).
Bravyi, S. et al. Simulation of quantum circuits by lowrank stabilizer decompositions. Quantum 3, 181 (2019).
Sekino, Y. & Susskind, L. Fast scramblers. J. High Energy Phys. 2008, 065 (2008).
Hangleiter, D. & Gullans, M. J. Bell sampling from quantum circuits. Preprint at https://arxiv.org/abs/2306.00083 (2023).
Haug, T. & Kim, M. S. Scalable measures of magic resource for quantum computers. PRX Quantum 4, 010301 (2023).
Kim, Y. et al. Evidence for the utility of quantum computing before fault tolerance. Nature 618, 500–505 (2023).
Bravyi, S. et al. Highthreshold and lowoverhead faulttolerant quantum memory. Preprint at https://arxiv.org/abs/2308.07915 (2023).
Xu, Q. et al. Constantoverhead faulttolerant quantum computation with reconfigurable atom arrays. Preprint at https://arxiv.org/abs/2308.08648 (2023).
Wu, Y., Kolkowitz, S., Puri, S. & Thompson, J. D. Erasure conversion for faulttolerant quantum computing in alkaline earth Rydberg atom arrays. Nat. Commun. 13, 4657 (2022).
Dordević, T. et al. Entanglement transport and a nanophotonic interface for atoms in optical tweezers. Science 373, 1511–1514 (2021).
Tao, R., Ammenwerth, M., Gyger, F., Bloch, I. & Zeiher, J. Highfidelity detection of largescale atom arrays in an optical lattice. Preprint at https://arxiv.org/abs/2309.04717 (2023).
Xu, W. et al. Fast preparation and detection of a Rydberg qubit using atomic ensembles. Phys. Rev. Lett. 127, 050501 (2021).
Litinski, D. & Nickerson, N. Active volume: an architecture for efficient faulttolerant quantum computers with limited nonlocal connections. Preprint at https://arxiv.org/abs/2211.15465 (2022).
Barredo, D., De Léséleuc, S., Lienhard, V., Lahaye, T. & Browaeys, A. An atombyatom assembler of defectfree arbitrary twodimensional atomic arrays. Science 354, 1021–1023 (2016).
Levine, H. et al. Dispersive optics for scalable Raman driving of hyperfine qubits. Phys. Rev. A 105, 032618 (2022).
Jandura, S. & Pupillo, G. Timeoptimal two and threequbit gates for Rydberg atoms. Quantum 6, 712 (2022).
Pagano, A. et al. Error budgeting for a controlledphase gate with strontium88 Rydberg atoms. Phys. Rev. Res. 4, 033019 (2022).
Lengwenus, A., Kruse, J., Schlosser, M., Tichelmann, S. & Birkl, G. Coherent transport of atomic quantum states in a scalable shift register. Phys. Rev. Lett. 105, 170502 (2010).
Schlosser, M., Tichelmann, S., Kruse, J. & Birkl, G. Scalable architecture for quantum information processing with atoms in optical microstructures. Quantum Inf. Process. 10, 907 (2011).
Levine, H. et al. Parallel implementation of highfidelity multiqubit gates with neutral atoms. Phys. Rev. Lett. 123, 170503 (2019).
Tan, D. B., Bluvstein, D., Lukin, M. D. & Cong, J. Compiling quantum circuits for dynamically fieldprogrammable neutral atoms array processors. Preprint at https://arxiv.org/abs/2306.03487 (2023).
Wimperis, S. Broadband, narrowband, and passband composite pulses for use in advanced NMR experiments. J. Magn. Reson. A 109, 221–231 (1994).
Cummins, H. K., Llewellyn, G. & Jones, J. A. Tackling systematic errors in quantum logic gates with composite rotations. Phys. Rev. A 67, 042308 (2003).
Barnes, K. et al. Assembly and coherent control of a register of nuclear spin qubits. Nat. Commun. 13, 2779 (2022).
Le Kien, F., Schneeweiss, P. & Rauschenbeutel, A. Dynamical polarizability of atoms in arbitrary light fields: General theory and application to cesium. Eur. Phys. J. D 67, 92 (2013).
Hutzler, N. R., Liu, L. R., Yu, Y. & Ni, K. K. Eliminating light shifts for single atom trapping. New J. Phys. 19, 023007 (2017).
Shea, M. E., Baker, P. M., Joseph, J. A., Kim, J. & Gauthier, D. J. Submillisecond, nondestructive, timeresolved quantumstate readout of a single, trapped neutral atom. Phys. Rev. A 102, 053101 (2020).
Gidney, C. Stim: a fast stabilizer circuit simulator. Quantum 5, 497 (2021).
Higgott, O., Bohdanowicz, T. C., Kubica, A., Flammia, S. T. & Campbell, E. T. Improved decoding of circuit noise and fragile boundaries of tailored surface codes. Phys. Rev. X 13, 031007 (2023).
Gottesman, D. Opportunities and challenges in faulttolerant quantum computation. Preprint at https://arxiv.org/abs/2210.15844 (2022).
Delfosse, N. & Paetznick, A. Spacetime codes of Clifford circuits. Preprint at https://arxiv.org/abs/2304.05943 (2023).
Steane, A. M. Active stabilization, quantum computation, and quantum state synthesis. Phys. Rev. Lett. 78, 2252 (1997).
McEwen, M., Bacon, D. & Gidney, C. Relaxing hardware requirements for surface code circuits using timedynamics. Quantum 7, 1172 (2023).
Gurobi Optimization. Gurobi optimizer reference manual. Gurobi Optimization https://www.gurobi.com/documentation/current/refman/index.html (2023).
Landahl, A. J., Anderson, J. T. & Rice, P. R. Faulttolerant quantum computing with color codes. Preprint at https://arxiv.org/abs/1108.5738 (2011).
Monz, T. et al. 14qubit entanglement: creation and coherence. Phys. Rev. Lett. 106, 130506 (2011).
Gottesman, D. Stabilizer Codes and Quantum Error Correction. Thesis, California Institute of Technology (1997).
Knill, E. Quantum computing with realistically noisy devices. Nature 434, 39–44 (2005).
Shor, P. W. Scheme for reducing decoherence in quantum computer memory. Phys. Rev. A 52, R2493 (1995).
Krinner, S. et al. Realizing repeated quantum error correction in a distancethree surface code. Nature 605, 669–674 (2022).
Horsman, C., Fowler, A. G., Devitt, S. & Meter, R. V. Surface code quantum computing by lattice surgery. New J. Phys. 14, 123011 (2012).
Tóth, G. & Gühne, O. Entanglement detection in the stabilizer formalism. Phys. Rev. A 72, 022340 (2005).
Kubica, A., Yoshida, B. & Pastawski, F. Unfolding the color code. New J. Phys. 17, 083026 (2015).
Chamberland, C., Kubica, A., Yoder, T. J. & Zhu, G. Triangular color codes on trivalent graphs with flag qubits. New J. Phys. 22, 023019 (2020).
Kubica, A. & Beverland, M. E. Universal transversal gates with color codes: a simplified approach. Phys. Rev. A 91, 032330 (2015).
Mi, X. et al. Information scrambling in quantum circuits. Science 374, 1479–1483 (2021).
Linke, N. M. Faulttolerant quantum error detection. Sci. Adv. 3, e1701074 (2017).
Hashizume, T., Bentsen, G. S., Weber, S. & Daley, A. J. Deterministic fast scrambling with neutral atom arrays. Phys. Rev. Lett. 126, 200603 (2021).
Jia, Y. & Verbaarschot, J. J. Chaos on the hypercube. J. High Energy Phys. 2020, 154 (2020).
Bremner, M. J., Jozsa, R. & Shepherd, D. J. Classical simulation of commuting quantum computations implies collapse of the polynomial hierarchy. Proc. R. Soc. A Math. Phys. Eng. Sci. 467, 459–472 (2011).
Hangleiter, D., BermejoVega, J., Schwarz, M. & Eisert, J. Anticoncentration theorems for schemes showing a quantum speedup. Quantum 2, 65 (2018).
Bouland, A., Fefferman, B., Nirkhe, C. & Vazirani, U. On the complexity and verification of quantum random circuit sampling. Nat. Phys. 15, 159–163 (2019).
Bremner, M. J., Montanaro, A. & Shepherd, D. J. Achieving quantum supremacy with sparse and noisy commuting quantum computations. Quantum 1, 8 (2017).
Gao, X. et al. Limitations of linear crossentropy as a measure for quantum advantage. Preprint at https://arxiv.org/abs/2112.01657 (2021).
Morvan, A. et al. Phase transition in random circuit sampling. Preprint at https://arxiv.org/abs/2304.11119 (2023).
Ware, B. et al. A sharp phase transition in linear crossentropy benchmarking. Preprint at https://arxiv.org/abs/2305.04954 (2023).
Shepherd, D. & Bremner, M. J. Temporally unstructured quantum computation. Proc. R. Soc. A Math. Phys. Eng. Sci. 465, 1413–1439 (2009).
Pan, F. & Zhang, P. Simulation of quantum circuits using the bigbatch tensor network method. Phys. Rev. Lett. 128, 030501 (2022).
Boixo, S. et al. Characterizing quantum supremacy in nearterm devices. Nat. Phys. 14, 595–600 (2018).
Zhong, H.S. et al. Quantum computational advantage using photons. Science 370, 1460–1463 (2020).
Madsen, L. S. et al. Quantum computational advantage with a programmable photonic processor. Nature 606, 75–81 (2022).
Iverson, J. K. & Preskill, J. Coherence in logical quantum channels. New J. Phys. 22, 073066 (2020).
Iyer, P. & Poulin, D. A small quantum computer is needed to optimize faulttolerant protocols. Quantum Sci. Technol. 3, 030504 (2017).
Kaufman, A. M. et al. Quantum thermalization through entanglement in an isolated manybody system. Science 353, 794–800 (2016).
Brydges, T. et al. Probing Rényi entanglement entropy via randomized measurements. Science 364, 260–263 (2019).
Acknowledgements
We thank A. Kubica for pointing us to the connection between our transversal gate set and IQP circuits, J. Campo, S. Haney, T. Wong, T. T. Wang, P. Stroganov and especially J. AmatoGrill for contributions in the development of the FPGA technology and fast CMOS readout. We gratefully acknowledge useful discussions with B. Braverman, H. Briegel, S. Cantu, S. Choi, J. Cong, M. Devoret, H.Y. Huang, A. Keesling, H. Levine, A. Lukin, K. V. Kirk, N. Meister, H. Pichler, H. Poulsen, J. Ramette, J. Sinclair, D. Tan and all members of the Lukin group. We acknowledge financial support from the DARPA ONISQ programme (grant number W911NF2010021), the Center for Ultracold Atoms (a NSF Physics Frontier Center), the National Science Foundation, the Army Research Office MURI (grant number W911NF2010082), IARPA and the Army Research Office, under the Entangled Logical Qubits programme (Cooperative Agreement Number W911NF2320219) and QuEra Computing. D.B. acknowledges support from the NSF Graduate Research Fellowship Program (grant DGE1745303) and the Fannie and John Hertz Foundation. S.J.E. acknowledges support from the National Defense Science and Engineering Graduate (NDSEG) fellowship. T.M. acknowledges support from the Harvard Quantum Initiative Postdoctoral Fellowship in Science and Engineering. M.C. acknowledges support from the Department of Energy Computational Science Graduate Fellowship under award number DESC0020347. D.H. acknowledges support from the U.S. Department of Defense through a QuICS Hartree fellowship. J.P.B.A. acknowledges support from the Generation Q G2 Fellowship and the Ramsay Centre for Western Civilisation. N.M. acknowledges support by the Department of Energy Computational Science Graduate Fellowship under award number DESC0021110. I.C. acknowledges support from the Alfred Spector and Rhonda Kost Fellowship of the Hertz Foundation, the Paul and Daisy Soros Fellowship and NDSEG. M.J.G. and D.H. acknowledge support from NSF QLCI (award no. OMA2120757). The commercial equipment used in this work does not reflect endorsement by the NIST. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of IARPA, the Army Research Office, or the US Government. The US Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.
Author information
Authors and Affiliations
Contributions
D.B., S.J.E., A.A.G., S.H.L., H.Z., T.M., S.E. and G.S. contributed to the building of the experimental setup, performed the measurements and analysed the data. M.C., M.K., D.H., J.P.B.A., N.M., I.C. and X.G. performed theoretical analysis. P.S.R. and T.K. developed the FPGA electronics. All work was supervised by M.J.G., M.G., V.V. and M.D.L. All authors contributed to the logical processor vision, discussed the results and contributed to the manuscript.
Corresponding author
Ethics declarations
Competing interests
M.G., V.V. and M.D.L. are cofounders and shareholders and H.Z., P.S.R. and T.K. are employees of QuEra Computing.
Peer review
Peer review information
Nature thanks Benjamin Brown and the other, anonymous, reviewer(s) for their contribution to the peer review of this work. Peer reviewer reports are available.
Additional information
Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Extended data figures and tables
Extended Data Fig. 1 Neutralatom quantum computer architecture.
a, Experimental layout, featuring optical tools including static SLM and 2D moving AOD traps, global and local Raman singlequbit laser beams, 420nm and 1,013nm Rydberg beams and imaging system for both global and local imaging. b, Level structure for ^{87}Rb atoms, with the relevant atomic transitions used in this work. c, Control infrastructure used for programming quantum circuits, featuring several AWGs. In particular, the moving and Raman 2D AODs are each controlled by two waveforms (one for the x axis and one for the y axis). An additional AWG is used in firstinfirstout (FIFO) mode for rearrangement before the circuit begins and then the moving AOD control is switched to the ‘Moving AWG’. See ref. ^{30} for further SLM and precircuit rearrangement details, ref. ^{8} for further Rydberg AWG details and Rydberg excitation details, refs. ^{7,63} for further Raman laser and microwave control infrastructure details and ref. ^{7} for further moving AWG details. All AWGs (other than the ‘Rearrangement AWG’) are synchronized to <10 ns jitter. During Rydberg gates, the traps are briefly pulsed off by a TTL. The FPGA processes images from the camera in real time and, in this work, sends control signals to the Raman 2D AOD for local singlequbit control. d, Example array layout featuring entangling, storage and readout zones. Zones can be directly reprogrammed and repositioned for different applications, as well as specific tweezer site locations. Tweezer beams and local Raman control are projected from out of plane. The entire objective field of view is 400 μm in diameter and, consequently, we do not expect or observe substantial tweezer deformation near the edges of our processor. During twoqubit Rydberg gates, we place atoms ≲2 μm apart within a gate site and gate sites are separated such that atoms in different gate sites are no closer than 10 μm during the gate. At our present n = 53 and twophoton Rabi frequency of 4.6 MHz, the blockade radius is roughly 4.3 μm, such that adjacent atoms are well within blockade and distant atoms are well outside blockade.
Extended Data Fig. 2 Singlequbit Raman addressing.
a, 5S_{1/2} hyperfine level diagram illustrating the two possible implementations of local singlequbit gates: resonant X(θ) (purple) and offresonant Z(θ) (turquoise) rotations with twophoton Rabi frequencies Ω_{Raman}. In this work, we use the Z rotation scheme and are bluedetuned by 2 MHz from the twophoton resonance. Owing to Clebsch–Gordan coefficients, \({\widetilde{\Omega }}_{{\rm{Raman}}}^{Z}=\sqrt{3}{\Omega }_{{\rm{Raman}}}^{Z}\). b, Schematic showing the conversion of local Z(π/2) into local X(±π/2) gates, in which the pulses before (after) the central Y(π) have positive (negative) sign, while leaving nonaddressed qubit states unchanged. The Gaussiansmoothed local pulses have duration 2.5 μs for π/4 pulses and 5 μs for π/2 pulses and are performed on single rows at a time with a 3μs gap between subsequent gates to allow the RF tones in the AODs to be changed (including this, duration is 5–8 μs per row). In this way, arbitrary patterns of qubits, such as the example drawn, can be addressed. c, Calibration procedure used to homogenize the Rabi frequency over a 220 μm × 35 μm array. The position calibration is illustrated for 80 sites: approximate X(π/2) gates are locally performed and the horizontal/vertical position of all tones is scanned in parallel such that a Gaussian fit returns the optimal alignment. After this, powers are iteratively calibrated until the fitted scale factors for the individual RF tones converge to unity. d, Singlequbit randomized benchmarking of local Z(π/2) gates. The local gates are interleaved with random global singlequbit Clifford gates and the final operation C_{f} is chosen to return to the initial state. Each data point is the average of 100 random sets of Clifford gates and fitting an exponential decay to the return probability quantifies the fidelity \({\mathcal{F}}\) per local gate. Note that we apply all 51 global Clifford gates for each data point, such that errors from the global Clifford gates (as well as SPAM errors) do not contribute to the fitted value.
Extended Data Fig. 3 Midcircuit readout and feedforward.
a, Singleshot 500μs local image in the readout zone, in which the peak corresponds to roughly 50 photons collected by the CMOS camera. b, Atomic transition and pulse sequence used for local imaging of ancilla qubits. The dataqubit traplight shift suppresses data qubit errors, as well as the large spatial separation between entangling and readout zones. We avoid quickly losing the readoutzone atoms during local imaging by using a 5× higher trap depth and we pulse the ancilla qubit traps and local imaging light to image directly on resonance while avoiding negative effects of large traplight shifts. c, Diagram of components involved in midcircuit readout and feedforward steps. Atom detection and logicalstate decoding occur using the FPGA, which then outputs a conditional TTL to gate local Raman pulses performed on logical qubits in the entangling zone. d, Diagram of approximate timings for a midcircuit feedforward cycle. First, the F = 2 population is pushed out (in 10 μs) and then the remaining F = 1 population is imaged locally for 500 μs. The 24 rows of pixels covering the readout zone are read out to the FPGA in 200 μs, after which processing is performed. Finally, a conditional TTL output based on the decoded state gates on or off local Raman pulses. The whole readout and feedforward cycle takes less than 1 ms and can be sped up in the future by optimizing local imaging and camera readout. e–g, Characterization of the error probability of data qubits during local imaging. e, Dataqubit error probability (fraction of population depumped from F = 2 to F = 1) as a function of local imaging duration out to 20 ms to quantify the effect of the local imaging beam on dataqubit coherence for very long illumination. f, Dataqubit error probability after 20 ms of local imaging, as a function of detuning of the local imaging beam, showing suppression of error reddetuned or bluedetuned from the dataqubit transition. g, Equivalently, increasing the trap depth of the data qubits enables suppression of decoherence owing to the local imaging beam. Because qubits in the readout zone are imaged while their traps are pulsed off, any light shift of the dataqubit transition from the traps contributes directly to the relative detuning. h, For a long, 10.5ms local beam illumination with optimal local imaging parameters, we observe a 0.7(1)% increase in dataqubit error during an XY8 dynamical decoupling sequence. This suggests a roughly 0.034(5)% error probability for the data qubits during the 500μs midcircuit readout image used in this work.
Extended Data Fig. 4 Further surfacecode data.
a, Depiction of Bellstate circuit and d = 7 surface codes. b, Diagram showing the transversal CNOT and physical error propagation rules. c, Covariance of the 48 measured stabilizers in both bases. The correlations near the diagonal corresponds to adjacent stabilizers within each block. Strong correlations are also observed with the stabilizers of the other block owing to the error propagation in the transversal CNOT. d, Bellpair infidelity upper bound (as opposed to estimated Bellpair error in Fig. 2d; see Methods), showing improvement with increasing code distance. e, Probability of no detected error for each of the 96 measured stabilizers, showing agreement when compared with the theoretical values from empirically chosen error rates (experiment average = 77%, theory average = 82%). Note that Xbasis logical 1 and Zbasis logical 2 have higher stabilizer error probability owing to the error propagation in the transversal CNOT (reducing expectation values relative to if the transversal CNOT is not performed). f, Using the empirical error rates that correspond to datatheory agreement for the measured stabilizers in e, our simulations for improvement in Bellpair error, as a function of code distance, are in good agreement with experiments. The empirical error rates used are consistent with the 99.3% twoqubit gate fidelity, measured for this larger array, as well as the roughly 4% dataqubit decoherence error (integrated over the entire circuit and measured by the Ramsey method). These dephasing error rates are dominated by a complex moving sequence as we prepare the two surface codes in a serial fashion (see Supplementary Video) and would be much smaller for a repetitive errorcorrection experiment.
Extended Data Fig. 5 Surfacecode preparation and decoding data.
a, Surfacecode stabilizers for the two independent d = 7 codes following state preparation. The entire movement circuit corresponding to the transversal CNOT is implemented and the transversal entanglinggate pulse is simply turned off. The mean stabilizer probability of success across the 96 total stabilizers is 83%. The high probability of stabilizer success of the two independent codes in both the X and Z bases shows that topological surface codes were prepared (and Extended Data Fig. 4 shows that they were preserved during the transversal CNOT). We note that physical fidelities were slightly lower during this measurement because of calibration drift and, therefore, these results slightly underestimate performance relative to the data in Fig. 2 and Extended Data Fig. 4. b, Logical Bellpair error while optimizing the decoder by (inversely) scaling the weights of the interlogical edges and hyperedges that connect the stabilizers of the two logical qubits (higher values correspond to lower pairing weights). More concretely, the probability p of the error mechanism corresponding to the interlogical edges/hyperedges is scaled and the weights are calculated as log((1 − p)/p). Qualitatively, optimizing this scaling value optimizes with respect to the probability that errors are before or after the transversal CNOT, as errors before the CNOT will lead to correlations between the two logical qubits, corresponding to the interlogical edges. As the decoder is optimized by tuning the interlogical scaling factor, the performance for all three code distances improves, and the larger code distances improve faster when approaching the optimal decoding configuration, as expected. These data are consistent with the decoder being properly optimized for all three code distances, consistent with the fact that our improvement with code size does not originate from suboptimal decoder performance for low distance. Note that the y axis is log scale. c, Logical Bellpair error when using (black) and not using (grey) the ancilla stabilizer measurement values, as a function of the scaling of the interlogical edges and hyperedges that connect the stabilizers of the two logical qubits. The ancilla measurements contribute to the correction procedure and contribute more for smaller values of the interlogical scaling, as they correspond to errors that happen before the transversal CNOT. 0× interlogical scaling corresponds to conventional decoding within the two independent surface codes. For the 1× interlogical scaling plotted here, the d = 7 interlogical scaling parameter is chosen slightly different from in Fig. 2d to have consistency across the three code distances (which produces measured values within error bars).
Extended Data Fig. 6 [[8,3,2]] and hypercube encoding.
a, Statepreparation circuit for the [[8,3,2]] code, in which two fourqubit GHZ states are simultaneously prepared and subsequently entangled. This initializes an [[8,3,2]] code with logical states −_{L1},+_{L2},−_{L3}⟩. b, 4D hypercube circuit performed on 48 logical qubits (128 physical qubits). The circuit is drawn on the block level, in which each block consists of three logical qubits and eight physical qubits. The first inblock gate layer is performed with a global T^{†}. The local gate patterns, and the corresponding logical gates they execute within each code block, are illustrated in the inset. c, Diagram illustrating the codeblock movements and use of the processor’s zoned architecture throughout the circuit. Initially, eight [[8,3,2]] code blocks are prepared in the entangling zone and atoms for later state preparation of eight additional code blocks are loaded in the storage zone. The code blocks in the entangling zone are then picked up and interlaced with adjacent blocks to perform three transversal CNOT layers. The two groups of eight code blocks are then swapped and the same procedure is repeated with the second group of code blocks. The first group of code blocks is then moved back into the entangling zone and interleaved with the atoms of the first group to perform a final parallel transversal CNOT. The layers of CNOT gates connect the code blocks such that a 4D hypercube on 16 blocks of [[8,3,2]] codes is constructed. See also Supplementary Video.
Extended Data Fig. 7 Further [[8,3,2]] circuit sampling data.
a, Overlap of errordetected 12qubit sampling data with the theoretical distribution (same data as fully errordetected case in Fig. 5b). Progressive zoomins show the agreement between theory and experiment, down to the level of 10^{−4} probability per bitstring. This errordetected dataset is composed of 23,545 shots (raw dataset is 138,626 shots). Note that we simultaneously measure on two groups of 12 logical qubits; plotted here is only one of the two 12logical groups with an XEB of 0.69(1), whereas in plots Fig. 5e,f and Extended Data Fig. 7b, we average the two logical groups, which gives a measured XEB of 0.616(7). b, Same data as Fig. 5f but with purity (orange), as measured by twocopy measurement, also plotted. The measured XEB is slightly below the measured purity, providing evidence that the XEB is a faithful fidelity proxy. We further note that, under error detection, the logical XEB for these IQP circuits should be a good fidelity proxy. Notably, the behaviour can be different for the raw, uncorrected data, as the circuit we apply on the physical level is not IQP. Without applying error detection, not all errors are logical errors and, therefore, the circuit differs from IQP behaviour and can lend itself to a different scaling. For systems of 3, 6 and 12 logical qubits, several systems are measured in parallel and their results are averaged. We note that, although our preparation of [[8,3,2]] code states makes these states on a cube, it does not have CNOTs between two pairs of qubits in the first step and, therefore, does not have the full gate connectivity of a cube. Instead, we can interpret these CNOTs as having been included but then compiled away as they commute with the state. We neglect this in plotting our physicalqubit connectivity, which is derived from entangling 3D cubes on a 4D hypercube connectivity, realizing a 7D hypercube. c, 48qubit XEB slidingscale errordetection data. The point with full postselection on all stabilizers being perfect returned only eight samples, so we omit this point from the plot in the main text for clarity.
Extended Data Fig. 8 Theoretical exploration of hypercube IQP circuits.
a, Anticoncentration property of our circuits. The circuit is said to be anticoncentrated if its output distribution is spread almost uniformly among all outcomes, without the probability being concentrated on a subset of bitstrings. This property is crucial for many proofs of classical hardness^{20,100} and, thus, it is desired for our sampling circuits to anticoncentrate. The plot shows that the output distribution of random hypercube circuits (randomized inblock operations and randomized control/target in outblock CNOT layers) anticoncentrates as the dimension of the hypercube is increased and the XEB (which captures the output collision probability) converges to the uniform IQP value of 2 (here using Clifford circuits; that is, circuits comprising random CZ and Z only)^{20}. This suggests that sampling from the ideal output distribution can be classically hard. In general, the hypercube IQP circuit ensemble converges to the uniform IQP ensemble in total variation distance as the depth and hypercube dimension are increased (M.K. et al., manuscript in preparation). The specific circuit instances implemented in the experiment also anticoncentrate quickly with increasing hypercube dimension. b, A single layer of the hypercube circuit admits an efficient tensornetwork contraction scheme, which allows us to evaluate the ideal and experimental XEB values. The final outblock CNOT layer is immediately followed by the measurement, which can be incorporated into a nonunitary tensor that is contracted between the two halves of the system (controls and targets of the final CNOT layer). This contraction scheme reduces the memory requirements to half the system size, which enables bitstring amplitude evaluation for the 48qubit experiment. This simulation approach can be made much more expensive by applying further outblock operations within the two subsystems, forcing the blocking of the intrapartition tensors, which increases the memory and runtime requirements (Fig. 5d). c, To understand the effects of finite XEB on required classical simulation time, we explore whether our circuit families can be ‘spoofed’ with a cheaper, approximate simulation that achieves moderately high XEB scores^{102}, studied here for a 24qubit system with full statevector simulation. The spoofing algorithm works by independently sampling from the two halves of the system (two groups of 12 qubits), effectively removing the final layer of CNOTs. This further reduces the simulation complexity, as each of the halves can, in principle, be independently simulated with the efficient approach from b. The plot shows that the spoofed XEB for the 24qubit nonClifford circuit can be exponentially reduced by extending the circuit with further gate layers (similar to the approach used to decrease the performance of the efficient hypercube contraction), for a particular extension of our circuit. This result shows that future work can consider adding extra CNOT layers into these circuits to demonstrate quantum advantage (in the presence of finite experimental noise).
Extended Data Fig. 9 Further Bellbasis measurement results.
a, Histogram of \( {\rm{tr}}(P\rho ){ }^{2}\) for all 4^{6} Pauli strings P in the sixlogicalqubit circuit, as a function of stabilizer postselection threshold (that is, the number of correct stabilizers across the 6 × 2 logical qubits). Blue (red) indicate Pauli strings that are expected to have \( {\rm{tr}}(P\rho ){ }^{2}=0.0625\) (0). The separation between the histograms improves as more postselection is applied. b, Signal to noise (purity divided by statistical uncertainty of purity) as a function of slidingscale error detection (converted into accepted fraction) for the 12logicalqubit twocopy measurements, in which subsystem size 1 indicates a single logical qubit in one copy and subsystem size 12 indicates all logical qubits. For subsystem size 1, the signaltonoise ratio gets worse as data are discarded, as the signal does not change (maximally mixed) but the number of repetitions decreases. By contrast, for the global purity, the signal to noise increases, as nearunity purities are faster to measure^{113}. c,d, Entanglement entropy when analysing the circuit as a physical Bellbasis measurement as opposed to a logical Bellbasis measurement. For logical entanglement entropy calculations, we average over all possible subsystems of that given subsystem size, which we find behaves very similarly to, for example, contiguous subsystems owing to the highdimensional hypercube connectivity. In the physical qubit entanglement entropy calculations, we randomly choose from the possible subsystems, as there are many. c, Six logical (16 physical) qubits per copy. d, 12 logical (32 physical) qubits per copy. The finite sampling imposes a noise floor for very high entanglement entropy values. e, Entanglement entropy measurements, as in Fig. 6b, but as a function of logical subsystem size. f, Logical circuits used for benchmarking magic. For one CCZ, we include U_{1} and omit U_{0}; for two CCZs, we include U_{0} and omit U_{1}; for the three CCZs, we include both U_{0} and U_{1}.
Supplementary information
Supplementary Video 1
Supplementary Videos 1–3 are atom videos for coherent atom motions used in this work. These videos depict the coherent atom motions used for the quantum circuits realized in these experiments. To perform parallel entangling gates, indicated by red ovals, the relevant pairs of atoms are brought in close vicinity (about 2 μm). Supplementary Video 1: Faulttolerant fourqubit GHZ state using d = 3 colour codes (Fig. 3). Ten colour codes, arranged in two rows of five codes with seven physical qubits per code, are encoded in parallel and the bottom row of five logical qubits are used as ancillas in the transversal CNOT and are then moved to the storage zone. The leftmost four computation logical qubits are then used to prepare a GHZ state.
Supplementary Video 2
Entanglement teleportation using midcircuit measurement (Fig. 4d,e). Five colour codes are faulttolerantly encoded, as in Supplementary Video 1, then the central three computation logical qubits in the top row are prepared into a GHZ state. The middle logical qubit is transported to the readout zone (about 100 μm away) for midcircuit measurement, illustrated by the local imaging beam.
Supplementary Video 3
Scrambling circuit with 48 logical qubits using the [[8,3,2]] code (Figs. 5 and 6). Eight [[8,3,2]] code blocks, arranged in two rows of four blocks, are encoded with three layers of entangling gates, followed by three transversal CNOTs. This is repeated with eight further codes (originally in the storage zone) before a final transversal CNOT between the two groups, forming 4D hypercube connectivity between the 48 logical qubit triplets, or a 7D physical hypercube connectivity.
Supplementary Video 4
Supplementary Videos 4 and 5 are animations illustrating atom and trap positions for the coherent atom motions used in this work. The static light green circles show the positions of SLM traps, the light red circles the moveable tweezers and the darkgreen circles are the individual atoms. The positions of the X (Y) AOD tones are indicated by the vertical (horizontal) dashed lines such that the AOD traps lie on the resulting multiplicative grid and the power of each AOD tone is indicated by the shading of the lines. The AOD tones are smoothly turned on to pick up and move atoms, always ensuring atoms avoid other traps, and are ramped down again to transfer the atoms to SLM traps. One unit on the x/y axes corresponds to approximately 2 microns. Supplementary Video 4: Animation of Bell state with two d = 7 surface codes (Fig. 2). To encode the first code, a 7 × 7 grid of data qubits is first loaded into the entangling zone, split into 4 × 7 (left half) and 3 × 7 (right half). Ancilla qubits are brought from the storage zone for stabilizer measurement and, notably, three ancilla atoms move from the top left to bottom right of the entangling zone to connect the full 7 × 7 grid. The ancilla and data qubits are then stored and the process repeated for a second code. Finally, the two prepared d = 7 codes are interleaved in the entangling zone and a final transversal CNOT is performed to generate the logical Bell state.
Supplementary Video 5
Animation of operation of 40 d = 3 colour codes (Fig. 4a–c). Ten colour codes are encoded in the entangling zone and half are used as ancillas to faulttolerantly prepare the others as in Supplementary Video 1 and stored; this is repeated four times.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Bluvstein, D., Evered, S.J., Geim, A.A. et al. Logical quantum processor based on reconfigurable atom arrays. Nature 626, 58–65 (2024). https://doi.org/10.1038/s41586023069273
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1038/s41586023069273
This article is cited by

An elementary review on basic principles and developments of qubits for quantum computing
Nano Convergence (2024)

Faulttolerant connection of errorcorrected qubits with noisy links
npj Quantum Information (2024)

A series of fastpaced advances in Quantum Error Correction
Nature Reviews Physics (2024)

Constantoverhead faulttolerant quantum computation with reconfigurable atom arrays
Nature Physics (2024)

Harnessing quantum information to advance computing
Nature Computational Science (2024)
Comments
By submitting a comment you agree to abide by our Terms and Community Guidelines. If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.