Noise Types

KrausChannel

KrausChannel is a base class for digital noise models that use Kraus operators to represent quantum noise channels. Kraus operators can be used to represent a generic quantum channel \(\mathcal{E}\) acting on a density matrix \(\rho\) as:

\[\mathcal{E}(\rho) = \sum_i K_i \rho K_i^\dagger,\]

where \(K_i\) are the Kraus operators satisfying the completeness relation \(\sum_i K_i^\dagger K_i = I\). The class is initialized with a list of Kraus operators given as QTensors.

from qilisdk.noise import KrausChannel
from qilisdk.core import QTensor
import numpy as np
p = 0.1
K1 = QTensor(np.array([[1, 0], [0, np.sqrt(1 - p)]]))
K2 = QTensor(np.array([[0, np.sqrt(p)], [0, 0]]))
kraus_noise = KrausChannel(operators=[K1, K2])

LindbladGenerator

LindbladGenerator is a base class for analog noise models that use the Lindblad master equation to represent quantum noise processes. The Lindblad master equation describes the time evolution of a density matrix \(\rho\) under both unitary dynamics and dissipative processes:

\[\frac{d\rho}{dt} = -i[H, \rho] + \sum_i \left( J_i \rho J_i^\dagger - \frac{1}{2} \{ J_i^\dagger J_i, \rho \} \right),\]

where \(H\) is the system Hamiltonian, and \(J_i\) are the jump operators representing different dissipation channels. The class is initialized with a list of jump operators given as QTensors and their corresponding rates (assumed to be 1 if not specified).

from qilisdk.noise import LindbladGenerator
from qilisdk.core import QTensor
import numpy as np
J1 = QTensor(np.array([[0, 1], [0, 0]]))
J2 = QTensor(np.array([[1, 0], [0, 0]]))
lindblad_noise = LindbladGenerator(jump_operators=[J1, J2], rates=[0.1, 0.2])

PauliChannel

PauliChannel is a base class for noise models that use Pauli operators. A Pauli channel applies the Pauli operators (I, X, Y, Z) with certain probabilities. The channel can be represented as:

\[\mathcal{E}(\rho) = p_I \rho + p_X X \rho X + p_Y Y \rho Y + p_Z Z \rho Z,\]

where \(p_I\), \(p_X\), \(p_Y\), and \(p_Z\) are the probabilities for applying the respective Pauli operators, satisfying \(p_I + p_X + p_Y + p_Z = 1\). This corresponds to Kraus operators:

\[K_0 = \sqrt{p_I} I, \quad K_1 = \sqrt{p_X} X, \quad K_2 = \sqrt{p_Y} Y, \quad K_3 = \sqrt{p_Z} Z,\]

Or jump operators:

\[J_1 = \sqrt{\gamma_X} X, \quad J_2 = \sqrt{\gamma_Y} Y, \quad J_3 = \sqrt{\gamma_Z} Z,\]

where \(\gamma_i\) are rates related to the probabilities.

from qilisdk.noise import PauliChannel
pauli_noise = PauliChannel(pX=0.1, pY=0.1, pZ=0.1)

BitFlip

BitFlip represents a bit-flip error model where each qubit has a certain probability of flipping its state from \(|0⟩\) to \(|1⟩\) or from \(|1⟩\) to \(|0⟩\). This corresponds to the following channel:

\[\mathcal{E}(\rho) = (1 - p) \rho + p X \rho X,\]

where \(p\) is the bit-flip probability. As such, it is a special case of PauliChannel with \(p_X = p\) and \(p_I = 1 - p\). This can therefore be written as Kraus operators:

\[K_0 = \sqrt{1 - p} I, \quad K_1 = \sqrt{p} X,\]

or similarly as a jump operator:

\[J = \sqrt{\gamma} X,\]

where now \(\gamma\) is the bit-flip rate.

from qilisdk.noise import BitFlip
bit_flip_noise = BitFlip(probability=0.1)

PhaseFlip

PhaseFlip represents a phase-flip error model where each qubit has a certain probability of flipping its phase, changing the sign of the \(|1⟩\) state. This corresponds to the following channel:

\[\mathcal{E}(\rho) = (1 - p) \rho + p Z \rho Z,\]

where \(p\) is the phase-flip probability. As such, it is a special case of PauliChannel with \(p_Z = p\) and \(p_I = 1 - p\). This can therefore be written as Kraus operators:

\[K_0 = \sqrt{1 - p} I, \quad K_1 = \sqrt{p} Z,\]

or similarly as a jump operator:

\[J = \sqrt{\gamma} Z,\]

where now \(\gamma\) is the phase-flip rate.

from qilisdk.noise import PhaseFlip
phase_flip_noise = PhaseFlip(probability=0.1)

Depolarizing

Depolarizing represents a depolarizing error model where each qubit has a certain probability of being replaced by the maximally mixed state. This corresponds to the following channel:

\[\mathcal{E}(\rho) = (1 - p) \rho + \frac{p}{3} (X \rho X + Y \rho Y + Z \rho Z),\]

where \(p\) is the depolarizing probability. As such, it is a special case of PauliChannel with \(p_X = p_Y = p_Z = p/3\) and \(p_I = 1 - p\). This can therefore be written as Kraus operators:

\[K_0 = \sqrt{1 - p} I, \quad K_1 = \sqrt{\frac{p}{3}} X, \quad K_2 = \sqrt{\frac{p}{3}} Y, \quad K_3 = \sqrt{\frac{p}{3}} Z,\]

or similarly as jump operators:

\[J_1 = \sqrt{\frac{\gamma}{3}} X, \quad J_2 = \sqrt{\frac{\gamma}{3}} Y, \quad J_3 = \sqrt{\frac{\gamma}{3}} Z,\]

where \(\gamma\) is the depolarizing rate.

from qilisdk.noise import Depolarizing
depolarizing_noise = Depolarizing(probability=0.1)

AmplitudeDamping

AmplitudeDamping represents an amplitude damping error model where each qubit has a certain probability of decaying from the excited state \(|1⟩\) to the ground state \(|0⟩\). This corresponds to the following channel:

\[\mathcal{E}(\rho) = E_0 \rho E_0^\dagger + E_1 \rho E_1^\dagger.\]

Here the Kraus operators are defined as:

\[\begin{split}E_0 = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1 - p} \end{pmatrix}, \quad E_1 = \begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0 \end{pmatrix},\end{split}\]

where \(p\) is the amplitude damping probability. The channel can also be represented using the jump operator:

\[J = \sqrt{\gamma} \sigma_-,\]

where \(\gamma\) is the amplitude damping rate and \(\sigma_-\) is the lowering operator. The channel is defined by the \(T_1\) time constant, with the relations:

\[p = 1 - e^{-t / T_1}, \gamma = \frac{1}{T_1},\]

where \(t\) is the time duration over which the amplitude damping occurs.

from qilisdk.noise import AmplitudeDamping
amplitude_damping_noise = AmplitudeDamping(t1=0.1)

Dephasing

Dephasing represents a dephasing error model where each qubit has a certain probability of losing coherence between its \(|0⟩\) and \(|1⟩\) states. This corresponds to the following channel:

\[\mathcal{E}(\rho) = (1 - p) \rho + p Z \rho Z\]

where \(p\) is the dephasing probability. As such, it is a special case of PauliChannel with \(p_Z = p\) and \(p_I = 1 - p\). This can therefore be written as Kraus operators:

\[K_0 = \sqrt{1 - p} I, \quad K_1 = \sqrt{p} Z,\]

or similarly as a jump operator:

\[J = \sqrt{\gamma} Z,\]

where now \(\gamma\) is the dephasing rate. The channel is defined by the \(T_\phi\) time constant, with the relations:

\[p = \frac{1}{2} \left( 1 - e^{-t / T_\phi} \right), \gamma = \frac{1}{T_\phi},\]

where \(t\) is the time duration over which the dephasing occurs.

from qilisdk.noise import Dephasing
dephasing_noise = Dephasing(t_phi=0.1)

GaussianPerturbation

GaussianPerturbation represents a noise model that adds Gaussian-distributed perturbations to the parameters of gates or Hamiltonian terms in a quantum circuit or schedule. This simulates imperfections in control signals that can lead to deviations from the intended operations. The perturbations are drawn from a Gaussian distribution with a specified standard deviation:

\[\delta \theta \sim \mathcal{N}(\mu, \sigma^2),\]

where \(\sigma\) is the standard deviation of the perturbations and \(\mu\) is the mean (defaulting to 0).

from qilisdk.noise import GaussianPerturbation
gaussian_perturbation_noise = GaussianPerturbation(std=0.05, mean=0.0)

OffsetPerturbation

OffsetPerturbation represents a noise model that adds fixed offset perturbations to the parameters of gates or Hamiltonian terms in a quantum circuit or schedule. This simulates systematic errors in control signals that consistently shift the intended operations. The offsets are specified as fixed values for each parameter.

from qilisdk.noise import OffsetPerturbation
offset_perturbation_noise = OffsetPerturbation(offset=1.3)

ReadoutAssignment

ReadoutAssignment represents a readout error model that simulates imperfections in the measurement process of qubits. It is defined by two probabilities: the probability of misreading a \(|0⟩\) state as \(|1⟩\) (\(p_{0 \to 1}\)) and the probability of misreading a \(|1⟩\) state as \(|0⟩\) (\(p_{1 \to 0}\)).

from qilisdk.noise import ReadoutAssignment
readout_assignment_noise = ReadoutAssignment(p01=0.05, p10=0.1)