DYNAMO: Neutral Atom Multi-programming Optimizer

• DYNAMO is a compilation and scheduling framework for neutral-atom QPUs that enables concurrent execution of multiple quantum programs by managing spatial, temporal, and motion constraints.
• It employs a two-layer pipeline with a top-level greedy placer across QPUs and an intra-QPU SMT scheduler to optimize placement, movement, and gate scheduling under strict hardware restrictions.
• An extended fidelity-aware design integrates Moving Target Defense and noise/crosstalk modeling to safely co-locate analog Hamiltonian simulations and improve overall quantum execution fidelity.

Dynamic Neutral Atom Multi-programming Optimizer (DYNAMO) is a compilation and scheduling framework for concurrent execution of multiple quantum programs on neutral-atom quantum processing units (QPUs), and is presented as a method toward quantum operating systems on neutral-atom architectures (Sun et al., 7 Jul 2025). Its central purpose is to realize multi-programming on hardware whose native strengths—global Rydberg entangling pulses, dynamically reconfigurable qubit positions, and large 2D arrays—are coupled to unusually strong global constraints, especially blockade, crosstalk, and order-preserving AOD motion (Sun et al., 7 Jul 2025). In complementary work, the DYNAMO label is also used for a scheduler blueprint that incorporates nonstationary noise, distance-dependent crosstalk, and Moving Target Defense (MTD) to enable safer co-location of analog Hamiltonian simulations on neutral-atom platforms (Sharma et al., 29 Jul 2025).

1. Conceptual scope and operating-system context

DYNAMO is motivated by a specific systems gap: most quantum compilation work focuses solely on single-circuit execution, which underutilizes neutral-atom hardware and hinders the development of quantum operating systems (Sun et al., 7 Jul 2025). The framework therefore targets multi-programming as the core operating-system functionality, enabling concurrent execution of multiple quantum programs on one or several neutral-atom QPUs through parallel compilation and intelligent resource allocation in space and time (Sun et al., 7 Jul 2025).

The need for such a framework follows from the physical structure of neutral-atom devices. Neutral-atom QPUs offer high parallelism, but they do not admit naïve partitioning. Two-qubit gates are executed when pairs are brought within an interaction radius $r_b$; gates within the same Rydberg stage must satisfy spatial exclusivity constraints defined by blockade and crosstalk; and AOD rows and columns cannot cross during movement (Sun et al., 7 Jul 2025). The resulting Order-Preserving Zones (OPZs) create nonlocal constraints, so local placement decisions for one program can globally restrict legal movement trajectories for others (Sun et al., 7 Jul 2025). A common misconception is that neutral-atom multi-programming is simply a packing problem. DYNAMO rejects that view by treating placement, timing, and movement as a coupled constraint system rather than independent subproblems (Sun et al., 7 Jul 2025).

In its AHS-oriented extension, the same DYNAMO concept is used in a more explicitly fidelity-centric sense: a scheduler that understands the neutral atom platform, quantifies the fidelity impact of time-varying noise and spatial crosstalk under co-location, and actively mitigates those effects via placement, pulse timing, and motion (Sharma et al., 29 Jul 2025). This suggests that the term “DYNAMO” now spans both a concrete compilation framework and a broader optimizer design pattern for neutral-atom multi-tenancy.

2. Hardware model and physical constraints

The neutral-atom architecture assumed by DYNAMO is a 2D array of atoms in which each qubit can reside either in a static SLM trap or a mobile AOD trap (Sun et al., 7 Jul 2025). AOD rows and columns can be translated to move atoms, but rows may not pass each other, and likewise for columns (Sun et al., 7 Jul 2025). Two-qubit gates are mediated by global Rydberg excitation; gates execute when qubit pairs are placed within $r_b$ while remaining sufficiently isolated from other pairs (Sun et al., 7 Jul 2025).

DYNAMO models time as cycles, each with two ordered steps: an AOD movement step and a non-movement step containing two-qubit gates, single-qubit gates, and measurement (Sun et al., 7 Jul 2025). This decomposition is not cosmetic. It exposes exactly how one program’s movements constrain another’s, and it provides the substrate for cycle-by-cycle SMT scheduling under shared hardware constraints (Sun et al., 7 Jul 2025).

At the outer level, the multi-program, multi-QPU problem is expressed through program-to-QPU assignment variables $a_{p,u} \in \{0,1\}$, per-program start times $s_p$, and per-cycle capacity constraints of the form

$$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$

where $\bar w_p(\cdot)$ is the instantaneous width of program $p$ and $W_{\max}(u)$ is the QPU capacity (Sun et al., 7 Jul 2025). Precedence constraints within each circuit take the standard form $s_j \ge s_i + d_i$ for dependent gates, while same-cycle blockade or crosstalk conflicts are handled by separation constraints or equivalent big-$M$ encodings (Sun et al., 7 Jul 2025).

Within a QPU, DYNAMO adopts the DPQA variable set: $r_b$0 for SLM coordinates, $r_b$1 for trap type, $r_b$2 for AOD row and column indices, and $r_b$3 for the cycle at which gate $r_b$4 executes (Sun et al., 7 Jul 2025). Correctness depends on two classes of constraints. The first is AOD order-preserving movement, formalized through OPZ implications that preserve relative row and column order across a movement step (Sun et al., 7 Jul 2025). The second is parallel two-qubit gate exclusivity, which forbids a new gate from occupying the same interaction site at the same cycle as an already placed gate and is combined with hardware spacing requirements to satisfy blockade and crosstalk limits (Sun et al., 7 Jul 2025).

3. Two-layer compilation and scheduling pipeline

DYNAMO’s pipeline has two coupled layers: a top-level greedy placer across multiple QPUs, and an intra-QPU SMT scheduler that performs physically feasible multi-program packing (Sun et al., 7 Jul 2025).

At the top level, the input is a set of circuits and QPUs, together with a DAG-derived 2D shape profile for each circuit, where the “length” is the number of layers and the layer width records concurrent resource demand (Sun et al., 7 Jul 2025). DYNAMO sorts circuits by ascending length so that short circuits are scheduled first (Sun et al., 7 Jul 2025). The rationale is architecture-specific: in neutral atoms, long circuits create large spatiotemporal obstacles due to global AOD constraints, so placing shorter jobs first reduces interference for everything that follows (Sun et al., 7 Jul 2025). The greedy algorithm seeds the first $r_b$5 QPUs with the first $r_b$6 circuits at $r_b$7, then incrementally inserts remaining circuits by simulating placements on each QPU until capacity constraints are respected at all cycles, choosing the placement with the smallest post-placement span (Sun et al., 7 Jul 2025).

Inside each QPU, DYNAMO introduces a spatial deformation model based on OPZ and OFZ regions (Sun et al., 7 Jul 2025). Already-compiled programs generate OPZs in subsequent cycles; regions not affected are OFZs (Sun et al., 7 Jul 2025). When a new program is placed into a partially occupied timeline, its movements and gates must be threaded through this OPZ/OFZ pattern. OFZ-confined moves are unconstrained, but moves intersecting OPZs must obey order-preserving rules (Sun et al., 7 Jul 2025). The SMT layer then solves for a schedule that respects pre-existing OPZs and OFZs, satisfies two-qubit gate proximity and parallel-execution exclusivity, and honors the circuit’s own precedence constraints (Sun et al., 7 Jul 2025).

If a desired movement would cross an OPZ boundary, DYNAMO does not assume a single resolution mechanism. The solver can route via local SLM/AOD transfers, adjust timing to a later cycle, or reorder within the program’s legal DAG freedoms (Sun et al., 7 Jul 2025). This is a defining feature of the framework: multi-programming is achieved not by static partitioning alone, but by dynamic deformation of feasible motion and gate trajectories under global hardware constraints (Sun et al., 7 Jul 2025).

The top-level objective is typically to minimize

$r_b$8

or alternatively to minimize $r_b$9 to increase throughput, with optional load-balancing objectives such as $a_{p,u} \in \{0,1\}$0 (Sun et al., 7 Jul 2025). The top-level greedy placer is $a_{p,u} \in \{0,1\}$1 for assignments, while the per-QPU SMT problem is made tractable by cycle decomposition and OPZ/OFZ pruning (Sun et al., 7 Jul 2025).

4. Noise, crosstalk, and fidelity-aware co-location

A complementary DYNAMO blueprint extends the scheduling problem beyond geometric legality to explicit fidelity management under nonstationary noise and spatial crosstalk (Sharma et al., 29 Jul 2025). That work studies neutral-atom analog Hamiltonian simulations (AHS), using an AHS control decomposition

$a_{p,u} \in \{0,1\}$2

with a local shifting field

$a_{p,u} \in \{0,1\}$3

that can modulate vdW couplings and, if misconfigured, induce crosstalk to nearby qubits or simulations (Sharma et al., 29 Jul 2025).

The empirical study uses QuEra Aquila and the AWS Braket AHS simulator, with jobs submitted via qBraid Lab (Sharma et al., 29 Jul 2025). The temporal-noise experiment shifts a 3-qubit equilateral-triangle register of side length $a_{p,u} \in \{0,1\}$4 in $a_{p,u} \in \{0,1\}$5 steps across a $a_{p,u} \in \{0,1\}$6 area, repeating the process weekly over four weeks (Sharma et al., 29 Jul 2025). Relative fidelity is defined from final atom counts, with expectations obtained by averaging 20 executions in the simulator (Sharma et al., 29 Jul 2025). The reported heatmaps show week-to-week changes in spatial uniformity, with patterns described as largely random and changing week to week, supporting the treatment of noise as nonstationary and spatially inhomogeneous (Sharma et al., 29 Jul 2025).

The spatial crosstalk study co-locates two identical AHS runs at diagonal separations $a_{p,u} \in \{0,1\}$7 of $a_{p,u} \in \{0,1\}$8–$a_{p,u} \in \{0,1\}$9 and reports the following relative fidelities for the victim simulation: $s_p$0 at $s_p$1, $s_p$2 at $s_p$3, $s_p$4 at $s_p$5, and $s_p$6 at $s_p$7 (Sharma et al., 29 Jul 2025). As $s_p$8 increases beyond approximately $s_p$9, fidelity approaches $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$0, leading the paper to propose $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$1 as a promising lower bound for safe co-location (Sharma et al., 29 Jul 2025). The strongest disruption was observed at $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$2 (Sharma et al., 29 Jul 2025).

To mitigate this effect, the paper proposes Moving Target Defense (MTD): physically reposition the victim simulation within the register before, and optionally after, critical execution steps so that an attacker’s fixed spatial coupling and detuning patterns no longer align with the victim’s active region (Sharma et al., 29 Jul 2025). The algorithmic pattern is explicit: place jobs with safe initial separations where possible; segment control sequences into epochs $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$3 when co-location within $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$4 is unavoidable; reposition the atom subset by $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$5 before each epoch; execute the epoch’s control pulses; and optionally reposition again before measurement (Sharma et al., 29 Jul 2025). Under co-location, relative fidelity improves to approximately $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$6 with MTD on the simulator (Sharma et al., 29 Jul 2025).

The corresponding optimizer-level objective is given in generic form as

$$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$7

where $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$8 encodes placement, timing, and optional motion; $$\sum_{p\in P} a_{p,u}\cdot \bar w_p(t-s_p) \le W_{\max}(u),$$9 is predicted fidelity; $\bar w_p(\cdot)$0 is the crosstalk penalty; and $\bar w_p(\cdot)$1 includes motion and staggering costs (Sharma et al., 29 Jul 2025). This suggests a path from DYNAMO as a legality-and-throughput compiler to DYNAMO as a fidelity-aware scheduler.

5. Empirical performance and quantitative outcomes

The principal DYNAMO evaluation spans benchmarks from RevLib, SABRE, and QTetris, with circuit depths from 12 to 3847 gates, grouped as Minimal, Minor, Moderate, Major, and Maximal (Sun et al., 7 Jul 2025). The baselines are two adapted DPQA variants: DPQA$\bar w_p(\cdot)$2, which sequentially compiles each circuit and sums the results, and DPQA$\bar w_p(\cdot)$3, which merges all circuits into a single disjoint “mega-circuit” and compiles (Sun et al., 7 Jul 2025). Metrics are compilation time and total number of Rydberg stages, with a per-task time limit of 10,000 s (Sun et al., 7 Jul 2025).

Evaluation setting	Quantitative outcome	Context
Pairwise on one QPU	up to 14.39× speedup; average 7.50× in Minimal	vs. DPQA$\bar w_p(\cdot)$4
Pairwise on one QPU	stage reduction up to 50%; average reduction of 33.71% in Minimal	vs. DPQA$\bar w_p(\cdot)$5
Grouped multi-programming	stage reductions of −23.41% to −69.38%	mainly vs. DPQA$\bar w_p(\cdot)$6
Multi-QPU compilation	balanced $\bar w_p(\cdot)$7 across 2 and 3 QPUs	reduced wall-clock by classical parallelism

Compared with DPQA$\bar w_p(\cdot)$8, DYNAMO is consistently faster in pairwise multi-programming: Minimal workloads show up to $\bar w_p(\cdot)$9 speedup and an average $p$0 speedup, Minor up to $p$1, Moderate up to $p$2, Major an average $p$3, and Maximal an average $p$4 (Sun et al., 7 Jul 2025). Stage behavior is more mixed in this comparison: Minimal has only a small average overhead of $p$5, Minor shows an average reduction of $p$6, Moderate a mild increase of $p$7, Major $p$8, and Maximal $p$9 (Sun et al., 7 Jul 2025). The paper interprets this as an acceptable tradeoff against the substantial compilation acceleration (Sun et al., 7 Jul 2025).

Compared with DPQA$W_{\max}(u)$0, DYNAMO’s compilation time is modestly higher in many cases, approximately $W_{\max}(u)$1–$W_{\max}(u)$2, but it consistently reduces the number of Rydberg stages (Sun et al., 7 Jul 2025). Average stage reductions are $W_{\max}(u)$3 for Minimal, $W_{\max}(u)$4 for Minor, $W_{\max}(u)$5 for Moderate, $W_{\max}(u)$6 for Major, and $W_{\max}(u)$7 for Maximal, with peak reductions near $W_{\max}(u)$8 in several categories (Sun et al., 7 Jul 2025). In grouped multi-programming on one QPU, where DPQA$W_{\max}(u)$9 often times out, DYNAMO reduces total stages by $s_j \ge s_i + d_i$0 for Minimal, $s_j \ge s_i + d_i$1 for Minor, $s_j \ge s_i + d_i$2 for Moderate, $s_j \ge s_i + d_i$3 for Major, and $s_j \ge s_i + d_i$4 for Maximal (Sun et al., 7 Jul 2025).

Multi-QPU results show that DYNAMO also functions as a load balancer. With two QPUs, Major-group stage loads are reported as $s_j \ge s_i + d_i$5 $s_j \ge s_i + d_i$6 versus $s_j \ge s_i + d_i$7, and Maximal as $s_j \ge s_i + d_i$8 versus $s_j \ge s_i + d_i$9 (Sun et al., 7 Jul 2025). With three QPUs, Moderate-group sums are $M$0, $M$1, and $M$2, while Maximal is $M$3, $M$4, and $M$5 (Sun et al., 7 Jul 2025). Across all scenarios, the headline result is up to $M$6 compilation speedup and an average $M$7 reduction in execution stages, while distributing workloads across multiple QPUs with balanced resource utilization (Sun et al., 7 Jul 2025).

6. Relation to adjacent systems and unresolved questions

DYNAMO belongs to a broader line of neutral-atom systems work on concurrency, partitioning, and runtime coordination. MultiQ is described as the first system designed for multi-programming on zoned neutral-atom QPUs, introducing virtual zone layouts, a controller that maps layouts onto hardware and resolves conflicts, and a checker that verifies functional independence through ZX-calculus simplification (Romão et al., 13 Jan 2026). Its reported throughput improvement ranges from $M$8 to $M$9 when co-executing 4 to 14 circuits, with fidelity ranging from a $r_b$00 improvement for four circuits to a $r_b$01 loss for fourteen circuits (Romão et al., 13 Jan 2026). PAC, by contrast, is primarily a physics-aware compilation method for parallel execution across independent regions, using hardware plane partitioning and an improved Kernighan–Lin algorithm; it reports up to $r_b$02 speedup on $r_b$03 arrays and up to $r_b$04 on $r_b$05 arrays while maintaining comparable circuit quality (Chen et al., 19 May 2025). At a lower abstraction level, pulse-level scheduling for neutral-atom devices introduces absorption, allowing simultaneous execution of single- and multi-qubit gates acting on overlapping qubit sets under a single Raman and single Rydberg channel model (Tsai et al., 2022). This suggests that DYNAMO occupies an intermediate layer between pulse scheduling and full cross-layer runtime systems.

Several limitations remain explicit. In the 2025 DYNAMO paper, explicit noise models and crosstalk-aware pulse shaping are not optimized; the top-level scheduler is heuristic rather than optimal; and inter-QPU communication is not modeled (Sun et al., 7 Jul 2025). In the noise-and-crosstalk DYNAMO blueprint, the results are based on a 3-qubit AHS, a specific $r_b$06 triangle geometry, and Aquila/simulator access; local detuning was exercised only on the simulator; the paper used atom counts as the end metric; and motion overheads were not quantified, even though MTD efficacy was demonstrated (Sharma et al., 29 Jul 2025). A further misconception is that stage count alone captures deployability. The combined literature indicates otherwise: stage reduction, resource utilization, nonstationary noise, spatial crosstalk, motion overhead, and semantic independence all matter, and different DYNAMO-related formulations optimize different subsets of these variables (Sun et al., 7 Jul 2025).

Taken together, DYNAMO denotes a significant systems direction in neutral-atom quantum computing: architecture-aware multi-program compilation with multi-QPU load balancing, OPZ/OFZ-constrained scheduling, and an emerging fidelity-aware extension that treats co-location not merely as a capacity problem but as a dynamic control-and-noise management problem (Sun et al., 7 Jul 2025). A plausible implication is that future neutral-atom quantum operating systems will combine DYNAMO’s structure-aware scheduling with the virtual zoning of MultiQ, the region partitioning of PAC, and lower-level pulse scheduling mechanisms such as absorption (Romão et al., 13 Jan 2026).