Tipus de Soroll

KrausChannel

KrausChannel és una classe base per a models de soroll digital que utilitzen operadors de Kraus per representar canals de soroll quàntic. Els operadors de Kraus es poden utilitzar per representar un canal quàntic genèric \(\mathcal{E}\) que actua sobre una matriu de densitat \(\rho\) com:

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

on \(K_i\) són els operadors de Kraus que satisfan la relació de completitud \(\sum_i K_i^\dagger K_i = I\). La classe s’inicialitza amb una llista d’operadors de Kraus donats com a 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 és una classe base per a models de soroll analògic que utilitzen l’equació mestra de Lindblad per representar processos de soroll quàntic. L’equació mestra de Lindblad descriu l’evolució temporal d’una matriu de densitat \(\rho\) sota dinàmiques unitàries i processos dissipatius:

\[\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),\]

on \(H\) és l’Hamiltonià del sistema, i \(J_i\) són els operadors de salt que representen diferents canals de dissipació. La classe s’inicialitza amb una llista d’operadors de salt donats com a QTensors i les seves taxes corresponents (s’assumeix que són 1 si no s’especifiquen).

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 és una classe base per a models de soroll que utilitzen operadors de Pauli. Un canal de Pauli aplica els operadors de Pauli (I, X, Y, Z) amb certes probabilitats. El canal es pot representar com:

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

on \(p_I\), \(p_X\), \(p_Y\) i \(p_Z\) són les probabilitats d’aplicar els respectius operadors de Pauli, satisfent \(p_I + p_X + p_Y + p_Z = 1\). Això correspon a operadors de Kraus:

\[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,\]

O bé operadors de salt:

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

on \(\gamma_i\) són taxes relacionades amb les probabilitats.

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

BitFlip

BitFlip representa un model d’error d’inversió de bit on cada qubit té una certa probabilitat de canviar el seu estat de \(|0⟩\) a \(|1⟩\) o de \(|1⟩\) a \(|0⟩\). Això correspon al canal següent:

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

on \(p\) és la probabilitat d’inversió de bit. Per tant, és un cas especial de PauliChannel amb \(p_X = p\) i \(p_I = 1 - p\). Per tant, pot escriure’s com operadors de Kraus:

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

o de manera similar com a operador de salt:

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

on ara \(\gamma\) és la taxa d’inversió de bit.

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

PhaseFlip

PhaseFlip representa un model d’error d’inversió de fase on cada qubit té una certa probabilitat d’invertir la seva fase, canviant el signe de l’estat \(|1⟩\). Això correspon al canal següent:

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

on \(p\) és la probabilitat d’inversió de fase. Per tant, és un cas especial de PauliChannel amb \(p_Z = p\) i \(p_I = 1 - p\). Per tant, pot escriure’s com operadors de Kraus:

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

o de manera similar com a operador de salt:

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

on ara \(\gamma\) és la taxa d’inversió de fase.

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

Despolaritzant

Depolarizing representa un model d’error despolaritzant on cada qubit té una certa probabilitat de ser substituït per l’estat màximament mesclat. Això correspon al canal següent:

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

on \(p\) és la probabilitat despolaritzant. Per tant, és un cas especial de PauliChannel amb \(p_X = p_Y = p_Z = p/3\) i \(p_I = 1 - p\). Per tant, pot escriure’s com operadors de Kraus:

\[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,\]

o de manera similar com a operadors de salt:

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

on \(\gamma\) és la taxa despolaritzant.

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

AmplitudeDamping

AmplitudeDamping representa un model d’error d’amortiment d’amplitud on cada qubit té una certa probabilitat de decaure des de l’estat excitat \(|1⟩\) a l’estat fonamental \(|0⟩\). Això correspon al canal següent:

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

Aquí els operadors de Kraus es defineixen com:

\[\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}\]

on \(p\) és la probabilitat d’amortiment d’amplitud. El canal també es pot representar utilitzant l’operador de salt:

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

on \(\gamma\) és la taxa d’amortiment d’amplitud i \(\sigma_-\) és l’operador d’abaixament. El canal està definit per la constant de temps \(T_1\), amb les relacions:

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

on \(t\) és la durada temporal sobre la qual es produeix l’amortiment d’amplitud.

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

Desfasament

Dephasing representa un model d’error de desfasament on cada qubit té una certa probabilitat de perdre coherència entre els seus estats \(|0⟩\) i \(|1⟩\). Això correspon al canal següent:

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

on \(p\) és la probabilitat de desfasament. Per tant, és un cas especial de PauliChannel amb \(p_Z = p\) i \(p_I = 1 - p\). Per tant, pot escriure’s com operadors de Kraus:

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

o de manera similar com a operador de salt:

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

on ara \(\gamma\) és la taxa de desfasament. El canal està definit per la constant de temps \(T_\phi\), amb les relacions:

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

on \(t\) és la durada temporal sobre la qual es produeix el desfasament.

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

GaussianPerturbation

GaussianPerturbation representa un model de soroll que afegeix pertorbacions distribuïdes gaussianament als paràmetres de portes o termes Hamiltonians en un circuit o programa quàntic. Això simula imperfeccions en els senyals de control que poden portar a desviacions de les operacions previstes. Les pertorbacions s’extreuen d’una distribució gaussiana amb una desviació estàndard especificada:

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

on \(\sigma\) és la desviació estàndard de les pertorbacions i \(\mu\) és la mitjana (per defecte 0).

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

OffsetPerturbation

OffsetPerturbation representa un model de soroll que afegeix pertorbacions de desplaçament fix als paràmetres de portes o termes Hamiltonians en un circuit o programa quàntic. Això simula errors sistemàtics en els senyals de control que desplacen consistentment les operacions previstes. Els desplaçaments s’especifiquen com a valors fixos per a cada paràmetre.

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

ReadoutAssignment

ReadoutAssignment representa un model d’error de lectura que simula imperfeccions en el procés de mesura dels qubits. Està definit per dues probabilitats: la probabilitat de llegir erròniament un estat \(|0⟩\) com a \(|1⟩\) (\(p_{0 \to 1}\)) i la probabilitat de llegir erròniament un estat \(|1⟩\) com a \(|0⟩\) (\(p_{1 \to 0}\)).

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