Quantum channels and noise models

Kraus channel

class graphix.channels.KrausChannel(kraus_data: Iterable[KrausData])

Quantum channel class in the Kraus representation.

Defined by Kraus operators \(K_i\) with scalar prefactors coef) \(c_i\), where the channel act on density matrix as \(\rho' = \sum_i K_i^\dagger \rho K_i\). The data should satisfy \(\sum K_i^\dagger K_i = I\).

__init__(kraus_data: Iterable[KrausData]) → None

Initialize KrausChannel given a Kraus operator.

Parameters:

kraus_data (Iterable[KrausData]) – Iterable of Kraus operator data.

Raises:

ValueError – If kraus_data is empty.

property nqubit: int

Return the number of qubits.

graphix.channels.dephasing_channel(prob: float) → KrausChannel

Single-qubit dephasing channel, \((1-p) \rho + p Z \rho Z\).

Parameters:

prob (float) – The probability associated to the channel

Returns:

containing the corresponding Kraus operators

Return type:

graphix.channels.KrausChannel object

graphix.channels.depolarising_channel(prob: float) → KrausChannel

Single-qubit depolarizing channel.

\[(1-p) \rho + \frac{p}{3} (X \rho X + Y \rho Y + Z \rho Z) = (1 - 4 \frac{p}{3}) \rho + 4 \frac{p}{3} id\]

Parameters:

prob (float) – The probability associated to the channel

graphix.channels.pauli_channel(px: float, py: float, pz: float) → KrausChannel

Single-qubit Pauli channel.

\[(1-p_X-p_Y-p_Z) \rho + p_X X \rho X + p_Y Y \rho Y + p_Z Z \rho Z)\]

graphix.channels.two_qubit_depolarising_channel(prob: float) → KrausChannel

Two-qubit depolarising channel.

\[\mathcal{E} (\rho) = (1-p) \rho + \frac{p}{15} \sum_{P_i \in \{id, X, Y ,Z\}^{\otimes 2}/(id \otimes id)}P_i \rho P_i\]

Parameters:

prob (float) – The probability associated to the channel

Returns:

containing the corresponding Kraus operators

Return type:

graphix.channels.KrausChannel object

graphix.channels.two_qubit_depolarising_tensor_channel(prob: float) → KrausChannel

Two-qubit tensor channel of single-qubit depolarising channels with same probability.

Kraus operators:

\[\Big\{ \sqrt{(1-p)} id, \sqrt{(p/3)} X, \sqrt{(p/3)} Y , \sqrt{(p/3)} Z \Big\} \otimes \Big\{ \sqrt{(1-p)} id, \sqrt{(p/3)} X, \sqrt{(p/3)} Y , \sqrt{(p/3)} Z \Big\}\]

Parameters:

prob (float) – The probability associated to the channel

Returns:

containing the corresponding Kraus operators

Return type:

graphix.channels.KrausChannel object

Noise model classes

class graphix.noise_models.noise_model.Noise

Abstract base class for noise.

abstract property nqubits: int

Return the number of qubits targetted by the noise.

abstractmethod to_kraus_channel() → KrausChannel

Return the Kraus channel describing the noise.

class graphix.noise_models.noise_model.ApplyNoise(noise: Noise, nodes: list[int], domain: set[int] | None = None)

Apply noise command.

Parameters:

• noise (Noise) – noise to be applied

• nodes (list[Node]) – list of node indices on which to apply noise

• domain (set[Node] | None = None) – Optional domain for conditional noise. If None, the noise is applied unconditionally. Otherwise, the noise is applied if there is an odd number of nodes among domain that have been measured with outcome 1 (as for X and Z commands). Note that the noise is never applied if domain is the empty set.

__init__(noise: Noise, nodes: list[int], domain: set[int] | None = None) → None

class graphix.noise_models.noise_model.NoiseModel

Abstract base class for all noise models.

abstractmethod command(cmd: CommandOrNoise, rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to the command cmd.

abstractmethod confuse_result(cmd: BaseM, result: Outcome, rng: Generator | None = None, *, stacklevel: int = 1) → Outcome

Return a possibly flipped measurement outcome.

Parameters:

• result (Outcome) – Ideal measurement result.

• cmd (BaseM) – The measurement command that produced the given outcome.

Returns:

Possibly corrupted result.

Return type:

Outcome

abstractmethod input_nodes(nodes: Iterable[int], rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to input nodes.

transpile(sequence: Iterable[CommandOrNoise], rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Apply the noise to a sequence of commands and return the resulting sequence.

class graphix.noise_models.noise_model.NoiselessNoiseModel

Noise model that performs no operation.

command(cmd: CommandOrNoise, rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to the command cmd.

confuse_result(cmd: BaseM, result: Outcome, rng: Generator | None = None, *, stacklevel: int = 1) → Outcome

Assign wrong measurement result.

input_nodes(nodes: Iterable[int], rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to input nodes.

class graphix.noise_models.noise_model.ComposeNoiseModel(models: list[NoiseModel])

Compose noise models.

__init__(models: list[NoiseModel]) → None

command(cmd: CommandOrNoise, rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to the command cmd.

confuse_result(cmd: BaseM, result: Outcome, rng: Generator | None = None, *, stacklevel: int = 1) → Outcome

Assign wrong measurement result.

input_nodes(nodes: Iterable[int], rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to input nodes.

class graphix.noise_models.depolarising.DepolarisingNoise(prob: float)

One-qubit depolarising noise with probabibity prob.

__init__(prob: float) → None

Initialize one-qubit depolarizing noise.

Parameters:

prob (float) – Probability parameter of the noise, between 0 and 1.

property nqubits: int

Return the number of qubits targetted by the noise element.

to_kraus_channel() → KrausChannel

Return the Kraus channel describing the noise element.

class graphix.noise_models.depolarising.TwoQubitDepolarisingNoise(prob: float)

Two-qubits depolarising noise with probabibity prob.

__init__(prob: float) → None

Initialize two-qubit depolarizing noise.

Parameters:

prob (float) – Probability parameter of the noise, between 0 and 1.

property nqubits: int

Return the number of qubits targetted by the noise element.

to_kraus_channel() → KrausChannel

Return the Kraus channel describing the noise element.

class graphix.noise_models.depolarising.DepolarisingNoiseModel(prepare_error_prob: float = 0.0, x_error_prob: float = 0.0, z_error_prob: float = 0.0, entanglement_error_prob: float = 0.0, measure_channel_prob: float = 0.0, measure_error_prob: float = 0.0)

Depolarising noise model.

Parameters:

NoiseModel (class) – Parent abstract class class:NoiseModel

__init__(prepare_error_prob: float = 0.0, x_error_prob: float = 0.0, z_error_prob: float = 0.0, entanglement_error_prob: float = 0.0, measure_channel_prob: float = 0.0, measure_error_prob: float = 0.0) → None

command(cmd: CommandOrNoise, rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to the command cmd.

confuse_result(cmd: BaseM, result: Outcome, rng: Generator | None = None, *, stacklevel: int = 1) → Outcome

Assign wrong measurement result cmd = “M”.

input_nodes(nodes: Iterable[int], rng: Generator | None = None, *, stacklevel: int = 1) → list[CommandOrNoise]

Return the noise to apply to input nodes.