PauliTwirlingMitigation#

class qiskit_calculquebec.mitigation.pauli_twirling.PauliTwirlingMitigation(backend, num_variants: int = 10, shots: int = 1024)#

Bases: object

Pauli Twirling (PT) for MonarQ, with optional ZNE combination.

Generates num_variants twirled copies of the circuit, executes each one, and averages the results to reduce variance from the randomized Pauli insertions.

Parameters:

backend (MonarQBackend) – Calcul Québec backend.
num_variants (int) – Number of twirled variants to average. Higher values reduce variance but increase total shot count (num_variants × shots executions). Default: 10.
shots (int) – Shots per variant. Default: 1024.

Examples

PT alone:

>>> pt = PauliTwirlingMitigation(backend, num_variants=10)
>>> result = pt.run(circuit)

PT combined with ZNE:

>>> pt = PauliTwirlingMitigation(backend, num_variants=10)
>>> result = pt.run_with_zne(circuit, scale_factors=[1.0, 2.0, 3.0])

PT + ZNE with a custom factory:

>>> from mitiq.zne.inference import RichardsonFactory
>>> pt = PauliTwirlingMitigation(backend, num_variants=10)
>>> result = pt.run_with_zne(
...     circuit,
...     factory=RichardsonFactory([1.0, 2.0, 3.0]),
... )

Methods

`run`(circuit[, rem, qubits])	Run the circuit with Pauli Twirling and return the averaged result.
`run_unmitigated`(circuit[, rem, qubits])	Run the circuit without twirling for baseline comparison.
`run_variants`(circuit[, rem, qubits])	Return the individual result of each twirled variant without averaging.
`run_with_zne`(circuit[, scale_factors, ...])	Run the circuit with PT + ZNE (twirling combined with zero-noise extrapolation).

run(circuit, rem=None, qubits=None) → float#

Run the circuit with Pauli Twirling and return the averaged result.

Parameters:

circuit (QuantumCircuit) – Circuit to execute.
rem (ReadoutMitigation | None) – Optional REM correction applied to each variant.
qubits (list[int] | None) – Physical qubits; required when rem is provided.

Returns:

P(|0…0⟩) averaged over num_variants twirled variants.

Return type:

float

run_unmitigated(circuit, rem=None, qubits=None) → float#

Run the circuit without twirling for baseline comparison.

Parameters:

circuit (QuantumCircuit) – Circuit to execute.
rem (ReadoutMitigation | None) – Optional REM correction applied to the counts.
qubits (list[int] | None) – Physical qubits; required when rem is provided.

Returns:

Raw P(|0…0⟩) without any twirling.

Return type:

float

run_variants(circuit, rem=None, qubits=None) → list[float]#

Return the individual result of each twirled variant without averaging.

Useful for inspecting the variance introduced by twirling.

Parameters:

circuit (QuantumCircuit) – Circuit to execute.
rem (ReadoutMitigation | None) – Optional REM correction applied to each variant.
qubits (list[int] | None) – Physical qubits; required when rem is provided.

Returns:

P(|0…0⟩) for each of the num_variants twirled: variants.

Return type:

list[float]

run_with_zne(circuit, scale_factors: list[float] | None = None, factory=None, scale_noise=None, rem=None, qubits=None) → float#

Run the circuit with PT + ZNE (twirling combined with zero-noise extrapolation).

Each point on the ZNE noise curve is computed by a PT executor that averages num_variants twirled variants.

Parameters:

circuit (QuantumCircuit) – Circuit to execute. Measurements are stripped internally.
scale_factors (list[float] | None) – Noise scale factors. Ignored if factory is provided. Default: [1.0, 1.5, 2.0, 2.5, 3.0].
factory (mitiq.zne.inference.Factory | None) – Extrapolation method. None → LinearFactory(scale_factors). LinearFactory is more stable than Richardson with 4+ scale factors.
scale_noise (callable | None) – Noise scaling method. None → fold_gates_at_random.
rem (ReadoutMitigation | None) – Optional REM correction applied inside each variant executor.
qubits (list[int] | None) – Physical qubits; required when rem is provided.

Returns:

Zero-noise extrapolated value from PT + ZNE.

Return type:

float

PauliTwirlingMitigation

Contents

PauliTwirlingMitigation#

Methods