El código de Shor de 9 qubits

Ahora pasamos al código de Shor de 9 qubits, un código corrector de errores cuánticos que surge de la combinación de los dos códigos considerados en la sección anterior: el código de repetición de 3 bits para qubits, que permite la corrección de un solo error de inversión de bit, y la versión modificada de este código, que permite la corrección de un solo error de inversión de fase.

Descripción del código

El código de Shor de 9 qubits se obtiene mediante la concatenación de los dos códigos de la sección anterior. Esto significa que primero aplicamos una codificación que codifica un qubit en tres, y luego aplicamos la otra codificación a cada uno de los tres qubits de la primera codificación, lo que da un total de nueve qubits.

Más precisamente, aunque en este caso particular podríamos aplicar los dos códigos en cualquier orden, elegimos aplicar primero la versión modificada del código de repetición de 3 bits (que detecta errores de inversión de fase), y luego codificar cada uno de los tres qubits resultantes de forma independiente con el código de repetición de 3 bits original (que detecta errores de inversión de bit). Aquí hay una representación en diagrama de circuito de esta codificación.

Como sugiere la figura, consideraremos los nueve qubits del código de Shor agrupados en tres bloques de tres qubits cada uno, donde cada bloque se obtiene del segundo paso de codificación (el código de repetición de 3 bits ordinario). El código de repetición de 3 bits ordinario, aplicado aquí tres veces de forma independiente, se denomina en este contexto el código interno, mientras que el código externo es el código utilizado para el primer paso de codificación: la versión modificada del código de repetición de 3 bits que detecta errores de inversión de fase.

Alternativamente, podemos especificar el código describiendo cómo se codifican los dos estados de la base estándar de nuestro qubit original.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Una vez que sabemos esto, podemos determinar por linealidad cómo se codifica cualquier vector de estado de qubit arbitrario.

Corrección de errores de inversión de bit y de fase

Errores y puertas CNOT

Para analizar cómo los errores $X$ y $Z$ afectan a las codificaciones de qubits — tanto para el código de Shor de 9 qubits como para otros códigos —, es útil observar algunas relaciones simples entre estos errores y las puertas CNOT. Al inicio del análisis del código de Shor de 9 qubits, es un buen momento para hacerlo.

Los siguientes diagramas de circuito ilustran tres relaciones fundamentales entre las puertas $X$ y las puertas CNOT. Concretamente: aplicar una puerta $X$ al qubit objetivo antes de una CNOT equivale a invertir el orden y realizar la CNOT primero, pero aplicar una puerta $X$ al qubit de control antes de una CNOT equivale a aplicar puertas $X$ a ambos qubits después de la CNOT. Finalmente, aplicar puertas $X$ a ambos qubits antes de una CNOT equivale a realizar la CNOT primero y luego aplicar una puerta $X$ al qubit de control. Estas relaciones se pueden verificar mediante las multiplicaciones matriciales necesarias o calculando la acción de los circuitos sobre los estados de la base estándar.

La situación es similar para las puertas $Z$, excepto que los roles del qubit de control y del qubit objetivo se intercambian. En particular, tenemos las tres relaciones representadas por los siguientes circuitos cuánticos.

Corrección de errores de inversión de bit

Ahora consideremos cómo se pueden detectar y corregir errores utilizando el código de Shor de 9 qubits, comenzando con los errores de inversión de bit — que en adelante, por brevedad, denominaremos errores $X$.

Para detectar y corregir errores $X$, podemos tratar cada uno de los tres bloques de la codificación por separado. Cada bloque es una codificación de un qubit con el código de repetición de 3 bits, que protege contra errores $X$ — por lo que, aplicando las mediciones de síndrome y las correcciones de errores $X$ descritas anteriormente a cada bloque, podemos detectar y corregir hasta un error $X$ por bloque. Así, si hay a lo sumo un error $X$ en los nueve qubits de la codificación, este error será detectado y corregido por este procedimiento.

En resumen: la corrección de errores de inversión de bit es sencilla para este código, ya que el código interno corrige errores de inversión de bit.

Corrección de errores de inversión de fase

A continuación, consideremos los errores de inversión de fase, o errores $Z$ para abreviar. Esta vez no es tan claro qué hacer, ya que el código externo es el que detecta errores $Z$, pero el código interno parece estar de alguna manera "en el camino", lo que hace la detección y corrección de estos errores un poco más difícil.

Supongamos que un error $Z$ ocurre en uno de los 9 qubits del código de Shor, como se muestra en este diagrama.

Ya hemos observado lo que sucede cuando ocurre un error $Z$ mientras usamos el código de repetición de 3 bits — equivale a un error $Z$ que ocurre antes de la codificación. En el contexto del código de Shor de 9 qubits, esto significa que un error $Z$ en cualquiera de los tres qubits dentro de un bloque siempre tiene el mismo efecto, que corresponde a un error $Z$ en el qubit correspondiente antes de la aplicación del código interno.

El diagrama de circuito anterior, por ejemplo, es equivalente al siguiente diagrama. Esto se puede justificar usando las relaciones entre $Z$ y las puertas CNOT descritas anteriormente, o simplemente evaluando los circuitos sobre un estado de qubit arbitrario $\vert\psi\rangle$.

Esto sugiere una forma de detectar y corregir errores $Z$: decodificar el código interno, de modo que obtengamos los tres qubits de la codificación externa junto con seis qubits de trabajo inicializados. Luego podemos verificar estos tres qubits del código externo en busca de errores $Z$ y finalmente volver a codificar con el código interno para regresar a la codificación de 9 qubits que obtenemos del código de Shor. Si detectamos un error $Z$, podemos corregirlo antes de volver a codificar con el código interno, o después, aplicando una puerta $Z$ a uno de los qubits en ese bloque.

Aquí hay un diagrama de circuito que contiene el circuito de codificación y el error sugerido anteriormente, junto con los pasos recién descritos (pero no el paso de corrección real).

En este ejemplo concreto, el resultado de la medición del síndrome es $11$, lo que identifica el error $Z$ como ocurrido en uno de los qubits del bloque central.

Una ventaja de corregir los errores $Z$ después del paso de recodificación en lugar de antes es que el circuito anterior se puede simplificar. El siguiente circuito es equivalente, pero requiere cuatro puertas CNOT menos.

Nuevamente, el síndrome no indica qué qubit ha sido afectado por un error $Z$, sino qué bloque ha experimentado un error $Z$, siendo el efecto el mismo independientemente de qué qubit dentro del bloque fue afectado. Podemos entonces corregir el error aplicando una puerta $Z$ a uno de los tres qubits del bloque afectado.

Por cierto, aquí vemos un ejemplo de degeneración en un código corrector de errores cuánticos: podemos corregir ciertos errores (en este caso errores $Z$) sin poder identificarlos de manera única.

Errores simultáneos de inversión de bit y de fase

Hemos visto ahora cómo se pueden detectar y corregir tanto los errores $X$ como los errores $Z$ utilizando el código de Shor de 9 qubits — en particular, cómo se puede detectar y corregir a lo sumo un error $X$ o a lo sumo un error $Z$. Supongamos ahora que ocurren tanto un error de inversión de bit como un error de inversión de fase, posiblemente en el mismo qubit. Resulta que en esta situación no es necesario hacer nada diferente de lo ya discutido — el código puede detectar y corregir hasta un error $X$ y un error $Z$ simultáneamente, sin modificación alguna.

Más precisamente, los errores $X$ se detectan aplicando la medición de síndrome del código de repetición de 3 bits ordinario, que se aplica por separado a cada uno de los tres bloques de tres qubits; y los errores $Z$ se detectan mediante el procedimiento descrito justo arriba, que equivale a decodificar el código interno, realizar la medición de síndrome para el código de repetición de 3 bits modificado para inversiones de fase, y luego volver a codificar. Estos dos pasos de detección de errores — así como las correcciones correspondientes — se pueden realizar de manera completamente independiente, y de hecho no importa en qué orden se realicen.

Para entender por qué esto es así, considera el siguiente diagrama de circuito, en el que tanto un error $X$ como un error $Z$ han afectado al qubit inferior del bloque central.

Primero, observamos que el orden de los errores no importa, en el sentido de que intercambiar la posición de los errores $X$ y $Z$ produce un circuito equivalente. Aquí está claro: $X$ y $Z$ no conmutan, anticonmutan:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Esto implica que el siguiente circuito es equivalente al que se acaba de mostrar, salvo un factor de fase global de $-1$.

Ahora podemos desplazar el error $Z$ como antes para obtener otro circuito equivalente.

En este punto es obvio: si el procedimiento para detectar y corregir errores $X$ se realiza primero, el error $X$ se corrige, tras lo cual el procedimiento para detectar y corregir errores $Z$ puede realizarse como antes para eliminar el error $Z$.

Alternativamente, el procedimiento para detectar y corregir errores $Z$ puede realizarse primero. El hecho de que este procedimiento funcione como se espera, incluso en presencia de uno o más errores $X$, se debe a que las puertas $X$ en cualquiera de los nueve qubits de la codificación conmutan con todas las puertas en nuestro circuito simplificado para medir el síndrome de errores $Z$. Por lo tanto, esta medición de síndrome seguirá identificando correctamente el bloque afectado por un error $Z$. El hecho de que un error $Z$ en cualquier bloque se corrija aplicando una puerta $Z$ a cualquier qubit de ese bloque, incluso si también ha ocurrido un error $X$, se deduce del mismo argumento sobre el orden de las puertas $X$ y $Z$, que nos da circuitos equivalentes salvo un factor de fase global.

Se concluye que el código de Shor de 9 qubits puede corregir un error $X$, un error $Z$ o ambos en cualquiera de los nueve qubits de este código. De hecho, podemos corregir más errores que eso, incluyendo múltiples errores $X$ (siempre que caigan en bloques diferentes) o múltiples errores $Z$ (siempre que a lo sumo un bloque experimente un número impar de ellos) — pero para los propósitos de esta lección, lo más relevante es que podemos corregir un error $X$, un error $Z$ o ambos en cualquier qubit.

Reducción de errores para errores aleatorios

Antes de pasar a la última sección de la lección, que trata sobre errores cuánticos arbitrarios, consideremos brevemente el rendimiento del código de Shor de 9 qubits cuando ocurren errores representados por matrices de Pauli de forma aleatoria en los qubits.

Más concretamente, consideremos un modelo de ruido simple en el que los errores ocurren de manera independiente en los qubits, donde cada qubit experimenta un error con probabilidad $p$ y no hay correlación entre errores en qubits diferentes — de forma similar a un canal binario simétrico para bits clásicos. Podríamos asignar diferentes probabilidades para la ocurrencia de errores $X$, $Y$ y $Z$, pero para mantener las cosas lo más simples posible, consideremos el peor caso para el código de Shor de 9 qubits, a saber, que un error $Y$ ocurre en cada uno de los qubits afectados. Un error $Y$, por cierto, es equivalente (salvo un factor de fase global irrelevante) a que tanto un error $X$ como un error $Z$ ocurran en el mismo qubit, ya que $Y = iXZ.$ Esto explica nuestra aparente omisión de los errores $Y$ hasta este punto.

Supongamos ahora que $\mathsf{Q}$ es un qubit en un determinado estado que queremos proteger contra errores, y consideremos la opción de usar el código de Shor de 9 qubits. Una pregunta natural es: "¿Deberíamos usarlo?"

La respuesta no es necesariamente "sí". Si hay demasiado ruido — en este contexto eso significa que $p$ es demasiado grande —, usar el código de Shor podría incluso empeorar las cosas — al igual que el código de repetición de 3 bits es peor que no tener código si $p$ es mayor que un medio. Pero si $p$ es suficientemente pequeño, la respuesta es "sí", deberíamos usar el código, porque reduce la probabilidad de que el estado codificado se corrompa. Veamos por qué es así y qué significa que $p$ sea demasiado grande o suficientemente pequeño para este código.

El código de Shor corrige cualquier error de Pauli en un solo qubit, incluyendo un error $Y$ por supuesto, pero no corrige adecuadamente dos o más errores $Y$. Para ser claros: suponemos que estamos usando las correcciones de errores $X$ y $Z$ descritas anteriormente en la sección. (Por supuesto, si supiéramos de antemano que solo debemos preocuparnos por errores $Y$, elegiríamos nuestras correcciones de manera diferente — pero eso sería engañar al modelo de ruido, y siempre podríamos cambiar el modelo seleccionando otros errores de Pauli para hacer fallar esta nueva elección de correcciones cuando dos o más qubits estén afectados por errores.)

El código protege a $\mathsf{Q}$ siempre que a lo sumo uno de los nueve qubits esté afectado por un error, lo cual ocurre con probabilidad

$$(1-p)^9 + 9 p (1-p)^8$$

De lo contrario, el código falla con probabilidad

$$1 - (1-p)^9 - 9 p (1-p)^8$$

en proteger a $\mathsf{Q}.$

Concretamente, lo que esto significa en este contexto es que — salvo un factor de fase global — una operación de Pauli no identidad se aplica a nuestro qubit $\mathsf{Q}$ (como qubit lógico). Es decir: si los errores $X$ y $Z$ para el código de Shor se detectan y corrigen como se describió anteriormente en la lección, nos quedamos con la codificación de un estado que — salvo un factor de fase global — es equivalente a la codificación de una operación de Pauli no identidad aplicada al estado original de $\mathsf{Q}$. Dicho de manera más breve: ha ocurrido un error lógico. Esto puede afectar o no al estado original de $\mathsf{Q}$ — o en otras palabras, al qubit lógico que hemos codificado con nueve qubits físicos —, pero para este análisis consideramos este evento como un fallo.

Si, por otro lado, no usamos el código en absoluto, nuestro único qubit sufriría un destino similar (ser sometido a una operación de Pauli no identidad) con probabilidad $p$. El código ayuda cuando la primera probabilidad es menor que la segunda:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Aquí hay un diagrama que muestra, para valores muy pequeños de $p$, que el código proporciona una ventaja, con el punto de equilibrio situado aproximadamente en $0{,}0323$.

Si $p$ es menor que este punto de equilibrio, el código ayuda; en el punto de equilibrio, las probabilidades son iguales, de modo que al usar el código solo estamos desperdiciando tiempo y 8 qubits; y más allá del punto de equilibrio, definitivamente no deberíamos usar este código porque aumenta la probabilidad de un error lógico en $\mathsf{Q}$.

Algo más del tres por ciento puede no parecer un punto de equilibrio particularmente bueno, especialmente en comparación con el $50\%$, que es el punto de equilibrio análogo para el código de repetición de 3 bits para información clásica. Esta diferencia se debe en gran parte a que la información cuántica es más sensible y difícil de proteger que la información clásica. Pero también — aunque se reconoce que el código de Shor de 9 qubits representa un descubrimiento brillante, como el primer código corrector de errores cuánticos del mundo — hay que reconocer que, desde un punto de vista práctico, no es un código particularmente bueno.