> ## Documentation Index
> Fetch the complete documentation index at: https://docs.classiq.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Publicly Available Noise Models

Classiq hosts public logical noise models that any user can reference **by name**, with no
simulation to run yourself. This is the fastest way to get started — retrieve one with
`get_logical_noise`:

[comment]: DO_NOT_TEST

```python theme={null}
from classiq.error_correction import get_logical_noise

logical_noise = get_logical_noise("public/google_willow_like")
```

More public models can be added by request, and will be introduced over time. To model
hardware that none of them describes, build your own instead — see
[Custom Noise Models](/user-guide/error-correction/logical-noise).

## The models

| Name | Character | Λ (X) | Λ (Z) | Λ (S) |
| - | - | - | - | - |
| `public/depolarize_1e-3` | Uniform depolarizing, `p = 1e-3` | 4.80 | 4.88 | 6.22 |
| `public/google_willow_like` | Superconducting, error-correction tuned | 1.30 | 1.29 | 1.62 |
| `public/ibm_heron_r2_like` | Superconducting, long coherence, slower readout | 1.14 | 1.17 | 1.41 |

`Λ` is the error-suppression factor per two units of code distance — how much the logical
error rate improves each time you grow the code. Larger is better, and `Λ ≤ 1` means the
code no longer suppresses errors at all.

<Note>
  The two device-flavored models are **illustrative reference points, not vendor calibration
  snapshots**. They are rounded from published figures to give you a feel for how real
  superconducting hardware behaves; they are not tracked against any vendor's live
  calibration data, and no vendor publishes every parameter the engine needs.
</Note>

### Physical parameters

| Field | `depolarize_1e-3` | `google_willow_like` | `ibm_heron_r2_like` |
| - | - | - | - |
| `idle` | 1e-4 | 6e-4 | 3e-4 |
| `long_idle` | 2e-3 | 7e-3 | 6e-3 |
| `clifford_1q` | 1e-4 | 3.5e-4 | 3e-4 |
| `clifford_2q` | 1e-3 | 3.3e-3 | 4e-3 |
| `measure` (`X` and `Z`) | 5e-3 | 7.7e-3 | 1e-2 |
| `R` / `RX` | 2e-3 | 2e-3 | 1e-2 |

See [Custom Noise Models](/user-guide/error-correction/logical-noise) for what each field
means and which rules it accepts.

## `public/depolarize_1e-3`

A general-purpose depolarizing model, generated from `custom_noise_model(1e-3)` as defined
in [Custom Noise Models](/user-guide/error-correction/logical-noise). Use it as a
well-behaved baseline rather than as a model of any particular machine.

## `public/google_willow_like`

Flavored after a superconducting processor tuned for error correction: fast surface-code
cycle, comparatively short coherence, and a dedicated multi-level reset with leakage
removal — so its reset error is well below its readout error.

```python theme={null}
from classiq.error_correction import (
    DepolarizeRule,
    PauliRule,
    PhysicalNoiseModel,
)

google_willow_like = PhysicalNoiseModel(
    idle=[DepolarizeRule(p=6e-4)],
    long_idle=[DepolarizeRule(p=7e-3)],
    clifford_1q=[DepolarizeRule(p=3.5e-4)],
    clifford_2q=[DepolarizeRule(p=3.3e-3)],
    measure={"Z": 7.7e-3, "X": 7.7e-3},
    gates={
        "R": [PauliRule(pauli="X", p=2e-3)],
        "RX": [PauliRule(pauli="Z", p=2e-3)],
    },
)
```

The single-qubit, two-qubit and measurement values are rounded from Google's published
Willow spec sheet for its error-correction chip (0.035%, 0.33% CZ, and 0.77% measurement,
all measured under simultaneous operation). The idle terms are derived from the published
mean `T1` of 68 µs against the gate and cycle durations; reset is an assumption.

## `public/ibm_heron_r2_like`

Flavored after a superconducting processor with roughly three times the coherence but
slower, measurement-limited readout and reset.

```python theme={null}
from classiq.error_correction import (
    DepolarizeRule,
    PauliRule,
    PhysicalNoiseModel,
)

ibm_heron_r2_like = PhysicalNoiseModel(
    idle=[DepolarizeRule(p=3e-4)],
    long_idle=[DepolarizeRule(p=6e-3)],
    clifford_1q=[DepolarizeRule(p=3e-4)],
    clifford_2q=[DepolarizeRule(p=4e-3)],
    measure={"Z": 1e-2, "X": 1e-2},
    gates={
        "R": [PauliRule(pauli="X", p=1e-2)],
        "RX": [PauliRule(pauli="Z", p=1e-2)],
    },
)
```

The two-qubit value uses a published **layered** error figure rather than an isolated
median, because a surface code runs its two-qubit gates simultaneously and the isolated
figure understates what the code actually sees. The idle terms are derived from a published
median `T1` on the order of 200 µs against the gate and readout durations; reset is assumed
to be measurement-limited.

<Warning>
  Both device-flavored models are deliberately conservative — their simulated `Λ` comes out
  below what the corresponding real hardware achieves. Their T gate error rates are also
  high enough that magic-state distillation is impractical at these noise levels, so treat
  them as a guide to Clifford-level behavior rather than as a basis for end-to-end resource
  estimates.
</Warning>

## References

The device-flavored models are rounded from the public sources below. All of them are
point-in-time figures — vendors recalibrate continuously, and these models are not tracked
against live calibration data.

* [Willow Spec Sheet](https://quantumai.google/static/site-assets/downloads/willow-spec-sheet.pdf)
  (Google Quantum AI, 9 December 2024) — single-qubit, CZ and measurement error under
  simultaneous operation, mean `T1`, surface-code cycle time, reset capabilities, and the
  measured `Λ₃,₅,₇ = 2.14 ± 0.02` for the error-correction chip.
* [Quantum error correction below the surface code threshold](https://arxiv.org/abs/2408.13687)
  (Google Quantum AI, *Nature*, 2024; arXiv:2408.13687) — gate and cycle durations,
  coherence, and the surface-code memory experiment that `Λ` is measured from.
* [IBM Quantum compute resources](https://quantum.cloud.ibm.com/computers) — per-device
  calibration for the Heron r2 systems (`ibm_fez`, `ibm_kingston`, `ibm_marrakesh`),
  including both best-pair and layered two-qubit error and median readout error.
* [IBM Quantum Computers: Evolution, Performance, and Future Directions](https://arxiv.org/abs/2410.00916)
  (arXiv:2410.00916) — Heron r2 CZ gate duration and median CZ error.
* [Parameter Analysis and Optimization of Layer Fidelity for Quantum Processor Benchmarking at Scale](https://arxiv.org/abs/2510.16915)
  (arXiv:2510.16915) — layer fidelity and error per layered gate for Heron r2, the basis for
  modeling the two-qubit error with a layered rather than an isolated figure.