El código de Shor corrige cualquier error de un cúbit

En la lección anterior vimos cómo el código de Shor de 9 cúbits responde a los obstáculos (a) y (c) de la lección 1. Queda el más inquietante, el (b): los errores cuánticos son continuos. Un cúbit puede girar un poco, o mucho, de infinitas maneras. En las lecciones 3 y 4 vimos que un error $\cos\theta\,I-i\sin\theta\,X$ quedaba, al medir el síndrome, en «nada» o en «$X$». Hoy vemos que el mismo argumento vale para cualquier error en un cúbit. Es la lección central del curso.

La idea

Dos ingredientes, y ninguno es nuevo.

1. Linealidad. Toda matriz $2\times2$ es combinación lineal de cuatro matrices fijas, $I$, $X$, $Y$ y $Z$. Así que un error cualquiera $E$ en el cúbit $k$ actúa sobre el estado codificado como una suma de cuatro términos: «nada», «$X_k$», «$Y_k$» y «$Z_k$».
2. La medida del síndrome. Cada uno de esos cuatro términos tiene un síndrome distinto, y medir el síndrome se queda con un solo término y descarta el resto. Después de medir, el error es $I$, $X_k$, $Y_k$ o $Z_k$, y el síndrome nos dice cuál (o, para los $Z$, uno que hace lo mismo).

Si sabemos corregir esos tres errores de Pauli en cada cúbit, sabemos corregir cualquier error que afecte a un solo cúbit. Este paso de lo continuo a lo discreto se llama discretización de los errores.

Lo justo de las matrices de Pauli

Además de $X$ (cambio de bit) y $Z$ (cambio de fase) necesitamos su producto:

$$X=\begin{pmatrix}0&1\\1&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\\0&-1\end{pmatrix},\quad Y=iXZ=\begin{pmatrix}0&-i\\i&0\end{pmatrix}.$$

$Y$ es «los dos errores a la vez», salvo el factor $i$. Tres propiedades, que se comprueban multiplicando:

• $X^2=Y^2=Z^2=I$: cada una es su propia inversa, así que un error de Pauli se deshace aplicándolo otra vez.
• Anticonmutan dos a dos: $XZ=-ZX$, $XY=-YX$, $YZ=-ZY$.
• $I$, $X$, $Y$, $Z$ forman una base del espacio de las matrices $2\times 2$, que tiene dimensión 4.

Por la última propiedad, toda matriz $2\times2$ se escribe de forma única como

$$M=e_0I+e_1X+e_2Y+e_3Z,\qquad e_j=\tfrac12\operatorname{tr}(\sigma_jM),$$

con $\sigma_0,\sigma_1,\sigma_2,\sigma_3=I,X,Y,Z$. La fórmula de los coeficientes sale de que $\operatorname{tr}(\sigma_i\sigma_j)$ vale $2$ si $i=j$ y $0$ si no.

Repaso La traza

La traza de una matriz cuadrada es la suma de su diagonal: $\operatorname{tr}\begin{pmatrix}a&b\\c&d\end{pmatrix}=a+d$. Es lineal: $\operatorname{tr}(A+B)=\operatorname{tr}A+\operatorname{tr}B$ y $\operatorname{tr}(cA)=c\operatorname{tr}A$.

El síndrome de un error de un cúbit

Recordemos los 8 observables que se miden, en este orden:

$$Z_1Z_2,\ Z_2Z_3,\ Z_4Z_5,\ Z_5Z_6,\ Z_7Z_8,\ Z_8Z_9,\ X_1X_2X_3X_4X_5X_6,\ X_4X_5X_6X_7X_8X_9.$$

Los llamamos $g_1,\dots,g_8$. Los dos estados lógicos, y por tanto $\ket{\psi_L}=\alpha\ket{0_L}+\beta\ket{1_L}$, son autoestados $+1$ de los ocho. Como en la lección 3, si $E$ es un producto de operadores de Pauli, al medir $g_j$ sobre $E\ket{\psi_L}$ sale $+1$ con certeza si $g_j$ y $E$ conmutan, y $-1$ si anticonmutan. Apuntamos un $0$ por cada $+1$ y un $1$ por cada $-1$: eso es el síndrome, una cadena de 8 bits.

¿Cómo saber si conmutan? Es el criterio de la lección 3, ahora con $Y$: se miran los cúbits donde los dos operadores tienen matrices de Pauli distintas (ninguna $I$). Cada choque aporta un signo $-1$. Con un número par de choques, conmutan; con uno impar, anticonmutan.

• $X_i$ choca con los $Z_aZ_b$ que contienen el cúbit $i$: eso localiza el $X$ dentro de su bloque, como en el código de repetición.
• $Z_i$ choca con los $X\cdots X$ de seis cúbits que contienen $i$: eso dice en qué bloque está, pero no en qué cúbit del bloque.
• $Y_i$ choca con todos ellos, porque $Y$ es distinta de $X$ y de $Z$: su síndrome es la suma (bit a bit, módulo 2) de los de $X_i$ y $Z_i$.

Aquí está la tabla completa de los $9\times3=27$ errores de peso 1.

cúbit	$X_i$	$Z_i$	$Y_i$
1	10000000	00000010	10000010
2	11000000	00000010	11000010
3	01000000	00000010	01000010
4	00100000	00000011	00100011
5	00110000	00000011	00110011
6	00010000	00000011	00010011
7	00001000	00000001	00001001
8	00001100	00000001	00001101
9	00000100	00000001	00000101

Ningún síndrome es $00000000$, así que todos se detectan. Pero solo hay 21 síndromes distintos para 27 errores: los nueve $X_i$ y los nueve $Y_i$ tienen síndromes propios, mientras que $Z_1,Z_2,Z_3$ comparten $00000010$, y lo mismo pasa con $Z_4,Z_5,Z_6$ y con $Z_7,Z_8,Z_9$. En un código clásico, dos errores con el mismo síndrome serían un desastre: no sabríamos cuál corregir. Aquí no lo es.

Corregir, y por qué no hace falta saber qué error fue

El decodificador es una tabla: a cada síndrome le asigna una corrección. Para los síndromes de $X_i$ e $Y_i$, la corrección es ese mismo $X_i$ o $Y_i$. Para los tres síndromes de tipo $Z$ elegimos uno por bloque: $Z_1$, $Z_4$ y $Z_7$.

Error $X_5$. $X_5$ choca con $Z_4Z_5$ y con $Z_5Z_6$, y con nada más. Síndrome $00110000$. La tabla dice $X_5$; como $X_5X_5=I$, el estado queda exactamente $\alpha\ket{0_L}+\beta\ket{1_L}$.

Error $Z_2$. $Z_2$ solo choca con $X_1\cdots X_6$. Síndrome $00000010$. La tabla no dice $Z_2$, sino $Z_1$. ¿Lo estropeamos? No:

$$Z_1Z_2\ket{\psi_L}=\ket{\psi_L},$$

porque $Z_1Z_2$ es $g_1$, uno de los observables que fijan el código. Dicho de otra forma: $Z_1\ket{\psi_L}$ y $Z_2\ket{\psi_L}$ son el mismo vector. Los dos cambian el signo de $\ket{111}$ en el primer bloque, y nada más:

$$Z_1\ket{\psi_L}=Z_2\ket{\psi_L}=\tfrac{\alpha}{2\sqrt2}(\ket{000}-\ket{111})(\ket{000}+\ket{111})(\ket{000}+\ket{111})+\tfrac{\beta}{2\sqrt2}(\ket{000}+\ket{111})(\ket{000}-\ket{111})(\ket{000}-\ket{111}).$$

La pregunta «¿fue $Z_1$, $Z_2$ o $Z_3$?» no tiene respuesta, y no la necesita: sobre el código, los tres errores hacen exactamente lo mismo. Corregir con cualquiera de ellos devuelve el estado. Esto es la degeneración: errores distintos que actúan igual sobre el código, porque se diferencian en un operador que lo fija ($Z_1Z_2$, $Z_2Z_3$ o $Z_1Z_3=g_1g_2$). No tiene análogo clásico, y es la razón de que 21 síndromes basten para 27 errores.

Error $Y_8$. Como $Y_8=iX_8Z_8$, su síndrome es el de $X_8$ más el de $Z_8$: $00001100+00000001=00001101$. La tabla dice $Y_8$, y $Y_8Y_8=I$.

Un error continuo se vuelve discreto

Ahora el caso general. Un error cualquiera $E$ en el cúbit $k$ se escribe $E=e_0I+e_1X+e_2Y+e_3Z$, así que

$$E_k\ket{\psi_L}=e_0\ket{\psi_L}+e_1X_k\ket{\psi_L}+e_2Y_k\ket{\psi_L}+e_3Z_k\ket{\psi_L}.$$

Cada uno de esos cuatro vectores es autoestado de los 8 observables, con síndromes $00000000$, el de $X_k$, el de $Y_k$ y el de $Z_k$: cuatro síndromes distintos, para cualquier $k$ (la tabla lo muestra). Medir los 8 observables, que conmutan entre sí, es proyectar sobre el subespacio de un síndrome $s$, con el proyector

$$P_s=\prod_{j=1}^{8}\frac{I+(-1)^{s_j}g_j}{2}.$$

Ese proyector deja intacto el término con síndrome $s$ y anula los otros tres. Además los cuatro vectores son ortogonales (están en autoespacios distintos) y tienen norma 1 (las matrices de Pauli son unitarias: conservan la longitud, lección 1). Si $E$ es unitaria, $E_k\ket{\psi_L}$ tiene norma 1 y, por Pitágoras, $|e_0|^2+|e_1|^2+|e_2|^2+|e_3|^2=1$. Por tanto:

• el resultado es el de $X_k$ con probabilidad $|e_1|^2$, el de $Y_k$ con $|e_2|^2$, el de $Z_k$ con $|e_3|^2$ y $00000000$ con $|e_0|^2$;
• después de medir, el estado es el término correspondiente, por ejemplo $X_k\ket{\psi_L}$, multiplicado por una fase $e_1/|e_1|$;
• la tabla aplica $X_k$ (o $Y_k$, o $Z_k$, o nada) y queda $\ket{\psi_L}$ salvo esa fase global, que no se puede observar (lección 1).

Fíjate en que las probabilidades no dependen de $\alpha$ ni de $\beta$: medir el síndrome no aprende nada del dato. Que las probabilidades sumen 1 sí usa que $E$ es unitaria, pero lo demás no: para cualquier matriz, cada rama sale con probabilidad proporcional a $|e_j|^2$ y se corrige igual.

¿Y si el error afecta a varios cúbits? Entonces puede que varios términos de Pauli tengan el mismo síndrome, y la medida se queda con el grupo de términos de ese síndrome. Si dentro del grupo todos se diferencian, salvo un signo o una fase, en operadores que fijan el código (como $Z_1$ y $Z_2$), sobre el código son el mismo vector salvo ese factor, y una corrección arregla el grupo entero (ejercicio 3). Si se diferencian en algo que cambia el dato, la corrección falla; lo veremos al final.

Ejemplo resuelto

Un error que no es de Pauli actúa sobre el cúbit 4:

$$U=\frac{1}{2\sqrt3}\begin{pmatrix}3+i&1+i\\-1+i&3-i\end{pmatrix}.$$

Es unitaria: cada columna tiene norma 1 ($\tfrac{|3+i|^2+|-1+i|^2}{12}=\tfrac{10+2}{12}=1$, e igual la segunda) y las dos son ortogonales. No es ninguna de las cuatro matrices de Pauli.

Paso 1: la base de Pauli. Para $U=\begin{pmatrix}u_{11}&u_{12}\\u_{21}&u_{22}\end{pmatrix}$ no hace falta multiplicar las matrices enteras: $\operatorname{tr}(XU)=u_{12}+u_{21}$, $\operatorname{tr}(YU)=i(u_{12}-u_{21})$ y $\operatorname{tr}(ZU)=u_{11}-u_{22}$. Aquí:

• $\operatorname{tr}U=\tfrac{6}{2\sqrt3}=\sqrt3$, luego $e_0=\tfrac{\sqrt3}{2}$.
• $\operatorname{tr}(XU)=\tfrac{(1+i)+(-1+i)}{2\sqrt3}=\tfrac{i}{\sqrt3}$, luego $e_1=\tfrac{i}{2\sqrt3}$.
• $\operatorname{tr}(YU)=i\,\tfrac{(1+i)-(-1+i)}{2\sqrt3}=\tfrac{i}{\sqrt3}$, luego $e_2=\tfrac{i}{2\sqrt3}$.
• $\operatorname{tr}(ZU)=\tfrac{(3+i)-(3-i)}{2\sqrt3}=\tfrac{i}{\sqrt3}$, luego $e_3=\tfrac{i}{2\sqrt3}$.

Así que

$$U=\frac{\sqrt3}{2}\,I+\frac{i}{2\sqrt3}\,(X+Y+Z).$$

Compruébalo con $X+Y+Z=\begin{pmatrix}1&1-i\\1+i&-1\end{pmatrix}$.

Paso 2: el estado con error.

$$U_4\ket{\psi_L}=\frac{\sqrt3}{2}\ket{\psi_L}+\frac{i}{2\sqrt3}X_4\ket{\psi_L}+\frac{i}{2\sqrt3}Y_4\ket{\psi_L}+\frac{i}{2\sqrt3}Z_4\ket{\psi_L}.$$

Paso 3: medir el síndrome. Los cuatro términos tienen síndromes distintos (filas del cúbit 4 de la tabla):

resultado	probabilidad	estado tras medir	corrección	estado final
00000000	$\tfrac34$	$\ket{\psi_L}$	ninguna	$\ket{\psi_L}$
00100000	$\tfrac1{12}$	$iX_4\ket{\psi_L}$	$X_4$	$i\ket{\psi_L}$
00100011	$\tfrac1{12}$	$iY_4\ket{\psi_L}$	$Y_4$	$i\ket{\psi_L}$
00000011	$\tfrac1{12}$	$iZ_4\ket{\psi_L}$	$Z_4$	$i\ket{\psi_L}$

Las probabilidades son $|e_0|^2=\tfrac34$ y $|e_j|^2=\tfrac1{12}$, y suman 1.

Resultado: en las cuatro ramas acabamos en $\alpha\ket{0_L}+\beta\ket{1_L}$, con una fase global $1$ o $i$ que no tiene ningún efecto. Un error continuo, que nadie conocía de antemano, se ha corregido exactamente. Ni siquiera hemos usado la forma concreta de $U$: solo que actúa en un único cúbit.

Cuando hay dos errores

El código tiene distancia 3 (lo veremos en la lección 8): corrige un error, no dos. Supón que ocurren $X_1$ y $X_2$. El síndrome es la suma de los suyos:

$$10000000+11000000=01000000,$$

que es el síndrome de $X_3$. El decodificador aplica $X_3$ y el resultado es

$$X_3X_1X_2\ket{\psi_L}=X_1X_2X_3\ket{\psi_L}=\alpha\ket{0_L}-\beta\ket{1_L},$$

porque $X_1X_2X_3$ es el operador lógico $\bar Z$ de la lección 4. Es un estado del código válido, pero no es el que guardamos. Es un error lógico, y nada lo avisa. Pasa como con dos errores en el Hamming clásico (decodificación por síndrome): con más errores de la cuenta, el decodificador se equivoca sin saberlo. Algunos errores de peso 2 sí se arreglan, como $Z_1Z_2$, que tiene síndrome $00000000$ y no hace nada porque fija el código.

Fíjate en la diferencia con $Z_1$ y $Z_2$: $X_1X_2$ y $X_3$ tienen el mismo síndrome, pero se diferencian en $X_1X_2X_3$, que sí cambia el dato. Eso es lo que separa la degeneración (inofensiva) del error lógico.

Ejercicios

Ejercicio 1

Calcula el síndrome de $Z_6$ y el de $Y_3$, y di qué aplica el decodificador en cada caso. ¿Recupera el estado?

Ver la solución

$Z_6$ solo choca con los dos observables de seis $X$, porque el cúbit 6 está en los dos: síndrome $00000011$. El decodificador aplica $Z_4$, y $Z_4Z_6=(Z_4Z_5)(Z_5Z_6)=g_3g_4$ fija el código: el estado vuelve exactamente.

$Y_3$ choca con $Z_2Z_3$ y con $X_1\cdots X_6$: síndrome $01000000+00000010=01000010$. El decodificador aplica $Y_3$ y $Y_3Y_3=I$: recupera el estado.

Ejercicio 2

Un error de fase pequeño $D=\begin{pmatrix}1&0\\0&e^{i\theta}\end{pmatrix}$ actúa sobre el cúbit 2. Escríbelo en la base de Pauli, da los resultados posibles del síndrome con sus probabilidades y comprueba que se corrige. ¿Cuánto vale la probabilidad de detectar algo si $\theta=0{,}1$?

Ver la solución

Las trazas dan $e_0=\tfrac12\operatorname{tr}D=\tfrac{1+e^{i\theta}}{2}$, $e_3=\tfrac12\operatorname{tr}(ZD)=\tfrac{1-e^{i\theta}}{2}$ y $e_1=e_2=0$ ($XD$ e $YD$ tienen la diagonal nula). Así que $D=\tfrac{1+e^{i\theta}}{2}I+\tfrac{1-e^{i\theta}}{2}Z$ y

$$D_2\ket{\psi_L}=\tfrac{1+e^{i\theta}}{2}\ket{\psi_L}+\tfrac{1-e^{i\theta}}{2}Z_2\ket{\psi_L}.$$

Hay dos resultados. $00000000$ con probabilidad $\left|\tfrac{1+e^{i\theta}}{2}\right|^2=\cos^2\tfrac\theta2$: el estado queda $\ket{\psi_L}$ salvo fase. $00000010$ con probabilidad $\left|\tfrac{1-e^{i\theta}}{2}\right|^2=\sin^2\tfrac\theta2$: queda $Z_2\ket{\psi_L}$ salvo fase; el decodificador aplica $Z_1$, y $Z_1Z_2\ket{\psi_L}=\ket{\psi_L}$. Se corrige en los dos casos, aunque el decodificador «se equivoque» de cúbit.

Con $\theta=0{,}1$, $\sin^2(0{,}05)\approx0{,}0025$: un $0{,}25\,\%$. Casi siempre la medida dice «no hay error», y entonces el error desaparece: el estado queda limpio.

Ejercicio 3

Un error de fase conjunto actúa a la vez sobre los cúbits 1 y 2: $E=R\otimes R$ en esos dos cúbits, con $R=\cos\tfrac\theta2\,I-i\sin\tfrac\theta2\,Z$. Es un error de peso 2. Desarróllalo en la base de Pauli, mide el síndrome y comprueba que, aun así, se corrige.

Ver la solución

Con $c=\cos\tfrac\theta2$ y $s=\sin\tfrac\theta2$:

$$E=c^2I-ics\,(Z_1+Z_2)-s^2Z_1Z_2.$$

Los cuatro términos forman dos grupos por síndrome. $I$ y $Z_1Z_2$ tienen síndrome $00000000$; $Z_1$ y $Z_2$ tienen $00000010$. Sobre el código, $Z_1Z_2$ actúa como $I$ y $Z_2$ como $Z_1$. Así que

$$E\ket{\psi_L}=(c^2-s^2)\ket{\psi_L}-2ics\,Z_1\ket{\psi_L}=\cos\theta\,\ket{\psi_L}-i\sin\theta\,Z_1\ket{\psi_L}.$$

Resultado $00000000$ con probabilidad $\cos^2\theta$, y el estado queda $\ket{\psi_L}$ (salvo el signo de $\cos\theta$). Resultado $00000010$ con probabilidad $\sin^2\theta$, y queda $Z_1\ket{\psi_L}$ salvo fase; el decodificador aplica $Z_1$ y se recupera. Este error de peso 2 se corrige siempre: dentro de cada grupo, los términos se diferencian en $Z_1Z_2$, que fija el código.

En resumen

• $\{I,X,Y,Z\}$, con $Y=iXZ$, es una base de las matrices $2\times2$: todo error de un cúbit es $e_0I+e_1X+e_2Y+e_3Z$, con $e_j=\tfrac12\operatorname{tr}(\sigma_jM)$.
• En el código de Shor, $I$, $X_k$, $Y_k$ y $Z_k$ tienen síndromes distintos. Medir el síndrome proyecta el error continuo sobre uno solo, con probabilidad $|e_j|^2$, que no depende del dato, y tras corregir queda $\alpha\ket{0_L}+\beta\ket{1_L}$ salvo una fase global. Es la respuesta al obstáculo (b).
• Los 27 errores de peso 1 dan 21 síndromes: $Z_1,Z_2,Z_3$ comparten uno (y así cada bloque), pero da igual cuál se corrija, porque $Z_1Z_2$ fija el código. Es la degeneración.
• Con dos errores puede fallar: $X_1X_2$ se «corrige» con $X_3$ y deja $\alpha\ket{0_L}-\beta\ket{1_L}$, un error lógico silencioso.

Siguiente lección: Matrices de Pauli y producto simpléctico