Discretización de errores

Hasta ahora hemos considerado errores $X$ y errores $Z$ en el contexto del código de Shor de 9 qubits. En esta sección nos ocuparemos de errores arbitrarios. Comprobaremos que para tratar tales errores no necesitamos hacer nada diferente de lo que ya hemos discutido; la capacidad de corregir errores $X$, errores $Z$ o ambos implica la capacidad de corregir errores arbitrarios. Este fenómeno se denomina a veces discretización de errores.

Errores unitarios de qubit

Comencemos con errores unitarios de un solo qubit. Un error así podría corresponder, por ejemplo, a una rotación muy pequeña de la esfera de Bloch, representando un error debido a una puerta imperfecta. O podría ser cualquier otra operación unitaria sobre un qubit, que no necesariamente está cerca de la identidad.

Puede parecer que corregir tales errores sería difícil. Después de todo, hay infinitos errores posibles de este tipo, y es inconcebible identificar cada error exactamente y luego revertirlo. Sin embargo, siempre que podamos corregir una inversión de bit, una inversión de fase o ambas, los procedimientos descritos anteriormente en la lección corregirán con éxito cualquier error unitario arbitrario de un solo qubit.

Para entender por qué esto es así, reconocemos primero que cualquier matriz unitaria $2 \times 2$ arbitraria $U$, que representa un error en un solo qubit, puede expresarse como combinación lineal de las cuatro matrices de Pauli (incluyendo la matriz identidad).

$$U = \alpha \mathbb{I} + \beta X + \gamma Y + \delta Z$$

Como veremos, al ejecutar los circuitos de detección de errores, las mediciones que nos proporcionan los bits del síndrome colapsan probabilísticamente el estado de la codificación a un estado en el que ha ocurrido un error (o ningún error) representado por una de las cuatro matrices de Pauli. (Del hecho de que $U$ es unitaria se deduce que los números $\alpha,$ $\beta,$ $\gamma,$ y $\delta$ deben satisfacer la condición $\vert\alpha\vert^2 + \vert\beta\vert^2 + \vert\gamma\vert^2 + \vert\delta\vert^2 = 1$, y de hecho $\vert\alpha\vert^2,$ $\vert\beta\vert^2,$ $\vert\gamma\vert^2,$ y $\vert\delta\vert^2$ son las probabilidades con las que el estado codificado colapsa a un estado en el que ha ocurrido el error de Pauli correspondiente.)

Para explicar cómo funciona esto más precisamente, es conveniente usar índices para indicar en qué qubit actúa una determinada operación unitaria de qubit. Por ejemplo, si usamos la convención de numeración de qubits de Qiskit $(\mathsf{Q}_8,\mathsf{Q}_7,\ldots,\mathsf{Q}_0)$ para numerar los 9 qubits del código de Shor, obtenemos estas expresiones para diversas operaciones unitarias sobre qubits individuales, donde en cada caso tensoramos la matriz unitaria con la matriz identidad en cada otro qubit.

$$\begin{aligned} X_0 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes X \\[1.5mm] Z_4 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \\[1.5mm] U_7 & = \mathbb{I} \otimes U \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \end{aligned}$$

Para una operación unitaria de qubit $U$ dada, podemos expresar la acción de $U$ sobre el qubit $k$ con la siguiente fórmula, similar a la anterior, donde cada matriz representa una operación aplicada al qubit $k$.

$$U_k = \alpha \mathbb{I}_k + \beta X_k + \gamma Y_k + \delta Z_k$$

Ahora sea $\vert\psi\rangle$ la codificación de 9 qubits de un estado de qubit. Si el error $U$ ocurre en el qubit $k$, obtenemos el estado $U_k \vert\psi\rangle$, que puede expresarse como combinación lineal de operaciones de Pauli actuando sobre $\vert\psi\rangle$ de la siguiente manera.

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + \gamma Y_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

En este punto hacemos la sustitución $Y = iXZ$.

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + i \gamma X_kZ_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

Consideremos ahora los pasos de detección y corrección de errores descritos anteriormente. Podemos considerar los resultados de medición de las tres verificaciones de paridad del código interno junto con las del código externo como un solo síndrome de 8 bits. Inmediatamente antes de las mediciones reales en la base estándar que producen estos bits de síndrome, el estado tiene la siguiente forma.

$$\begin{gathered} \alpha\,\vert \mathbb{I} \text{ síndrome}\rangle \otimes \vert\psi\rangle \\ + \beta\,\vert X_k \text{ síndrome}\rangle \otimes X_k\vert\psi\rangle \\ + i \gamma\,\vert X_k Z_k \text{ síndrome}\rangle \otimes X_k Z_k\vert\psi\rangle \\ + \delta\,\vert Z_k \text{ síndrome}\rangle \otimes Z_k\vert\psi\rangle \end{gathered}$$

Para ser claros: en este punto tenemos dos sistemas. El sistema de la izquierda son los 8 qubits que medimos para obtener el síndrome, donde $\vert \mathbb{I} \text{ síndrome}\rangle,$ $\vert X_k \text{ síndrome}\rangle$ etc. representan el estado de la base estándar de 8 qubits correspondiente al error (o no error) respectivo. El sistema de la derecha son los 9 qubits que usamos para la codificación.

Nótese que estos dos sistemas están ahora (en general) correlacionados — y esta es la clave de por qué esto funciona. Al medir el síndrome, el estado de los 9 qubits de la derecha colapsa efectivamente a uno en el que un error de Pauli, consistente con el síndrome medido, ha sido aplicado a uno de los qubits. Además, el síndrome mismo proporciona suficiente información para revertir el error y restaurar la codificación original $\vert\psi\rangle$.

Cuando se miden los qubits del síndrome y se realizan las correcciones correspondientes, obtenemos un estado que puede expresarse como una matriz de densidad:

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

donde

$$\begin{aligned} \xi = & \vert\alpha\vert^2 \vert \mathbb{I} \text{ síndrome}\rangle\langle \mathbb{I} \text{ síndrome}\vert \\[1mm] & + \vert\beta\vert^2 \vert X_k \text{ síndrome}\rangle\langle X_k \text{ síndrome}\vert\\[1mm] & + \vert\gamma\vert^2 \vert X_k Z_k \text{ síndrome}\rangle\langle X_k Z_k \text{ síndrome}\vert\\[1mm] & + \vert\delta\vert^2 \vert Z_k \text{ síndrome}\rangle\langle Z_k \text{ síndrome}\vert. \end{aligned}$$

Lo crucial es que este es un estado producto: tenemos nuestra codificación original, no corrompida, como factor tensorial derecho, y a la izquierda tenemos una matriz de densidad $\xi$ que describe un síndrome de error aleatorio. Ya no hay correlación con el sistema de la derecha, que es el único que nos interesa, porque los errores han sido corregidos. En este punto podemos descartar o reinicializar los qubits del síndrome, de modo que podamos reutilizarlos. Así es como la aleatoriedad — o entropía — generada por los errores se elimina del sistema.

Esto es la discretización de errores para el caso especial de errores unitarios. En esencia, al medir el síndrome, efectivamente proyectamos el error en un error descrito por una matriz de Pauli.

A primera vista puede parecer demasiado bueno para ser verdad que podamos corregir errores unitarios arbitrarios de esta manera, incluso errores que son diminutos y apenas perceptibles por sí mismos. Sin embargo, lo que hay que entender aquí es: se trata de un error unitario en un solo qubit, y por el diseño del código, una operación de un solo qubit no puede cambiar el estado del qubit lógico codificado. Todo lo que puede hacer es mover el estado fuera del subespacio de codificaciones válidas — pero entonces las detecciones de errores colapsan el estado, y las correcciones lo devuelven a su punto de partida.

Errores de qubit arbitrarios

Finalmente, consideremos errores arbitrarios que no son necesariamente unitarios. Más precisamente, consideramos un error descrito por un canal de qubit arbitrario $\Phi$. Esto podría ser, por ejemplo, un canal de desfasamiento o despolarización, un canal de reinicio, o un canal inusual en el que nunca hemos pensado.

El primer paso es considerar una representación de Kraus arbitraria de $\Phi$.

$$\Phi(\sigma) = \sum_j A_j \sigma A_j^{\dagger}$$

Este es un canal de qubit, por lo que cada $A_j$ es una matriz de $2\times 2$ que podemos expresar como combinación lineal de matrices de Pauli.

$$A_j = \alpha_j \mathbb{I} + \beta_j X + \gamma_j Y + \delta_j Z$$

Con esto, podemos expresar la acción del error $\Phi$ sobre un qubit elegido $k$ en términos de matrices de Pauli de la siguiente manera.

$$\Phi_k \bigl( \vert\psi\rangle\langle\psi\vert\bigr) = \sum_j (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k) \vert\psi\rangle\langle\psi\vert (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k)^{\dagger}$$

En resumen: hemos desarrollado todas nuestras matrices de Kraus como combinaciones lineales de matrices de Pauli.

Si ahora calculamos y medimos el síndrome de error y corregimos todos los errores descubiertos, obtenemos un estado similar al del caso de un error unitario:

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

donde esta vez:

$$\begin{aligned} \xi = & \sum_j \Bigl(\vert\alpha_j\vert^2 \vert \mathbb{I} \text{ síndrome}\rangle\langle \mathbb{I} \text{ síndrome}\vert \\[-3mm] & \qquad + \vert\beta_j\vert^2 \vert X_k \text{ síndrome}\rangle\langle X_k \text{ síndrome}\vert\\[2mm] & \qquad + \vert\gamma_j\vert^2 \vert X_k Z_k \text{ síndrome}\rangle\langle X_k Z_k \text{ síndrome}\vert\\[2mm] & \qquad + \vert\delta_j\vert^2 \vert Z_k \text{ síndrome}\rangle\langle Z_k \text{ síndrome}\vert \Bigr). \end{aligned}$$

Los detalles son algo más engorrosos y no se muestran aquí. Conceptualmente, la idea es idéntica al caso unitario.

Generalización

La discretización de errores se generaliza a otros códigos correctores de errores cuánticos, incluidos aquellos que pueden detectar y corregir errores en múltiples qubits. En tales casos, los errores en múltiples qubits pueden expresarse como productos tensoriales de matrices de Pauli, y diferentes síndromes correspondientes prescriben correcciones de operaciones de Pauli que posiblemente se realizan en múltiples qubits en lugar de uno solo.

Al medir el síndrome, los errores se proyectan o colapsan efectivamente en un conjunto discreto de posibilidades representadas por productos tensoriales de matrices de Pauli; al corregir estos errores de Pauli, podemos restaurar el estado originalmente codificado. La aleatoriedad generada en este proceso se transfiere a los qubits del síndrome, que se descartan o reinicializan — y así la aleatoriedad generada en este proceso se elimina del sistema que almacena la codificación.