Learn the device's noise.
Sign it. Then mitigation binds it.
Learn a model of a device's noise, which error mitigation then uses, named by its hash.
Error mitigation's highest-fidelity methods don't run on a fidelity number — they run on a
learned noise model: the sparse Pauli–Lindblad model, whose rates are estimated by
Cycle Benchmarking and Cycle Error Reconstruction. Twirling a repeated gate cycle
turns its noise into a Pauli channel; the coherence each Pauli retains over cycle depth measures its
fidelity f_a = exp(-2 Σ λ_k); and the model's rates invert out of the fidelities by a
linear solve.
Here it is in pure integer Rust, byte-identical on every machine, recovering a hidden
device's rates from a simulated experiment. It seals the signed model — and its content hash is
exactly the noise_model_hash a wai.quantum.mitigate receipt binds. So this
is the producer for that hook: learn the model, sign it, and a probabilistic-error-cancellation
of a Pauli observable binds the exact model it used. Scope: a Pauli-channel model on a
simulated cycle (no QPU); what is exact is the reconstruction and the receipts.
Cycle Error Reconstruction · sparse Pauli–Lindblad model
The loop close · PEC bound to the learned model
The characterization deliverable that mitigation consumes — signed end-to-end
The reconstruction panel recovers the rate λ_k of every sparse generator (each weight-1
Pauli and each weight-2 Pauli on the qubit connectivity) from a bank of Pauli-fidelity measurements,
by a positivity-preserving multiplicative solve of -½ ln f_a = (M λ)_a — the learned
bars track the hidden truth it was never told. The loop-close panel then uses that model: a
Pauli observable attenuated by the channel is restored by PEC, ⟨P⟩_ideal = ⟨P⟩_noisy / f_P,
and the mitigation receipt's noise_model_hash is exactly the learned model's hash — the
hash wai.quantum.mitigate takes a noise model by. Every step
hashes identically on every machine and carries a signed receipt. A learned noise model
you can put in an auditor's hands, reproduce from the git repo, and bind a mitigation to.
Where it lives. The learned model is sealed as a wai.quantum.calibration
receipt, which is in the standard (the quantum-ops extension). The noise-learning and mitigation
engines are reference code in the open-standards repo, Apache-2.0.
Energy: not metered. Receipts sealed in this tab carry a placeholder joule value, so the page shows none.