Compiling Quantum Circuits for Dynamically Field-Programmable Neutral Atoms Array Processors

TL;DR

This work tackles the challenge of compiling quantum circuits for dynamically field-programmable neutral-atom arrays (DPQA), where qubit connectivity can be reconfigured during computation. It introduces OLSQ-DPQA, an SMT-based compiler that discretizes the DPQA state in spacetime and minimizes circuit depth $S$ by solving constraint systems that capture movement, occupancy, and Rydberg-gate rules. A hybrid approach combining greedy layer-peeling with optimal SMT solves markedly improves scalability, achieving up to 90-qubit compilations with significantly fewer two-qubit gates than fixed-architecture baselines. The results demonstrate that hardware-aware, SMT-guided layout synthesis can unlock non-local, high-connectivity quantum circuits on neutral-atom platforms, informing both compiler design and hardware development for scalable quantum computing.

Abstract

Dynamically field-programmable qubit arrays (DPQA) have recently emerged as a promising platform for quantum information processing. In DPQA, atomic qubits are selectively loaded into arrays of optical traps that can be reconfigured during the computation itself. Leveraging qubit transport and parallel, entangling quantum operations, different pairs of qubits, even those initially far away, can be entangled at different stages of the quantum program execution. Such reconfigurability and non-local connectivity present new challenges for compilation, especially in the layout synthesis step which places and routes the qubits and schedules the gates. In this paper, we consider a DPQA architecture that contains multiple arrays and supports 2D array movements, representing cutting-edge experimental platforms. Within this architecture, we discretize the state space and formulate layout synthesis as a satisfiability modulo theories problem, which can be solved by existing solvers optimally in terms of circuit depth. For a set of benchmark circuits generated by random graphs with complex connectivities, our compiler OLSQ-DPQA reduces the number of two-qubit entangling gates on small problem instances by 1.7x compared to optimal compilation results on a fixed planar architecture. To further improve scalability and practicality of the method, we introduce a greedy heuristic inspired by the iterative peeling approach in classical integrated circuit routing. Using a hybrid approach that combined the greedy and optimal methods, we demonstrate that our DPQA-based compiled circuits feature reduced scaling overhead compared to a grid fixed architecture, resulting in 5.1X less two-qubit gates for 90 qubit quantum circuits. These methods enable programmable, complex quantum circuits with neutral atom quantum computers, as well as informing both future compilers and future hardware choices.

Figures (9)

• Figure 1: Compiling quantum circuits to dynamically field-programmable qubit arrays (DPQA). (a) Non-local connectivity of DPQA. Atoms are kept in traps generated by a 2D acousto-optic deflector (AOD, dashed grid) and a spatial light modulator (SLM, all others). Entangling two-qubit gates are enabled by a Rydberg laser illuminating the plane (glow). Only when two atoms are within the Rydberg blockade range $r_b$ can they perform an entangling gate (pairs in colored ovals). We can change the location of AOD atoms, and transfer atoms between AOD and SLM traps natphys07-beugnon-tweezerin the middle of computation (each arrow corresponding to some AOD reconfiguration). Through such reconfigurations, new non-local connectivities are established (oval dashes), i.e., different pairs of atoms can now perform entangling gates. (b) Our compilation approach. The input consists of the quantum circuit to execute and the DPQA architecture specification, e.g., how large the plane is and how many AOD rows and columns we can have. The compiled instructions have to respect the constraints of DPQA. For example, when a two-qubit gate is executed, the two qubits should be closer than $r_b$ and there cannot be another qubit nearby. Also, all traps in the same AOD row/column move together and must stay in the same order from the beginning to the end of the process. We formulate all the constraints to a satisfiability modulo theories (SMT) model and use an existing SMT solver to find solutions, with which we can derive valid DPQA instructions to run the circuit. (c) Structure of compiled results. We discretize space by prescribing interaction sites shown as the proximity of integer points in the plane. The distance between sites is sufficient to suppress Rydberg interaction strengths nature22-lukim-bluvstein-atom-arrayevered2023highfidelity so the two-qubit entangling gates can only take place within sites. Our compiler places the qubits in the quantum circuit to atoms in SLM or AOD at a specific interaction site in the beginning of execution. We discretize time by setting stages when two-qubit gates are performed. After each stage, some AOD movements and atom transfers serve as routing for the gates executed at the next stage.
• Figure 2: A compiled example. (a) The quantum circuit to compile. (b) Stage 0. Qubits are loaded to the corresponding traps before this stage: blue qubits are in SLM, red qubits are in AOD. An AOD trap sits at every intersection of the AOD columns and rows (x and y dashed lines). An open circle represents an unoccupied SLM trap. At stage 0, $(q_4, q_2)$ and $(q_5, q_3)$ are at same sites to enable a Rydberg interaction. Thus, two gates $g_0$ and $g_1$ are applied to these two pairs of qubits. After stage 0, the movement shifts the lower AOD row from $y=0$ to $1$ and the middle two columns go from $x=1$ and $2$ to $x=2$ and $3$, respectively. (c) Stage 1. Shadows of qubits indicate the direction of the movements from the previous stage to the current one. (d) The moment after the movement between stage 1 and 2. (e) Stage 2. $q_5$ is transferred from AOD to SLM (red to blue) after the movement and before stage 2 by shifting the leftmost AOD column to align with the SLM trap at $(1,0)$ and then turning off this column. (f) Stage 3 finishing the circuit execution.
• Figure 3: Workflow of our compiler OLSQ-DPQA. The inputs to the compiler are the quantum circuit to execute and the specifications of the DPQA architecture considered. If the problem is small, the compiler directly takes the optimal approach by constructing an SMT model where all the gates are applied to the first $S$ stages. If the model is satisfiable, then we find a solution; otherwise, we increase $S$ and try again. Thus, we find a solution with the minimum number of stages in the end, because lower-depth models are all checked and unsatisfiable. The SMT solution goes through a post-processing to extract the instructions for executing the quantum circuit on DPQA. There are only five types of instruction: init for initialization; rydberg to turn on the Rydberg laser and perform two-qubit gates; move for changing the coordinates of AOD rows/columns; activate for turning on certain AOD rows/columns for atom transfer; and deactivate for turning off certain AOD rows/columns. If the problem is large, the compiler takes a hybrid approach by iteratively "peeling off" the maximum number of gates possible. It generates a single-step (two-stage) SMT model with a constraint of executing more than $M$ gates in one step. After possible decreases of $M$, we find the solution with as many gates executed in one step as possible. Then, we stitch this partial solution, which is one "layer peeled off", to the whole solution. When the problem becomes sufficiently small ($5\%$ of gates left), the compiler switches to the optimal approach.
• Figure 4: Evaluation of the optimal compiler. (a) Graph circuits. Given any graph, we treat each node as a qubit and add a two-qubit entangling gate for every edge in the graph to construct the graph circuit. We assume the gates are commutable, so gate order does not matter. The benchmarks used are graph circuits generated by 3-regular graphs of size 10 to 22. For each size, we have 10 random graphs. (b) Comparison of infidelity caused by the Rydberg laser (performing two-qubit gates) and the AOD movements. The latter is 27x smaller on average. We make such estimation using $99.5\%$ two-qubit gate fidelity evered2023highfidelity and a movement scheme that yields low atom heating as in Ref. nature22-lukim-bluvstein-atom-array. (c) Comparison of the number of two-qubit gates required on a fixed planar architecture (Google's Sycamore) and DPQA employing different compilers. Error bars are standard deviations among 10 random graphs of the same size. The compilers are t$|$ket$\rangle$, SABRE (integrated in Qiskit), and TB-OLSQ2. Note that TB-OLSQ2 is optimal for fixed architectures, but there is still a significant gap (1.7x) between it and the optimal DPQA compiler. The gaps mainly come from SWAP gates inserted on the fixed architecture, which requires three entangling gates (controlled $R_z$) micro20-gokhale-javadi-abhari-earnest-shi-chong-compilation-openpulse.
• Figure 5: Evaluation of the greedy-optimal hybrid compiler. (a, b) One of the largest benchmarks we are able to compile, a 90-node 3-regular graph. The highlighted edges are gates executed at the stages in (c) and (d), respectively. (c) One stage of the compiled result. The dots are qubits in SLM. The ovals indicate two-qubit gates performed at this stage, which have a 1-to-1 correspondence with the edges in (a). After this stage, some qubits are transferred to AOD and moved. (d) The next stage. The red dots are the AOD qubits, and the arrows indicate the parallel movements from (c) to the current state. Readers are welcome to check out our code base for this animation. (e) Comparison of the number of two-qubit gates required on a fixed planar architecture (10x10 grid) using different compilers and DPQA. For DPQA, the number of two-qubit gates scales as $n$, whereas for the state-of-the-art heuristic solver on the fixed planar architecture, SABRE, scales as $n^{1.52\pm0.02}$ where $n$ is the number of qubits. DPQA requires far less two-qubit gates, 5.1X less than SABRE, and scales linearly. (f) Comparison of runtime of the optimal and hybrid approaches in OLSQ-DPQA. Since both of them internally rely on SMT solving, the runtime scalings are both exponential in the size of the graph with which we generate the quantum circuit. However, the hybrid approach is significantly faster so that large instances can be solved (up to 90 qubits in $10^5$$\sim$ a day). Compared to the optimal approach, the scaling of the hybrid approach is mainly related to size rather than the specific graph, which is demonstrated by the much smaller spread of data points at the each size.