---
title: 'DYNAMO: Neutral Atom Multi-programming Optimizer'
url: https://www.emergentmind.com/topics/dynamic-neutral-atom-multi-programming-optimizer-dynamo
type: topic
---

# DYNAMO: Neutral Atom Multi-programming Optimizer

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 [2507.04874]. 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 [2507.04874]. 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 [2507.22140].

## 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 [2507.04874]. 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 [2507.04874].

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 [2507.04874]. The resulting Order-Preserving Zones (OPZs) create nonlocal constraints, so local placement decisions for one program can globally restrict legal movement trajectories for others [2507.04874]. 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 [2507.04874].

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 [2507.22140]. 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 [2507.04874]. AOD rows and columns can be translated to move atoms, but rows may not pass each other, and likewise for columns [2507.04874]. 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 [2507.04874].

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 [2507.04874]. 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 [2507.04874].

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 [2507.04874]. 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 [2507.04874].

Within a QPU, DYNAMO adopts the DPQA variable set: $x_{i,t}, y_{i,t}$ for SLM coordinates, $a_{i,t}$ for trap type, $r_{i,t}, c_{i,t}$ for AOD row and column indices, and $t_j$ for the cycle at which gate $j$ executes [2507.04874]. 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 [2507.04874]. 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 [2507.04874].

## 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 [2507.04874].

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 [2507.04874]. DYNAMO sorts circuits by ascending length so that short circuits are scheduled first [2507.04874]. 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 [2507.04874]. The greedy algorithm seeds the first $N$ QPUs with the first $N$ circuits at $t=0$, 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 [2507.04874].

Inside each QPU, DYNAMO introduces a **spatial deformation model** based on OPZ and OFZ regions [2507.04874]. Already-compiled programs generate OPZs in subsequent cycles; regions not affected are OFZs [2507.04874]. 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 [2507.04874]. 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 [2507.04874].

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 [2507.04874]. 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 [2507.04874].

The top-level objective is typically to minimize
$$
T = \max_{u\in U} S_u,
$$
or alternatively to minimize $\sum_{u\in U} S_u$ to increase throughput, with optional load-balancing objectives such as $\sum_u (L_u-\bar L)^2$ [2507.04874]. The top-level greedy placer is $O(M\cdot N)$ for assignments, while the per-QPU SMT problem is made tractable by cycle decomposition and OPZ/OFZ pruning [2507.04874].

## 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 [2507.22140]. That work studies neutral-atom analog Hamiltonian simulations (AHS), using an AHS control decomposition
$$
H(t)=\sum_{k=1}^N H_{drive,k}(t)+\sum_{k=1}^N H_{shift,k}(t)+\sum_{j=1}^{N-1}\sum_{k=j+1}^N H_{vdW,j,k},
$$
with a local shifting field
$$
H_{shift,k}(t)=-\Delta_{local}(t) h_k n_k
$$
that can modulate vdW couplings and, if misconfigured, induce crosstalk to nearby qubits or simulations [2507.22140].

The empirical study uses QuEra Aquila and the AWS Braket AHS simulator, with jobs submitted via qBraid Lab [2507.22140]. The temporal-noise experiment shifts a 3-qubit equilateral-triangle register of side length $5.5\,\mu\text{m}$ in $10\,\mu\text{m}$ steps across a $40\,\mu\text{m} \times 50\,\mu\text{m}$ area, repeating the process weekly over four weeks [2507.22140]. Relative fidelity is defined from final atom counts, with expectations obtained by averaging 20 executions in the simulator [2507.22140]. 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 [2507.22140].

The spatial crosstalk study co-locates two identical AHS runs at diagonal separations $r$ of $4$–$7\,\mu\text{m}$ and reports the following relative fidelities for the victim simulation: $0.963 \pm 0.026$ at $4\,\mu\text{m}$, $0.882 \pm 0.010$ at $5\,\mu\text{m}$, $0.925 \pm 0.033$ at $6\,\mu\text{m}$, and $0.984 \pm 0.009$ at $7\,\mu\text{m}$ [2507.22140]. As $r$ increases beyond approximately $8\,\mu\text{m}$, fidelity approaches $1$, leading the paper to propose $8\,\mu\text{m}$ as a promising lower bound for safe co-location [2507.22140]. The strongest disruption was observed at $5\,\mu\text{m}$ [2507.22140].

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 [2507.22140]. The algorithmic pattern is explicit: place jobs with safe initial separations where possible; segment control sequences into epochs $E_m$ when co-location within $r<r_{min}$ is unavoidable; reposition the atom subset by $\delta x_m$ before each epoch; execute the epoch’s control pulses; and optionally reposition again before measurement [2507.22140]. Under co-location, relative fidelity improves to approximately $0.995$ with MTD on the simulator [2507.22140].

The corresponding optimizer-level objective is given in generic form as
$$
\max_{\Pi}\sum_{s\in jobs} w_s\cdot F_s(\Pi)-\lambda \sum_{i\neq j} C_{ij}(\Pi)-\mu\cdot Overhead(\Pi),
$$
where $\Pi$ encodes placement, timing, and optional motion; $F_s(\Pi)$ is predicted fidelity; $C_{ij}(\Pi)$ is the crosstalk penalty; and $Overhead(\Pi)$ includes motion and staggering costs [2507.22140]. 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 [2507.04874]. The baselines are two adapted DPQA variants: DPQA$^s$, which sequentially compiles each circuit and sums the results, and DPQA$^c$, which merges all circuits into a single disjoint “mega-circuit” and compiles [2507.04874]. Metrics are compilation time and total number of Rydberg stages, with a per-task time limit of 10,000 s [2507.04874].

| Evaluation setting | Quantitative outcome | Context |
|---|---|---|
| Pairwise on one QPU | up to 14.39× speedup; average 7.50× in Minimal | vs. DPQA$^c$ |
| Pairwise on one QPU | stage reduction up to 50%; average reduction of 33.71% in Minimal | vs. DPQA$^s$ |
| Grouped multi-programming | stage reductions of −23.41% to −69.38% | mainly vs. DPQA$^s$ |
| Multi-QPU compilation | balanced $\Delta L$ across 2 and 3 QPUs | reduced wall-clock by classical parallelism |

Compared with DPQA$^c$, DYNAMO is consistently faster in pairwise multi-programming: Minimal workloads show up to $14.39\times$ speedup and an average $7.50\times$ speedup, Minor up to $4.92\times$, Moderate up to $6.76\times$, Major an average $2.33\times$, and Maximal an average $2.32\times$ [2507.04874]. Stage behavior is more mixed in this comparison: Minimal has only a small average overhead of $+4.93\%$, Minor shows an average reduction of $-4.83\%$, Moderate a mild increase of $+9.86\%$, Major $+40.64\%$, and Maximal $+25.01\%$ [2507.04874]. The paper interprets this as an acceptable tradeoff against the substantial compilation acceleration [2507.04874].

Compared with DPQA$^s$, DYNAMO’s compilation time is modestly higher in many cases, approximately $1.1$–$1.3\times$, but it consistently reduces the number of Rydberg stages [2507.04874]. Average stage reductions are $-33.71\%$ for Minimal, $-13.74\%$ for Minor, $-37.45\%$ for Moderate, $-25.16\%$ for Major, and $-24.97\%$ for Maximal, with peak reductions near $50\%$ in several categories [2507.04874]. In grouped multi-programming on one QPU, where DPQA$^c$ often times out, DYNAMO reduces total stages by $-52.42\%$ for Minimal, $-23.41\%$ for Minor, $-69.38\%$ for Moderate, $-45.23\%$ for Major, and $-61.90\%$ for Maximal [2507.04874].

Multi-QPU results show that DYNAMO also functions as a load balancer. With two QPUs, Major-group stage loads are reported as $\Delta L$ $1093$ versus $1077$, and Maximal as $4198$ versus $4058$ [2507.04874]. With three QPUs, Moderate-group sums are $810$, $758$, and $683$, while Maximal is $3182$, $3794$, and $3054$ [2507.04874]. Across all scenarios, the headline result is up to $14.39\times$ compilation speedup and an average $50.47\%$ reduction in execution stages, while distributing workloads across multiple QPUs with balanced resource utilization [2507.04874].

## 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 [2601.08504]. Its reported throughput improvement ranges from $3.8\times$ to $12.3\times$ when co-executing 4 to 14 circuits, with fidelity ranging from a $1.3\%$ improvement for four circuits to a $3.5\%$ loss for fourteen circuits [2601.08504]. 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 $78.5\times$ speedup on $16\times16$ arrays and up to $139.16\times$ on $64\times64$ arrays while maintaining comparable circuit quality [2505.13049]. 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 [2206.05144]. 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 [2507.04874]. In the noise-and-crosstalk DYNAMO blueprint, the results are based on a 3-qubit AHS, a specific $5.5\,\mu\text{m}$ 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 [2507.22140]. 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 [2507.04874].

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 [2507.04874]. 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 [2601.08504].

Source: https://www.emergentmind.com/topics/dynamic-neutral-atom-multi-programming-optimizer-dynamo