ZAP: Zoned Architecture and Performant Compiler for Field Programmable Atom Array

ZAP introduces a co-designed zoned architecture and deterministic compiler for field-programmable atom arrays that achieves multi-order-of-magnitude compilation speedups (up to 10,000$\times$) while maintaining competitive execution quality by replacing iterative global searches with a single-pass, hardware-aware flow.

The Gist

Imagine you are trying to organize a massive, high-stakes dance performance for thousands of dancers (the atoms) on a giant stage. In a standard quantum computer, the dancers are stuck in fixed spots, and to make them interact, you have to make them "jump" over each other using complex, slow moves.

But in Neutral Atom Quantum Computing, the dancers are actually floating on invisible magnetic bubbles (optical tweezers). You can pick them up and move them anywhere on the stage instantly. This sounds amazing, right? But there's a catch: if you move too many dancers at once, they bump into each other (crosstalk), or the music gets so loud that the dancers get confused and lose their rhythm (noise).

The problem is that writing the "choreography" (the compiler) for these thousands of moving dancers is incredibly hard. Previous methods tried to solve this by running millions of simulations to find the perfect dance, which took hours or even days. This is too slow for real-world use.

Enter ZAP (Zoned Architecture and Performant Compiler). Think of ZAP as a brilliant new stage manager who uses a simple, clever trick to solve the chaos.

The Big Idea: Two Special Rooms

Instead of treating the whole stage as one big mess, ZAP divides the stage into two distinct "rooms":

1. The Storage Room: This is a quiet, safe waiting area where dancers sit when they aren't dancing. They are far apart here so they don't accidentally bump into each other.
2. The Dance Floor (Entanglement Zone): This is a small, special area where the actual "partner dances" (two-qubit gates) happen. The floor is set up with specific spots where pairs of dancers can hold hands perfectly.

How ZAP Works (The Choreography)

When a dance routine needs to happen, ZAP doesn't try to plan every single move for the whole show at once. Instead, it uses a deterministic, one-pass strategy:

1. The "Look-Ahead" Move: Before the music starts, ZAP quickly figures out which dancers need to go to the Dance Floor. It doesn't just pick the closest ones; it looks ahead to see which dancers will need to move next. It arranges them in the Storage Room so that when they are called up, they can all move to the Dance Floor at the same time without bumping into each other.
2. The "Stay or Go" Decision: Once a pair of dancers finishes their dance on the floor, they have a choice: stay on the floor for the next dance, or go back to the Storage Room?
   • Old methods were rigid: they either kept everyone on the floor (risking noise) or sent everyone back immediately (wasting time moving them).
   • ZAP's trick: It calculates the cost. "If we keep this dancer here, will they get noisy? If we send them back, will it take too long?" It makes the smartest choice for each dancer, balancing speed and safety.
3. The One-Pass Flow: Unlike previous managers who would try a plan, realize it was bad, and start over (iterative search), ZAP plans the whole thing in one go. It's like a conductor who knows the score so well they don't need to rehearse the whole orchestra 50 times; they just give the cues, and the music flows.

The Results: Speed and Quality

The paper claims ZAP is a game-changer in two ways:

• Speed: It is incredibly fast. While other managers took minutes or hours to plan a routine for 100 dancers, ZAP does it in less than a tenth of a second. That's a speedup of 1,000 to 10,000 times. It turns a process that used to be a bottleneck into something that happens instantly.
• Quality: Because ZAP is so smart about when to move dancers and when to keep them still, it reduces "bumping" (crosstalk) and "confusion" (decoherence). The dance ends up being more accurate and the music clearer. This is especially true for complex, messy routines (structured algorithms) where the dancers have to interact in weird patterns.

Why This Matters

The paper argues that by designing the hardware (the two rooms) and the software (the manager) to work together, we can finally scale up quantum computers. Instead of getting stuck trying to solve an impossible puzzle, ZAP provides a practical, fast, and reliable way to run quantum programs.

In short: ZAP is like a super-efficient traffic controller for a city of moving cars. Instead of trying to simulate every possible traffic jam to find the perfect route, it uses a smart, pre-planned system of lanes and signals to get everyone to their destination instantly and without accidents.

Technical Summary

Technical Summary: ZAP – Zoned Architecture and Performant Compiler for Field Programmable Atom Array

1. Problem Statement

Neutral-atom quantum computing has emerged as a leading platform for scalability, offering systems with thousands of physical qubits and high-fidelity gate operations. A defining feature of this architecture is the ability to dynamically reposition atoms using optical tweezers (Acousto-Optic Deflectors, or AODs) to establish connectivity, eliminating the need for costly SWAP gate chains found in static architectures like superconducting circuits.

However, this dynamic capability introduces a severe compiler–architecture challenge. Existing compilers (e.g., Enola, ZAC, PowerMove) rely on slow, iterative, search-based algorithms to map logical circuits onto reconfigurable atom arrays. These approaches fail to scale: compilation times for modestly sized problems explode from minutes to hours, creating a bottleneck that hinders fault-tolerant system development and disrupts the rapid feedback loops essential for algorithm research. Furthermore, these compilers struggle to simultaneously optimize for execution quality (fidelity) and speed, often failing to adequately manage the trade-offs between atom transport overhead, crosstalk from global laser fields, and decoherence.

2. Methodology

The authors propose ZAP (Zoned Architecture and Performant Compiler), a co-designed framework that integrates a specific hardware layout with a deterministic, non-iterative compiler.

Hardware Architecture: The Zoned Approach

ZAP imposes a spatial structure on the atom array by partitioning it into two distinct regions:

• Storage Zone: A static region where idle qubits are held in deep potential wells (generated by Spatial Light Modulators, SLMs) to preserve coherence and minimize crosstalk.
• Entanglement Zone: A dynamic region where active qubits are transported for two-qubit gate execution. This zone is optimized for Rydberg blockade interactions, with atom pairs spaced within the blockade radius while maintaining separation between pairs to prevent unwanted interactions.

This physical separation isolates idle qubits from the global laser fields used for entanglement, significantly reducing crosstalk.

The ZAP Compiler Framework

ZAP replaces iterative global search with a single-pass, deterministic compilation flow consisting of three key stages:

1. ASAP-Separate Scheduling:
   Unlike standard "ASAP-joint" scheduling which minimizes logical depth by grouping all gates, ZAP employs an ASAP-separate strategy. It schedules all two-qubit gates first and then fills remaining temporal slots with single-qubit gates. This decoupling reduces the frequency of qubit shuttling between stages, a dominant source of decoherence in zoned architectures.

2. Routing-Aware Placement:

   • Initial Mapping: Qubits are mapped to storage sites based on a weighted priority system that favors qubits participating in early stages. Crucially, this mapping incorporates a "parallel-awareness" term that scores candidate sites based on their likelihood of generating AOD-compatible movement vectors, anticipating future routing conflicts.
   • Stage-wise Refinement: For each stage, the compiler dynamically decides whether to keep an idle qubit in the entanglement zone or return it to storage. This decision is based on a cost-benefit analysis comparing the fidelity loss from crosstalk (if kept) against the transfer and decoherence costs (if moved).
   • Greedy Assignment: Active qubits are assigned to entanglement pairs using a heuristic that minimizes movement distance while prioritizing movement patterns that avoid AOD row/column conflicts.

3. Conflict-Aware Routing:
   The router translates logical movements into physical instructions. It identifies sets of mutually compatible moves (preserving AOD row/column constraints) and executes them in parallel batches. When conflicts arise (e.g., two atoms in the same row needing to move to different rows), ZAP employs parking operations—short, intermediate displacements—to resolve conflicts and enable parallel transport without full serialization.

3. Key Contributions

• Deterministic, Single-Pass Compilation: ZAP eliminates the iterative search loops found in prior work (ZAC, Enola), transforming the mapping problem into a deterministic process that scales efficiently.
• Hardware-Structured Co-Design: By explicitly partitioning the hardware into storage and entanglement zones, ZAP simplifies the compilation task, allowing for specialized scheduling and placement strategies that suppress crosstalk.
• Hybrid Idle-Qubit Management: The compiler introduces a dynamic policy that balances crosstalk exposure against transport overhead, outperforming static "always-move" or "always-stay" strategies.
• Routing-Aware Placement: The placement heuristic explicitly accounts for AOD constraints (row/column coupling) during the mapping phase, reducing the need for complex conflict resolution during routing.

4. Experimental Results

The authors evaluated ZAP on structured quantum benchmarks (e.g., QFT, QRAM, Adder, QAOA) and random 3-regular circuits, comparing it against Enola, ZAC, and PowerMove.

• Compilation Speed: ZAP achieves multi-order-of-magnitude speedups.
  • Compared to ZAC and PowerMove, compilation times drop from tens of seconds to below 0.1 seconds (speedups >1,000×).
  • Compared to Enola, speedups exceed 10,000× on the evaluated suite.
  • ZAP maintains sub-0.1s compilation times even for 100-qubit circuits and scales effectively to 500 qubits, whereas baselines become computationally prohibitive.
• Execution Quality (Fidelity):
  • ZAP consistently delivers competitive or superior fidelity.
  • On structured workloads with irregular connectivity (e.g., QRAM, QFT), ZAP shows significant fidelity gains by effectively suppressing crosstalk and limiting transport-related loss.
  • On random 3-regular circuits, where topological motifs are less pronounced, the fidelity gap narrows, but ZAP remains competitive.
• Execution Time: ZAP is often the fastest among zoned compilers in terms of physical execution time (makespan), as its reduced shuttling overhead and efficient scheduling minimize total circuit duration.

5. Significance and Claims

The paper claims that ZAP demonstrates that hardware-structured, non-iterative compilation provides a practical path toward fast, scalable, and noise-aware neutral-atom quantum computing.

• Scalability: By removing the iterative search bottleneck, ZAP enables the compilation of large-scale circuits (hundreds of qubits) that were previously intractable within reasonable timeframes.
• Practical Utility: The drastic reduction in compilation time facilitates interactive workflows, iterative algorithm development, and closed-loop calibration, which are critical for advancing quantum research.
• Fidelity vs. Speed Trade-off: The work challenges the notion that speed must come at the cost of quality. ZAP achieves massive speedups while simultaneously improving or maintaining execution fidelity, particularly on complex, structured workloads where compiler decisions regarding crosstalk and transport are most impactful.
• Future Outlook: The authors suggest that as hardware coherence improves, the relative importance of compiler-level decisions regarding crosstalk and transport will increase, making the ZAP co-design philosophy increasingly vital for future fault-tolerant systems.