Position Graph

Bao Bach, Ilya Safro, Ed Younis. Efficient Compilation for Shuttling Trapped-Ion Machines via the Position Graph Architectural Abstraction. arXiv 2025. arXiv:2501.12470 · their code: not published

A graph of ion positions as the compiler's view of any shuttling machine, and two compilers on it (SHAPER, SHAW), compared with QCCDSim on grid devices.

No code or circuits are published (the paper says a link will follow acceptance), so this paper is reproduced at the level of its model: its device, its timing table and its baseline simulator.

G2x3 at capacity 5, the device of the paper's QFT-20 comparison

configuration	time: their code	our replay	the paper	the paper's rules
QFT-20 on G2x3, capacity 5: QCCDSim ▶ watch it in the Studio	47,580 µs = ours	47,580 µs	70,134 µs differsTable 3, QCCDSim on the paper's own transpiled QFT-20 (not published)	all 11 rules hold
fidelity	0.677 = ours	0.677	–

Why the QCCDSim number differsThe paper transpiles every circuit to Quantinuum's native gates with BQSKit before scheduling, and its QCCDSim column (70,134 µs for QFT-20 on G2x3 at capacity 5) is for that transpiled circuit, which is not published. QCCDSim on the textbook QFT-20 (380 CNOTs) takes 47,580 µs on the same device. The paper's SHAPER (39,966 µs) and SHAW (39,871 µs) are therefore not directly comparable with any schedule we can produce; our comparison is with QCCDSim on the same circuit.

Our schedule on the same machine, under the same rules

Made by sched, a list scheduler we wrote for the QCCDSim family's model; it is not the compiler that compiles this website's leaderboard entries.

The same scheduler as for QCCDSim, on the paper's G2x3 device with QCCDSim's primitives. The paper's own compilers are not public, so they are compared by the numbers the paper prints, under the paper's model rather than this one. 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		fidelity: theirs	ours	the paper's rules
QFT-20 on G2x3, capacity 5 against: QFT-20 on G2x3, capacity 5: QCCDSim ▶ watch ours in the Studio	47,580 µs	27,015 µs	1.76× faster	0.677	0.8721 1.29× higher	all 11 rules hold all 11 rules hold under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept

The paper's own compilers on this circuit: SHAW 39,871 µs, SHAPER 39,966 µs, printed under the paper's model, which has no public code; ours is 27,015 µs under QCCDSim's.

The rules each run is judged by

This paper's model is written as the rule sets QCCDSim's rules, QCCDSim's rules, with a physical gate swap. 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
QFT-20 on G2x3, capacity 5: QCCDSim · QCCDSim's rules	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: QFT-20 on G2x3, capacity 5 · QCCDSim's rules	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: QFT-20 on G2x3, capacity 5 · QCCDSim's rules, with a physical gate swap	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓

✓ 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