Custom Noise Models

The engine needs to know how noisy the underlying hardware is. A logical noise model holds the simulated logical error rates of the fundamental operations (Clifford gates and T gate) as a function of code distance. If a ready-made model is enough, pick one from Publicly Available Noise Models — no simulation to run yourself. This page covers the other route: describing your own hardware as a PhysicalNoiseModel and simulating it.

Describe the physical noise

A PhysicalNoiseModel is a set of per-operation noise rules. Each field takes a list of rules that compose, except measure, which maps a measurement basis to a flip probability.

Field	Accepts	Applies to
`idle`	exactly one `DepolarizeRule`	Idle qubits while other qubits are operated on
`long_idle`	exactly one `DepolarizeRule`	Idle qubits during measurement or reset, in addition to `idle`
`clifford_1q`	at most one `DepolarizeRule`, plus at most one `PauliRule` per Pauli	Every 1-qubit Clifford operation
`clifford_2q`	exactly one `DepolarizeRule`; `PauliRule` is not supported	Every 2-qubit Clifford operation
`measure`	a mapping from Pauli-string basis to flip probability	The reported measurement result
`gates`	per-gate rules, keyed by gate name	A specific gate, overriding `clifford_1q` / `clifford_2q`

Only reset gates (R, RX) and recognized 1- and 2-qubit Clifford gates may appear in gates; any other gate name is rejected. Supplying two rules of the same kind to one field is also rejected, so idle=[DepolarizeRule(p=1e-4), DepolarizeRule(p=2e-4)] is an error rather than a composition.

Noise rules

DepolarizeRule(p=...) applies a uniformly random Pauli error with total probability p; with probability 1 - p nothing happens. On a 1-qubit operation each of X, Y and Z is applied with probability p / 3; on a 2-qubit operation each of the 15 non-identity two-qubit Paulis is applied with probability p / 15. PauliRule(pauli=..., p=...) applies one specific Pauli error — "X", "Y" or "Z" — with probability p. This is the natural way to express a biased error, such as a reset to |0⟩ that occasionally leaves the qubit in |1⟩:

from classiq.error_correction import PauliRule

reset_failure = PauliRule(pauli="X", p=2e-3)

A complete model

Composing those rules into a single model, scaled by one parameter p. This is the model public/depolarize_1e-3 was generated from, with p = 1e-3:

from classiq.error_correction import (
    DepolarizeRule,
    PauliRule,
    PhysicalNoiseModel,
)


def custom_noise_model(p: float) -> PhysicalNoiseModel:
    return PhysicalNoiseModel(
        idle=[DepolarizeRule(p=p / 10)],
        long_idle=[DepolarizeRule(p=2 * p)],
        clifford_1q=[DepolarizeRule(p=p / 10)],
        clifford_2q=[DepolarizeRule(p=p)],
        measure={"Z": p * 5, "X": p * 5},
        gates={
            "R": [PauliRule(pauli="X", p=p * 2)],
            "RX": [PauliRule(pauli="Z", p=p * 2)],
        },
    )

Initialize the model

Call initialize_logical_noise to simulate the resulting logical error rates and store them under a name you choose.

initialize_logical_noise runs a logical-noise simulation on the backend and is a long-running operation. You only need to run it once per noise model — afterwards, retrieve the stored result with get_logical_noise.

from classiq.error_correction.logical_noise import (
    get_logical_noise,
    initialize_logical_noise,
)

noise_model = custom_noise_model(1e-3)

initialize_logical_noise("my_device", noise_model)
logical_noise = get_logical_noise("my_device")

Once retrieved, you can inspect and plot the fitted logical error rates — for example, the 1-qubit Clifford curves as a function of code distance:

logical_noise.plot_clifford()

Logical errors of a 1-qubit Clifford by code distance — Logical X and Z error of a 1-qubit Clifford, exponentially suppressed as the code distance grows.

Each curve is a log-linear fit 10 ** (a * cd + b); the legend reports the suppression factor Λ (the improvement per two units of code distance). LogicalNoise also provides plot_cnot() and plot_s(), and get_clifford_logical_error, get_cnot_logical_error and get_s_logical_error to read a single rate at a given code distance.

Remove a logical noise model

When you no longer need a model you created, delete it with remove_logical_noise. Public models (those whose name begins with public/) are shared and cannot be removed this way.

from classiq.error_correction.logical_noise import remove_logical_noise

remove_logical_noise("my_device")

Next, route a program onto the lattice.

AI

Authentication

Modeling

Synthesis

Execution

Analysis

Error Correction

Studio

Applications

Describe the physical noise

Noise rules

A complete model

Initialize the model

Remove a logical noise model

​Describe the physical noise

​Noise rules

​A complete model

​Initialize the model

​Remove a logical noise model

Describe the physical noise

Noise rules

A complete model

Initialize the model

Remove a logical noise model