Códigos estabilizadores

Ahora vamos a definir los códigos estabilizadores en general. También analizaremos algunas de sus propiedades básicas y cómo funcionan, incluyendo cómo se pueden codificar estados y cómo se detectan y corrigen errores usando estos códigos.

Definición de los códigos estabilizadores

Un código estabilizador de $n$ qubits se especifica mediante una lista de operaciones de Pauli sobre $n$ qubits, $P_1,\ldots,P_r.$ Estas operaciones se denominan generadores del estabilizador en este contexto, y deben satisfacer las siguientes tres propiedades.

1. Los generadores del estabilizador conmutan entre sí.

   $$P_j P_k = P_k P_j \qquad \text{(para todo $j,k\in\{1,\ldots,r\}$)}$$

2. Los generadores del estabilizador forman un conjunto generador minimal.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(para todo $k\in\{1,\ldots,r\}$)}$$

3. Al menos un vector de estado cuántico queda fijo por todos los generadores del estabilizador.

   $$-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$$

   (No es obvio que la existencia de un vector de estado cuántico $\vert\psi\rangle$ fijo por todos los generadores del estabilizador, es decir, tal que $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ sea equivalente a que $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ pero así es, y veremos por qué un poco más adelante en la lección.)

Suponiendo que tenemos dicha lista $P_1,\ldots,P_r,$ el espacio del código definido por estos generadores del estabilizador es el subespacio $\mathcal{C}$ que contiene todos los vectores de estado cuántico de $n$ qubits fijos por los $r$ generadores del estabilizador.

$$\mathcal{C} = \bigl\{ \vert\psi\rangle \,:\, P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle \bigr\}$$

Los vectores de estado cuántico en este subespacio son precisamente los que pueden verse como codificaciones válidas de estados cuánticos. Discutiremos el proceso de codificación en sí más adelante.

Finalmente, el estabilizador del código definido por los generadores del estabilizador $P_1, \ldots, P_r$ es el conjunto generado por estas operaciones:

$$\langle P_1,\ldots,P_r\rangle.$$

Una forma natural de pensar en un código estabilizador es ver los generadores del estabilizador como observables, e interpretar colectivamente los resultados de las mediciones asociadas a estos observables como un síndrome de error. Las codificaciones válidas son vectores de estado cuántico de $n$ qubits para los cuales los resultados de la medición, como valores propios, tienen garantizado ser todos $+1.$ Cualquier otro síndrome, donde ocurre al menos un resultado de medición igual a $-1$, señala que se ha detectado un error.

Veremos varios ejemplos en breve, pero primero unas pocas observaciones sobre las tres condiciones de los generadores del estabilizador son pertinentes.

La primera condición es natural, a la luz de la interpretación de los generadores del estabilizador como observables, pues implica que no importa en qué orden se realizan las mediciones: los observables conmutan, por lo que las mediciones también conmutan. Esto impone naturalmente ciertas restricciones algebraicas sobre los códigos estabilizadores que son importantes para su funcionamiento.

La segunda condición exige que los generadores del estabilizador formen un conjunto generador minimal, lo que significa que eliminar cualquiera de ellos daría lugar a un estabilizador más pequeño. Hablando con propiedad, esta condición no es realmente esencial para el funcionamiento de los códigos estabilizadores en un sentido operacional — y, como veremos en la siguiente lección, a veces tiene sentido pensar en conjuntos de generadores del estabilizador para códigos que en realidad no satisfacen esta condición. Sin embargo, a efectos de analizar los códigos estabilizadores y explicar sus propiedades, asumiremos que esta condición está vigente. En resumen, esta condición garantiza que cada observable que medimos para obtener el síndrome de error aporta información sobre posibles errores, en lugar de ser redundante y producir resultados que podrían inferirse de las mediciones de los otros generadores del estabilizador.

La tercera condición exige que al menos un vector no nulo quede fijo por todos los generadores del estabilizador, lo cual es equivalente a que $-\mathbb{I}^{\otimes n}$ no esté contenido en el estabilizador. La necesidad de esta condición proviene del hecho de que en realidad es posible elegir un conjunto generador minimal de operaciones de Pauli sobre $n$ qubits que conmuten entre sí y, sin embargo, ningún vector no nulo quede fijo por todas las operaciones. No nos interesan los "códigos" para los que no existen codificaciones válidas, así que descartamos esta posibilidad al exigir esta condición como parte de la definición.

Ejemplos

Aquí hay algunos ejemplos de códigos estabilizadores para valores pequeños de $n.$ Veremos más ejemplos, incluyendo algunos para los que $n$ puede ser mucho mayor, en la siguiente lección.

Código de repetición de 3 bits

El código de repetición de 3 bits es un ejemplo de código estabilizador, donde los generadores del estabilizador son $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z.$

Podemos verificar fácilmente que estos dos generadores del estabilizador cumplen las condiciones requeridas. Primero, los dos generadores del estabilizador $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z$ conmutan entre sí.

$$(Z \otimes Z \otimes \mathbb{I})(\mathbb{I} \otimes Z \otimes Z) = Z \otimes \mathbb{I} \otimes Z = (\mathbb{I} \otimes Z \otimes Z)(Z \otimes Z \otimes \mathbb{I})$$

Segundo, tenemos un conjunto generador minimal (de manera más bien trivial en este caso).

$$\begin{aligned} Z \otimes Z \otimes \mathbb{I} \notin \langle\mathbb{I} \otimes Z \otimes Z\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, \mathbb{I} \otimes Z \otimes Z\}\\[1mm] \mathbb{I} \otimes Z \otimes Z \notin \langle Z \otimes Z \otimes \mathbb{I}\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z \otimes Z \otimes \mathbb{I}\} \end{aligned}$$

Y tercero, ya sabemos que $\vert 000\rangle$ y $\vert 111\rangle,$ así como cualquier combinación lineal de estos vectores, quedan fijos tanto por $Z \otimes Z \otimes \mathbb{I}$ como por $\mathbb{I} \otimes Z \otimes Z.$ Alternativamente, podemos concluir esto usando la condición equivalente de la definición.

$$-\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\notin \langle Z \otimes Z \otimes \mathbb{I}, \mathbb{I} \otimes Z \otimes Z\rangle = \{ \mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z\otimes Z\otimes\mathbb{I}, Z\otimes\mathbb{I}\otimes Z, \mathbb{I}\otimes Z\otimes Z \}$$

Estas condiciones pueden ser mucho más difíciles de verificar para códigos estabilizadores más complicados.

Código de repetición de 3 bits modificado

En la lección anterior, vimos que es posible modificar el código de repetición de 3 bits para que proteja contra errores de cambio de fase en lugar de errores de cambio de bit. Como código estabilizador, este nuevo código es fácil de describir: sus generadores del estabilizador son $X \otimes X \otimes \mathbb{I}$ e $\mathbb{I} \otimes X \otimes X.$

Esta vez los generadores del estabilizador representan observables $X\otimes X$ en lugar de observables $Z\otimes Z$, por lo que esencialmente son comprobaciones de paridad en la base más/menos en lugar de la base estándar. Las tres condiciones requeridas sobre los generadores del estabilizador se verifican fácilmente, de manera similar al código de repetición de 3 bits ordinario.

Código Shor de 9 qubits

Aquí está el código Shor de 9 qubits, que también es un código estabilizador, expresado mediante generadores del estabilizador.

$$\begin{gathered} Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z\\[1mm] X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\otimes X \otimes X \otimes X \otimes X \otimes X \otimes X \end{gathered}$$

En este caso, básicamente tenemos tres copias del código de repetición de 3 bits, una para cada uno de los tres bloques de tres qubits, así como los dos últimos generadores del estabilizador, que toman una forma reminiscente del circuito para detectar cambios de fase en este código.

Una forma alternativa de pensar en los dos últimos generadores del estabilizador es que toman la misma forma que en el código de repetición de 3 bits para cambios de fase, excepto que $X\otimes X\otimes X$ se sustituye por $X$, lo cual es consistente con el hecho de que $X\otimes X\otimes X$ corresponde a una operación $X$ sobre qubits lógicos codificados usando el código de repetición de 3 bits.

Antes de pasar a otros ejemplos, cabe señalar que los símbolos del producto tensorial suelen omitirse cuando se describen códigos estabilizadores mediante listas de generadores del estabilizador, porque tiende a hacerlos más fáciles de leer y de ver sus patrones. Por ejemplo, los mismos generadores del estabilizador del código Shor de 9 qubits tienen el siguiente aspecto sin los símbolos del producto tensorial escritos explícitamente.

$$\begin{array}{ccccccccc} Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & \mathbb{I} & Z & Z\\[1mm] X & X & X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I}\\[1mm] \mathbb{I} & \mathbb{I} & \mathbb{I}& X & X & X & X & X & X \end{array}$$

Código Steane de 7 qubits

Aquí hay otro ejemplo de código estabilizador, conocido como el código Steane de 7 qubits. Tiene algunas características notables, y volveremos a este código de vez en cuando a lo largo de las lecciones restantes del curso.

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Por ahora, observemos simplemente que este es un código estabilizador válido. Los tres primeros generadores del estabilizador claramente conmutan entre sí, porque $Z$ conmuta consigo mismo y la identidad conmuta con todo, y la situación es similar para los tres últimos generadores del estabilizador. Queda por verificar que si tomamos uno de los generadores del estabilizador de tipo $Z$ (es decir, uno de los tres primeros) y uno de los generadores del estabilizador de tipo $X$ (es decir, uno de los tres últimos), estos dos generadores conmutan, y se pueden recorrer los 9 posibles emparejamientos para comprobarlo. En todos estos casos, una matriz de Pauli $X$ y una $Z$ siempre coinciden en la misma posición un número par de veces, por lo que los dos generadores conmutarán, igual que $X\otimes X$ y $Z\otimes Z$ conmutan. Este también es un conjunto generador minimal y define un espacio del código no trivial, hechos que se dejan para que reflexiones sobre ellos.

El código Steane de 7 qubits es similar al código Shor de 9 qubits en que codifica un único qubit y permite la corrección de un error arbitrario en un qubit, pero requiere solo 7 qubits en lugar de 9.

Código de 5 qubits

Siete no es el menor número de qubits necesario para codificar un qubit y protegerlo contra un error arbitrario en un qubit — aquí hay un código estabilizador que lo hace usando solo 5 qubits.

$$\begin{array}{ccccc} X & Z & Z & X & \mathbb{I} \\[1mm] \mathbb{I} & X & Z & Z & X \\[1mm] X & \mathbb{I} & X & Z & Z \\[1mm] Z & X & \mathbb{I} & X & Z \\[1mm] \end{array}$$

Este código se denomina típicamente el código de 5 qubits. Es el menor número de qubits en un código de corrección de errores cuánticos que puede permitir la corrección de un error arbitrario en un solo qubit.

Códigos estabilizadores unidimensionales

Aquí hay otro ejemplo de código estabilizador, aunque en realidad no codifica ningún qubit: el espacio del código es unidimensional. Sin embargo, sigue siendo un código estabilizador válido según la definición.

$$\begin{array}{cc} Z & Z \\[1mm] X & X \end{array}$$

Concretamente, el espacio del código es el espacio unidimensional generado por un e-bit $\vert\phi^+\rangle.$

Aquí hay un ejemplo relacionado de un código estabilizador cuyo espacio del código es el espacio unidimensional generado por un estado GHZ $(\vert 000\rangle + \vert 111\rangle)/\sqrt{2}.$

$$\begin{array}{cc} Z & Z & \mathbb{I} \\[1mm] \mathbb{I} & Z & Z \\[1mm] X & X & X \end{array}$$

Dimensión del espacio del código

Supongamos que tenemos un código estabilizador descrito por generadores del estabilizador de $n$ qubits $P_1,\ldots,P_r.$ Quizás la primera pregunta que viene a la mente sobre este código es: "¿Cuántos qubits codifica?"

Esta pregunta tiene una respuesta sencilla. Suponiendo que los generadores del estabilizador de $n$ qubits $P_1, \ldots, P_r$ satisfacen los tres requisitos de la definición (a saber, que los generadores del estabilizador conmutan entre sí, que es un conjunto generador minimal y que el espacio del código no es vacío), entonces el espacio del código de este código estabilizador tiene dimensión $2^{n-r}$, de modo que se pueden codificar $n-r$ qubits usando este código.

Hablando intuitivamente, tenemos $n$ qubits para usar en esta codificación, y cada generador del estabilizador efectivamente "quita un qubit" en términos de cuántos qubits podemos codificar. Ten en cuenta que esto no tiene que ver con qué errores ni cuántos errores pueden detectarse o corregirse, sino que es únicamente un enunciado sobre la dimensión del espacio del código.

Por ejemplo, tanto para el código de repetición de 3 bits como para la versión modificada de ese código para errores de cambio de fase, tenemos $n=3$ qubits y $r=2$ generadores del estabilizador, y por tanto cada uno de estos códigos puede codificar 1 qubit. Como otro ejemplo, considera el código de 5 qubits: tenemos 5 qubits y 4 generadores del estabilizador, por lo que nuevamente el espacio del código tiene dimensión 2, lo que significa que se puede codificar un qubit usando este código. Como último ejemplo, el código cuyos generadores del estabilizador son $X\otimes X$ y $Z\otimes Z$ tiene un espacio del código unidimensional, generado por el estado $\vert\phi^+\rangle,$ lo cual es consistente con tener $n=2$ qubits y $r=2$ generadores del estabilizador.

Veamos ahora cómo se puede demostrar este hecho. El primer paso es observar que, dado que los generadores del estabilizador conmutan, y dado que toda operación de Pauli es su propia inversa, cada elemento del estabilizador puede expresarse como un producto

$$P_1^{a_1} \cdots P_r^{a_r},$$

donde $a_1,\ldots,a_r\in\{0,1\}.$ Equivalentemente, cada elemento del estabilizador se obtiene multiplicando algún subconjunto de los generadores del estabilizador. De hecho, cada elemento del estabilizador puede expresarse de forma única de esta manera, gracias a la condición de que $\{P_1,\ldots,P_r\}$ es un conjunto generador minimal.

A continuación, definamos $\Pi_k$ como la proyección sobre el espacio de vectores propios de valor $+1$ de $P_k$, para cada $k\in\{1,\ldots,r\}.$ Estas proyecciones pueden obtenerse promediando las operaciones de Pauli correspondientes con la operación identidad de la siguiente manera.

$$\Pi_k = \frac{\mathbb{I}^{\otimes n} + P_k}{2}$$

El espacio del código $\mathcal{C}$ es el subespacio de todos los vectores que quedan fijos por los $r$ generadores del estabilizador $P_1,\ldots,P_r,$ o equivalentemente, por las $r$ proyecciones $\Pi_1,\ldots,\Pi_r.$

Dado que los generadores del estabilizador conmutan entre sí, las proyecciones $\Pi_1,\ldots,\Pi_r$ también deben conmutar. Esto nos permite usar un hecho del álgebra lineal, que establece que el producto de estas proyecciones es la proyección sobre la intersección de los subespacios correspondientes a las proyecciones individuales. Es decir, el producto $\Pi_1\cdots\Pi_r$ es la proyección sobre el espacio del código $\mathcal{C}.$

Ahora podemos expandir el producto $\Pi_1\cdots\Pi_r$ usando las fórmulas de estas proyecciones para obtener la siguiente expresión.

$$\Pi_1\cdots\Pi_r = \biggl(\frac{\mathbb{I}^{\otimes n} + P_1}{2}\biggr)\cdots\biggl(\frac{\mathbb{I}^{\otimes n} + P_r}{2}\biggr) = \frac{1}{2^r}\sum_{a_1,\ldots,a_r \in \{0,1\}} P_1^{a_1}\cdots P_r^{a_r}$$

En palabras, la proyección sobre el espacio del código de un código estabilizador es igual, como matriz, al promedio sobre todos los elementos del estabilizador de ese código.

Finalmente, podemos calcular la dimensión del espacio del código usando el hecho de que la dimensión de cualquier subespacio es igual a la traza de la proyección sobre ese subespacio. Así, la dimensión del espacio del código $\mathcal{C}$ viene dada por la siguiente fórmula.

$$\operatorname{dim}(\mathcal{C}) = \operatorname{Tr}(\Pi_1\cdots\Pi_r) = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r})$$

Podemos evaluar esta expresión haciendo uso de un par de hechos básicos.

• Tenemos $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ y por tanto

  $$\operatorname{Tr}(P_1^{0}\cdots P_r^{0}) = 2^n.$$

• Para $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ el producto $P_1^{a_1}\cdots P_r^{a_r}$ debe ser $\pm 1$ veces una operación de Pauli — pero no podemos obtener $\mathbb{I}^{\otimes n}$ porque esto contradiría la minimalidad del conjunto $\{P_1,\ldots,P_r\},$ y no podemos obtener $-\mathbb{I}^{\otimes n}$ porque la tercera condición sobre los generadores del estabilizador lo prohíbe. Por tanto, como la traza de toda operación de Pauli no identidad es cero, obtenemos

  $$\operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) = 0.$$

La dimensión del espacio del código es por tanto $2^{n-r}$ como se afirmó:

$$\begin{aligned} \operatorname{dim}(\mathcal{C}) & = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) \\ & = \frac{1}{2^r} \operatorname{Tr}(P_1^{0}\cdots P_r^{0}) \\ & = 2^{n-r}. \end{aligned}$$

Como nota al margen, podemos ver ahora que la suposición de que $-\mathbb{I}^{\otimes n}$ no está contenido en el estabilizador implica que el espacio del código debe contener al menos un vector de estado cuántico. Esto se debe a que, como acabamos de verificar, esta suposición implica que el espacio del código tiene dimensión $2^{n-r},$ que no puede ser cero. La implicación recíproca resulta ser trivial: si $-\mathbb{I}^{\otimes n}$ está contenido en el estabilizador, entonces el espacio del código no puede contener ningún vector de estado cuántico, porque ningún vector no nulo queda fijo por esta operación.

Operaciones de Clifford y codificaciones

A continuación, hablaremos brevemente sobre cómo se pueden codificar qubits usando códigos estabilizadores, pero para eso primero necesitamos introducir las operaciones de Clifford.

Operaciones de Clifford

Las operaciones de Clifford son operaciones unitarias, sobre cualquier número de qubits, que se pueden implementar mediante circuitos cuánticos con un conjunto restringido de compuertas:

• Compuertas de Hadamard
• Compuertas $S$
• Compuertas CNOT

Nota que las compuertas $T$ no están incluidas, ni tampoco las compuertas Toffoli ni Fredkin. No solo esas compuertas no figuran en la lista, sino que de hecho no es posible implementarlas usando las que sí están enumeradas; no son operaciones de Clifford. Las operaciones de Pauli, en cambio, sí son operaciones de Clifford porque se pueden implementar con secuencias de compuertas de Hadamard y $S$.

Esa es una forma sencilla de definir las operaciones de Clifford, pero no explica por qué se definen así ni qué tiene de especial esta colección particular de compuertas. La razón real por la que las operaciones de Clifford se definen de este modo es que, salvo factores de fase global, las operaciones de Clifford son precisamente las operaciones unitarias que siempre transforman operaciones de Pauli en operaciones de Pauli mediante conjugación. Para ser más precisos, una operación unitaria de $n$ qubits $U$ es equivalente a una operación de Clifford salvo un factor de fase si, y solo si, para toda operación de Pauli de $n$ qubits $P$, se tiene que

$$U P U^{\dagger} = \pm Q$$

para alguna operación de Pauli de $n$ qubits $Q$.

(Observa que no es posible tener $U P U^{\dagger} = \alpha Q$ con $\alpha\notin\{+1,-1\}$ cuando $U$ es unitaria y $P$ y $Q$ son operaciones de Pauli. Esto se sigue del hecho de que la matriz en el lado izquierdo de la ecuación en cuestión es a la vez unitaria y hermítica, y $+1$ y $-1$ son las únicas opciones para $\alpha$ que permiten que el lado derecho también sea unitario y hermítico.)

Es sencillo verificar la propiedad de conjugación recién descrita cuando $U$ es una compuerta de Hadamard, $S$ o CNOT. En particular, esto es fácil para compuertas de Hadamard,

$$H X H^{\dagger} = Z, \qquad H Y H^{\dagger} = -Y, \qquad H Z H^{\dagger} = X,$$

y compuertas $S$,

$$S X S^{\dagger} = Y, \qquad S Y S^{\dagger} = -X, \qquad S Z S^{\dagger} = Z.$$

Para compuertas CNOT, hay 15 operaciones de Pauli no identidad sobre dos qubits que verificar. Naturalmente, se pueden revisar una por una, pero las relaciones entre las compuertas CNOT y las compuertas $X$ y $Z$ listadas (en forma de circuito) en la lección anterior, junto con las reglas de multiplicación de las matrices de Pauli, ofrecen un atajo para llegar a la misma conclusión.

Una vez que sabemos que esta propiedad de conjugación es válida para las compuertas de Hadamard, $S$ y CNOT, podemos concluir de inmediato que también lo es para circuitos compuestos por estas compuertas, es decir, para todas las operaciones de Clifford.

Es más difícil demostrar que la relación funciona en la otra dirección, esto es, que si una operación unitaria dada $U$ satisface la propiedad de conjugación para operaciones de Pauli, entonces debe ser posible implementarla (salvo una fase global) usando solo compuertas de Hadamard, $S$ y CNOT. Esto no se explicará en esta lección, pero es cierto.

Las operaciones de Clifford no son universales para la computación cuántica; a diferencia de los conjuntos universales de compuertas cuánticas, no es posible aproximar operaciones unitarias arbitrarias con el nivel de precisión deseado usando operaciones de Clifford. De hecho, para un valor dado de $n$, solo hay una cantidad finita de operaciones de Clifford de $n$ qubits (salvo factores de fase). Aplicar operaciones de Clifford sobre estados de la base estándar seguidas de mediciones en la base estándar tampoco nos permite realizar cálculos que estén fuera del alcance de los algoritmos clásicos, porque podemos simular eficientemente cómputos de esta forma de manera clásica. Este hecho se conoce como el teorema de Gottesman-Knill.

Codificadores para códigos estabilizadores

Un código estabilizador define un espacio de código de cierta dimensión, y tenemos la libertad de usar ese espacio de código como queramos: nada nos obliga a codificar qubits en ese espacio de una manera específica. Sin embargo, siempre es posible usar una operación de Clifford como codificador, si así lo elegimos. Para ser más precisos, para cualquier código estabilizador que permita codificar $m$ qubits en $n$ qubits, existe una operación de Clifford de $n$ qubits $U$ tal que, para cualquier vector de estado cuántico de $m$ qubits $\vert\phi\rangle$, se tiene que

$$\vert\psi\rangle = U \bigl(\vert 0^{n-m} \rangle \otimes \vert \phi\rangle\bigr)$$

es un vector de estado cuántico en el espacio de código de nuestro código que podemos interpretar como una codificación de $\vert\phi\rangle$.

Esto es ventajoso porque las operaciones de Clifford son relativamente simples en comparación con las operaciones unitarias arbitrarias, y existen formas de optimizar su implementación mediante técnicas similares a las que se encuentran en la demostración del teorema de Gottesman-Knill. Como resultado, los circuitos para codificar estados con códigos estabilizadores nunca necesitan ser demasiado grandes. En particular, siempre es posible realizar una codificación para un código estabilizador de $n$ qubits usando una operación de Clifford que requiere $O(n^2/\log(n))$ compuertas. Esto se debe a que toda operación de Clifford sobre $n$ qubits puede implementarse mediante un circuito de este tamaño.

Por ejemplo, aquí hay un codificador para el código de Steane de 7 qubits. Es efectivamente una operación de Clifford y, resulta que, este en particular ni siquiera necesita compuertas $S$.

Detección de errores

Para un código estabilizador de $n$ qubits descrito por los generadores estabilizadores $P_1,\ldots, P_r$, la detección de errores funciona de la siguiente manera.

Para detectar errores, se miden todos los generadores estabilizadores como observables. Hay $r$ generadores estabilizadores y, por tanto, $r$ resultados de medición, cada uno siendo $+1$ o $-1$ (o un valor binario si elegimos asociar $0$ con $+1$ y $1$ con $-1$, respectivamente). Interpretamos los $r$ resultados colectivamente, como un vector o cadena, como un síndrome. El síndrome $(+1,\ldots,+1)$ indica que no se ha detectado ningún error, mientras que al menos un $-1$ en algún lugar del síndrome indica que se ha detectado un error.

Supón, en particular, que $E$ es una operación de Pauli de $n$ qubits que representa un hipotético error. (Solo estamos considerando operaciones de Pauli como errores, por cierto, porque la discretización de errores funciona de la misma manera para códigos estabilizadores arbitrarios que para el código de Shor de 9 qubits.) Hay tres casos que determinan si $E$ es detectado como error o no.

Casos de detección de errores

1. La operación $E$ es proporcional a un elemento del estabilizador.

   $$E = \pm Q \; \text{para algún}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   En este caso, $E$ debe conmutar con cada generador estabilizador, por lo que obtenemos el síndrome $(+1,\ldots,+1)$. Esto significa que $E$ no es detectado como error.

2. La operación $E$ no es proporcional a un elemento del estabilizador, pero aun así conmuta con todos los generadores estabilizadores.

   $$E\neq \pm Q\; \text{para} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{pero}\; E P_k = P_k E \;\text{para todo}\; k\in\{1,\ldots,r\}$$

   Este es un error que modifica los vectores en el espacio de código de alguna manera no trivial. Pero, como $E$ conmuta con todos los generadores estabilizadores, el síndrome es $(+1,\ldots,+1)$, por lo que $E$ pasa desapercibido para el código.

3. La operación $E$ anticonmuta con al menos uno de los generadores estabilizadores.

   $$P_k E = -E P_k \; \text{para al menos un} \; k\in\{1,\ldots,r\}$$

   El síndrome es distinto de $(+1,\ldots,+1)$, por lo que el error $E$ es detectado por el código.

En el primer caso, el error $E$ no es motivo de preocupación porque esta operación no hace nada a los vectores en el espacio de código, salvo posiblemente inyectar una fase global irrelevante: $E \ket{\psi} = \pm\ket{\psi}$ para todo estado codificado $\ket{\psi}$. En esencia, esto no es realmente un error — cualquier acción no trivial que $E$ pueda tener ocurre fuera del espacio de código — así que es correcto que $E$ no sea detectado como error, porque no hay nada que hacer al respecto.

El segundo caso es, intuitivamente hablando, el caso problemático. Es la anticonmutación de un error con un generador estabilizador lo que hace que aparezca un $-1$ en algún lugar del síndrome, señalando un error, pero eso no ocurre en este caso. Entonces, tenemos un error $E$ que sí modifica los vectores en el espacio de código de alguna manera no trivial, pero el código no lo detecta. Por ejemplo, para el código de repetición de 3 bits, la operación $E = X\otimes X\otimes X$ entra en esta categoría.

El hecho de que tal error $E$ deba cambiar algunos vectores en el espacio de código de manera no trivial puede argumentarse como sigue. Dada la suposición de que $E$ conmuta con $P_1,\ldots,P_r$ pero no es proporcional a un elemento del estabilizador, podemos concluir que obtendríamos un nuevo código estabilizador válido al incluir $E$ como generador estabilizador junto con $P_1,\ldots,P_r$. Sin embargo, el espacio de código de este nuevo código tiene solo la mitad de la dimensión del espacio de código original, de lo cual podemos concluir que la acción de $E$ sobre el espacio de código original no puede ser proporcional a la operación identidad.

Para el último de los tres casos, en el que el error $E$ anticonmuta con al menos un generador estabilizador, el síndrome tiene al menos un $-1$ en algún lugar, lo cual indica que algo está mal. Como ya hemos discutido, el síndrome no identificará unívocamente a $E$ en general, por lo que sigue siendo necesario elegir una operación de corrección para cada síndrome, que puede o no corregir el error $E$. Discutiremos este paso en breve, en la última parte de la lección.

Distancia de un código estabilizador

Como terminología, cuando nos referimos a la distancia de un código estabilizador, nos referimos al peso mínimo de una operación de Pauli $E$ que cae en la segunda categoría anterior, es decir, que modifica el espacio de código de alguna manera no trivial pero el código no lo detecta. Cuando se dice que un código estabilizador es un código estabilizador $[[n,m,d]]$, usando dobles corchetes cuadrados, esto significa lo siguiente:

1. Las codificaciones tienen $n$ qubits de longitud,
2. el código permite codificar $m$ qubits, y
3. la distancia del código es $d$.

Como ejemplo, consideremos el código de Steane de 7 qubits. Aquí están los generadores estabilizadores de este código:

$$\begin{array}{ccccccc} Z & Z & Z & Z & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] Z & Z & \mathbb{I} & \mathbb{I} & Z & Z & \mathbb{I} \\[1mm] Z & \mathbb{I} & Z & \mathbb{I} & Z & \mathbb{I} & Z \\[1mm] X & X & X & X & \mathbb{I} & \mathbb{I} & \mathbb{I} \\[1mm] X & X & \mathbb{I} & \mathbb{I} & X & X & \mathbb{I} \\[1mm] X & \mathbb{I} & X & \mathbb{I} & X & \mathbb{I} & X \end{array}$$

Este código tiene distancia 3, y podemos argumentarlo de la siguiente manera.

Primero, considera cualquier operación de Pauli $E$ de peso a lo sumo 2, y supón que esta operación conmuta con los seis generadores estabilizadores. Concluiremos que $E$ debe ser la operación identidad, que (como siempre) es un elemento del estabilizador. Esto mostrará que la distancia del código es estrictamente mayor que 2. Supón, en particular, que $E$ tiene la forma

$$E = P \otimes Q \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

con $P$ y $Q$ siendo posiblemente matrices de Pauli no identidad. Este es solo un caso, y es necesario repetir el argumento que sigue para todas las demás ubicaciones posibles de matrices de Pauli no identidad entre los factores tensoriales de $E$, pero el argumento es esencialmente el mismo para todas las ubicaciones posibles.

La operación $E$ conmuta con los seis generadores estabilizadores, por lo que conmuta con estos dos en particular:

$$\begin{gathered} Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z\\[1mm] X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \end{gathered}$$

El factor tensorial $Q$ en nuestro error $E$ se alinea con la matriz identidad en ambos generadores estabilizadores (por eso se seleccionaron). Dado que tenemos matrices identidad en las 5 posiciones más a la derecha de $E$, concluimos que $P$ debe conmutar con $X$ y con $Z$; de lo contrario, $E$ anticonmutaría con uno de los dos generadores. Sin embargo, la única matriz de Pauli que conmuta con $X$ y con $Z$ es la matriz identidad, por lo que $P = \mathbb{I}$.

Ahora que sabemos esto, podemos elegir dos generadores estabilizadores más que tengan una $X$ y una $Z$ en la segunda posición desde la izquierda, y llegamos a una conclusión similar: $Q = \mathbb{I}$. Por tanto, $E$ es la operación identidad.

Así pues, no hay manera de que un error de peso a lo sumo 2 pase desapercibido para este código, a menos que el error sea la operación identidad (que está en el estabilizador y, por tanto, no es realmente un error). Por otro lado, hay operaciones de Pauli de peso 3 que conmutan con los seis generadores estabilizadores pero no son proporcionales a elementos del estabilizador, como $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ y $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z$. Esto establece que este código tiene distancia 3, como se afirmó.

Corrección de errores

El último tema de discusión de esta lección es la corrección de errores para los códigos estabilizadores. Como de costumbre, supón que tenemos un código estabilizador especificado por generadores estabilizadores de $n$ qubits $P_1, \ldots, P_r$.

Las operaciones de Pauli de $n$ qubits, como errores que podrían afectar a los estados codificados con este código, se dividen en colecciones de igual tamaño según qué síndrome producen. Hay $2^r$ síndromes distintos y $4^n$ operaciones de Pauli, lo que significa que hay $4^n/2^r$ operaciones de Pauli que producen cada síndrome. Cualquiera de estos errores podría ser responsable del síndrome correspondiente.

Sin embargo, entre las $4^n/2^r$ operaciones de Pauli que producen cada síndrome, hay algunas que deben considerarse equivalentes. En particular, si el producto de dos operaciones de Pauli es proporcional a un elemento del estabilizador, entonces esas dos operaciones son efectivamente equivalentes como errores.

Otra forma de decirlo es que si aplicamos una operación de corrección $C$ para intentar corregir un error $E$, entonces esta corrección tiene éxito siempre que la composición $CE$ sea proporcional a un elemento del estabilizador. Dado que hay $2^r$ elementos en el estabilizador, se sigue que cada operación de corrección $C$ corrige $2^r$ errores de Pauli distintos. Esto deja $4^{n-r}$ clases inequivalentes de operaciones de Pauli, consideradas como errores, que son consistentes con cada síndrome posible.

Esto significa que, a menos que $n=r$ (en cuyo caso tenemos un espacio de código trivial de una dimensión), no podemos posiblemente corregir todos los errores detectados por un código estabilizador. Lo que debemos hacer en cambio es elegir una sola operación de corrección para cada síndrome, con la esperanza de corregir solo una clase de errores equivalentes que producen ese síndrome.

Una estrategia natural para elegir qué operación de corrección realizar para cada síndrome es seleccionar la operación de Pauli de menor peso que, como error, produce ese síndrome. De hecho, puede haber múltiples operaciones que empaten en el menor peso de error consistente con un síndrome dado, en cuyo caso se puede seleccionar cualquiera de ellas. La idea es que las operaciones de Pauli de menor peso representan explicaciones más probables para cualquier síndrome que haya sido medido. Esto puede no ser el caso para algunos modelos de ruido, y una estrategia alternativa es calcular el error más probable que produce el síndrome dado, basándose en el modelo de ruido elegido. Para esta lección, sin embargo, mantendremos las cosas simples y solo consideraremos correcciones de menor peso.

Para un código estabilizador de distancia $d$, esta estrategia de elegir la operación de corrección como la operación de Pauli de menor peso consistente con el síndrome medido siempre permite corregir errores de peso estrictamente menor que la mitad de $d$, o en otras palabras, de peso a lo sumo $(d-1)/2$. Esto muestra, por ejemplo, que el código de Steane de 7 qubits puede corregir cualquier error de Pauli de peso uno y, por la discretización de errores, esto significa que el código de Steane puede corregir un error arbitrario en un qubit.

Para ver cómo funciona esto, considera el diagrama siguiente. El círculo de la izquierda representa todas las operaciones de Pauli que producen el síndrome $(+1,\ldots,+1)$, que es el síndrome que sugiere que no han ocurrido errores y que todo está bien. Entre estas operaciones tenemos elementos del estabilizador (o más precisamente, operaciones que son proporcionales a elementos del estabilizador) y también errores no triviales que modifican el espacio de código de alguna manera pero no son detectados por el código. Por la definición de distancia, toda operación de Pauli en esta categoría debe tener peso al menos $d$, ya que $d$ se define como el peso mínimo de estas operaciones.

El círculo de la derecha representa las operaciones de Pauli que producen un síndrome diferente $s\neq(+1,\ldots,+1)$, incluyendo un error $E$ de peso estrictamente menor que $d/2$ que consideraremos.

La operación de corrección $C$ elegida para el síndrome $s$ es la operación de Pauli de menor peso en la colección representada por el círculo de la derecha en el diagrama (o cualquiera de ellas en caso de empate). Por tanto, podría ser que $C = E$, pero no necesariamente. Lo que sí podemos afirmar con certeza, sin embargo, es que $C$ no puede tener un peso mayor que el de $E$, porque $C$ tiene peso mínimo entre las operaciones de esta colección, y por lo tanto $C$ tiene peso estrictamente menor que $d/2$.

Ahora considera qué ocurre cuando se aplica la operación de corrección $C$ al estado que obtuvimos después de que ocurre el error $E$. Suponiendo que la codificación original era $\vert\psi\rangle$, nos quedamos con $CE\vert\psi\rangle$. Nuestro objetivo será mostrar que $CE$ es proporcional a un elemento del estabilizador, lo que implica que la corrección es exitosa y (salvo una fase global) nos quedamos con el estado codificado original $\vert\psi\rangle$.

En primer lugar, como $E$ y $C$ producen el mismo síndrome, la composición $CE$ debe conmutar con cada generador estabilizador. En particular, si $P_k$ es alguno de los generadores estabilizadores, entonces debemos tener

$$P_k E = \alpha E P_k \quad\text{y}\quad P_k C = \alpha C P_k$$

para el mismo valor de $\alpha\in\{+1,-1\}$, ya que esta es la $k$-ésima entrada del síndrome $s$ que tanto $C$ como $E$ generan. Por tanto, tenemos

$$P_k (CE) = \alpha C P_k E = \alpha^2 (CE) P_k = (CE) P_k,$$

por lo que $P_k$ conmuta con $CE$. Hemos demostrado así que $CE$ pertenece al círculo de la izquierda en el diagrama, ya que genera el síndrome $(+1,\ldots,+1)$.

En segundo lugar, la composición $CE$ debe tener peso a lo sumo la suma de los pesos de $C$ y $E$, lo cual se sigue de pensar un momento en los productos de operaciones de Pauli, y por tanto el peso de $CE$ es estrictamente menor que $d$. Esto implica que $CE$ es proporcional a un elemento del estabilizador de nuestro código, que es lo que queríamos demostrar. Al elegir nuestras operaciones de corrección como representantes de menor peso del conjunto de errores que generan cada síndrome, garantizamos corregir cualquier error de Pauli de peso menor que la mitad de la distancia del código.

Sin embargo, hay un problema. Para códigos estabilizadores en general, calcular la operación de Pauli de menor peso que produce un síndrome dado es un problema computacionalmente difícil. (De hecho, esto es cierto incluso para los códigos clásicos, que en este contexto podemos pensar como códigos estabilizadores donde solo aparecen matrices $\mathbb{I}$ y $Z$ como factores tensoriales dentro de los generadores estabilizadores.) Así que, a diferencia del paso de codificación, las operaciones de Clifford no vendrán a rescatarnos esta vez.

La solución es elegir códigos específicos para los que se puedan calcular buenas correcciones de manera eficiente, para lo cual no hay una receta simple. En pocas palabras, diseñar códigos estabilizadores para los que se puedan calcular buenas operaciones de corrección de manera eficiente es parte del arte del diseño de códigos cuánticos. Veremos este arte en acción en la próxima lección.