Chapter 31: Pulse-Level Programming — and What Replaced It

This chapter was planned as a tour of qiskit.pulse: shaped microwave envelopes, DRAG corrections, calibrating a gate from Rabi oscillations upward, and attaching a custom pulse schedule to a circuit instruction.

The first thing the probe script did was fail.

   qiskit 2.5.1
     qiskit.pulse                          GONE: ModuleNotFoundError
     QuantumCircuit.calibrations           REMOVED
     QuantumCircuit.add_calibration        REMOVED
     FakeSherbrooke.defaults               REMOVED
     FakeSherbrooke.instruction_schedule_map  REMOVED
     FakeSherbrooke.drive_channel          REMOVED

Pulse-level programming, as a Qiskit feature, no longer exists. It was deprecated through the 1.x series and removed in 2.0. Every tutorial written against it — and there are many, including ones still linked from current documentation — describes an API you cannot import.

So this chapter is about three things instead, and they are more useful than the one it replaced: what survives below the gate, what you can still control, and a measured result about dynamical decoupling that turns out to be the sharpest illustration in this book of a simulator's limits.

Part V closes here.

31.1 What a gate physically is

Even without the pulse API, the physics is worth stating, because the numbers that survive only make sense against it.

A superconducting qubit is an anharmonic oscillator. A gate is a shaped microwave pulse applied near the qubit's transition frequency for a precisely controlled duration. The pulse's area sets the rotation angle; its phase sets the rotation axis; its envelope shape determines how much population leaks into the third level $|2\rangle$, which is why real pulses use DRAG corrections rather than square envelopes.

The hardware clock is exposed:

   target.dt = 2.2222e-10 s = 0.2222 ns

Every duration on this device is an integer multiple of 0.2222 ns. That is the sample period of the arbitrary waveform generator driving the qubits, and it is the finest time resolution anything — including the scheduler — can express.

And the gate durations:

   sx        56.9 ns  (all qubits)
   x         56.9 ns  (all qubits)
   rz         0.0 ns  (all qubits)
   ecr       341.3 - 881.8 ns, median 533.3
   measure  1216.0 ns

Two of these deserve attention.

⚛️ The Physics Underneath: rz takes zero time.

A $Z$ rotation is not performed. It is absorbed into the phase of every subsequent pulse — the control software simply redefines what "the $X$ axis" means from that moment on. This is the virtual Z gate, and it is exact, instantaneous, and error-free.

It is why Chapter 28's transpiled circuits are full of rz and nobody minds: 83 rz gates in the Chapter 29 ansatz cost literally nothing. The basis $\{$rz, sx, x, ecr$\}$ is not arbitrary — it is one free gate, two fixed 56.9 ns pulses, and one expensive entangler.

📐 Math Aside: why a frame change is exact, and why it is free.

A drive pulse at the qubit's transition frequency with carrier phase $\phi$ implements a rotation about the equatorial axis

$$X_\phi \;=\; \cos\phi \, X + \sin\phi \, Y$$

The phase of the microwave is the choice of rotation axis. That is the whole mechanism. Now conjugate that axis by a $Z$ rotation, $R_Z(\theta) = e^{-i\theta Z/2} = \mathrm{diag}(e^{-i\theta/2}, e^{i\theta/2})$:

$$R_Z(\theta)\, X\, R_Z(\theta)^\dagger \;=\; \begin{pmatrix} 0 & e^{-i\theta} \\ e^{i\theta} & 0 > \end{pmatrix} \;=\; \cos\theta\, X + \sin\theta\, Y \;=\; X_\theta$$

and more generally $R_Z(\theta)\, X_\phi\, R_Z(\theta)^\dagger = X_{\phi+\theta}$. So for any drive rotation $R_\phi(\alpha) = e^{-i\frac{\alpha}{2} X_\phi}$,

$$R_Z(\theta)\, R_\phi(\alpha) \;=\; R_{\phi+\theta}(\alpha)\, R_Z(\theta).$$

A $Z$ rotation can be pushed rightward past every subsequent drive pulse, at the cost of adding $\theta$ to each of their phases. Push it all the way to the end of the circuit and it arrives at the measurement — where it commutes with the computational-basis projectors and can be dropped outright.

So the control software never emits a $Z$ pulse. It keeps a running phase offset per qubit, adds $\theta$ to it, and generates every later pulse with the updated phase. The offset is a number in a register. Updating it consumes no time, no waveform samples, and — the part that matters — no fidelity, because there is no imperfect pulse to be imperfect.

Two caveats. The identity is exact for the ideal drive; a real pulse has finite bandwidth, and the frame bookkeeping has to stay consistent across every channel that touches the qubit, including the two-qubit drive. And it works only for rotations about the quantization axis. There is no free $X$ gate. That asymmetry is the entire reason sx costs 56.9 ns and rz costs nothing.

And measure costs 1,216 ns — more than twice the median two-qubit gate. Measurement is the slowest operation on the device by a wide margin, which is one reason Chapter 25 §25.7's syndrome-extraction cycle is hard: it is measurement-bound, not gate-bound.

What the 56.9 nanoseconds actually contains

The target still exposes one physical quantity besides time, and it is worth putting next to the durations:

   qubit frequency   median 4.7940 GHz   (range 4.4553 - 5.0575 GHz)
   carrier period    208.6 ps
   1 / dt            4,500,000,000 Sa/s  =  4.5 GSa/s exactly

The sample rate is 4.5 gigasamples per second, and $\mathrm{dt} = 1/(4.5\ \text{GHz})$ exactly. That is where 0.2222 ns comes from — it is not a rounded physical constant, it is one tick of the arbitrary waveform generator.

Two ratios fall straight out. A 56.9 ns sx pulse spans 272.7 cycles of the 4.79 GHz carrier, so the pulse is not "a wiggle" — it is a few hundred oscillations under a slowly varying envelope. And one dt is 1.07 carrier cycles, which tells you what the AWG is actually sampling: not the carrier, but the envelope that multiplies it. The envelope is the only thing a pulse programmer ever shaped.

That envelope is where DRAG lives. A transmon is an anharmonic ladder: the $|1\rangle \to |2\rangle$ transition sits below $|0\rangle \to |1\rangle$ by the anharmonicity, close enough that a pulse short enough to be fast is spectrally broad enough to drive it. A square envelope, switched on and off abruptly, has spectral weight spread across a wide band — including at the leakage transition. DRAG adds a component proportional to the derivative of the envelope, in the quadrature channel, tuned to cancel that spectral weight at the leakage frequency. It is the reason real pulses are shaped rather than rectangular, and the reason a naïvely faster gate leaks.

And the target does not tell you what the anharmonicity is. qubit_properties exposes exactly three fields — frequency, t1, t2 — and nothing else. You can read how long a gate takes and how long the qubit lives; you cannot read the parameter that would let you reason about leakage at all. That is a concrete measure of how much the removal took away, and it is not recoverable from what remains.

Every duration is a multiple of 16 dt

Reading the durations in units of dt rather than nanoseconds makes the hardware's real constraint visible:

   gate       distinct values     duration in dt units
   sx / x                   1     256
   ecr                      6     1536, ..., 3968
   measure                  1     5472
   reset                    7     5728, 5792, 5856, 5984, 6048, 6112, 6304

Every one of those numbers is divisible by 16. That is not a coincidence, and it is not an inference — the target says so directly:

   target.granularity        16      waveform lengths must be a multiple of 16 samples
   target.min_length         64      no pulse shorter than 64 samples (14.2 ns)
   target.pulse_alignment    16      pulses must START on a multiple of 16 samples
   target.acquire_alignment  16      the same, for readout

Sixteen samples is 3.5556 ns. That is the true time quantum of this device: not dt, but 16×dt. Anything the scheduler emits at a finer alignment is not something the hardware can play.

⚠️ Common Pitfall: PadDynamicalDecoupling defaults to pulse_alignment=1, and this device wants 16.

The signature is PadDynamicalDecoupling(durations, dd_sequence, qubits, spacing, skip_reset_qubits, pulse_alignment=1, ...). Left at the default, the pass is free to place decoupling pulses at start times the control electronics cannot express, and the four timing constraints sitting in target.pulse_alignment — which the pass will happily ignore if you pass durations instead of target — are exactly the data that would have prevented it.

These four fields are the last surviving fragment of the pulse layer in the public API. They were there to let qiskit.pulse validate a schedule before submission. The scheduler still needs them; almost nobody passes them.

⚙️ Under the Transpiler: what the 83 rz gates would cost if they were real.

Chapter 29's ansatz transpiles at level 2 to {rz: 83, sx: 61, ecr: 15, measure: 6} — depth 54. Of the 144 single-qubit operations in that circuit, 83 are free. That is 57.6% of the single-qubit gate count costing nothing at all.

Price them as if they were physical, at sx's 56.9 ns and the device's median single-qubit error of $2.362\times10^{-4}$:

text 83 rz at 56.9 ns = 4.72 us of extra qubit-time 83 rz at 2.362e-04 = 1 - (1-p)^83 = 0.0194 of fidelity

A 1.94% fidelity loss — 3.7 times the entire measured cost of dynamical decoupling in §31.4. The single largest fidelity saving available on this device is one that no user asks for, no transpiler flag controls, and no chapter of this book measured, because it was already applied before anything was counted.

It also explains a transpiler behaviour that looks pathological until you know this: Chapter 28's optimized circuits contain more rz gates than the input, because the compiler is deliberately rewriting expensive rotations into free ones plus fixed pulses. rz is where the transpiler puts the rounding error.

🔀 In Another Framework: Qiskit deleted its pulse module. PennyLane still ships one — and it is a different kind of thing.

text qiskit.pulse (2.5.1) ModuleNotFoundError qml.pulse (0.45.1) HardwareHamiltonian, ParametrizedEvolution, ParametrizedHamiltonian, transmon_drive, transmon_interaction, rydberg_drive, rydberg_interaction, rect, pwc, constant, and qml.evolve

The two are not competitors, and the difference is the whole argument of §31.6. qiskit.pulse was a waveform scheduling interface: channels, envelopes, sample-level timing, all denominated in one vendor's control electronics. qml.pulse is a Hamiltonian interface: you write $H(t)$ — a drive term, an interaction term, a time-dependent coefficient — and qml.evolve integrates it.

A Hamiltonian ports. transmon_drive and rydberg_drive sit in the same module because the abstraction is the physics, not the hardware. A DriveChannel(3) with a Drag envelope ports nowhere, not even to the next chip from the same vendor.

Cirq 1.7.0 takes a third position: no pulse layer at all, but cirq.Duration, cirq.WaitGate, cirq.GridDeviceMetadata and a moment-based circuit model in which timing is structural rather than annotated — a Moment is by construction a set of operations that happen together, so Cirq circuits are implicitly ASAP-scheduled before anyone asks.

The abstraction that survived is the one that was about physics. That is not a coincidence and it is not luck; it is the criterion.

31.2 The coherence budget

   median T1 = 278.4 us       median T2 = 170.0 us
   median ecr = 533.3 ns  ->  T1 / ecr = 522 gates before decoherence

Five hundred and twenty-two two-qubit gates fit inside $T_1$. That sounds generous until you set it beside Chapter 12's median gate error of 0.0075: at that error rate, 522 gates survive with probability $(1-0.0075)^{522} \approx 0.020$.

Gate error, not decoherence, is the binding constraint on this device. You will lose your signal to imperfect gates long before you run out of coherence time.

That balance is device-specific and it has shifted historically — early superconducting devices were decoherence-limited, and trapped-ion systems still have very long coherence times and slow gates. Check which regime you are in before optimizing for the wrong one.

The number the target does not print

$T_1$ and $T_2$ are both reported. The quantity that matters most for this chapter is neither of them, and it has to be derived.

$T_1$ is amplitude damping — the qubit decaying toward $|0\rangle$, losing its excitation to the environment. $T_2$ is the total loss of phase coherence, and it has two independent contributors: the phase information destroyed as a side effect of energy decay, and pure dephasing from the qubit's frequency wandering while the state sits in superposition. The rates add:

$$\frac{1}{T_2} \;=\; \frac{1}{2T_1} \;+\; \frac{1}{T_\varphi}$$

The factor of two is the standard result that an amplitude-damping event costs half as much phase coherence per unit time as it costs population. Rearranged, with this device's medians:

   T1                 278.4 us
   T2                 170.0 us
   2 x T1             556.8 us     <- the ceiling T2 would reach with zero pure dephasing
   T2 / 2T1            0.3053
   T_phi (derived)    244.7 us     <- 1/Tphi = 1/T2 - 1/(2 T1)

$T_2$ is only 30.5% of its $2T_1$ ceiling. There is a pure-dephasing channel on this device with a characteristic time of 245 μs, and it is doing most of the damage to phase.

That derived number is the entire subject of §31.4, because dynamical decoupling does not touch $T_1$. Nothing you do with refocusing pulses stops a qubit from emitting a photon. DD targets $T_\varphi$ — and, as §31.5 establishes, only the part of $T_\varphi$ that is correlated over the timescale of the pulse sequence.

So the best possible outcome of perfect decoupling on this device is bounded, and the bound is computable before you run anything: $T_2$ rises toward $2T_1$, from 170.0 μs to at most 556.8 μs, a factor of 3.28. Not unbounded, and not a matter of opinion. It is set by $T_1$, which DD cannot help.

📊 What the Numbers Say: the median hides a factor of 188.

Every figure in this section is a median over 127 qubits, and the medians conceal a great deal:

text min median max spread T1 73.2 us 278.4 us 514.9 us 7.0x T2 2.6 us 170.0 us 488.8 us 188.0x sx error 1.07e-04 2.36e-04 1.33e-02 124x ecr error 3.47e-03 7.79e-03 1.00e+00 dead links

The worst qubit on this chip has a $T_2$ of 2.6 μs. A 7.10 μs circuit does not fit inside it at all; that one qubit takes the circuit from "4% of budget" to "you cannot run this." The median says the device has enormous headroom. The median is not a promise about the qubits you get.

This is Chapter 30's finding again — one chip quoting two-qubit errors from 0.00750 to 0.07205, a factor of 9.6 — except that the coherence spread is twenty times wider than the gate-error spread. Chapter 39 measured $T_1$ from 15.2 to 483.0 μs on a different device, a factor of 31.8, so this is a property of the technology rather than of one chip.

And it is why Chapter 29's headline result looks the way it does: hardware-aware layout at optimization level 1 scored 0.9116 against naive level 3's 0.7720, +0.1397, because choosing which qubits is worth more than choosing what to do with them. A coherence table with a 188× spread is what that finding looks like from underneath.

Where the binding constraint flips

"Gate error binds" is a conclusion with a threshold behind it, and the threshold is worth computing, because it says exactly what would have to change for the answer to reverse.

Take the survival criterion the section already used — 522 gates fit in $T_1$, surviving with probability $(1-p)^{522}$ — set that to one half, and solve:

$$p^{*} \;=\; 1 - 2^{-1/522} \;=\; 1.327\times10^{-3}$$

   gate error    survival over 522 gates    binding constraint
   0.0075                 0.0196            GATE ERROR  (measured, Chapter 12)
   0.001327               0.5000            the crossover
   0.001                  0.5932            DECOHERENCE
   0.0001                 0.9491            DECOHERENCE
   0.00001                0.9948            DECOHERENCE

The measured error rate is 5.7× above the crossover. Two-qubit gate error would have to improve by a factor of 5.7 — not an order of magnitude, but not a calibration tweak either — before decoherence became the thing worth optimizing on this device. That is a falsifiable prediction with a date on it, which is the kind of statement Chapter 40 §40.3 argues the field produces too few of.

Two footnotes on the arithmetic, because the headline number is friendlier than it should be. First, $T_1/t_{\text{ecr}} = 522$ uses the amplitude budget; the phase budget is smaller, $T_2 / t_{\text{ecr}} = 318.8$ gates, and phase is what interference algorithms actually spend. Second, 522 sequential two-qubit gates on one pair is not a circuit anybody writes — real circuits interleave, so the operative quantity is the accumulated duration on the busiest qubit, which is precisely what the scheduler reports and what the next block measures.

Now schedule an actual circuit. Chapter 29's linear-entanglement ansatz, transpiled at level 2:

   circuit duration ~ 7.10 us   (depth 54, 15 ecr gates)
   the circuit uses 4.17% of the T2 coherence budget
   qubit-time IDLE: 873.40 us of 901.30 us total (97%)

Two numbers worth sitting with.

The circuit uses 4% of its coherence budget. There is enormous headroom, which again says the limit is gate quality.

And 97% of qubit-time is idle. The circuit occupies 6 qubits on a 127-qubit chip; every qubit not currently being acted on is waiting, decohering, and doing nothing useful. That idle time is what the next section is about.

⚠️ Common Pitfall: 97% is a fact about the chip, not about the circuit — and it is the number that makes the intervention look necessary.

Take the denominator apart. The scheduled circuit spans all 127 wires, and $127 \times 7.0969\ \mu \text{s} = 901.3\ \mu\text{s}$ — which is exactly the total reported. The circuit touches six physical qubits, and they are contiguous: 120, 121, 122, 123, 124, 125. The other 121 wires are padded with a full-duration delay each and do nothing whatsoever.

text denominator busy idle total idle fraction all 127 wires 27.90 us 873.40 us 901.30 us 96.90% the 6 active only 27.90 us 14.68 us 42.58 us 34.47%

The 121 untouched wires supply 858.72 μs — 98.3% of the "idle time" the headline figure is computed from. They are not idle in any sense that matters; they are unused. Decoupling them would be like running the engine in a car nobody is in.

The honest figure for a decoupling decision is 34.47%, and it changes the character of the question. At 97% idle, dynamical decoupling looks mandatory. At 34% it looks like a close call — and a close call is precisely what §31.4 measures it to be.

PadDynamicalDecoupling already agrees. Its skip_reset_qubits argument defaults to True, and the measured result is that the pass placed 121 delays and exactly zero $X$ gates on the untouched wires. Every decoupling pulse it inserted went on one of the six active qubits. The pass computed the honest denominator; the report did not.

This is the book's recurring shape with the polarity worth noticing: the easy number is almost always the flattering one, and here "flattering" does not mean optimistic. It means the number that justifies doing the thing you were already going to do. The easy denominator was len(circuit .qubits); the one that answers the question required asking which qubits carried an instruction.

31.3 What you can still control

The pulse API is gone. Scheduling is not.

   qiskit.transpiler.passes.ALAPScheduleAnalysis    present
   qiskit.transpiler.passes.ASAPScheduleAnalysis    present
   qiskit.transpiler.passes.PadDynamicalDecoupling  present
   qiskit.transpiler.passes.PadDelay                present

ALAP (as late as possible) and ASAP (as soon as possible) decide where the idle time goes. ASAP starts every instruction the moment its inputs are ready, so idle time accumulates at the end of a qubit's life; ALAP delays everything as long as possible, so idle accumulates at the beginning. For a circuit ending in measurement, ALAP generally means a qubit sits idle for less time after its last gate, which matters because that idle time is immediately before readout.

PadDynamicalDecoupling fills idle periods with pulse sequences that are the identity overall — XX, or the four-pulse XY4 — intended to refocus dephasing accumulated while the qubit waits.

ASAP and ALAP on the same circuit, measured

Run both schedulers over the same transpiled ansatz, pad the idle windows with plain delays, and the comparison is unusually clean:

   scheduler   duration     busy      idle      delays   idle immediately
                                                          before measure
   ASAP        7.0400 us  26.88 us  867.20 us     138        6,243.6 ns
   ALAP        7.0400 us  26.88 us  867.20 us     137            0.0 ns

Identical duration. Identical busy time. Identical total idle time. The only thing that changed is where the idle sits — and one of the two put 6.2 μs of it directly in front of readout while the other put none there at all.

That is what "scheduling" means on this device. It is not an optimization in the sense Chapter 28 used the word: nothing gets shorter, nothing gets cheaper, and the instruction count is unchanged. It is a placement decision, and its entire value is in which part of a qubit's life the waiting happens during.

Why it matters is physical rather than arithmetic. A qubit sitting idle at the start of the circuit, before any gate has touched it, is in $|0\rangle$ — the ground state, which is exactly what amplitude damping drives it toward. Idle time in $|0\rangle$ costs nothing to $T_1$, and it has no phase to lose either. A qubit sitting idle at the end, after gates have put it in superposition and before the measurement reads it out, is exposed to both channels at full rate.

ALAP delays every instruction as long as its successors allow, which pushes the idle backwards toward the start of the circuit, where the qubit is still in its ground state. ASAP does the opposite. Hence the 6,243.6 ns against 0.0 ns.

Scale it: 6,243.6 ns is 3.67% of the median $T_2$, spread across the six measured qubits — about 1,040 ns each — and it amounts to 88.7% of the circuit's own 7,040 ns duration. ASAP nearly doubles the time the circuit's qubits spend in a fragile state, at zero benefit, for a circuit that is otherwise identical.

   ASAP    |--gate--|........idle........|--measure--|      exposed while waiting
   ALAP    |........idle........|--gate--|--measure--|      waiting in |0>

This is the one lever in the chapter whose sign is not in doubt. ALAP is free, it is the default in every scheduling pass listed above, and it is the correct default. §31.4's contested result is about what you put into the idle time; this is about where you put the idle time itself, and the two questions have very different answer qualities.

🐛 Debug This: PadDelay(durations) fails with TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'.

The obvious way to write the delay-padded version of the pass manager is by analogy with the decoupling one:

python PassManager([ALAPScheduleAnalysis(DURATIONS), PadDynamicalDecoupling(DURATIONS, [XGate()]*2)]) # works PassManager([ALAPScheduleAnalysis(DURATIONS), PadDelay(DURATIONS)]) # explodes

The traceback lands seven frames deep, inside transpiler/passes/scheduling/padding/base_padding.py, on the line t1 = t0 + dur, and says nothing about arguments. The cause is in the signatures:

text ALAPScheduleAnalysis (durations=None, target=None) PadDynamicalDecoupling(durations=None, dd_sequence=None, qubits=None, spacing=None, ...) PadDelay (fill_very_end=True, target=None, durations=None)

PadDelay's first positional argument is fill_very_end, not durations. Passing an InstructionDurations positionally sets a boolean flag to a truthy object, leaves durations at None, and the pass then tries to add None to an integer while computing a delay length. Two padding passes in the same subpackage, used together in every tutorial, with different first positional arguments.

The fix is one keyword: PadDelay(durations=DURATIONS), or better PadDelay(target=backend.target), which also carries the alignment constraints from §31.1.

This is Chapter 26 §26.1's lesson in miniature — the failure surfaced at a place with no relationship to the mistake. A TypeError about NoneType in an arithmetic expression inside a padding pass is not a message about argument order, and no amount of reading it more carefully makes it one. Read the signature, not the traceback.

That is a real technique with a real physical basis, and it is the natural thing to reach for given that 97% of qubit-time is idle. So: does it work?

31.4 Dynamical decoupling, measured

Chapter 29's ansatz, six transpiler seeds, 20,000 shots, scored as $1-\text{TVD}$ against the noiseless distribution:

   configuration                     x added   delays     1-TVD      std
   no DD                                   0        0    0.9288   0.0017
   XX  dynamical decoupling               20      159    0.9235   0.0025
   XY4 dynamical decoupling               36      175    0.9231   0.0023

   XX  vs no DD:  -0.0053 +/- 0.0012   SIGNIFICANT
   XY4 vs no DD:  -0.0057 +/- 0.0012   SIGNIFICANT

Both sequences made it significantly worse. And inserting a deliberate 20 μs idle period — 12% of $T_2$, where decoupling should have every advantage — made the gap larger, not smaller.

The obvious reading is that DD costs more in added gate error than it saves in dephasing. That reading is arithmetically correct here and it is the wrong conclusion.

📊 What the Numbers Say: the six seeds are simulator seeds, and that changes what the error bar licenses.

The measurement script transpiles once — transpile(qc, backend, optimization_level=2, seed_transpiler=7) — and then varies seed_simulator=600 + seed across six runs of 20,000 shots. All three configurations are built from the same transpiled circuit. The prose above calls them transpiler seeds; they are not, and it is worth being precise about what follows from the difference.

What the $\pm 0.0012$ does cover: sampling variation and the simulator's own noise realizations, at one fixed layout, one fixed routing, one fixed gate sequence.

What it does not cover: layout and routing variability. Chapter 39 §39.6 measured that separately on a 14-qubit circuit — 24 transpiler seeds spanning fidelity 0.5755 to 0.7911, a 2.03× spread in error — which is more than two orders of magnitude larger than the effect being measured here. Six transpiler seeds would have produced an error bar that swallowed the result whole.

And here is why the conclusion nonetheless holds: the comparison is paired. Because all three arms share one transpiled circuit, layout and routing are common-mode and cancel exactly from the difference. The narrow error bar is the correct one for the question "does DD help on this circuit?" It is the wrong one for "does DD help on circuits like this one," and nothing in §31.4 licenses the second reading.

There is a second common-mode term worth naming. Chapter 27 §27.5 measured the TVD of a perfectly correct GHZ(3) circuit at 0.00423 ± 0.00283 over 10,000 shots, scaling as $1/\sqrt{N}$ — that is the error of a circuit with nothing wrong with it. This chapter's circuit has up to 64 outcomes rather than GHZ's two, so its floor at 20,000 shots is larger, and this book did not measure it. Some unmeasured part of the $1 - 0.9288 = 0.0712$ deficit is therefore the estimator rather than the device. It is identical in all three arms, so it cancels from $-0.0053$ and does not cancel from $0.9288$. The difference is the trustworthy number in that table; the absolute is not.

The gate counts in that table are a coin flip

While re-deriving the arithmetic for this section, the transpiled circuit refused to reproduce.

   transpile(ansatz, FakeSherbrooke, optimization_level=2, seed_transpiler=7)
   96 transpiles across 12 fresh processes:

      75 / 96  (78.1%)   rz 83   sx 61   x 0   ecr 15   depth 54
      21 / 96  (21.9%)   rz 88   sx 62   x 1   ecr 15   depth 54

A fixed seed_transpiler does not make optimization levels 2 and 3 deterministic in Qiskit 2.5.1. Level 1, checked the same way, was identical on every repeat: rz 78, sx 60, ecr 15, depth 41. The variation persists with PYTHONHASHSEED pinned and occurs between repeated calls inside a single process, so it is not environment hashing.

Downstream, that propagates into §31.4's table: the XX-padded circuit is 20 x / 159 delays in the 78% case and 19 x / 155 delays in the other. The counts printed in the table are the majority outcome, not the only one.

Three things follow, and they are all more interesting than the bug.

First, the result is unaffected. ecr (15) and depth (54) — the quantities that carry almost all of the fidelity — are identical in both variants. One extra $XX$ insertion is worth roughly $2 \times 2.362\times10^{-4} = 4.7\times10^{-4}$, well inside the $\pm 0.0012$ error bar.

Second, the nondeterminism lands exactly where §31.1 said it would be free. Five rz gates and one sx↔x substitution: the transpiler's residual freedom is expressed almost entirely in the one gate that costs nothing. That is not luck — it is what a cost model that prices rz at zero should produce, and it means the compiler is behaving correctly while being irreproducible.

Third, this breaks a test somebody has written. Chapter 27 §27.2 priced exact assertions at 174,000 per CI-minute and recommended them. An exact assertion on count_ops()['rz'] would go red about one run in five, with no code change, and the bisection in Chapter 26 would find nothing. Assert on ecr count and depth, which are stable; do not assert on the free gates, which are where the compiler keeps its slack.

📊 And note how the sample size behaved. The first check ran 10 processes and saw 9-to-1, which reads as 90/10. Ninety-six transpiles put it at 78/22. The small sample was off by more than a factor of two on the minority rate, in the direction that would have made the effect look rarer than it is.

Chapter 40 §40.4 tabulates seven occasions on which this book drew a conclusion from too small a sample and had to correct it in print. This is the eighth, and it happened while writing the paragraph that warns about it.

Is the obvious reading even arithmetically right?

"DD costs more in gate error than it saves" is a quantitative claim, and the chapter has the numbers to check it rather than assert it.

The device's median single-qubit gate error is $2.362\times10^{-4}$. If added $X$ pulses fail independently, the predicted fidelity cost of $n$ of them is $1 - (1-p)^n$:

   sequence   x added   predicted 1-(1-p)^n    measured   measured / predicted
   XX              20              0.0047       0.0053                  1.13
   XY4             36              0.0085       0.0057                  0.67

For XX the independent-error model is right to within 13%. That is a genuinely good fit for a first-principles estimate with no fitting parameters, and it is the strongest evidence in the chapter that in this simulation DD is doing nothing but adding gates.

For XY4 the model overshoots by 49%, and the discrepancy is not noise. Scale XX's measured cost by pulse count — $-0.0053 \times 36/20 = -0.0095$ — against a measured $-0.0057$. The gap of $0.0038$ is more than three times the $0.0012$ standard error. A strictly additive gate-error model is rejected.

Turn it around and the same fact is starker:

   XY4 vs XX:  -0.0004 +/- 0.0014   ->  0.29 standard errors   NOT SIGNIFICANT

Eighty percent more decoupling pulses produced no measurable additional harm. Both sequences differ significantly from no-DD; neither differs measurably from the other.

Two candidate explanations, offered as such:

Saturation. $1-\text{TVD}$ against a fixed reference is bounded — as the noisy distribution drifts toward uniform over 64 outcomes, the distance stops growing, so equal increments of error move the score by less and less. A metric with a floor cannot be linear in error, and this one is being read near enough to the floor to notice.

Displaced idle. Every inserted $X$ pulse occupies 56.9 ns that was previously a delay. XY4's 16 extra pulses displace $16 \times 56.9 = 910$ ns of idle exposure across the circuit — but spread over six qubits against a 170 μs $T_2$ that is worth around $9\times10^{-4}$, which is the right sign and roughly a quarter of the size needed. It contributes; it does not close the gap.

We did not chase the residual, and the reason is the subject of §31.5: in a model that omits the phenomenon under study, fitting the leftovers is fitting noise about noise. The finding that survives is the one that matters — even the cost side of the argument, the half everyone agrees is simple, does not behave the way the obvious reading assumes.

31.5 Why the simulator cannot answer this question

Look at what is actually in the noise model:

   AerSimulator.from_backend(FakeSherbrooke)
     noisy instructions:   ['ecr', 'id', 'measure', 'reset', 'sx', 'x']
     error channels:       thermal relaxation (T1/T2), depolarizing, readout

Every one of those channels is Markovian — memoryless, with each instant's noise independent of every other instant's.

Dynamical decoupling does not work against Markovian noise. It works by refocusing correlated, low-frequency dephasing: $1/f$ flux noise, slow frequency drift, static coupling to spectator qubits — errors whose sign is predictable over the timescale of the pulse sequence, so that flipping the qubit halfway through makes the accumulated phase cancel. A memoryless channel has no such structure. There is nothing for the refocusing pulse to refocus.

📐 Math Aside: the refocusing identity, and exactly what it requires.

A qubit idling for time $T$ with a fluctuating detuning $\delta\omega(t)$ accumulates a phase

$$\varphi(T) \;=\; \int_0^{T} \delta\omega(t)\, \mathrm{d}t$$

and the surviving coherence is $|\langle e^{i\varphi}\rangle|$, averaged over realizations of the noise. Now insert a single $\pi$ pulse at the midpoint — the Hahn echo, of which XX is the two-pulse version. The pulse flips the qubit, which flips the sign of subsequent accumulation:

$$\varphi_{\text{echo}}(T) \;=\; \int_0^{T/2} \delta\omega\, \mathrm{d}t \;-\; \int_{T/2}^{T} > \delta\omega\, \mathrm{d}t$$

Two limits, and they are the whole argument.

Static offset. If $\delta\omega$ is constant across the window — a frequency shift from slow flux drift, or a spectator qubit sitting in $|1\rangle$ — then the two integrals are equal and $\varphi_{\text{echo}} = 0$ exactly. Not reduced: cancelled. This is why the technique exists.

Memoryless noise. If $\delta\omega(t)$ is white, the two half-window integrals are independent, zero-mean random variables. Variances of independent terms add regardless of sign, so

$$\mathrm{Var}[\varphi_{\text{echo}}] \;=\; \mathrm{Var}\!\left[\int_0^{T/2}\right] + > \mathrm{Var}\!\left[\int_{T/2}^{T}\right] \;=\; \mathrm{Var}[\varphi_{\text{free}}]$$

The echo changes nothing. The dephasing is identical with and without the pulse, and the pulse still costs its own error.

The general statement is the filter function. For Gaussian dephasing with noise power spectrum $S(\omega)$, the coherence decays as $e^{-\chi}$ with

$$\chi \;=\; \frac{1}{2\pi}\int_0^{\infty} \frac{S(\omega)}{\omega^{2}}\, \bigl|F(\omega T)\bigr|^{2} > \, \mathrm{d}\omega$$

where $F$ depends only on the pulse timings. Free evolution has a filter that passes $\omega \to 0$; every decoupling sequence has $F(0) = 0$ and passes a band near its pulse repetition rate. Dynamical decoupling is a high-pass filter applied to the noise spectrum.

That reduces the question to one line. Against $1/f$ noise — where the power diverges at low $\omega$ and the integrand is concentrated exactly where $F$ vanishes — DD removes nearly all of it. Against white noise, $S(\omega)$ is flat: there is as much power in the pass band as in the stop band, and filtering moves nothing.

Aer's thermal-relaxation channel is the flat case. So the sign of §31.4's result was fixed before a single shot was taken, and no amount of tuning the sequence, the spacing, or the idle length could have changed it.

So in this simulation, DD can only add the error of its own $X$ gates — and the measurement confirms it does, significantly, at every idle length tested.

🔬 Honest Assessment: this result is a property of the simulator, not of dynamical decoupling.

DD is the one technique in this book that cannot be evaluated on a noise model, because the thing it corrects is not in the model. A Markovian simulator will report DD as harmful every single time, with tight error bars and perfect reproducibility, and the report will be meaningless.

Its benefit is real and it is measured on hardware, where $1/f$ noise exists. To evaluate it you must run on hardware, or use a simulator with explicitly correlated noise — which AerSimulator.from_backend is not.

Where DD would help, and by how much

"Not evaluable here" is not the same as "unknowable," and the chapter's own numbers bound the answer from both sides. This is the arithmetic to do before buying hardware time.

The ceiling. §31.2 derived $T_\varphi = 244.7$ μs and showed $T_2$ sitting at 30.5% of its $2T_1$ ceiling. Perfect decoupling — every bit of pure dephasing refocused — takes $T_2$ from 170.0 μs to at most 556.8 μs. Translate that into what the circuit would feel, using $1 - e^{-\tau/T_2}$ as the dephasing exposure of a 7.0969 μs circuit:

   exposure at the measured T2 = 170.0 us       0.0409
   exposure at the 2*T1 ceiling = 556.8 us      0.0127
   ------------------------------------------------------
   maximum recoverable by ANY decoupling         0.0282
   DD's measured cost in this simulation         0.0053
   ratio                                         5.3x

The prize is 5.3× the cost. That is the honest framing of the question §31.4 could not answer: DD is not a marginal proposition on this device, it is a 5-to-1 bet — if the dephasing is correlated enough to refocus.

The break-even. Invert it. DD costs 0.0053 and the circuit's total dephasing exposure is 0.0409, so

$$\text{break-even} \;=\; \frac{0.0053}{0.0409} \;=\; 13.0\%$$

Refocus one-eighth of the dephasing and DD has paid for itself. On hardware, where the low-frequency part of the spectrum is typically the dominant part, one-eighth is a low bar. The measured $-0.0053$ does not argue against clearing it; it does not bear on the question at all.

How it scales. The two sides scale differently, which is what determines when the answer flips:

   DD's cost        ~ (number of idle WINDOWS) x (pulses per window) x (gate error)
   DD's benefit     ~ (total idle DURATION)    x (correlated fraction of dephasing)

The cost tracks window count; the benefit tracks window length. So the case for DD improves with every microsecond a qubit waits and worsens with every additional place it has to wait. A circuit with the same structure but ten times the idle time carries ten times the recoverable dephasing at roughly the same pulse cost — a break-even of 1.3% rather than 13%. The regime where DD is unambiguous is long idle windows, few of them: a qubit parked while a neighbour runs a long subroutine, a mid-circuit measurement's classical latency (Chapter 9), or a syndrome-extraction round waiting on readout (Chapter 25 §25.7, where measure at 1,216 ns dominates the cycle).

The regime where it is marginal is this chapter's circuit: 34% idle by the honest denominator, spread across many short windows, on a device where gate error already binds.

🧪 Run It: the two experiments that would actually settle this.

The cheap one, in simulation. Exercise 31.28's build: sample a static frequency offset $\delta\omega \sim \mathcal{N}(0, \sigma^2)$ once per shot, apply it as an rz of angle $\delta\omega\,\tau$ on each idle window of length $\tau$, and average over shots. That single change — drawing the offset per shot rather than per instant — is the entire difference between a memoryless channel and a correlated one, and it is enough to make the echo work. Run the §31.4 comparison against it. Predicted outcome: XX beats no-DD, and the margin grows with $\sigma\tau$ until the pulse errors dominate. That is a prediction, not a result; this book did not run it.

The real one, on hardware. Do not rebuild the transpiler pass. Chapter 39 §39.7's primitives layer exposes decoupling as a runtime option:

python sampler.options.dynamical_decoupling.enable = True sampler.options.dynamical_decoupling.sequence_type = "XpXm" # or "XX", "XY4"

Submit the same circuit twice in one job, once with enable = True and once without, interleaved rather than sequentially, because Chapter 39 §39.6's calibration drift will otherwise be confounded with the effect. Six repetitions, error bars on the difference, and the answer to the question this chapter opened costs a few minutes of QPU time.

💰 Cost and Queue: what asking the question properly costs.

§31.4 as run: 20,000 shots × 6 seeds × 3 configurations = 360,000 shots. At the circuit's measured 7.10 μs, that is

text execution time 2.55 s of device time at Chapter 39's ~$96/min $4.09

Four dollars. The experiment that Part V's sharpest result rests on is, in device terms, essentially free — which is the point Chapter 39 §39.3 makes from the other direction: the device is never the expensive part.

The expensive part is the shape of the submission:

text 18 separate jobs, 5-minute queue 90 minutes 2,114x the compute time 1 batched job, 5-minute queue 5 minutes 117x the compute time

An 18× saving from a decision that has nothing to do with quantum computing. Chapter 39's conclusion holds here exactly: batching outranks every transpiler setting in this chapter, and the first question about a slow hardware experiment is "how many jobs?" rather than "how deep is the circuit?"

Note what this does to the economics of the negative result. The measurement §31.4 reports cost about four dollars and five minutes and it produced the most-cited finding in Part V. Cheap experiments that could embarrass you are the best value in the field, and Chapter 40 §40.3's scorecard is largely built from them.

This is the sharpest instance in the book of a pattern Part V has returned to repeatedly:

• Chapter 25: a QEC test storing an eigenstate of its own failure mode.
• Chapter 26: a bisection whose default input could not see the bug.
• Chapter 27: three of four oracle-free properties passing a broken circuit.
• Chapter 29: a layout chosen by connectivity alone, routing through dead edges.
• Chapter 30: a benchmark robust to readout error, silent when readout error broke everything.
• Chapter 31: a simulator with no correlated noise, reporting that decoupling correlated noise does not help.

Every one is a measurement that cannot detect the thing being asked about, and in every case the blindness was a documented property of the method sitting in plain sight. Chapter 26 §26.1's rule — debug on a simulator, validate on hardware — has a corollary this chapter supplies: some questions cannot be asked of a simulator at all.

The most trustworthy measurement in the book, and it is still wrong

There is a property of $-0.0053 \pm 0.0012$ worth stating plainly, because it is unusual and because it cuts against the conclusion just reached.

Nobody wanted that number. Trace the incentives backwards. The chapter was planned as a qiskit.pulse tour and lost its subject on the first import. Dynamical decoupling was the salvage — the one remaining technique that could carry a chapter about time. The idle fraction said 97%, which made a win look almost arithmetically guaranteed. DD is standard practice, endorsed by the vendor, enabled by one line. A result reading "decoupling recovered 2% of fidelity" would have been tidy, publishable, and completely unremarkable. A result reading "decoupling made it significantly worse" invites the reader to assume you configured it wrong.

Every pressure in the situation pushed toward a positive finding, and the measurement produced a negative one anyway. By the standard Chapter 40 §40.6 recommends applying to other people's work — what is the most interesting negative result your team has produced? — this is as good as evidence gets about the process that generated it.

And it is still not evidence about dynamical decoupling.

That pairing is what makes §31.4 unique in this book. Everywhere else, the unwanted result was also the correct one. Chapter 27's false-failure rate really was 0.150% and not 1.0%. Chapter 33's reuploading classifier really did lose to kNN by 9 standard errors. Chapter 37's QAOA really did win zero of ten instances. In every one of those cases, "the measurement resisted the measurer's wishes" and "the measurement was valid" pointed the same way, and it became easy to treat them as one property. They are two properties, and this chapter is where they come apart.

   did the result resist the person who wanted it otherwise?      YES, completely
   could the instrument respond to the quantity being asked about?  NO, not at all

The practical consequence is a gap in the field's filtering. Publication bias selects on direction — positive findings are easier to publish, so a negative one that reaches print has usually survived somebody's wish that it hadn't. That selection is real and it is why Chapter 40 §40.3 treats negative results as the field's most valuable output. But it filters on direction, not on instrument sensitivity. A well-executed measurement of a model that omits the phenomenon passes every filter the community applies, in either direction.

So the honest citation of §31.4 is narrow and it should be quoted this way:

On a Markovian noise model derived from a 127-qubit superconducting backend, inserting XX decoupling into the idle windows of a 6-qubit ansatz reduced $1-\text{TVD}$ by $0.0053 \pm 0.0012$.

Every word of that is true, and it is a statement about Aer. The sentence people will actually write down — "dynamical decoupling was measured not to help" — is not supported by it, and nothing in the numbers distinguishes the two readings. Only knowing what was in the model does.

Chapter 40 §40.4's first checklist question is "Compared to what?" This chapter supplies the question that has to be asked immediately after it, and the two failures it catches are different:

"Measured with what — and can that instrument see the thing?"

The first question catches a weak baseline. The second catches a blind one. Part V found six instances of the blind instrument; the weak baselines are almost all in Part VI, where there was a classical method to compare against. That split is itself informative: engineering chapters fail by measuring with something that cannot see, and results chapters fail by measuring against something that cannot win.

31.6 Why the pulse API went away

Not because pulse control stopped mattering. Because the abstraction did not hold.

It was device-specific in a way that could not be papered over. A pulse schedule written for one superconducting backend is meaningless on another, and completely meaningless on trapped ions (Chapter 17). Qiskit's other abstractions survive a change of hardware; this one could not.

It was a maintenance burden disproportionate to its use. The overwhelming majority of users never touched it, and the small number who did were largely calibration teams working inside the vendor with access to better tools.

And the hardware moved. Fractional gates, parametrized native operations, and richer Target metadata cover many cases that previously required dropping to pulses. The vendor-side control stacks (Qiskit Dynamics, and OpenPulse-derived interfaces exposed selectively) still exist for those who genuinely need them.

What actually replaced it: the primitives layer

The maintenance-burden argument is true and it is not sufficient on its own. Libraries carry unpopular modules for years. What made deletion possible was that the things people actually did with pulses had already moved somewhere else — up, into the job submission, rather than down into the hardware.

Look at what qiskit-ibm-runtime 0.48.0 exposes on a primitive:

   SamplerOptions fields:
     default_shots, max_execution_time, environment, simulator,
     dynamical_decoupling, execution, twirling, experimental

   DynamicalDecouplingOptions:
     enable                  bool
     sequence_type           Literal['XX', 'XpXm', 'XY4']
     scheduling_method       'alap' | 'asap'
     extra_slack_distribution
     skip_reset_qubits

Every knob §31.3 assembled by hand out of transpiler passes is a field on the job. ALAP versus ASAP, the decoupling sequence, the slack distribution, whether to skip reset qubits — the same decisions, relocated from a PassManager you build to a dataclass you fill in. Chapter 39 §39.7 walks through the rest of that layer; this is the piece of it that belongs to Chapter 31.

Then look at the one entry in sequence_type that §31.3's pass does not offer.

XpXm is not XX. It is a $+\pi$ rotation followed by a $-\pi$ rotation — two pulses that each flip the qubit and together return it, exactly like XX, but driven with opposite phase. The difference is what happens when the pulse amplitude is miscalibrated. If each nominal $\pi$ pulse actually rotates by $\pi(1+\epsilon)$, then

   XX     rotates by  +pi(1+eps) +pi(1+eps)  =  2pi + 2*pi*eps      error ACCUMULATES
   XpXm   rotates by  +pi(1+eps) -pi(1+eps)  =  0                   error CANCELS to first order

That is a pulse-level correction, and it is exposed as a string in a config object. It is the clearest available statement of what the removal actually did: not less control, but control relocated to the side of the API where the people who own the calibration data can implement it correctly for a chip you will never characterize yourself.

Which is the real trade, and it is worth naming honestly rather than celebrating.

You lost the ability to do the thing nobody anticipated. A pulse API is general: it lets you build a sequence its authors never imagined, which is exactly what the research code in Case Study 1 was doing. That capability is gone and no config field replaces it.

You gained the anticipated things, correct by construction. XpXm on hardware you cannot calibrate, with alignment constraints honoured, timed against the current calibration rather than a snapshot — implemented once, by the vendor, rather than approximately, by every user.

The removal traded generality for correctness. For the overwhelming majority of users that is the right trade, and the fact that it is right is precisely why you need to know if you are the exception.

One cost is easy to miss. Decoupling applied through the runtime option happens server-side, after your circuit leaves. You cannot count the added pulses, you cannot inspect the padded circuit, and you cannot reproduce it locally — which is Chapter 39 §39.8's problem exactly: a result you cannot re-run. The transpiler pass this chapter measured is worse in every respect except one. It is the version you can look at, which is the only reason §31.4 has a table of gate counts to be nondeterministic about.

🗝️ Version Note. qiskit.pulse was deprecated across the 1.x series and removed in Qiskit 2.0. QuantumCircuit.add_calibration, QuantumCircuit.calibrations, backend.defaults(), backend.instruction_schedule_map, and the channel accessors went with it. What remains is target.dt, target[gate][qubits].duration, qubit_properties[q].t1/.t2, and the scheduling and padding passes.

Check the current state before relying on any of this. The pulse story is the clearest example in this book of an API that was documented, tutorialized, built on — and then deleted.

The lesson for your own code

An API being present, documented, and demonstrated is not a commitment. Chapter 24 found shots= on a PennyLane device deprecated. Chapter 19 found mcx(mode="v-chain") removed in Qiskit 2.1. Chapter 28 found basis_gates=['h','barrier'] newly rejected. This chapter found an entire subsystem gone.

The defence is Chapter 27's: a test suite that exercises the APIs you depend on will tell you when one disappears, at upgrade time rather than in production. The cost of writing it is small. The cost of discovering a removal from a failing user report is not.

31.7 What Part V adds up to

Six chapters of engineering, and they compose into a single ordering:

   Ch. 29  SHAPE      match the circuit to the chip       +0.1658
   Ch. 28  OPTIMIZE   let the transpiler do its work      +0.0262
   Ch. 31  SCHEDULE   place the idle time                 measurable, and
                                                          not evaluable in simulation
   Ch. 13  MITIGATE   correct what remains                -79% with the right ordering

Each layer is worth roughly an order of magnitude less than the one above it, and each is attempted, in practice, in the opposite order — because mitigation is a library call and shape is a design decision.

And underneath all four, the discipline:

   Ch. 26  DEBUG      exactly, on a simulator, before touching hardware
   Ch. 27  TEST       with properties a bug can violate and shots enough to see it
   Ch. 30  BENCHMARK  your circuit, not the device

Part VI turns to quantum machine learning, where every one of these constraints applies at once — and where Chapter 24's shot budget, Chapter 16's barren plateaus, and this chapter's coherence budget all arrive together, attached to a field with more claims than measurements.

What we measured

• qiskit.pulse does not exist in Qiskit 2.5.1, along with add_calibration, calibrations, backend.defaults, instruction_schedule_map, and the channel accessors. Removed in 2.0.
• target.dt = 0.2222 ns — every duration on the device is an integer multiple of it.
• Gate durations: sx/x 56.9 ns, ecr 341.3–881.8 ns (median 533.3), measure 1,216 ns — measurement is the slowest operation by more than 2×.
• ★ rz takes 0.0 ns. It is a virtual Z: absorbed into the phase of subsequent pulses, exact and free. The Chapter 29 ansatz's 83 rz gates cost nothing.
• T1 median 278.4 μs, T2 median 170.0 μs; $T_1/\text{ecr} = 522$ gates. At Chapter 12's 0.0075 error rate those 522 gates survive with probability 0.020 — gate error binds, not decoherence.
• A scheduled 6-qubit ansatz runs in 7.10 μs = 4.17% of $T_2$, with 97% of qubit-time idle.
• ★★ Dynamical decoupling measured significantly WORSE: XX $-0.0053 \pm 0.0012$, XY4 $-0.0057 \pm 0.0012$.
• ★★★ And that result is a property of the simulator. AerSimulator.from_backend builds a purely Markovian model; DD refocuses correlated, low-frequency dephasing, which is not in it. DD is the one technique in this book that cannot be evaluated on a noise model.
• The sample rate is 4.5 GSa/s exactly ($\mathrm{dt} = 1/4.5\,\text{GHz}$), median qubit frequency 4.7940 GHz, so an sx pulse spans 272.7 carrier cycles. target.granularity, pulse_alignment and acquire_alignment are all 16, and every gate duration on the device is a multiple of 16 dt = 3.5556 ns.
• Derived from the reported medians: $T_\varphi = 244.7$ μs, with $T_2$ at only 30.5% of its $2T_1$ ceiling. Perfect decoupling could therefore buy at most 3.28× on $T_2$ — DD does not touch $T_1$.
• The medians hide a 188× spread in $T_2$ (2.6–488.8 μs) against 7.0× in $T_1$ — twenty times wider than Chapter 30's 9.6× gate-error spread.
• ★ ASAP and ALAP gave identical duration, busy time and idle time — and 6,243.6 ns versus 0.0 ns of idle immediately before readout. Scheduling places idle; it does not remove it.
• ★ The 97% idle figure counts 121 untouched wires. Over the six qubits the circuit actually uses, the honest idle fraction is 34.47% — and PadDynamicalDecoupling already knew, placing 121 delays and zero $X$ gates on the unused wires.
• ★ transpile(..., seed_transpiler=7) is not deterministic at optimization levels 2 and 3: 96 transpiles gave rz 83 in 78.1% of runs and rz 88 in 21.9%, with ecr (15) and depth (54) identical throughout. The nondeterminism lands almost entirely on the free gate. Level 1 was stable on every repeat.
• Testing the "DD just costs its own gates" reading: the independent-error model fits XX to 13% and overshoots XY4 by 49%; scaling XX's cost by pulse count is rejected at more than three standard errors; and XY4 vs XX is $-0.0004 \pm 0.0014$, 0.29 SE — not significant. 80% more pulses, no measurable extra harm.
• What DD is worth if the dephasing is correlated: maximum recoverable 0.0282 against a cost of 0.0053 — a 5.3× prize, with break-even at refocusing just 13.0% of the dephasing.
• The whole experiment is 360,000 shots = 2.55 s of device time ≈ $4.09 at Chapter 39's rate; as 18 jobs behind a five-minute queue it is 90 minutes, and batched it is 5.

The theme: some questions cannot be asked of a simulator at all — and an API being documented, tutorialized, and built upon is not a commitment that it will exist next year.