Tipos de Ruido

KrausChannel

KrausChannel es una clase base para modelos de ruido digital que utilizan operadores de Kraus para representar canales de ruido cuántico. Los operadores de Kraus pueden utilizarse para representar un canal cuántico genérico \(\mathcal{E}\) que actúa sobre una matriz de densidad \(\rho\) como:

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

donde \(K_i\) son los operadores de Kraus que satisfacen la relación de completitud \(\sum_i K_i^\dagger K_i = I\). La clase se inicializa con una lista de operadores de Kraus dados como 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 es una clase base para modelos de ruido analógico que utilizan la ecuación maestra de Lindblad para representar procesos de ruido cuántico. La ecuación maestra de Lindblad describe la evolución temporal de una matriz de densidad \(\rho\) bajo dinámicas unitarias y procesos disipativos:

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

donde \(H\) es el Hamiltoniano del sistema, y \(J_i\) son los operadores de salto que representan diferentes canales de disipación. La clase se inicializa con una lista de operadores de salto dados como QTensors y sus tasas correspondientes (se asume que son 1 si no se especifican).

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 es una clase base para modelos de ruido que utilizan operadores de Pauli. Un canal de Pauli aplica los operadores de Pauli (I, X, Y, Z) con ciertas probabilidades. El canal puede representarse como:

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

donde \(p_I\), \(p_X\), \(p_Y\) y \(p_Z\) son las probabilidades de aplicar los respectivos operadores de Pauli, satisfaciendo \(p_I + p_X + p_Y + p_Z = 1\). Esto corresponde a operadores 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 bien operadores de salto:

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

donde \(\gamma_i\) son tasas relacionadas con las probabilidades.

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

BitFlip

BitFlip representa un modelo de error de inversión de bit donde cada qubit tiene cierta probabilidad de cambiar su estado de \(|0⟩\) a \(|1⟩\) o de \(|1⟩\) a \(|0⟩\). Esto corresponde al siguiente canal:

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

donde \(p\) es la probabilidad de inversión de bit. Por tanto, es un caso especial de PauliChannel con \(p_X = p\) y \(p_I = 1 - p\). Por ello, puede escribirse como operadores de Kraus:

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

o de forma similar como operador de salto:

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

donde ahora \(\gamma\) es la tasa de inversión de bit.

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

PhaseFlip

PhaseFlip representa un modelo de error de inversión de fase donde cada qubit tiene cierta probabilidad de invertir su fase, cambiando el signo del estado \(|1⟩\). Esto corresponde al siguiente canal:

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

donde \(p\) es la probabilidad de inversión de fase. Por tanto, es un caso especial de PauliChannel con \(p_Z = p\) y \(p_I = 1 - p\). Por ello, puede escribirse como operadores de Kraus:

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

o de forma similar como operador de salto:

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

donde ahora \(\gamma\) es la tasa de inversión de fase.

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

Despolarizante

Depolarizing representa un modelo de error despolarizante donde cada qubit tiene cierta probabilidad de ser reemplazado por el estado máximamente mezclado. Esto corresponde al siguiente canal:

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

donde \(p\) es la probabilidad despolarizante. Por tanto, es un caso especial de PauliChannel con \(p_X = p_Y = p_Z = p/3\) y \(p_I = 1 - p\). Por ello, puede escribirse como operadores 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 forma similar como operadores de salto:

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

donde \(\gamma\) es la tasa despolarizante.

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

AmplitudeDamping

AmplitudeDamping representa un modelo de error de amortiguamiento de amplitud donde cada qubit tiene cierta probabilidad de decaer desde el estado excitado \(|1⟩\) al estado fundamental \(|0⟩\). Esto corresponde al siguiente canal:

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

Aquí los operadores de Kraus se definen como:

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

donde \(p\) es la probabilidad de amortiguamiento de amplitud. El canal también puede representarse utilizando el operador de salto:

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

donde \(\gamma\) es la tasa de amortiguamiento de amplitud y \(\sigma_-\) es el operador de descenso. El canal está definido por la constante de tiempo \(T_1\), con las relaciones:

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

donde \(t\) es la duración temporal sobre la que ocurre el amortiguamiento de amplitud.

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

Desfasamiento

Dephasing representa un modelo de error de desfasamiento donde cada qubit tiene cierta probabilidad de perder coherencia entre sus estados \(|0⟩\) y \(|1⟩\). Esto corresponde al siguiente canal:

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

donde \(p\) es la probabilidad de desfasamiento. Por tanto, es un caso especial de PauliChannel con \(p_Z = p\) y \(p_I = 1 - p\). Por ello, puede escribirse como operadores de Kraus:

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

o de forma similar como operador de salto:

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

donde ahora \(\gamma\) es la tasa de desfasamiento. El canal está definido por la constante de tiempo \(T_\phi\), con las relaciones:

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

donde \(t\) es la duración temporal sobre la que ocurre el desfasamiento.

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

GaussianPerturbation

GaussianPerturbation representa un modelo de ruido que añade perturbaciones distribuidas gaussianamente a los parámetros de puertas o términos Hamiltonianos en un circuito o programa cuántico. Esto simula imperfecciones en las señales de control que pueden llevar a desviaciones de las operaciones previstas. Las perturbaciones se extraen de una distribución gaussiana con una desviación estándar especificada:

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

donde \(\sigma\) es la desviación estándar de las perturbaciones y \(\mu\) es la media (por defecto 0).

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

OffsetPerturbation

OffsetPerturbation representa un modelo de ruido que añade perturbaciones de desplazamiento fijo a los parámetros de puertas o términos Hamiltonianos en un circuito o programa cuántico. Esto simula errores sistemáticos en las señales de control que desplazan consistentemente las operaciones previstas. Los desplazamientos se especifican como valores fijos para cada parámetro.

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

ReadoutAssignment

ReadoutAssignment representa un modelo de error de lectura que simula imperfecciones en el proceso de medición de los qubits. Está definido por dos probabilidades: la probabilidad de leer erróneamente un estado \(|0⟩\) como \(|1⟩\) (\(p_{0 \to 1}\)) y la probabilidad de leer erróneamente un estado \(|1⟩\) como \(|0⟩\) (\(p_{1 \to 0}\)).

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