REVIEW 2 major objections 7 minor
Efficient atom rearrangements for quantum error correction primitives with a single AOD
T0 review · 2 major / 7 minor · reviewed 2026-07-31 · grok-4.5
Pith's one-line read A single AOD pair can rotate a surface-code atom array for a transversal Hadamard in logarithmic strokes by factoring the turn into three binary shears.
desk verdict Clean, usable single-AOD schedules that cut surface-code H/S movement from O(d^{7/3}) to O(d^{1/3}); math checks out, novelty is real but incremental. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
Paeth’s three-shear factorization of a 90° rotation, each shear executed by a binary (or, for signed displacements, negabinary) AOD stroke list that encodes every required row/column offset as a subset sum. The binary list saturates the logarithmic lower bound on the number of strokes while keeping total tweezer travel linear in d.
What would settle it
On a concrete static-lattice platform, attempt the binary Paeth rotation for several odd d and record whether every intermediate configuration is collision-free without extra costly routing; if the measured stroke count or constant-jerk duration exceeds the claimed 3⌊log₂(d−1)⌋+4 and O(d^{1/3}) scalings once realistic collision avoidance is included, the central efficiency claim fails.
Extended reading notes
Core claim
With a single dynamic crossed AOD pair addressing rectangular sub-arrays by rigid horizontal or vertical translations, any shear of a rectangular atom block can be realized in ⌊log₂(d−1)⌋+1 binary strokes, and a 90° rotation of a d×d block (d odd) therefore costs exactly 3⌊log₂(d−1)⌋+4 strokes and O(d^{1/3}) constant-jerk time when the rotation is factored into three Paeth shears. That is within a small constant of the information-theoretic lower bound on stroke count and a polynomial improvement over sequential atom-by-atom rearrangement.
Load-bearing premise
The schedules assume collisions with both filled and empty static traps can always be avoided during every move, either by turning those traps off or by routing halfway between lattice sites, and that the extra half-spacing moves can be ignored in the reported time.
Editorial extensions
If this is right
- Transversal Hadamard on a rotated surface code of distance d becomes an O(log d)-stroke geometric operation rather than an O(d²)-stroke rearrangement.
- Fold-transversal S can be reduced to O(log d) strokes (space-permitting logarithmic variant) or to linear but still improved cost (compact variant).
- Toric-code 90° automorphism and Dehn-twist shears, Iceberg reflections, and Bacon-Shor patch rotations for La-cross addressable Cliffords inherit the same logarithmic stroke counts.
- Logical throughput on reconfigurable atom arrays is no longer dominated by naive atom-by-atom movement time for these primitives.
Reading between the lines
- If the remaining factor-3/2 gap to the stroke lower bound can be closed, large-distance surface-code Hadamards would sit at the absolute information limit of single-AOD control.
- The same binary-shear vocabulary likely extends to other stabilizer automorphisms and to non-square patches once rectangular addressing is retained.
- Hardware that cannot cheaply blank static traps or route at half-spacing would force a redesign of the collision model and could erase the O(d^{1/3}) timing advantage.
Signed reviews
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The manuscript develops AOD movement schedules that implement shears, 90° rotations, axis reflections, and related 2D rearrangements of atom arrays using only a single crossed AOD pair and rigid row/column translations. Under an explicit hardware model (§2.1–2.2), binary and negabinary stroke lists realize a shear (resp. axis reflection) in ⌊log₂(d−1)⌋+1 (resp. ⌈log₂ ℓ⌉) strokes, saturating or nearly saturating the subset-sum lower bound of Lemma 1. Composing three shears via Paeth’s decomposition yields a 90° rotation of a d×d block in exactly 3⌊log₂(d−1)⌋+4 strokes and O(d^{1/3}) constant-jerk time (eq. (5), Table 1), versus O(d²) strokes and O(d^{7/3}) time for atom-by-atom moves. The same primitives are applied to transversal H and fold-transversal S on the surface code, selected code automorphisms (Iceberg, toric Dehn twist), and the Bacon–Shor gadget for La-cross codes.
Significance. Movement time is a first-order bottleneck for logical throughput on reconfigurable neutral-atom processors. Showing that several standard QEC geometric primitives can be done with a single AOD pair, logarithmic stroke count, and O(d^{1/3}) jerk time—without non-rigid row/column crossings—is a concrete and useful systems result. Strengths include a clean lower bound (Lemma 1), matching binary/negabinary constructions, an elementary collision-freedom argument for axis negation (Prop. 1), explicit resource tables against sequential baselines, and direct mapping onto surface-code H/S, toric automorphisms, and La-cross addressable Cliffords. The work is self-contained combinatorial algorithmics with falsifiable stroke-count claims; if the hardware assumptions hold, the schedules are immediately actionable.
major comments (2)
- [§2.1 Assumptions 5–9; Table 1; §2.5] §2.1 Assumptions 5 and 9, together with Table 1 and eq. (5): the reported D_tweezer and T_jerk omit the λ/2 offset strokes used to avoid collisions with static sites. For pure shears the paper argues offsets may be unnecessary if static traps on the moved line can be switched off; for axis reflection (§2.5) offsets “before and after every move” are stated as required. Because the main selling point is O(d^{1/3}) time and the comparison in Table 1, the manuscript should either (i) fold a worst-case O(1) offset per stroke into the Table 1 / eq. (5) bounds (asymptotics are unchanged for binary schedules, since N_moves = O(log d)), or (ii) clearly separate “stroke count (exact)” from “wall-clock time under technology X” and state for which static-lattice technologies the no-offset shear timing applies. This is a modeling completeness issue, not a flaw in the stroke-count theorem.
- [§3.1; Table 1] §3.1 fold-transversal S, logarithmic variant 3.a): the protocol needs enough free space to translate the upper-triangular block away, reflect it, and return. Unlike the compact variant, the spatial footprint is not quantified (in lattice spacings as a function of d). For dense or near-packed arrays this can dominate the architectural cost and may force the compact O(d)-stroke schedule. A short bound on the auxiliary workspace (or a statement that the log-S schedule assumes a sparse region of size Θ(d²)) would make Table 1’s “logarithmic” row usable for architecture sizing.
minor comments (7)
- [§2.4 eq. (5); Figure 2] Figure 2 caption and §2.4: state explicitly that the middle shear runs over 2d−1 columns and that ⌊log₂(2(d−1))⌋+1 = ⌊log₂(d−1)⌋+2 is what produces the “+4” in eq. (5). A one-line derivation would help readers verify the constant.
- [§2.4 Remark 2] Remark 2 (sub-block parallel shears) and Figures 3–4: the improved move counts are useful (including the d=3 saturation of the lower bound) but sit outside the main cost formulas. Either promote a single “best known N_moves(d)” expression into Table 1 or mark Remark 2 as optional and keep Table 1 strictly Paeth+binary for clarity.
- [§2.2 Lemma 1] Lemma 1: the proof relaxes to arbitrary (non-rectangular) selections and multi-occupancy. It would help to add one sentence that the binary shear constructions meet the bound under the actual rectangular+rigid constraints, so the relaxation is only for the converse lower bound.
- [§2.6; §3.1] §2.6 / Figure 6: the “stretched 45° rotation” snaps to the lattice and splits even/odd sublattices. Clarify whether subsequent CZ alignment for fold-transversal S undoes the 0.5-lattice stagger automatically or needs an extra correction stroke.
- [Table 1; Abstract] Table 1 header “Dtweezer” and several ⪅ entries: define ⪅ once in the table caption (as in the main text) so the table is self-contained. Also fix the inconsistent spacing in “F old-transversal” and the broken math in the abstract line “3⌊log 2(d− 1)⌋+ 4”.
- [§3.2; Figure 8] §3.2 Dehn twist: the extra ℓ−1 strokes of length ℓ after the binary shear dominate both N_moves and T_jerk and prevent a pure O(log ℓ) claim. State the leading term up front (N = ℓ + ⌊log₂(ℓ−1)⌋) so it is not misread as logarithmic.
- [Abstract; §1; §2.1] Minor typos: “Those translate directly” → “These”; “adistance” spacing artifacts in the abstract PDF text; “intermodulations” is fine but a pointer to Ref. [14] at first use in §2.1 would help.
Circularity Check
No circularity: combinatorial AOD schedules derived from binary place-value and Paeth, not from fitted inputs or self-justifying citations.
full rationale
The paper’s load-bearing claims are explicit movement schedules and resource counts under a stated AOD model (§2.1–2.2). Lemma 1 is a subset-sum lower bound on stroke count and distance; the binary/negabinary shear and reflection schemes saturate or approach that bound by construction of place-value representations; the 90° rotation cost 3⌊log₂(d−1)⌋+4 follows from composing three such shears via the classical Paeth factorization (cited as external graphics literature [31]), with the middle shear width 2d−1 accounted for in eq. (5). Constant-jerk timing is the standard α∑|m_i|^{1/3} model, not a fit. Applications to transversal H, fold-transversal S, automorphisms, and Bacon-Shor gadgets are uses of these primitives, not predictions forced by data or by the authors’ prior uniqueness theorems. Citations supply background (surface-code gates, AOD hardware, Paeth) and do not close a definitional loop. No fitted-parameter-as-prediction, self-definitional identity, or load-bearing self-citation chain appears.
Assumptions & free parameters
assumptions (6)
- domain assumption A single crossed AOD pair addresses only axis-aligned rectangular sub-arrays and applies a common rigid horizontal or vertical displacement to all selected atoms (assumptions 1–3, §2.1).
- domain assumption Collisions with static traps can always be avoided (by extinguishing traps or routing at λ/2); extra λ/2 cost is ignored in timing (assumptions 5, 9).
- domain assumption Stroke time follows constant-jerk scaling T = α ℓ^{1/3} with α = (12/jλ)^{1/3}; pickup/release time is negligible (assumptions 7–8).
- standard math Any integer displacement in {0…n} (resp. signed) is a subset sum of the binary (resp. negabinary) place values (standard place-value theorem).
- standard math Paeth’s identity: a 90° rotation factors into three shears (Paeth 1990, eq. (4)).
- domain assumption Transversal H on the rotated surface code requires a 90° data-block rotation; fold-transversal S requires 45° diagonal CZ pairing (Horsman, Chen, Moussa, Breuckmann).
invented entities (3)
-
Binary / block / line-by-line shear primitives under single-AOD rigid constraints
independent evidence
-
Paeth + binary 90° rotation schedule (3⌊log₂(d−1)⌋+4 strokes)
independent evidence
-
Negabinary axis-reflection schedule
independent evidence
Cite this review
Pith. "Pith review of Efficient atom rearrangements for quantum error correction primitives with a single AOD." pith.science (2026). https://pith.science/paper/TZ5VFCC3
@misc{pith2026260728149,
author = {Pith},
title = {Pith review of: Efficient atom rearrangements for quantum error correction primitives with a single AOD},
year = {2026},
howpublished = {\url{https://pith.science/paper/TZ5VFCC3}},
note = {Machine review of arXiv:2607.28149}
}
abstract
Neutral-atom quantum computers offer arbitrary connectivity enabled by atom transport. Some logical operations can then be simplified or reduced entirely to geometric rearrangements of the atoms. Minimizing the duration of these movements is therefore essential for high logical throughput. We introduce new primitives to shear, rotate and reflect 2D arrays of atoms in a static lattice using sweeps of a single dynamic crossed acousto-optic deflector (AOD) pair. Using (nega-)binary and geometric decompositions, we achieve an AOD stroke count scaling logarithmically in the linear size of the array. In one example, we use the Paeth decomposition to implement a $90^{\circ}$ rotation for a transversal Hadamard gate in a rotated surface code of distance $d$ in $3\lfloor\log_2(d-1)\rfloor + 4$ AOD strokes and $O(d^{1/3})$ constant-jerk time, against $O(d^2)$ strokes and $O(d^{7/3})$ time for atom-by-atom rearrangement.
Figures
Figures from the paper (5 more)
Reviewed July 31, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.