TISCC

Tyler LeBlond, Justin G. Lietz, Christopher M. Seck, Ryan S. Bennink. TISCC: A Surface Code Compiler and Resource Estimator for Trapped-Ion Processors. SC-W 2023. arXiv:2311.10687 · their code: ORNL-QCI/TISCC (UT-Battelle open source license (BSD-style))

A grid of trapping zones and X-junctions, one ion per zone; surface-code patches compiled to timed native operations.

one d = 5 patch: 36 cells of M O M J M O M, one ion per zone

configuration	time: their code	our replay	the paper	the paper's rules
one d=5 error-correction round (TISCC -x 5 -z 5 -t 1 -o idle) ▶ watch it in the Studio · timed schedule (JSON)	9,613 µs = ours	9,613 µs	–	all 8 rules hold
one d=6 round ▶ watch it in the Studio · timed schedule (JSON)	–	9,613 µs	–	all 8 rules hold

The time of a junction moveThe paper allots a junction move two Junction times (210 µs). The code, and the schedules it ships, allot one Move plus one Junction (110.25 µs). We replay the shipped schedules, so we use the code's figure.

Our schedule on the same machine, under the same rules

Made by sched_tiscc, a scheduler we wrote for TISCC's surface-code round; it is not the compiler that compiles this website's leaderboard entries.

TISCC's own operations for every ion, with the same partners in the same order (preparation, rotations, the ZZ gates, measurement), on TISCC's grid and clock. What changes is the transport: for each ZZ either the measure ion goes to the data ion or the data ion goes to the measure ion; nothing waits for a layer to finish; and an ion may go straight from one partner to the next across the same junction, borrowing the next partner's operation zone for its rotations while that partner steps aside. Rotations, preparation and measurement stay in operation zones, one crossing of a junction at a time, and every ion ends the round in the zone it started in. 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		the paper's rules
one d=5 error-correction round against: one d=5 error-correction round, idling ▶ watch ours in the Studio · timed schedule (JSON)	9,613 µs	8,864.50 µs	1.08× faster	all 9 rules hold under TISCC's rules, each qubit's order kept
one d=6 round ▶ watch ours in the Studio · timed schedule (JSON)	9,613 µs	8,866.75 µs	1.08× faster	all 9 rules hold under TISCC's rules, each qubit's order kept

Each measure ion has four ZZ gates of 2,000 µs in a row, so 8,000 µs of the round cannot move. Everything else (preparation, rotations, transport, measurement) takes TISCC 1,613 µs and ours about 865 µs, at d = 5 and d = 6 alike. What limits it now is the junctions: where two meetings fall in the same layer at one junction, their crossings take turns (a search over who travels, not a proof that nothing shorter exists).

The rules each run is judged by

This paper's model is written as the rule set TISCC's rules. 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	R8	R24	R25	R29	R32	R33
one d=5 error-correction round (TISCC -x 5 -z 5 -t 1 -o idle)	✓	✓	✓	✓	✓	·	✓	✓	✓
one d=6 round	✓	✓	✓	✓	✓	·	✓	✓	✓
ours: one d=5 error-correction round	✓	✓	✓	✓	✓	✓	✓	✓	✓
ours: one d=6 round	✓	✓	✓	✓	✓	✓	✓	✓	✓

✓ 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.

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.

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.

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.

R32 Single-ion operations run only in the zones the model allows

for all o in operations where kind(o) in {"gate1", "reset", "measure"}:
  zone(site(o)) in single_ion_zones

Rotations, preparation and measurement happen only in the zones listed in single_ion_zones.

R33 A two-ion gate acts on ions in one zone or in neighbouring zones

for all g in two_qubit_gates, i, j in ions(g):
  position(i, start(g)) = position(j, start(g))
  or neighbours(position(i, start(g)), position(j, start(g)))

On devices whose gate spans two zones of one rail, the two ions stand in the same zone or in zones next to each other.

The Studio's runtime is not the schedule's time. A Studio page plays a schedule as a programme in our language: operations of one kind that start at the same moment are one instruction, and each instruction starts when the one before it has ended, so the runtime it shows is its instructions added up. TISCC's round runs in layers, so played this way it takes 9,625 µs at d = 5, against 9,613 µs on TISCC's clock (12 µs more: where TISCC turns some ions about X or Y and others about Z at the same moment, our language writes two instructions). Ours does not wait for layers: its operations overlap in time, and the same addition gives 94,051.25 µs, which is not a time the schedule takes. Its time is the checker's, 8,864.50 µs, under TISCC's rules and clock, and the timed schedules beside each run list every event with its ions, its start and end and the zones, segments and junctions it holds, so the time can be checked without our code.

Instructions and steps. An instruction is one such batch. Its steps are the segments the longest move in it crosses (one to a neighbouring zone, two through a junction: zone, junction, zone), or one for any other operation; its cost counts every segment and every junction crossing of every move. So our d = 5 round is 392 instructions and 467 steps, TISCC's 48 and 59: more, smaller instructions, which overlap in time where the Studio cannot show it.

Rotations. The programmes write TISCC's operations in our language: TISCC's P_θ, exp(−iθP), is R(2θ, 0) about X, R(2θ, π/2) about Y and VZ(2θ) about Z, with the angles in the programme; Prepare_Z is a reset; the ZZ keeps its name. The Studio's list prints each rotation's angles, as R(θ, φ) or VZ(λ); the timed schedules name every operation as TISCC does. Ion by ion, ours runs exactly TISCC's operations, with the same partners, in the same order (checked).

R6b. On the Studio pages the rule R6b fails once for every ZZ: 80 times in one d=5 error-correction round, 120 times in one d=6 round. R6b is a rule of our language: both ions of a two-qubit gate stand in one zone. TISCC keeps one ion in each zone and runs a ZZ on ions in neighbouring zones of one segment; its 2,000 µs include merging the two into one zone, cooling, the gate and the split (TISCC's gate table). Under TISCC's rules, the checks in the tables above, a ZZ must act on ions in the same or neighbouring zones, which every one does, and since the merge and the split are inside the ZZ, every zone holds one ion throughout.

How a paper is checked · all papers