Moveless

Sahil Khan, Suhas Vittal, Kenneth Brown, Jonathan Baker. Moveless: Minimizing Overhead on QCCDs via Versatile Execution and Low Excess Shuttling. arXiv 2025. arXiv:2508.03914 · their code: sahilkhan123/Moveless (no license)

Syndrome extraction on a line of small traps where data ions stay put and few ancillas visit them, against QCCDSim moving whichever ion is cheaper.

No license file: we ran it locally and publish only the schedules it produced and the gate lists of its benchmark circuits.

L8: eight traps of capacity 5 + 2 on a line, for the d = 3 surface code

configuration	time: their code	our replay	the paper	the paper's rules
rotated surface code d=3 [[9,1,3]] on L8: Moveless, one ancilla ▶ watch it in the Studio	3,250 µs = ours	3,250 µs	–	all 10 rules hold
rotated surface code d=3 [[9,1,3]] on L8: moving the ancilla only ▶ watch it in the Studio	3,930 µs = ours	3,930 µs	–	all 10 rules hold
rotated surface code d=3 [[9,1,3]] on L8: QCCDSim, one ancilla per stabilizer ▶ watch it in the Studio	4,590 µs = ours	4,590 µs	–	all 10 rules hold
rotated surface code d=5 [[25,1,5]] on L24: Moveless, one ancilla ▶ watch it in the Studio	15,640 µs = ours	15,640 µs	–	all 10 rules hold
rotated surface code d=5 [[25,1,5]] on L24: moving the ancilla only ▶ watch it in the Studio	20,920 µs = ours	20,920 µs	–	all 10 rules hold
rotated surface code d=5 [[25,1,5]] on L24: QCCDSim, one ancilla per stabilizer ▶ watch it in the Studio	24,390 µs = ours	24,390 µs	–	all 10 rules hold
rotated surface code d=7 [[49,1,7]] on L48: Moveless, one ancilla ▶ watch it in the Studio	65,180 µs = ours	65,180 µs	–	all 10 rules hold
rotated surface code d=7 [[49,1,7]] on L48: moving the ancilla only ▶ watch it in the Studio	95,010 µs = ours	95,010 µs	–	all 10 rules hold
rotated surface code d=7 [[49,1,7]] on L48: QCCDSim, one ancilla per stabilizer ▶ watch it in the Studio	115,800 µs = ours	115,800 µs	–	all 10 rules hold
color code d=11 [[91,1,11]] on L90: Moveless, one ancilla ▶ watch it in the Studio	173,470 µs = ours	173,470 µs	–	all 10 rules hold
color code d=11 [[91,1,11]] on L90: moving the ancilla only ▶ watch it in the Studio	219,430 µs = ours	219,430 µs	–	all 10 rules hold
color code d=11 [[91,1,11]] on L90: QCCDSim, one ancilla per stabilizer ▶ watch it in the Studio	909,680 µs = ours	909,680 µs	–	R1 fails 9 others hold

The paper reports speedups. Each is the ratio of two of the replayed runs above, computed from our replays:

speedup	from our replays	the paper
rotated surface code d=3 [[9,1,3]] on L8: QCCDSim / Moveless	1.412308	1.412308 matchesFig. 13, bar height (vector data in the source)
rotated surface code d=5 [[25,1,5]] on L24: QCCDSim / Moveless	1.559463	1.559463 matchesFig. 13, bar height (vector data in the source)
rotated surface code d=7 [[49,1,7]] on L48: QCCDSim / Moveless	1.776619	1.776619 matchesFig. 13, bar height (vector data in the source)
color code d=11 [[91,1,11]] on L90: QCCDSim / Moveless	5.244019	5.244019 matchesFig. 13, bar height (vector data in the source)

What the benchmark circuits sayEach benchmark file lists one round's CNOTs for the ancillas it is compiled with, with no measurement between stabilizers, and the compiler runs them in whatever order it chooses (with one ancilla it runs some gate numbers twice and others never, while the CNOTs executed are exactly the file's). So we check that every CNOT runs exactly once, not their order.

The baseline passes through full trapsThe baseline is QCCDSim's scheduler; for the colour code it routes an ion through a full trap 4 times (capacity 5 + 2), the same behaviour described under Cyclone. The time is not affected.

Our schedule on the same machine, under the same rules

Made by sched_moveless, a scheduler we wrote for Moveless's one-ancilla benchmarks; it is not the compiler that compiles this website's leaderboard entries.

Every CNOT uses the one ancilla, so the CNOTs run one after another (100 µs each); what a compiler can save is the ancilla's travel. Ours runs them in exactly the order the benchmark file lists them, even where two commute: the order is the file's, not ours to change. The data stay put and the ancilla walks, one trap at a time, to each CNOT's data qubit in turn. A seeded search picks the placement with the shortest walk: up to 6 data per trap, at most 4 in the ancilla's starting end trap. No trap starts above the paper's 5 ions; a trap given a sixth receives it at the start, handed from trap to trap from the end of each chain. Ours is checked in the file's order; the paper's Moveless schedules are checked as a set, and its ancilla-only (MAO) runs, which keep the file's order, are shown beside them. Each schedule below is replayed by the same checker as the paper's, with the same timing law and circuit; an operation the paper's law does not price is refused.

configuration	their code	ours		their run in the circuit's order		fidelity: theirs	ours	the paper's rules
surface code d=3 on L8 against: rotated surface code d=3 [[9,1,3]] on L8: Moveless, one ancilla ▶ watch ours in the Studio	3,250 µs	3,250 µs	1.00× slower	3,930 µs	1.21× faster	0.803	0.7812 1.03× lower	all 11 rules hold under QCCDSim's chain bookkeeping, each qubit's order kept
surface code d=5 on L24 against: rotated surface code d=5 [[25,1,5]] on L24: Moveless, one ancilla ▶ watch ours in the Studio	15,640 µs	16,480 µs	1.05× slower	20,920 µs	1.27× faster	0.2622	0.3558 1.36× higher	all 11 rules hold under QCCDSim's chain bookkeeping, each qubit's order kept
surface code d=7 on L48 against: rotated surface code d=7 [[49,1,7]] on L48: Moveless, one ancilla ▶ watch ours in the Studio	65,180 µs	63,220 µs	1.03× faster	95,010 µs	1.50× faster	3.067e-04	0.02808 91.54× higher	all 11 rules hold under QCCDSim's chain bookkeeping, each qubit's order kept
colour code d=11 on L90 against: color code d=11 [[91,1,11]] on L90: Moveless, one ancilla ▶ watch ours in the Studio	173,470 µs	167,050 µs	1.04× faster	219,430 µs	1.31× faster	4.140e-13	7.128e-06 17219049.09× higher	all 11 rules hold under QCCDSim's chain bookkeeping, each qubit's order kept

The time is the CNOTs plus the walk: 170 µs per step to a neighbouring trap, plus a 300 µs gate swap when the ancilla leaves past data or passes through a trap that holds data. In the file's order the ancilla goes back and forth between neighbouring traps, so the walk is longer than the CNOTs for the larger codes. The paper's Moveless schedules run each trap's CNOTs together, which the file's order does not allow, and ours roughly ties them. Its ancilla-only runs keep the order: with their placement our walk takes exactly their time, and the searched placement is 1.2-1.5x faster.

The rules each run is judged by

This paper's model is written as the rule set QCCDSim's rules, with the circuit's gates as a set. Every run above was replayed and each rule of the set evaluated on it. Our schedules are held to the same rules, and also keep each qubit's gates in the circuit's exact order (R25): we may not reorder a circuit, even where its gates commute.

run	R0	R1	R2	R3	R6b	R8	R14	R24	R25	R27	R29
rotated surface code d=3 [[9,1,3]] on L8: Moveless, one ancilla	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=3 [[9,1,3]] on L8: moving the ancilla only	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=3 [[9,1,3]] on L8: QCCDSim, one ancilla per stabilizer	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=5 [[25,1,5]] on L24: Moveless, one ancilla	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=5 [[25,1,5]] on L24: moving the ancilla only	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=5 [[25,1,5]] on L24: QCCDSim, one ancilla per stabilizer	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=7 [[49,1,7]] on L48: Moveless, one ancilla	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=7 [[49,1,7]] on L48: moving the ancilla only	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
rotated surface code d=7 [[49,1,7]] on L48: QCCDSim, one ancilla per stabilizer	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
color code d=11 [[91,1,11]] on L90: Moveless, one ancilla	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
color code d=11 [[91,1,11]] on L90: moving the ancilla only	✓	✓	✓	✓	✓	✓	✓	✓	·	✓	✓
color code d=11 [[91,1,11]] on L90: QCCDSim, one ancilla per stabilizer	✓	✗ 4	✓	✓	✓	✓	✓	✓	·	✓	✓
ours: surface code d=3 on L8	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: surface code d=5 on L24	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: surface code d=7 on L48	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: colour code d=11 on L90	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓

✓ the rule holds on that run; ✗ it fails, with the number of counterexamples (hover for the first); – it does not apply to that run (hover for why); · the rule is not in that run's rule set.

what each rule says

R0 Every operation finds its ions where it says they are

setup_ok()
and (for all o in operations: well_formed(o) and found(o))
and (for all i in ions: position(i, final()) != none)

Each operation names its ions and where they are; replaying the execution from the start must find them there, and every ion must end it standing in a site.

R1 A site holds at most its capacity

for all s in sites, t in instants:
  occupancy(s, t) <= capacity(s)

An ion standing in a site, or passing through it, takes one of its places.

R2 A junction holds one ion at a time

for all j in junctions, t in instants:
  occupancy(j, t) <= 1

Where three or more rails meet, only one ion may be at any moment, resting or passing through.

R3 A rail carries at most its capacity

for all r in rails, t in instants:
  occupancy(r, t) <= capacity(r)

No more ions travel along one rail at once than the rail is built for (one, on most devices).

R6b A two-ion gate acts on two ions standing in one site

(for all g in two_qubit_gates, i in ions(g): position(i, start(g)) = site(g))
and (for all g in two_qubit_gates where size(declared_sites(g)) > 0:
       site(g) in declared_sites(g))

Both ions of a two-qubit gate are in the same trap when it starts, and in the trap the programme names for it, if it names one.

R8 An ion does one thing at a time

for all a, b in operations where a != b and simultaneous(a, b):
  disjoint(ions(a), ions(b))

No ion takes part in two operations at once: it cannot be gated in one place while it is carried to another.

R14 A split takes the ion at the end of its chain, or pays to reorder

for all m in splits: at_chain_end(m) or swap_paid(m)

An ion leaves its chain from the end that faces the rail; an ion further in must first be swapped to that end, which costs gates.

R24 Every two-qubit gate of the circuit is performed, and no other

(for all c in circuit_ops where needs_gate(c): gate_count(c) >= 1)
and (for all g in two_qubit_gates: serves_circuit(g))

Each two-qubit gate of the input circuit is carried out, and the execution performs no two-qubit gate the circuit does not ask for.

R25 Each qubit's operations keep the circuit's order

for all c1, c2 in circuit_ops where next_on_qubit(c1, c2) and performed(c1) and performed(c2):
  end(last(c1)) <= start(first(c2))

On every qubit, each operation is over before the next one on that qubit begins, in the order the circuit is written -- even where two of them would commute.

R27 One operation at a time in a trap

for all a, b in operations where a != b and kind(a) in serial_kinds and kind(b) in serial_kinds
    and site(a) = site(b) and site(a) != none:
  not simultaneous(a, b)

The operations of the kinds listed in serial_kinds hold their trap: two of them in one trap never overlap in time.

R29 Every operation lasts what the clock says

for all o in operations where clocked(o): approx(duration(o), clock(o))

Each operation's duration is the one the model's duration law gives it.

How a paper is checked · all papers