Case Study 2: The Technique the Simulator Could Not Judge

A well-founded decision

A team is running variational circuits on hardware. Scheduling their circuit reveals something striking:

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

Ninety-seven percent of qubit-time is spent waiting. Six qubits are active, the rest of the circuit is one qubit doing something while five decohere.

Dynamical decoupling exists precisely for this. Fill the idle windows with pulse sequences that are the identity overall — XX, or the four-pulse XY4 — and refocus the dephasing accumulated while the qubit waits. It is standard practice, it is a one-line transpiler pass, and the idle fraction says it should be worth a lot.

They do the responsible thing and test it on a noise model built from the device before spending hardware time.

   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. Six transpiler seeds, tight error bars, perfectly reproducible. They also test a deliberate 20 μs idle window — 12% of $T_2$, where decoupling should have every advantage — and the gap widens.

The conclusion writes itself: DD costs more in added gate error than it saves in dephasing, at least at our circuit's timescales. They drop it, and document why.

The conclusion is wrong

Not the arithmetic. The arithmetic is correct: 20 extra $X$ gates at a median error around $2.4\times 10^{-4}$ do cost something, and in this simulation nothing offsets it.

The error is in what the simulation is capable of representing.

   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 — the noise at each instant is statistically independent of the noise at every other instant.

Dynamical decoupling does not work against Markovian noise. It cannot. The mechanism is refocusing: if a qubit accumulates phase at some rate, and you flip it halfway through the idle window, the phase accumulated in the second half cancels the phase accumulated in the first. That cancellation requires the accumulation rate to be roughly the same in both halves — that is, the noise must be correlated over the timescale of the sequence.

Real devices have exactly that: $1/f$ flux noise, slow qubit-frequency drift, static coupling to spectator qubits. All are low-frequency, all are correlated over microseconds, and all are what DD was invented to cancel.

A memoryless channel has none of it. The phase accumulated in the second half of the window is statistically independent of the first. Flipping the qubit does not cancel anything, and the flip itself carries error.

🔬 Honest Assessment: the measurement is a property of the simulator, not of the technique.

A Markovian simulator will report dynamical decoupling as harmful every single time, with tight error bars and perfect reproducibility, at every idle length, for every sequence — and the report will be meaningless.

DD is the one technique in this book that cannot be evaluated on a noise model, because the thing it fixes is not in the model.

The uncomfortable part

Every quality marker of a good measurement was present.

The team used six seeds. They reported a standard error. They tested at multiple idle lengths. They checked significance at 2σ. They tested two different sequences and got consistent answers. By the standards this book has spent six chapters establishing, it is an exemplary experiment.

Chapter 27 §27.5's discipline — report an error bar, use enough shots, check both error rates — protects against noise in the measurement. It does not protect against a model that omits the phenomenon under study. No amount of statistical rigour recovers information that was never in the data.

A well-executed measurement of the wrong model is not a partial answer. It is a confident wrong answer, and it is more dangerous than no measurement, because it comes with error bars.

What they should have done

Ask what is in the model before trusting what comes out of it. One line:

NoiseModel.from_backend(backend).noise_instructions

and the knowledge that Aer's backend-derived models contain thermal relaxation, depolarizing error, and readout error — all Markovian. Then ask: is the effect I am testing for present in any of those channels? For DD the answer is no, and the experiment is over before it starts.

Then run it on hardware. DD's benefit is real and it is measured — on devices, where $1/f$ noise exists. This is one of the cases where Chapter 26 §26.1's rule has to be inverted: normally you debug on a simulator and validate on hardware, but here the simulator cannot even be asked.

Or simulate correlated noise explicitly. It can be done — stochastic Hamiltonian simulation with a $1/f$ spectrum, or Qiskit Dynamics — and it is a great deal more work than AerSimulator.from_backend. The effort is the point: the cheap simulation is cheap partly because it omits this.

The project module makes the refusal structural:

def evaluate_dynamical_decoupling(noise_model=None, **_):
    if noise_model is None or noise_model_is_markovian(noise_model):
        return DDEvaluation(verdict=DDVerdict.NOT_EVALUABLE, reason=...)

It does not return a number. It returns NOT_EVALUABLE, with the reason, the measurement it is declining to trust, and where the question can be answered.

Where this sits in Part V

Six chapters, six versions of the same shape:

   Ch. 25   a QEC test storing an eigenstate of its own failure mode
   Ch. 26   a bisection whose default input could not see the bug
   Ch. 27   three of four oracle-free properties passing a broken circuit
   Ch. 29   a layout chosen by connectivity alone, routing through dead edges
   Ch. 30   a benchmark robust to readout error, silent when readout error broke everything
   Ch. 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, deliberate property of the method, stated plainly in its own description — "SPAM-robust," "Markovian noise model," "worst-case guarantee," "self-inverse."

The recurring failure in this book is not wrong code. It is trusting an instrument without reading what it is insensitive to.

The lessons

Read what a model omits before trusting what it reports. Aer's backend models are Markovian, and that is written down.

Statistical rigour cannot rescue a model that lacks the phenomenon. Six seeds and a 2σ test made this wrong answer more convincing, not less.

Some questions cannot be asked of a simulator. Chapter 26's "debug on a simulator, validate on hardware" has a corollary, and this is it.

Return NOT_EVALUABLE rather than a number. A tool that cannot answer should say so, name why, and point at where the answer lives.

Reproduce it: code/example-02-dynamical-decoupling.py measures the idle fraction, runs both DD sequences, reports the significant negative result, and then inspects the noise model to explain why the result cannot be trusted. evaluate_dynamical_decoupling in code/vqelab/timing.py refuses, and test_the_refusal_explains_itself_and_names_the_alternative asserts that the refusal quotes the measurement it is declining to trust.