Operadores lógicos, distancia y estados lógicos de un código

En la lección anterior definimos un código estabilizador: un grupo abeliano $S$ de Pauli cuyo subespacio fijo es el código, y un síndrome $s_j=\langle g_j,e\rangle_s$ que dice qué generadores anticonmutan con el error. En el relato, Shor ya contestó a los tres obstáculos y el marco de Pauli y estabilizadores es el lenguaje general. Hoy lo usamos para medir un código: ¿qué errores no ve?, ¿cuántos corrige? y, por fin, ¿cómo son sus estados $\ket{0_L}$ y $\ket{1_L}$?

La idea

Un error de Pauli $E$ puede hacer tres cosas muy distintas. Puede delatarse: anticonmuta con algún generador y el síndrome sale distinto de cero. Puede no hacer nada: es un elemento de $S$ y fija todo el código. O puede ser el peor caso: conmuta con todo $S$, nadie lo detecta, pero cambia el dato. Son los operadores lógicos, y el más ligero de ellos marca la distancia del código.

Es la misma historia que en el curso de códigos: la distancia mínima decide cuánto daño aguanta el código. Aquí cambia un detalle esencial, y es que no todo vector que el código «no ve» es peligroso.

El normalizador y las tres clases

Sea $C\subseteq\mathbb{F}_2^{2n}$ el subespacio de los vectores de $S$, de dimensión $n-k$. Los Pauli que conmutan con todo $S$ son los de $C^{\perp_s}$, que tiene dimensión $2n-(n-k)=n+k$. Es el normalizador del código. Como $C\subseteq C^{\perp_s}$, cada error cae en una de tres clases:

1. Fuera de $C^{\perp_s}$: el síndrome no es nulo. El error se detecta.
2. En $C$: es un elemento de $S$ (salvo fase). Sobre el código actúa como la identidad: es inofensivo.
3. En $C^{\perp_s}\setminus C$: síndrome nulo, así que no se detecta, y no está en el grupo estabilizador, así que mueve estados del código a otros estados del código. Es un operador lógico.

Para la repetición de 3 cúbits ($S=\langle Z_1Z_2,Z_2Z_3\rangle$) hay $4^3=64$ errores de Pauli. El normalizador tiene $2^4=16$ elementos, de los cuales 4 están en $C$. Quedan $48$ con síndrome no nulo, $4$ inofensivos y $12$ lógicos.

Los operadores lógicos hacen en el cúbit protegido lo que $X$ y $Z$ hacen en un cúbit normal. Escogemos dos que anticonmuten entre sí, $\bar X$ y $\bar Z$ (para $k=1$ siempre se puede). Dos operadores lógicos que se diferencian en un elemento de $S$ hacen lo mismo sobre el código. En la repetición, $\bar Z=Z_1$, $Z_2$ o $Z_3$ dan igual, porque $Z_1Z_2\in S$.

Distancia

La distancia de un código estabilizador con $k\ge1$ es el peso del operador lógico más ligero:

$$d=\min\{\mathrm{wt}(v): v\in C^{\perp_s}\setminus C\}.$$

Se escribe $[[n,k,d]]$, con dobles corchetes para distinguirlo de $[n,k,d]$ clásico.

Consecuencias. El código detecta cualquier error de peso $\le d-1$: no puede ser lógico (pesa menos que $d$), así que o bien tiene síndrome no nulo, o bien está en $C$ y no hace nada. Y corrige $t=\lfloor (d-1)/2\rfloor$ errores. La razón de una línea: si $E$ y $E'$ pesan $\le t$ y tienen el mismo síndrome, $E'^{\dagger}E$ pesa $\le 2t<d$ y tiene síndrome nulo, luego no es lógico y está en $C$. Corregir con $E'$ cuando ocurrió $E$ deja el estado igual que estaba (salvo una fase global, que no importa).

Degeneración. Esa razón admite que $E\neq E'$. Dos errores distintos con el mismo síndrome y con $E'^{\dagger}E\in S$ tienen el mismo efecto sobre el código, y da igual cuál de los dos se corrija. No tiene análogo clásico: en un código lineal, dos errores distintos con el mismo síndrome se diferencian en una palabra no nula del código, y corregir con el equivocado deja una palabra equivocada. El ejemplo de Shor lo muestra: $Z_1$ y $Z_2$ dan el mismo síndrome y $Z_1Z_2\in S$.

Puente con el curso clásico. La distancia mínima clásica pide que toda palabra no nula pese al menos $d$. Aquí solo se exige a los vectores de $C^{\perp_s}\setminus C$, porque los de $C$ (los elementos de $S$) son inofensivos. Y el peso cuenta posiciones, sin importar si el error es $X$, $Z$ o $Y$. Por eso la repetición, que como código clásico $[3,1,3]$ tiene $d=3$, es un $[[3,1,1]]$: $Z_1$ pesa 1 y es lógico.

Estados lógicos de un código estabilizador

Un código con $k=1$ es un subespacio de dimensión 2. Para describirlo hay que dar una base $\ket{0_L},\ket{1_L}$. Con los operadores lógicos es inmediato.

Definición. $\ket{0_L}$ es el estado del código que es autoestado $+1$ de $\bar Z$ (y de todo $S$, por estar en el código). Con $k=1$ es único salvo fase. Y

$$\ket{1_L}=\bar X\ket{0_L}.$$

Como $\bar X$ conmuta con $S$, $\ket{1_L}$ también está en el código. Como $\bar Z\bar X=-\bar X\bar Z$, es autoestado $-1$ de $\bar Z$: es ortogonal a $\ket{0_L}$.

El truco de la suma. Hay una receta para fabricar $\ket{0_L}$ sin resolver ecuaciones. Sea

$$\ket{v}=\sum_{g\in S} g\ket{0\cdots0}.$$

Si multiplicas $\ket v$ por un $h\in S$, los $g$ se reordenan: $h\ket v=\ket v$. Luego $\ket v$ está en el código. (De hecho $\frac{1}{|S|}\sum_{g\in S}g$ es el proyector sobre el código, así que $\ket v$ es, salvo el factor $|S|$, la proyección de $\ket{0\cdots0}$.)

Hay que comprobar que no sale cero. Sale cero solo si $S$ contiene un operador de tipo $Z$ (solo $Z$ e identidades) con signo $-$, como $-Z_1Z_2$, que da $-1$ sobre $\ket{0\cdots0}$. En todos nuestros ejemplos no pasa.

¿Qué estado sale? La regla práctica: busca un operador lógico de tipo $Z$ y con signo $+$, un $Z(b)$ tal cual que conmute con $S$ sin estar en $S$. Con $k=1$ siempre hay alguno. Fija $\ket{0\cdots0}$ y conmuta con todo $S$, así que fija $\ket v$: $\ket v$ es su autoestado $+1$ dentro del código. Qué estado lógico es depende solo del nombre que le hayamos dado a ese operador:

• Si es nuestro $\bar Z$ (como en la repetición o, en la lección 10, en Steane), $\ket v\propto\ket{0_L}$.
• Si es nuestro $\bar X$, $\ket v$ es el estado con $\bar X=+1$, que es $(\ket{0_L}+\ket{1_L})/\sqrt2$. Para llegar a $\ket{0_L}$ se aplica $I+\bar Z$: $(I+\bar Z)(\ket{0_L}+\ket{1_L})=2\ket{0_L}$.

El segundo caso es el de Shor. En la lección 4 llamamos $\bar X$ al lógico de tipo $Z$, $Z_1Z_4Z_7$. Podríamos haberlo llamado $\bar Z$, pero entonces los estados de la lección 4 cambiarían de nombre. La suma no se equivoca: refleja la elección «cruzada».

Repaso Los detalles del truco de la suma

Por qué sale cero o no. Llama $S_Z$ a los elementos de $S$ de tipo $Z$, con su signo. Cada uno deja $\ket{0\cdots0}$ igual o le cambia el signo. Agrupa los $g\in S$ según su parte $X$: dos elementos con la misma parte $X$ se diferencian en un elemento de $S_Z$. Si todos los de $S_Z$ dan $+1$, cada grupo aporta $|S_Z|$ veces el mismo ket, y grupos distintos dan kets distintos: $\ket v\neq0$ y $\lVert v\rVert^2=|S|\cdot|S_Z|$. Si alguno diera $-1$, la mitad de cada grupo daría $-1$ y se cancelaría con la otra mitad: $\ket v=0$. Entonces se prueba con otro ket de la base en lugar de $\ket{0\cdots0}$.

Por qué siempre hay un lógico de tipo $Z$. Los $(0\mid b)$ que conmutan con $S$ forman un subespacio de dimensión $n-\operatorname{rg}A$ (con $A$ la parte $X$ de la matriz de estabilizadores de la lección 7), y los que están en $C$, uno de dimensión $r-\operatorname{rg}A$. La diferencia es $n-r=k\ge1$.

Todos los casos. Con $k=1$, un lógico $Z(b)$ actúa sobre el código como uno de $\pm\bar Z$, $\pm\bar X$ o $\pm\bar Y$, con $\bar Y=i\bar X\bar Z$, según cómo se hayan elegido $\bar X$ y $\bar Z$. La suma da su autoestado $+1$: $\ket{0_L}$, $\ket{1_L}$, $(\ket{0_L}\pm\ket{1_L})/\sqrt2$ o $(\ket{0_L}\pm i\ket{1_L})/\sqrt2$. Por ejemplo, si en la repetición se toma $\bar Z=-Z_1$ (también anticonmuta con $\bar X$), la suma da $\ket{1_L}$. Con la elección natural, $\bar Z=Z_1$, da $\ket{0_L}$.

Ejemplo resuelto

Repetición $[[3,1,1]]$. $S=\{I,\,Z_1Z_2,\,Z_2Z_3,\,Z_1Z_3\}$, $\bar Z=Z_1$ (de tipo $Z$), $\bar X=X_1X_2X_3$. Los cuatro elementos de $S$ fijan $\ket{000}$:

$$\ket v=4\ket{000}\quad\Longrightarrow\quad \ket{0_L}=\ket{000}.$$

Es no nulo y $Z_1\ket{000}=\ket{000}$. Entonces

$$\ket{1_L}=X_1X_2X_3\ket{000}=\ket{111}.$$

Son ortogonales, y $Z_1\ket{111}=-\ket{111}$. Reconocemos el código de la lección 3: $\alpha\ket{000}+\beta\ket{111}$. Y como $Z_1\in C^{\perp_s}\setminus C$ pesa 1, $d=1$: corrige $\lfloor 0/2\rfloor=0$ errores en general. Detecta $d-1=0$. Aun así, corrige los $X$, porque cada $X_i$ da un síndrome distinto. Los operadores lógicos de peso 1 son justo los $Z_i$.

Shor $[[9,1,3]]$. Los generadores son $Z_1Z_2,\dots,Z_8Z_9$ (6 de tipo $Z$) y $X_1\cdots X_6$, $X_4\cdots X_9$. Aquí $|S|=2^8=256$. Con $\bar X=Z_1Z_4Z_7$ (de tipo $Z$) y $\bar Z=X_1X_2X_3$.

Aplica la suma a $\ket{000000000}$. Los $64$ elementos de $S$ de tipo $Z$ lo fijan. Los $X$ de $S$ son 4: $I$, $X_1\cdots X_6$, $X_4\cdots X_9$ y su producto $X_1X_2X_3X_7X_8X_9$. Por tanto

$$\ket v=64\bigl(\ket{000000000}+\ket{111111000}+\ket{000111111}+\ket{111000111}\bigr),$$

con $\lVert v\rVert^2=256\cdot64$. Normalizando, cada término tiene amplitud $1/2$. Para comparar con la lección 4, escribe $\mathsf a=\ket{000}$ y $\mathsf b=\ket{111}$ para cada bloque. Los cuatro términos son $\mathsf{aaa},\mathsf{bba},\mathsf{abb},\mathsf{bab}$ (un número par de bloques $\mathsf b$). Por otra parte

$$\ket{0_L}+\ket{1_L}=\tfrac{1}{2\sqrt2}\bigl[(\mathsf a+\mathsf b)^{\otimes3}+(\mathsf a-\mathsf b)^{\otimes3}\bigr]=\tfrac{1}{\sqrt2}(\mathsf{aaa}+\mathsf{bba}+\mathsf{abb}+\mathsf{bab}),$$

porque los términos con número impar de $\mathsf b$ se cancelan y los pares se duplican. Así que la suma sobre $S$ da $(\ket{0_L}+\ket{1_L})/\sqrt2$, no $\ket{0_L}$ a secas, como anunciaba la regla: el lógico de tipo $Z$ es nuestro $\bar X$. Para llegar a $\ket{0_L}$ aplicamos $I+\bar Z=I+X_1X_2X_3$, que cambia $\mathsf a\leftrightarrow\mathsf b$ en el primer bloque y completa los ocho términos:

$$(I+X_1X_2X_3)\,\ket v\ \propto\ \mathsf{aaa}+\mathsf{baa}+\mathsf{aab}+\mathsf{aba}+\mathsf{bba}+\mathsf{abb}+\mathsf{bab}+\mathsf{bbb}=(\mathsf a+\mathsf b)^{\otimes3}.$$

Es $\ket{0_L}=\frac{1}{2\sqrt2}(\ket{000}+\ket{111})^{\otimes3}$ de la lección 4. Y $\bar X\ket{0_L}=Z_1Z_4Z_7\ket{0_L}$ cambia el signo de cada bloque $\mathsf b$ en las posiciones 1, 4 y 7, es decir, $(\mathsf a-\mathsf b)^{\otimes3}/(2\sqrt2)=\ket{1_L}$. Los dos son ortogonales.

Distancia de Shor. El normalizador tiene $2^{10}=1024$ vectores, 256 de ellos en $C$ y $768$ lógicos. Ninguno pesa 1 o 2: a mano son demasiados casos para recorrerlos, pero en la lección 9 lo veremos con un argumento corto. Los dos que ya conocemos, $\bar X=Z_1Z_4Z_7$ y $\bar Z=X_1X_2X_3$, pesan 3. Luego $d=3$, corrige $\lfloor 2/2\rfloor=1$ error y detecta 2. Hay 27 errores de peso 1 y solo 21 síndromes: los $Z$ de un mismo bloque comparten síndrome y $Z_1Z_2\in S$. Eso es degeneración.

Una cota y un código que la alcanza

No cualquier terna $[[n,k,d]]$ existe. La cota de Singleton cuántica dice que

$$n-k\ge 2(d-1).$$

Solo la enunciamos. Es el análogo de $d\le n-k+1$ del curso clásico, con un factor 2: hay que protegerse a la vez de los errores $X$ y de los $Z$, y la demostración (que no damos) se apoya en que un dato cuántico no se puede copiar. Repetición: $2\ge0$. Shor: $8\ge4$. El código de 5 cúbits, $[[5,1,3]]$, la cumple con igualdad, $4=2\cdot2$. Lo publicaron Laflamme, Miquel, Paz y Zurek en 1996 (Phys. Rev. Lett. 77, 198) y, por otro camino, Bennett, DiVincenzo, Smolin y Wootters dieron ese mismo año otro código de cinco cúbits con la misma capacidad (Phys. Rev. A 54, 3824, noviembre de 1996). Es el más pequeño posible: ningún código de menos de cinco cúbits protege un cúbit contra un error arbitrario en uno de ellos. Se puede escribir con los generadores $XZZXI$, $IXZZX$, $XIXZZ$ y $ZXIXZ$. Lo veremos otra vez al cerrar el curso.

Ejercicios

Ejercicio 1

En la repetición, con $S=\langle Z_1Z_2,Z_2Z_3\rangle$, clasifica cada error como detectable, inofensivo o lógico: $X_1X_2X_3$, $Z_2Z_3$, $Z_3$, $X_2$.

Ver la solución

Hay que ver cada síndrome, en el orden $(Z_1Z_2,Z_2Z_3)$.

• $X_1X_2X_3$ conmuta con $Z_1Z_2$ (anticonmuta dos veces) y con $Z_2Z_3$: síndrome $(0,0)$. No es de $S$. Es lógico (es $\bar X$).
• $Z_2Z_3\in S$: síndrome $(0,0)$ y es inofensivo.
• $Z_3$ conmuta con ambos: síndrome $(0,0)$ y no está en $S$. Es lógico (peso 1: por eso $d=1$).
• $X_2$ anticonmuta con los dos generadores: síndrome $(1,1)$. Es detectable.

Ejercicio 2

Código de fase: $S=\langle X_1X_2,X_2X_3\rangle$, con $\bar X=Z_1Z_2Z_3$ y $\bar Z=X_1$. Calcula $\ket v=\sum_{g\in S}g\ket{000}$ y úsalo para llegar a $\ket{0_L}$.

Ver la solución

$S=\{I,X_1X_2,X_2X_3,X_1X_3\}$, y $\ket v=\ket{000}+\ket{110}+\ket{011}+\ket{101}$. No sale cero (los cuatro términos son distintos). Aquí $\bar Z=X_1$ no es de tipo $Z$ pero $\bar X=Z_1Z_2Z_3$ sí: $\ket v$ tiene $\bar X=+1$ y $\lVert v\rVert^2=4$, luego $\ket v/2=(\ket{0_L}+\ket{1_L})/\sqrt2$. Con $I+\bar Z=I+X_1$:

$$(I+X_1)\ket v=\sum_{x\in\{0,1\}^3}\ket{x},$$

las ocho palabras, que es $2\sqrt2\,\ket{+++}$. Por tanto $\ket{0_L}=\ket{+++}$ y $\ket{1_L}=Z_1Z_2Z_3\ket{+++}=\ket{---}$, como en la lección 3.

Ejercicio 3

Con la cota de Singleton cuántica, ¿cuál es el menor $n$ posible para un $[[n,1,3]]$? ¿Y para un $[[n,1,5]]$? ¿Excluye la cota un $[[4,1,3]]$?

Ver la solución

Con $k=1$ la cota es $n-1\ge2(d-1)$, es decir, $n\ge 2d-1$. Para $d=3$ sale $n\ge5$ (el código de 5 cúbits lo alcanza). Para $d=5$ sale $n\ge9$. Un $[[4,1,3]]$ tendría $n-k=3<4=2(d-1)$: no puede existir. La cota solo dice qué es imposible, no qué existe: con ella sola no sabemos si hay un $[[9,1,5]]$.

En resumen

• Los errores de Pauli se reparten en tres clases: detectables (fuera de $C^{\perp_s}$), inofensivos (en $C$) y lógicos (en $C^{\perp_s}\setminus C$, indetectables y dañinos).
• La distancia $d$ es el peso del lógico más ligero. El código detecta $d-1$ errores y corrige $\lfloor (d-1)/2\rfloor$.
• Hay degeneración cuando dos errores distintos con el mismo síndrome difieren en un elemento de $S$: da igual cuál se corrija.
• $\ket{0_L}$ es el autoestado $+1$ de $\bar Z$ en el código y $\ket{1_L}=\bar X\ket{0_L}$. Además $\sum_{g\in S}g\ket{0\cdots0}$ (si no sale cero) es el autoestado $+1$ del lógico de tipo $Z$ con signo $+$: da $\ket{0_L}$ si ese lógico es $\bar Z$, y $(\ket{0_L}+\ket{1_L})/\sqrt2$ si es $\bar X$, como en Shor.
• La cota de Singleton cuántica $n-k\ge2(d-1)$ la alcanza el $[[5,1,3]]$.

Siguiente lección: Códigos CSS: un código cuántico hecho con dos clásicos