Noise and Reliability

13.1 Noise Models

An X gate should turn \(\ket0\) into \(\ket1\), yet a noisy device sometimes reports 0. Where did the error happen: in the gate, in the readout, or only in our finite sample? Before trying to correct anything, we need a model that separates these causes and predicts their effect. We define the two kinds of error first, then build a simulation that applies one of them.

13.1.1 Gate and readout errors

What can go wrong between the X gate and the reported bit? Either the gate leaves the qubit in a different state, or the state is right and the readout reports the wrong label. The first is a gate error, which changes the quantum state before measurement. The second is a readout error, which changes only the classical record.

A simple model of a gate error is depolarizing noise. With probability \(1-\lambda\) the gate acts correctly, and with probability \(\lambda\) the qubit is replaced by the completely random state \(I/2\). In density-matrix form, \(\mathcal E(\rho)=(1-\lambda)\rho+\lambda I/2\). The companion uses \(\lambda=0.1\) after X.

What probability of 1 should we then see? The intended state is \(\ketbra11\), so the noisy state is \(0.9\ketbra11+0.1\,I/2\). Its probability of 1 is \(0.9\cdot1+0.1\cdot\tfrac12=0.95\). So the parameter 0.1 is not the probability of a wrong bit. Half of the random replacements still give 1, and the wrong-bit probability is 0.05. A model’s parameter means only what its convention says.

13.1.2 Constructing noisy simulations

How do we tell a simulator to apply this error? Aer’s NoiseModel attaches errors to instructions by name. add_all_qubit_quantum_error(depolarizing_error(0.1, 1), ["x"]) says: after every x instruction on any qubit, apply one-qubit depolarizing noise of strength 0.1.

That attachment by name has a trap. Compilation can remove an instruction or replace it by others. If the compiled circuit no longer contains an x, an error attached to x never acts, and the simulation looks cleaner than intended. So we inspect the compiled circuit. The companion compiles with optimization_level=0, which makes no simplifications, and uses an X that the simulator supports directly, so the error stays attached where we put it.

A chosen noise model is a hypothesis about a device’s errors. It is not a calibrated description of any particular device.

13.2 Reliability Techniques

Knowing how noise acts, can we do anything about it? There are two broad answers. We can try to make fewer errors happen during the run, or we can accept the errors and correct the estimated quantity afterwards. Each works only under assumptions about the noise. We take reduction during the run first, then correction afterwards.

13.2.1 Error suppression

How can a program make fewer errors happen? The plainest ways reduce exposure. A better layout avoids swaps, and a shorter circuit gives noise less time and fewer gates to act on. Reducing errors during execution in such ways is called error suppression.

A less obvious method targets qubits that wait. Suppose an idle qubit slowly picks up an unwanted Z rotation \(R_z(a)\) during each half of its waiting time. If we apply X in the middle and again at the end, the total is \(X\,R_z(a)\,X\,R_z(a)\). Since \(XZX=-Z\), conjugating by X reverses the rotation, \(XR_z(a)X=R_z(-a)\), so the total is \(R_z(-a)R_z(a)=I\). Inserting such pulses into idle periods is called dynamical decoupling. It works only if the unwanted rotation stays the same over the waiting time.

That condition shows the general rule. A suppression technique adds operations and time, and if its assumption fails, the added gates can make the result worse. So we compare against a baseline run without the technique, and count the operations and duration it added.

13.2.2 Error mitigation and its assumptions

Suppose instead we accept the errors and correct the estimate afterwards. Estimating an ideal quantity from noisy data in this way is called error mitigation. It works by calibration, by inverting a model of the noise, or by extrapolating from runs at increased noise. How much can it recover, and at what price? Readout errors give a case we can compute exactly.

Suppose each reported bit is flipped with probability \(e\), the same for 0 and 1. A shot that should give \(s=\pm1\) then reports \(s\) with probability \(1-e\) and \(-s\) with probability \(e\). Its expected reported value is \((1-e)s-es=(1-2e)s\), so \[\langle Z\rangle_{\text{observed}}=(1-2e)\,\langle Z\rangle_{\text{true}}.\] If we know \(e\), dividing the observed mean by \(1-2e\) corrects it.

The price is variance. Dividing an estimate by \(1-2e\) multiplies its variance by \(1/(1-2e)^2\). As \(e\) approaches one half, the factor grows without bound, because the reported bits then carry almost no information. In practice \(e\) is itself estimated by calibration, so its uncertainty, and its drift between calibration and run, add to the error. The correction is right only if the model is right.

13.3 Interpreting Discrepancies

We can now name four possible causes for a result that disagrees with its prediction: a wrong program, an approximate circuit, random shots, and noise that our model does not describe. How do we decide which one is responsible, and what may we claim once we have? We set out the order of diagnosis first, then what a report must include.

13.3.1 Noise, approximation, and sampling

Suppose the noisy X run gives \(P(1)=0.90\) instead of 0.95. Where do we look first? We work through the causes from the most controlled experiment to the least. An exact simulation tests the program’s logic, with no sampling and no noise. If the circuit is approximate by design, its known error bound tells us how far the exact result may legitimately move. A sampled ideal simulation adds only shot noise, whose size we can derive. Only then does a noisy simulation test the noise model, and a device test the device.

Each step changes one thing, so a discrepancy that first appears at some step points to what that step added. More shots shrink the random fluctuation, but they cannot repair a biased model. Comparing an exact simulator directly with noisy hardware skips every step, and its disagreement diagnoses nothing.

13.3.2 Bias, uncertainty, and reporting limits

What does the companion actually establish? It runs 8192 simulated shots and compares the frequency of 1 with the predicted 0.95. The standard error is \(\sqrt{0.95\cdot0.05/8192}\approx0.0024\), so the tolerance of 0.03 is about 12 standard errors and deliberately generous. With seed 31 the run gave 0.9485.

The check confirms that the simulator applies the model we wrote down, with the convention we derived. It does not show that depolarizing noise describes any device. Nor is its tolerance a confidence interval suitable for other experiments. So with the output we report the model, its parameter convention, the instructions it is attached to after compilation, the seed and the number of shots. A comparison with hardware would add a device, a time and a calibration, and it would need all the records of a hardware run.

"""Runnable companion for Quantum Programming, Chapter 13."""
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit, transpile
from qiskit_aer.noise import NoiseModel, depolarizing_error

qc = QuantumCircuit(1)
qc.x(0); qc.measure_all()
noise = NoiseModel()
noise.add_all_qubit_quantum_error(depolarizing_error(0.1, 1), ["x"])
sim = AerSimulator(noise_model=noise, seed_simulator=31, max_parallel_threads=1)
counts = sim.run(transpile(qc, sim, optimization_level=0), shots=8192).result().get_counts()
p1 = counts.get("1", 0) / 8192
# E(rho) = .9 rho + .1 I/2, so expected P(1) = .95.
assert abs(p1 - 0.95) < 0.03
print("Simulated P(1):", p1, "analytic prediction: 0.95")

Companion script: chapter_13.py.

So far a person read each result and decided what to do next. Some programs let a classical optimizer make that decision, using estimates from a quantum circuit at every step. How do quantum measurements guide a classical optimization loop, and what does the noise in each estimate do to it?

Sources and further study: IBM, noise model construction.