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.NoiseModel

Abstract base class for all noise models.

assign_simulator(simulator: PatternSimulator) → None

Assign a simulator to the noise model.

abstract byproduct_x() → KrausChannel

Apply noise to qubits that happens in the X gate process.

abstract byproduct_z() → KrausChannel

Apply noise to qubits that happens in the Z gate process.

abstract clifford() → KrausChannel

Apply noise to qubits that happens in the Clifford gate process.

abstract confuse_result(result: bool) → bool

Assign wrong measurement result.

abstract entangle() → KrausChannel

Apply noise to qubits that happens in the CZ gate process.

abstract measure() → KrausChannel

Apply noise to qubits that happens in the measurement process.

abstract prepare_qubit() → KrausChannel

Return qubit to be added with preparation errors.

abstract tick_clock() → None

Notion of time in real devices - this is where we apply effect of T1 and T2.

We assume commands that lie between ‘T’ commands run simultaneously on the device.

class graphix.noise_models.noiseless_noise_model.NoiselessNoiseModel

Noiseless noise model for testing.

Only return the identity channel.

byproduct_x() → KrausChannel

Apply noise to qubits after X gate correction.

byproduct_z() → KrausChannel

Apply noise to qubits after Z gate correction.

clifford() → KrausChannel

Apply noise to qubits that happens in the Clifford gate process.

confuse_result(result: bool) → bool

Assign wrong measurement result.

entangle() → KrausChannel

Return noise model to qubits that happens after the CZ gates.

measure() → KrausChannel

Apply noise to qubit to be measured.

prepare_qubit() → KrausChannel

Return the channel to apply after clean single-qubit preparation. Here just identity.

tick_clock() → None

Notion of time in real devices - this is where we apply effect of T1 and T2.

See NoiseModel.tick_clock().