BRIDGE: Lazy-Move Compilation for Dual-Species Neutral-Atom Quantum Computers

arXiv:2606.31833 · quant-ph, cs.AR · Submitted 2026-06-30 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: We're looking at the paper: "BRIDGE: Lazy-Move Compilation for Dual-Species Neutral-Atom Quantum Computers".

Mira: Here's the gist of the paper. Neutral atom quantum computing offers strong scalability and flexible qubit connectivity but most existing compilation flows rely on reconfigurable atom arrays that physically shuttle qubit atoms during execution BRIDGE targets an optimized, dual-species 2D interleaved atom array using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots.

Kai: Across a 22-circuit matched benchmark suite BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively.

Mira: Pruning redundant reasoning tokens The paper introduces BRIDGE, a Buffer-Relay Interconnect for Data-stable Gate Execution that co-designs a static, compiler-managed bufferrelay fabric with a lazy-move compiler that exploits it.

Kai: This approach targets an optimized, dual-species 2D interleaved atom array by using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots.

Title and authors: Kai: So we're looking at this paper now, "BRIDGE: Lazy-Move Compilation for Dual-Species Neutral-Atom Quantum Computers." It’s about how to make these neutral atom systems scale better than they are right now.

Mira: Yeah, it’s interesting because most existing compilation flows rely on physically shuttling qubit atoms around during execution. This paper proposes a different way by using a static, compiler-managed buffer relay fabric with non-encoding atoms to mediate long-range interactions in the fixed baseline.

Lev: From my side, I'm thinking about how this affects the actual hardware. The goal here is to introduce limited data motion only for selected hotspots instead of continuous shuttling everywhere. That sounds like a big reduction in the physical movement overhead we deal with on real systems.

Kai: Exactly, and what they did is co-designing that static fabric with a lazy-move compiler that exploits it. The core idea is that you first compile a complete static relay schedule over this fabric before repositioning any data atom at all.

Mira: And they use these non-encoding buffer atoms to mediate those long-range interactions in the fixed baseline, which is key because the native Rydberg blockade radius, Rb, has a steep fall off with distance.

Lev: That's where I see the physical advantage coming from—they are using these buffer atoms to extend entanglement beyond that native blockade radius by inserting them between data endpoints and driving a coordinated off-resonant pulse sequence.

Kai: They even have this concept of a break-even test baked into the compiler workflow, which determines if repositioning an atom is justified by comparing the relay cost of keeping it stationary against the one time move cost of repositioning it.

Mira: That sounds like they're moving away from just guessing where to move things and instead having a more analytical way to decide when movement pays off.

Lev: I wonder how robust that break-even test is, because on real hardware, you need to know if the fidelity gain from the relay outweighs the actual latency and error introduced by moving an atom.

Kai: The evaluation shows that selective mobility is fidelity neutral at best in the median case for their benchmark suite, but it helps only the phase shift structured minority circuits and can even be harmful if you push it too hard.

Mira: That's a crucial caveat, so they aren't claiming perfect performance across the board; there are specific conditions where this lazy-move approach works best.

Lev: The total number of physical shuttling events is shown to be bounded by something related to K and five, which suggests that the benefit comes from a bounded number of targeted moves rather than unbounded movement.

Kai: And they quantified the lazy-move thesis by showing that the mean execution time drops from eight hundred twenty six microseconds when there's zero shuttling events to five hundred eighteen microseconds when there are at least two hundred fifty six shuttle events.

Title and authors: Mira: That reduction in execution time, that five hundred forty eight microsecond drop, is significant because it shows how this compilation strategy directly impacts the practical runtime of these quantum circuits.

Lev: It really comes down to whether you need to look at the fidelity gain or if you're more concerned with how much time it takes to get a result on a real machine.

Kai: And in terms of performance comparison, BRIDGE-F reaches a total fidelity of zero point six two seven versus zero point zero six zero for ZAP and zero point zero four for Enola, which is about ten times and sixteen times higher respectively.

Mira: It’s impressive that they achieve that with a total atom movement of exactly zero in their best case, which is what they call BRIDGE-F compared to the reconfiguration-centric SOTA compilers like ZAP and Enola.

Lev: Zero atom movement sounds ideal for hardware scalability because it means less wear on the physical system, but I need to know if that zero movement applies universally or just in those specific benchmark suites.

Kai: The sensitivity analysis of the hardware parameters shows that BRIDGE-H fidelity gain over BRIDGE-F is largest where physics favors it, specifically at a relay fidelity of point nine nine with the cheapest shuttles being zero point zero zero four.

Mira: So, it seems the real win for this approach isn't just about the compiler trick itself, but how well it lines up with the underlying physical constraints of the neutral atom arrays.

Lev: That makes sense because if you can only get a large fidelity boost under very specific physical conditions, then you need a strategy that is sensitive to those conditions.

Kai: The final conclusion is that treating these physical constraints as first-class compiler constraints provides a roadmap toward high-fidelity, large-scale quantum high performance computing while also opening the door to hybrid architectures.

Mira: They suggest this buffer network could support parity check execution and logical level entanglement routing, which makes this topology a promising target across both NISQ and fault tolerant regimes.

Lev: I think that moves us toward something more practical for building systems that can handle error correction, which is what we're really trying to do with these large-scale neutral atom arrays.

Kai: So in summary, the paper "BRIDGE: Lazy-Move Compilation for Dual-Species Neutral-Atom Quantum Computers" shows a way to use non-encoding atoms and a lazy-move compiler to get significantly higher fidelity and much faster execution times by making intelligent decisions about when to move data.

Mira: It’s not just about moving things around; it’s about using the static buffer relay fabric smartly, deciding that the cost of waiting is better than the cost of moving.

Lev: For real hardware, it suggests a path where we can avoid continuous transport events if we structure our compilation around these specific physics constraints.

Kai: It opens up a new way to think about how we manage connectivity in these arrays and points toward hybrid architectures that can balance stability with flexibility as well as fault tolerance.

The paper's summary: Kai: So, BRIDGE is essentially about fixing how we compile programs for these neutral atom arrays by moving away from those old methods where you had to physically shuttle every single atom around for every gate.

Mira: Right. The authors propose this Buffer-Relay Interconnect, which uses non-encoding buffer atoms to basically act as a fixed backbone for long-range interactions, and they only move the data atoms when it really makes sense.

Lev: So instead of you moving an atom everywhere during the whole calculation, you compile a static plan first over this buffer network, and then only move the data atom when keeping it still would cost more in terms of fidelity than actually moving it.

Kai: Exactly. The core idea is called lazy-move compilation, where you first compile a complete static schedule, and then you only reposition the data atom if a test shows that the cost of keeping it stationary is greater than the one time move cost to put it back where you need it.

Mira: And they’ve structured their hardware setup so that this works well. They use dual-species arrays with species selective addressing, which lets them control three different types of coupling—Rb to Cs, Cs to Cs, and Rb to Rb—which helps suppress unwanted interactions between the data atoms themselves.

Lev: That’s interesting because controlling those different coupling channels geometrically fixes the spacing in a way that ensures data atoms are strongly coupled to that buffer fabric through two channels but geometrically excluded from direct coupling through the third.

Kai: And they show some really strong numbers on how much better this is compared to existing compilers like ZAP and Enola. They're talking about geometric mean fidelity gains of about ten times higher, and execution times that are five hundred forty eight microseconds lower for some circuits.

Mira: But Lev’s point about the overhead is important, right? They show that selective movement isn't always perfect—it’s only fidelity neutral in the median case for their whole set of circuits, and it can even be harmful if you push it too hard.

Lev: That makes sense from a real hardware perspective. If you’re not careful with your budget, over-driving that lazy-move strategy just increases the total number of transport events without giving you the payoff.

Kai: So the paper is basically saying that treating those physical constraints as hard rules for the compiler—not just suggestions—is actually a way to build toward bigger quantum computers, maybe even hybrid ones.

Mira: They suggest this buffer network could be used for things like parity check execution and logical level entanglement routing, which points toward a really promising future for fault-tolerant architectures.

Lev: It means we can use this topology not just for running algorithms, but also to manage error correction levels directly on the hardware, which is a big step toward building systems that can handle those high error rates.

Kai: So it’s about moving from continuous physical manipulation to a smarter, more data-aware control scheme for these arrays. What we need to look at next is exactly how they designed that break-even test and their mobility budget K.

The paper's improvements: Tom: So, Kai and Mira are now looking at what they suggest to make BRIDGE even better than what they just built, focusing on how they can push those lazy-move ideas further.

Kai: They are suggesting several ways to refine the compilation workflow—it’s not just one single idea—to make that decision about moving an atom really more predictive.

Mira: They want to build in this analytical break-even test directly into the system so it can decide if a move is justified by comparing how much you save on relay cost versus how much you spend on moving the atom.

Lev: That sounds like they are trying to create a feedback loop where the compiler knows exactly when to stop and just keep things still, based on real-time performance metrics.

Kai: They’re introducing this mobility budget K and this Eshuttle term, which is basically a predictive tool that lets BRIDGE decide whether the expected gains from relay savings outweigh the physical cost of that move.

Mira: It’s about moving away from just reacting to the current state and toward making choices based on predicting what will happen in the future, which they call compiler aggressiveness knob tau.

Lev: That knob lets you set a policy, either conservative or aggressive, depending on whether the expected gains from relay fidelity clearly dominate the cost of transport.

Kai: And they also mention some hardware improvements for the actual physical layout—they want to use species selective addressing to get denser interleaving without those awkward guard regions between data and buffer atoms.

Mira: They are also talking about mid-circuit buffer reuse, where a buffer atom gets reset for a new relay path while the actual data register stays completely undisturbed, which saves even more movement.

Lev: That kind of hardware efficiency is huge because it means the physical system itself has to work less hard to execute the schedule.

Kai: They also plan to use a parallel hardware scheduler that uses a geometric non-crossing algorithm, which lets you orchestrate several disjoint relay paths simultaneously across time slices, managing fidelity by accounting for van der Waals coupling between those same-slice relays.

Mira: That scheduling part is interesting because it addresses the latency issue head-on by looking at how those simultaneous operations interfere with each other physically on the chip.

Lev: If you can manage that level of parallelism and fidelity folding, then the overhead for running a complex program on real hardware drops significantly, which is exactly what we need for actual quantum computers.

Kai: So they are taking this from just a good compiler to a whole system design that understands both the physics of the atoms and the constraints of how quickly we can run things on hardware.

Mira: It really shows how crucial it is to treat those physical constraints as first-class rules for the entire software stack, not just as something you worry about after you’ve written your code.

Lev: And this kind of architecture gives us a concrete roadmap for what high fidelity, large scale quantum computing could actually look like in practice, balancing stability with flexibility.

Conclusion: Kai: So to wrap up, BRIDGE is about using non-encoding buffer atoms and a lazy-move compiler to drastically improve fidelity and speed in these neutral atom systems by making smart decisions about when to move data.

Mira: The big implication here is that we can start thinking about how physical constraints are fundamental rules for the software itself, which could really help us build stable, large scale quantum computers.

Lev: It suggests a path toward hybrid architectures where you get the stability of error correction combined with the flexibility needed for complex gate operations across different regimes.

Kai: I think it gives us a concrete blueprint for how to manage connectivity in these arrays so we aren't just constantly shuffling atoms around and losing time.

Mira: Exactly, and this whole concept opens up possibilities for routing logical entanglement across the chip in a way that’s more robust than what we have now.

Lev: We can start designing hardware topologies that actually support parity check execution, which is essential if you want to get error correction working reliably on a large scale.

Kai: So, it’s not just about making circuits run faster; it’s about designing the whole quantum system around how the data moves through its physical structure.

Mira: And this leads us right into how these new compilation strategies interact with those complex noise models we've been discussing in other papers.

Lev: Because if we can control the movement so tightly, we might actually be able to use more realistic error correction codes on the hardware itself and see better results.

Kai: We’ll be looking at how this lazy-move approach holds up when you run it on actual hardware that has those specific coupling channel imbalances we talked about.

Mira: Right, and then we can see if this concept scales beyond just these small benchmark circuits into more complex scenarios where the overhead really starts to pile up.

Beijing Academy of Quantum Information Sciences, Beijing 100193, China · Department of Computer Science and Engineering, The Chinese University of Hong Kong, Hong Kong SAR, China · Open Quantum Intelligence (Shanghai) Co., Ltd. · State Key Laboratory of Quantum Information Technologies and Materials, The Chinese University of Hong Kong, Hong Kong SAR, China · CAS Cold Atom Technology (Wuhan) Co. Ltd. · Key Laboratory of Quantum Optics and Center of Cold Atom Physics, Shanghai Institute of Optics and Fine Mechanics, Chinese Academy of Sciences, Shanghai 201800 · State Key Laboratory of Low Dimensional Quantum Physics, Department of Physics, Tsinghua University, Beijing 100084 · Frontier Science Center for Quantum Information, Beijing 100184

quant-ph, cs.AR

Submitted: 2026-06-30

Updated: 2026-11-05

Comments: 14 pages, 11 figures

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 100/100

The gist: Neutral atom quantum computing offers strong scalability and flexible qubit connectivity but most existing compilation flows rely on reconfigurable atom arrays that physically shuttle qubit atoms…

Key concepts

Buffer-Relay Interconnect (BRIDGE)
This is a co-designed fabric where non-encoding 'buffer atoms' are used to mediate long-range interactions between data qubits. Instead of constantly moving data atoms, the compiler first creates a static schedule on this fabric, only moving data when it proves beneficial.
Lazy-Move Compiler
This compiler strategy inverts traditional methods by assuming a static buffer-relay fabric exists. It only moves a data atom if the calculated cost of keeping it stationary is greater than the one-time cost of moving it to a better position, minimizing physical data motion.
Buffer-Atom-Mediated (BAM) Gates
These are gates that extend entanglement beyond the native interaction range by inserting buffer atoms between data endpoints. A coordinated pulse sequence drives these interactions across the chain, allowing for long-range connectivity without requiring direct, costly data-data coupling.
Break-Even Test
This analytical test determines whether repositioning a data atom is worthwhile. It compares the cost associated with maintaining the atom stationary (relay cost) against the one-time cost of moving it (transport cost), ensuring shuttling only occurs when relay savings outweigh transport overhead.

Terminology

Summary

Neutral atom quantum computing offers strong scalability and flexible qubit connectivity but most existing compilation flows rely on reconfigurable atom arrays that physically shuttle qubit atoms during execution BRIDGE targets an optimized, dual-species 2D interleaved atom array using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots. p. 0

Where the paper says it

We present BRIDGE, a Buffer-Relay Interconnect for Data-stable Gate Execution that co-designs a static, compiler-managed bufferrelay fabric with a lazy-move compiler that exploits it. BRIDGE targets an optimized, dual-species 2D interleaved atom array, using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots.

Across a 22-circuit matched benchmark suite BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively. p. 0
Where the paper says it

By using calibrated heteronuclear and homonuclear Rydberg channels, BRIDGE realizes a static routing backbone in which data-buffer and buffer-buffer interactions are enabled while residual data-data crosstalk is suppressed. Across a 22-circuit matched benchmark suite re-estimated under a single shared error model, BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively, while reducing data-atom movement from thousands of transport events to zero.

Pruning redundant reasoning tokens

The paper introduces BRIDGE, a Buffer-Relay Interconnect for Data-stable Gate Execution that co-designs a static, compiler-managed bufferrelay fabric with a lazy-move compiler that exploits it. This approach targets an optimized, dual-species 2D interleaved atom array by using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots. p. 0

Where the paper says it

We present BRIDGE, a Buffer-Relay Interconnect for Data-stable Gate Execution that co-designs a static, compiler-managed bufferrelay fabric with a lazy-move compiler that exploits it. BRIDGE targets an optimized, dual-species 2D interleaved atom array, using non-encoding “buffer atoms” to mediate long-range interactions in the fixed baseline and introducing limited data motion only for selected hotspots.

The core principle of BRIDGE is lazy-move: compile a complete static relay schedule over the buffer-relay fabric first, then reposition a data atom only when a break-even test demonstrates that the relay cost of keeping it stationary exceeds the one-time move cost of repositioning it. p. 1
Where the paper says it

BRIDGEF (steel-blue circles) sits firmly in the top-left corner, whereas reconfiguration-centric ZAP (rose squares) and Enola (gold triangles) are pushed toward low fidelity and high runtime— BRIDGE-F gives geomean ∼10× higher fidelity and ∼540× lower execution time than ZAP, with zero atom movement. We present BRIDGE (Buffer-Relay Interconnect for Datastable Gate Execution), a neutral-atom compiler whose governing principle is lazy-move: compile a complete static relay schedule over the buffer-relay fabric first, then reposition a data atom only when a break-even test demonstrates that the relay cost of keeping it stationary exceeds the one-time move cost of repositioning it.

How the training signal is built

The hardware architecture is based on dual-species neutral-atom arrays where long-lived data atoms are separated from non-encoding buffer atoms through speciesselective addressing. This structure enables three independent coupling channels—Rb–Cs, Cs–Cs, and Rb–Rb—which allows for channel-selective connectivity by enhancing the Rb–Cs interaction while suppressing intraspecies Rb–Rb coupling. p. 3

Where the paper says it

a) Channel-selective connectivity. : Heteronuclear Forster resonances between ¨ 87Rb and 133Cs enhance the Rb–Cs interaction while suppressing intraspecies Rb–Rb coupling [5], [10], giving three channels with distinct blockade radii.

The staggered geometric arrangement fixes the three pairwise spacings by construction to satisfy all three channel inequalities of Eq. p. 3
Where the paper says it

BRIDGE meets both requirements through a staggered, interleaved arrangement of Rb data and Cs buffer atoms that fixes the three pairwise spacings by construction, making the fabric a permanent, compiler-managed connectivity resource rather than a consequence of atom movement. Staggered Geometric Arrangement The geometric arrangement is shown in Figure 4.

(6). This arrangement ensures that data atoms are strongly coupled to the surrounding buffer fabric through the Rb–Cs and Cs–Cs channels while direct data–data coupling through the suppressed Rb–Rb channel is geometrically excluded. p. 4
Where the paper says it

The three spacings jointly satisfy Eq. (6): data atoms are strongly coupled to the surrounding buffer fabric through the Rb–Cs and Cs–Cs channels, while direct data–data coupling through the suppressed Rb–Rb channel is geometrically excluded.

Where the gains come from

The primary mechanism for long-range connectivity is buffer-atom-mediated (BAM) gates which extend entanglement beyond the native blockade radius by inserting non-encoding buffer atoms between the data endpoints and driving a coordinated off-resonant pulse sequence across the resulting chain. The relay length L governs both the multiplicative fidelity degradation and the additive latency, as TBAM(P) ≈ (2L − 1) τp. p. 2

Where the paper says it

1–1 µs for the n ≈ 70 Rydberg states employed here [6]. The relay length L thus governs both the multiplicative fidelity degradation and the additive latency: longer relays are both lossier and slower.

BRIDGE-H uses a break-even condition to determine if a single repositioning move recovers sufficient relay cost to justify its fidelity and latency overhead. p. 1
Where the paper says it

• BRIDGE, the first lazy-move compiler for neutralatom quantum circuits. BRIDGE routes gates through the buffer-relay fabric via circuit-aware placement and disjoint-buffer scheduling over shortest-path relay routes, and invokes the break-even condition to determine, per data atom, whether a single repositioning move recovers sufficient relay cost to justify its fidelity and latency overhead.

The compiler workflow involves four tightly coupled co-design phases: the nativegate front-end, the Mobility-Aware Synthesis phase, the Baseline Generation phase, and the Analytical Mobility Resolution phase. The placement stage uses a consensus-based optimization (CBO) search guided by an objective function LK(π) that captures communication cost and enforces physical spacing constraints. p. 5

Where the paper says it

Algorithm 1: Mobility-Aware CBO Placement Input: Interaction graph G = (V, E), site grid S, mobility budget K Output: Static placement π and reserved buffer sites πB Initialize population P with random valid mappings over S; if ML warm-start is enabled then πml ← INFERMAPPING(G, S) ; // Use lightweight cached model Insert πml into P; // Apply edge-discounting heuristic for hybrid regime E˜ ← E; if K > 0 then Identify the top-K longest expected routing edges in E; Apply distance penalty discount to these edges to form E˜; for t = 1 to T do Evaluate each πˆ ∈ P using LK(ˆπ); E ← Top-ranked elite candidates from P; πconsensus ← Extract majority-vote assignment from E; P ← E∪ MUTATEANDSWAP(E, πconsensus); π ← arg minπˆ∈P LK(ˆπ); πB ← Reserve unused sites around π for buffer allocation; return (π, πB); relying on a generic regular embedding. Because the placement problem is combinatorial and NP-hard under one-toone site assignment and spacing constraints, BRIDGE uses a population-based search strategy.

BRIDGE-H authorizes atom shuttling only when the expected relay savings outweigh the physical cost, modeled by the inequality Eshuttle < τ (1 − F squared PNfuture i=1 L(i) static−L(i) move relay). p. 6
Where the paper says it

Instead of performing full pulse-level AOD waveform synthesis, BRIDGE-H captures transport constraints at the compiler level through three knobs: a mobility budget K that upper-bounds the number of approved transport events, a shuttling error term Eshuttle that penalizes each handoff/move, and a shuttle duration term used by the simulator. The resulting policy is predictive rather than reactive: BRIDGE-H first profiles the fixed schedule, identifies future relay-heavy interactions, and authorizes AOD transport only when the expected relay savings outweigh the physical cost.

The evaluation demonstrates that selective mobility is fidelity-neutral at best in the suite median, helping only the phase-shift–structured minority and being harmful if over-driven. The total number of physical shuttling events is a monotone surface min(K, 5) (right panel) for the representative circuit qft n18 when K=16 and τ≥0. p. 8

Where the paper says it

The compiler iteratively evaluates this break-even condition across all hotspots. As a result, the total number of physical shuttling events is an emergent outcome of the circuit’s temporal structure, the hardware’s ratio of shuttle infidelity to relay-pulse fidelity, the aggressiveness parameter τ , and the configured upper bound K.

75. The lazy-move thesis is quantified by showing that the mean execution time drops from 826 µs at K = 0 to 518 µs for K ≥ 256, indicating that the benefit comes from a bounded number of targeted moves. p. 9
Where the paper says it

(11) with the √ d transit time, while array-scale moves, bounded in practice by a finite peak transport speed, reach the few-hundred-µs regime reported for reconfigurable arrays [13]. The compiler’s ultimate goal is to maximize the fidelity of the entire circuit—defined as the product of all individual gate fidelities—while simultaneously minimizing the total circuit execution time.

BRIDGE-F outperforms SOTA reconfigurable neutral-atom compilers ZAP and Enola on every axis under the shared hardware and error model. BRIDGE-F reaches total fidelity 0. p. 0

Where the paper says it

By using calibrated heteronuclear and homonuclear Rydberg channels, BRIDGE realizes a static routing backbone in which data-buffer and buffer-buffer interactions are enabled while residual data-data crosstalk is suppressed. Across a 22-circuit matched benchmark suite re-estimated under a single shared error model, BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively, while reducing data-atom movement from thousands of transport events to zero.

627 versus 0. p. 1
Where the paper says it

reconfiguration-centric SOTA BRIDGE-F ZAP Enola Lower latency Lower loss Fig. 1: Quality–cost trade-off on the 22-circuit matched suite under one shared error model: total fidelity (higher better) versus execution time (log, lower better), so top-left is best.

060 (ZAP) and 0. p. 0
Where the paper says it

By using calibrated heteronuclear and homonuclear Rydberg channels, BRIDGE realizes a static routing backbone in which data-buffer and buffer-buffer interactions are enabled while residual data-data crosstalk is suppressed. Across a 22-circuit matched benchmark suite re-estimated under a single shared error model, BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively, while reducing data-atom movement from thousands of transport events to zero.

040 (Enola), ∼10× and ∼16× higher, with a total atom movement of zero. p. 0
Where the paper says it

By using calibrated heteronuclear and homonuclear Rydberg channels, BRIDGE realizes a static routing backbone in which data-buffer and buffer-buffer interactions are enabled while residual data-data crosstalk is suppressed. Across a 22-circuit matched benchmark suite re-estimated under a single shared error model, BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively, while reducing data-atom movement from thousands of transport events to zero.

This is because BRIDGE exposes a static buffer-relay fabric to the compiler so the gains reflect a change in co-design point rather than same-fabric, compileronly retuning. p. 1
Where the paper says it

Across the 22-circuit matched suite, re-estimated under a single shared error model, BRIDGE attains a geometricmean ∼ 16× higher total fidelity over Enola and ∼ 10× over ZAP (exceeding two orders of magnitude on the hardest circuits), together with ∼ 1000× and ∼ 540× lower circuit execution time, respectively, relative to these reconfigurationcentric baselines, while reducing data-atom movement from thousands of transport events to zero (Figure 1). This is an architecture-level comparison: ZAP and Enola recover connectivity through data-atom motion, whereas BRIDGE exposes a static buffer-relay fabric to the compiler, so the gains reflect a change in co-design point rather than same-fabric, compileronly retuning (overhead in §V-E).

The hardware parameters sensitivity analysis shows that BRIDGE-H fidelity gain over BRIDGE-F is largest where physics favors it, specifically at Frelay = 0.99 with the cheapest shuttles (Eshuttle = 0. p. 7

Where the paper says it

(a) Under static BRIDGE-F, q0 stays fixed, forcing Phase 2 onto expensive long-range BAM relays. (b) BRIDGE-H detects the phase shift and shuttles q0 to the new neighborhood, amortizing the move over multiple shorter relays.

004). The realized move count co-varies smoothly with this boundary, confirming that selective mobility wins only if relay fidelity regresses or transport becomes markedly cheaper. p. 1
Where the paper says it

BRIDGE is realized in two variants: BRIDGE-F, a fully static compiler in which data atoms are never repositioned, and BRIDGE-H, a lazy-move hybrid in which data atoms are repositioned only when the break-even condition is satisfied. Across the 22-circuit matched suite, re-estimated under a single shared error model, BRIDGE attains a geometricmean ∼ 16× higher total fidelity over Enola and ∼ 10× over ZAP (exceeding two orders of magnitude on the hardest circuits), together with ∼ 1000× and ∼ 540× lower circuit execution time, respectively, relative to these reconfigurationcentric baselines, while reducing data-atom movement from thousands of transport events to zero (Figure 1).

The final conclusion is that the realized mobility footprint is dictated jointly by the circuit’s temporal structure and the hardware’s ratio of shuttle infidelity to relay-pulse fidelity. p. 8
Where the paper says it

0) tolerates short-term fidelity deficits in exchange for aggressive structural defragmentation and congestion relief. Consequently, the realized mobility footprint is dictated jointly by the circuit’s temporal structure and the chosen compiler aggressiveness τ .

The paper concludes that treating physical constraints as first-class compiler constraints provides a roadmap toward high-fidelity, large-scale quantum high-performance computing. The architecture aligns with the syndrome-extraction structure of surface-code-style fault tolerance where data atoms hold algorithmic state and measure or syndrome qubits interact with nearby data qubits to extract parity information. p. 1

Where the paper says it

Rydberg Blockade and the Short-Range Connectivity Constraint Qubits in neutral-atom arrays are encoded in long-lived ground-state hyperfine levels, and entangling gates are realized by transiently coupling one hyperfine level to a highly excited Rydberg state. Except for the special case of resonant dipoledipole interactions, the interaction between two nearby atoms, both in Rydberg states, follows the van der Waals potential V (R) = C6 R6 , (1) where R is the inter-atomic distance and C6 is the dispersion coefficient of the chosen Rydberg level.

The work provides a roadmap toward high-fidelity, large-scale quantum high-performance computing while also opening the door to hybrid architectures that balance stability and flexibility. The buffer network could therefore support parity-check execution and logicallevel entanglement routing, making this topology a promising target across both NISQ and fault-tolerant regimes. p. 0

Where the paper says it

Across a 22-circuit matched benchmark suite re-estimated under a single shared error model, BRIDGE attains a geometric-mean ∼10× higher total fidelity than ZAP and ∼16× than Enola, together with ∼540× and ∼1000× lower circuit execution time, respectively, while reducing data-atom movement from thousands of transport events to zero. INTRODUCTION Neutral-atom platforms have emerged as a leading candidate for fault-tolerant quantum computing, owing to their high qubit counts, long coherence times, and the ability to realize long-range connectivity by repositioning atoms with optical tweezers [1], [2].

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Move from reconfiguration-centric compilation to a lazy-move compiler that exploits a static, compiler-managed bufferrelay fabric. This allows for data-atom movement only for selected hotspots, inverting the design logic of conventional compilers and reducing data-atom movement from thousands of transport events to zero.

  2. Implement an analytical break-even test within the BRIDGE system where it determines whether repositioning a data atom is justified by comparing the relay cost of keeping it stationary exceeds the one-time move cost of repositioning it.

  3. Develop a mobility budget K and an Eshuttle term that allows for predictive decision-making, enabling BRIDGE-H to authorize AOD transport only when the expected relay savings outweigh the physical cost, rather than relying on a generic routing primitive.

  4. Integrate dual-species neutral-atom arrays using speciesselective addressing to enable dense interleaving of data and buffer atoms in the geometric arrangement without guard regions and mid-circuit buffer reuse where a buffer is reset and reused for a subsequent relay while the data register remains undisturbed.

  5. Design a placement objective function LK that incorporates an edge discount coefficient alpha K, which is set to rho mob for edges in EK(p) to reserve headroom exactly where shuttling is later approved via an ML warm-start mechanism.

  6. Create a circuit-aware placement and scheduling pipeline that uses a shortest-path relay routing pass under fixed assumptions to construct the BRIDGE-F executable schedule, which then extracts structural hotspots for BRIDGE-H analysis.

  7. Enhance the compiler with a compiler aggressiveness knob tau that governs the break-even condition, allowing it to operate at either conservative or aggressive policies based on whether the future relay-fidelity gain clearly dominates the transport cost.

  8. Implement a parallel hardware scheduler that uses a geometric non-crossing algorithm to orchestrate simultaneous disjoint relay paths across time slices, managing fidelity by folding in the van der Waals coupling between same-slice relays.

Abstract

Neutral-atom quantum computers commonly connect distant qubits by transporting atoms, incurring trap-handover errors, heating, and atom loss. We present BRIDGE (Buffer-Relay Interconnect for Data-stable Gate Execution), a hardware--software co-design that connects stationary data atoms through a fixed, second-species buffer network. Short buffer chains mediate remote controlled-Z gates and return to their initial states after each operation. BRIDGE-F combines relay routing with buffer-mediated SWAPs to relocate quantum states without transporting atoms. BRIDGE-H additionally permits data-atom transport when its full modeled cost is offset by higher survival-weighted fidelity. Across 21 circuits, BRIDGE-F exceeds ZAP and Enola in modeled survival-weighted fidelity, with geometric-mean ratios of 2.1 times and 38 times and medians of 1.3 times and 3.7 times. Modeled execution latency is lower by factors of approximately 500 and 1, 350, respectively, with circuit single-qubit costs excluded and relay/SWAP Hadamards included. On the same fabric, BRIDGE-F matches or exceeds SABRE-based routing on 17 circuits. Rescoring nominal plans with relay-module error equal to direct-CZ error preserves the advantage over ZAP across all 21 circuits, although recompilation can underperform on QFT. These results identify stationary buffer-mediated connectivity as a promising alternative to repeated atom transport under the stated physical assumptions.

Related papers