← all papers

QCCDSim

Prakash Murali, Dripto M. Debroy, Kenneth R. Brown, Margaret Martonosi. Architecting Noisy Intermediate-Scale Trapped Ion Quantum Computers. ISCA 2020. arXiv:2004.04706 · their code: prakashmurali/QCCDSim (no license)

Two six-trap devices, a line (L6) and a two-by-three grid (G2x3), trap capacity swept from 14 to 34 ions, six NISQ benchmarks; the simulator every later paper in this list builds on.

What this website takes from this paper

No license file: we ran it locally and publish only the schedules it produced, never its code.

T0T1T2T3T4T5J0J1J2J3J4
L6: six traps on a line, a degree-2 junction between neighbours
T0T1T2T3T4T5J0J1J2
G2x3: six single-port traps on a three-junction bus
configurationtime: their codeour replaythe paperthe paper's rules
BV-64 on L6, capacity 14, Greedy mapper
▶ watch it in the Studio		13,274 µs = ours13,274 µs13,270 µs matchesFig. 6(a), plotted (vector data in the source)all 11 rules hold
fidelity0.9776 = ours0.97760.9776 matchesFig. 6(c), plotted
BV-64 on L6, capacity 20, Greedy mapper
▶ watch it in the Studio		18,297 µs = ours18,297 µs18,300 µs matchesFig. 6(a)all 11 rules hold
fidelity0.9697 = ours0.96970.9697 matchesFig. 6(c)
BV-64 on G2x3, capacity 14, Greedy mapper
▶ watch it in the Studio		14,354 µs = ours14,354 µs14,350 µs matchesFig. 7(b)all 11 rules hold
fidelity0.9775 = ours0.97750.9775 matchesFig. 7(b)
QAOA-64 (20 layers) on L6, capacity 14, program-order mapper
▶ watch it in the Studio		162,360 µs = ours162,360 µs162,400 µs matchesFig. 6(a)all 11 rules hold
fidelity0.4758 = ours0.47580.4758 matchesFig. 6(d)
QAOA-64 (20 layers) on L6, capacity 20, program-order mapper
▶ watch it in the Studio		254,144 µs = ours254,144 µs254,100 µs matchesFig. 6(a)all 11 rules hold
fidelity0.3827 = ours0.38270.3827 matchesFig. 6(d)
QAOA-64 (20 layers) on G2x3, capacity 14, program-order mapper
▶ watch it in the Studio		191,807 µs = ours191,807 µs191,800 µs matchesFig. 7(d)all 11 rules hold
fidelity0.4004 = ours0.40040.4004 matchesFig. 7(d)
Adder (32-bit) on L6, capacity 14, program-order mapper
▶ watch it in the Studio		90,135 µs = ours90,135 µs90,130 µs matchesFig. 6(a)all 11 rules hold
fidelity0.803 = ours0.8030.803 matchesFig. 6(c)
Adder (32-bit) on L6, capacity 20, program-order mapper
▶ watch it in the Studio		126,477 µs = ours126,477 µs126,500 µs matchesFig. 6(a)all 11 rules hold
fidelity0.7648 = ours0.76480.7648 matchesFig. 6(c)
QFT-64 on L6, capacity 14, Greedy mapper
▶ watch it in the Studio		333,074 µs = ours333,074 µs333,100 µs matchesFig. 6(a)all 11 rules hold
fidelity9.701e-04 = ours9.701e-049.701e-04 matchesFig. 6(e)
QFT-64 on L6, capacity 20, Greedy mapper
▶ watch it in the Studio		550,560 µs = ours550,560 µs550,600 µs matchesFig. 6(a)all 11 rules hold
fidelity0.001295 = ours0.0012950.001295 matchesFig. 6(e)
Supremacy-64 on L6, capacity 20, program-order mapper
▶ watch it in the Studio		223,295 µs = ours223,295 µs223,300 µs matchesFig. 6(a)all 11 rules hold
fidelity0.1563 = ours0.15630.1563 matchesFig. 6(d)
BV-64 on L6, capacity 14, Greedy mapper, ion swaps
▶ watch it in the Studio		21,634 µs = ours21,634 µs21,630 µs matchesFig. 8(h), ion swapall 11 rules hold
fidelity0.9813 = ours0.98130.9813 matchesFig. 8(b)
Which mapper and which QFT the figures useThe simulator has two mappers. The BV and QFT curves match its Greedy mapper (BV-64 on L6 at capacity 14: 13,274 µs, against 23,796 µs with the other); the QAOA, Adder and Supremacy curves match its program-order mapper. The paper describes one greedy mapper. The QFT curves match the inverse-QFT gate order (each controlled phase as two CNOTs); the textbook forward order gives 360,600 µs at capacity 14 against the plotted 333,100. With these choices, 58 of the 58 configurations we ran (every benchmark on L6 at capacities 14 to 34, and the G2x3 points) agree with the plotted values within 0.05 %.
Chain order after a gate swapWhen a split needs a gate swap, the simulator removes the departing ion from its place and keeps the end ion at the end. Physically the swap moves the end ion's state into the departing ion's place. Of the figure configurations we replayed, only QAOA on G2x3 is affected: under the physical rule 8 of its splits would leave from a different place than the one the simulator charged. The difference grows with gate swaps: 18 splits in the program-order BV-64 run at capacity 14, and hundreds in the simulator's runs of Muzzle the Shuttle's benchmarks.
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.

A list scheduler of our own over QCCDSim's primitives: every candidate step is timed exactly before it is chosen, with look-ahead; the qubits are spread over all six traps; a gate swap is used only where the chain bookkeeping of QCCDSim and of the physical machine agree, so the schedule passes under both. 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.

configurationtheir codeoursfidelity: theirsoursthe paper's rules
BV-64 on L6, capacity 14
against: BV-64 on L6, capacity 14, Greedy mapper
▶ watch ours in the Studio		13,274 µs12,287 µs1.08× faster0.97760.9824 1.00× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
BV-64 on L6, capacity 20
against: BV-64 on L6, capacity 20, Greedy mapper
▶ watch ours in the Studio		18,297 µs17,240 µs1.06× faster0.96970.9775 1.01× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
Adder on L6, capacity 14
against: Adder (32-bit) on L6, capacity 14, program-order mapper
▶ watch ours in the Studio		90,135 µs68,480 µs1.32× faster0.8030.856 1.07× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
Adder on L6, capacity 20
against: Adder (32-bit) on L6, capacity 20, program-order mapper
▶ watch ours in the Studio		126,477 µs102,080 µs1.24× faster0.76480.8195 1.07× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
QAOA-64 on L6, capacity 14
against: QAOA-64 (20 layers) on L6, capacity 14, program-order mapper
▶ watch ours in the Studio		162,360 µs55,139 µs2.94× faster0.47580.458 1.04× lowerall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
QAOA-64 on L6, capacity 20
against: QAOA-64 (20 layers) on L6, capacity 20, program-order mapper
▶ watch ours in the Studio		254,144 µs80,491 µs3.16× faster0.38270.412 1.08× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
Supremacy-64 on L6, capacity 20
against: Supremacy-64 on L6, capacity 20, program-order mapper
▶ watch ours in the Studio		223,295 µs108,864 µs2.05× faster0.15630.3792 2.43× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
QFT-64 on L6, capacity 14
against: QFT-64 on L6, capacity 14, Greedy mapper
▶ watch ours in the Studio		333,074 µs770,215 µs2.31× slower9.701e-041.558e-15 622735025495.33× lowerall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept
QFT-64 on L6, capacity 20
against: QFT-64 on L6, capacity 20, Greedy mapper
▶ watch ours in the Studio		550,560 µs699,806 µs1.27× slower0.0012950.002331 1.80× higherall 11 rules hold
all 11 rules hold
under QCCDSim's chain bookkeeping and the physical one, each qubit's order kept

QFT-64 is a loss: every trap crossing costs two gate swaps under both bookkeepings, only one travelling ion fits in a trap at a time, and finished ions have nowhere to go at these capacities.

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.

runR0R1R2R3R6bR8R14R24R25R27R29
BV-64 on L6, capacity 14, Greedy mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
BV-64 on L6, capacity 20, Greedy mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
BV-64 on G2x3, capacity 14, Greedy mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
QAOA-64 (20 layers) on L6, capacity 14, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
QAOA-64 (20 layers) on L6, capacity 20, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
QAOA-64 (20 layers) on G2x3, capacity 14, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
Adder (32-bit) on L6, capacity 14, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
Adder (32-bit) on L6, capacity 20, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
QFT-64 on L6, capacity 14, Greedy mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
QFT-64 on L6, capacity 20, Greedy mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
Supremacy-64 on L6, capacity 20, program-order mapper · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
BV-64 on L6, capacity 14, Greedy mapper, ion swaps · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: BV-64 on L6, capacity 14 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: BV-64 on L6, capacity 14 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: BV-64 on L6, capacity 20 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: BV-64 on L6, capacity 20 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: Adder on L6, capacity 14 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: Adder on L6, capacity 14 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: Adder on L6, capacity 20 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: Adder on L6, capacity 20 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: QAOA-64 on L6, capacity 14 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: QAOA-64 on L6, capacity 14 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: QAOA-64 on L6, capacity 20 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: QAOA-64 on L6, capacity 20 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: Supremacy-64 on L6, capacity 20 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: Supremacy-64 on L6, capacity 20 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: QFT-64 on L6, capacity 14 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: QFT-64 on L6, capacity 14 · QCCDSim's rules, with a physical gate swap✓✓✓✓✓✓✓✓✓✓✓
ours: QFT-64 on L6, capacity 20 · QCCDSim's rules✓✓✓✓✓✓✓✓✓✓✓
ours: QFT-64 on L6, capacity 20 · 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