Códigos CSS

Códigos lineales clásicos

Los códigos correctores de errores clásicos se estudiaron por primera vez en la década de 1940, y desde entonces se conocen muchos códigos diferentes. Los códigos más estudiados y utilizados pertenecen a la categoría de los llamados códigos lineales. Lo que significa exactamente la palabra "lineal" en este contexto quedará claro enseguida. En términos simples, los códigos lineales son códigos estabilizadores, pero de naturaleza clásica. Los códigos CSS son esencialmente pares de códigos lineales clásicos que se combinan para formar un código corrector de errores cuánticos. Para comprender la siguiente discusión, necesitamos conocer algunas propiedades básicas de los códigos lineales clásicos.

Sea $\Sigma$ el alfabeto binario para toda esta discusión. Cuando hablamos de un código lineal clásico, nos referimos a un conjunto no vacío $\mathcal{C}\subseteq\Sigma^n$ de cadenas binarias de longitud $n$ (para un entero positivo $n$) que debe satisfacer exactamente una propiedad fundamental: si $u$ y $v$ son cadenas binarias en $\mathcal{C}$, entonces $u\oplus v$ también debe estar en $\mathcal{C}$. Aquí, $u\oplus v$ denota el OR exclusivo bit a bit de $u$ y $v$, como lo hemos encontrado varias veces en el curso "Fundamentos de los algoritmos cuánticos".

En esencia, en los códigos lineales clásicos consideramos las cadenas binarias de longitud $n$ como vectores $n$-dimensionales con entradas de $\{0, 1\}$ y requerimos que el código mismo forme un subespacio lineal. En lugar de la suma vectorial ordinaria sobre los números reales o complejos, usamos la suma módulo $2$, es decir, el OR exclusivo. Es decir: si $u$ y $v$ son dos palabras código en $\mathcal{C}$, entonces $u + v$ módulo 2, es decir, $u\oplus v$, también debe ser una palabra código en $\mathcal{C}$. Nótese en particular que esto también es cierto cuando $u = v$. De esto se deduce que $\mathcal{C}$ debe contener la cadena nula $0^n$, ya que el OR exclusivo bit a bit de cualquier cadena consigo misma es la cadena nula.

Ejemplo: el código de repetición de 3 bits

El código de repetición de 3 bits es un ejemplo de un código lineal clásico. Concretamente, $\mathcal{C} = \{000,111\}$, y para la condición de linealidad hay exactamente dos opciones para $u$ y dos para $v$. Es fácil verificar que para los cuatro pares posibles, el OR exclusivo bit a bit siempre da una palabra código:

$$000 \oplus 000 = 000, \quad 000 \oplus 111 = 111, \quad 111 \oplus 000 = 111, \quad 111 \oplus 111 = 000.$$

Ejemplo: el código de Hamming $[7,4,3]$

Aquí hay otro ejemplo de un código lineal clásico: el código de Hamming $[7,4,3]$. Fue uno de los primeros códigos correctores de errores clásicos jamás descubiertos y consta de estas 16 cadenas binarias de longitud 7. (A veces se entiende por código de Hamming $[7,4,3]$ el código con las cadenas invertidas, pero aquí consideramos el código con las cadenas que se muestran a continuación.)

$$\begin{array}{cccc} 0000000 & 1100001 & 1010010 & 0110011\\[1mm] 0110100 & 1010101 & 1100110 & 0000111\\[1mm] 1111000 & 0011001 & 0101010 & 1001011\\[1mm] 1001100 & 0101101 & 0011110 & 1111111 \end{array}$$

Hay una lógica simple detrás de la selección de estas cadenas, pero es secundaria para esta lección y no se explica aquí. Basta con señalar que este es un código lineal clásico: el XOR de cualesquiera dos de estas cadenas siempre da otra cadena en el código.

La notación $[7,4,3]$ (entre corchetes simples) tiene un significado similar a la notación de doble corchete para códigos estabilizadores de la lección anterior, pero aplicada a códigos lineales clásicos. Concretamente significa: las palabras código tienen $7$ bits, se pueden codificar $4$ bits (ya que hay $16 = 2^4$ palabras código), y se trata de un código con distancia $3$, es decir, dos palabras código diferentes difieren en al menos $3$ posiciones — por lo que se necesitan invertir al menos $3$ bits para transformar una palabra código en otra. El hecho de que sea un código con distancia $3$ implica que puede corregir hasta un error de inversión de bit.

Descripción de códigos lineales clásicos

Los ejemplos mencionados son códigos lineales clásicos muy simples, pero incluso en el código de Hamming $[7,4,3]$, la mera enumeración de las palabras código resulta algo enigmática. Hay formas mejores y más eficientes de describir códigos lineales clásicos, entre ellas las dos siguientes.

1. Generadores. Una forma de describir un código lineal clásico es una lista mínima de palabras código que generan el código, es decir, seleccionando todos los subconjuntos posibles de estas palabras código y aplicando XOR se obtiene el código completo.

   Más precisamente, las cadenas $u_1,\ldots,u_m\in\Sigma^n$ generan el código lineal clásico $\mathcal{C}$ si

   $$\mathcal{C} = \bigl\{\alpha_1 u_1 \oplus \cdots \oplus \alpha_m u_m\,:\,\alpha_1,\ldots,\alpha_m\in\{0,1\}\bigr\},$$

   donde $\alpha u = u$ para $\alpha = 1$ y $\alpha u = 0^n$ para $\alpha = 0$, y esta lista se denomina mínima si la eliminación de cualquiera de las cadenas genera un código más pequeño. Una forma natural de ver esta descripción es que $\{u_1,\ldots,u_m\}$ forma una base para $\mathcal{C}$ como subespacio — consideramos las cadenas como vectores con entradas binarias y trabajamos en un espacio vectorial donde la aritmética se realiza módulo $2$.

2. Verificaciones de paridad. Otra descripción natural de un código lineal clásico son las verificaciones de paridad — es decir, una lista mínima de cadenas binarias tales que exactamente las cadenas del código son aquellas cuyo producto escalar binario con cada una de estas cadenas de verificación de paridad es cero. (Al igual que el OR exclusivo bit a bit, el producto escalar binario ha aparecido varias veces en el curso "Fundamentos de los algoritmos cuánticos".)

   Es decir: las cadenas $v_1,\ldots,v_r\in\Sigma^n$ son cadenas de verificación de paridad para el código lineal clásico $\mathcal{C}$ si

   $$\mathcal{C} = \bigl\{ u\in \Sigma^n\,:\, u\cdot v_1 = \cdots = u \cdot v_r = 0 \bigr\},$$

   y este conjunto de cadenas es mínimo si la eliminación de cualquiera de ellas conduce a un código más grande. Se llaman cadenas de verificación de paridad porque $u$ tiene producto escalar binario cero con $v$ exactamente cuando los bits de $u$ en las posiciones donde $v$ tiene un 1 tienen paridad par. Para verificar si una cadena $u$ está en el código $\mathcal{C}$, basta entonces con comprobar la paridad de ciertos subconjuntos de los bits de $u$.

   Una nota importante: el producto escalar binario no es un producto interno en el sentido formal. En particular, que el producto escalar binario de dos cadenas sea cero no significa que sean ortogonales en el sentido habitual. Por ejemplo, el producto escalar binario de la cadena $11$ consigo misma es cero — una cadena de verificación de paridad de un código lineal clásico puede pertenecer al propio código.

Los códigos lineales clásicos sobre el alfabeto binario siempre contienen una cantidad de cadenas que es una potencia de $2$ — y para un código lineal clásico representado de ambas formas descritas, siempre se cumple $n = m + r$. Concretamente: si tenemos un conjunto mínimo de $m$ generadores, el código codifica $m$ bits y tiene exactamente $2^m$ palabras código; si tenemos un conjunto mínimo de $r$ cadenas de verificación de paridad, hay $2^{n-r}$ palabras código. Cada generador duplica el tamaño del espacio de código, mientras que cada cadena de verificación de paridad lo divide a la mitad.

Por ejemplo, el código de repetición de 3 bits es un código lineal que puede describirse de ambas formas. Hay exactamente un generador que funciona: $111$. Alternativamente, el código puede describirse mediante dos cadenas de verificación de paridad, por ejemplo $110$ y $011$ — que deberían resultar familiares de discusiones anteriores de este código — o también $110$ y $101$ o $101$ y $011$. (Los generadores y las cadenas de verificación de paridad no son, en general, únicos para un código lineal clásico dado.)

Como segundo ejemplo, consideremos el código de Hamming $[7,4,3]$. Aquí hay una posible lista de generadores:

$$\begin{array}{c} 1111000\\[1mm] 0110100\\[1mm] 1010010\\[1mm] 1100001 \end{array}$$

Y aquí hay una posible lista de verificaciones de paridad para este código:

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Aquí vemos, por cierto, que todas las cadenas de verificación de paridad pertenecen al propio código.

Una observación final sobre los códigos lineales clásicos que los conecta con el formalismo de estabilizadores: las cadenas de verificación de paridad corresponden a generadores de estabilizador que contienen solo matrices de Pauli $Z$ e identidad. Las cadenas de verificación de paridad $110$ y $011$ del código de repetición de 3 bits, por ejemplo, corresponden exactamente a los generadores de estabilizador $Z\otimes Z\otimes \mathbb{I}$ y $\mathbb{I}\otimes Z\otimes Z$, lo cual es consistente con las discusiones sobre observables de Pauli de la lección anterior.

Definición de los códigos CSS

Los códigos CSS son códigos estabilizadores que se obtienen combinando ciertos pares de códigos lineales clásicos. Esto no funciona para cualesquiera dos códigos lineales clásicos — los dos códigos deben tener una relación particular entre sí. Sin embargo, esta construcción abre muchas posibilidades para códigos correctores de errores cuánticos, que se basan en parte en más de 75 años de teoría de codificación clásica.

En el formalismo de estabilizadores, los generadores de estabilizador que contienen solo matrices de Pauli $Z$ e identidad son equivalentes a verificaciones de paridad, como acabamos de ver con el código de repetición de 3 bits. Como otro ejemplo, consideremos las siguientes cadenas de verificación de paridad para el código de Hamming $[7,4,3]$:

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Estas cadenas de verificación de paridad corresponden a los siguientes generadores de estabilizador (sin símbolos de producto tensorial), que se obtienen reemplazando cada $1$ por $Z$ y cada $0$ por $\mathbb{I}$. Estos son tres de los seis generadores de estabilizador del código de Steane de 7 qubits.

$$\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 \end{array}$$

Los generadores de estabilizador de este tipo — en los que solo aparecen factores tensoriales de Pauli $Z$ e identidad (no aparecen matrices de Pauli $X$ ni $Y$) — los llamamos generadores de estabilizador $Z$.

Además, existen generadores de estabilizador en los que solo aparecen matrices de Pauli $X$ e identidad como factores tensoriales. Tales generadores son análogos a los generadores de estabilizador $Z$, pero describen verificaciones de paridad en la base $\{\vert+\rangle,\vert-\rangle\}$ en lugar de la base estándar. Los generadores de esta forma se llaman generadores de estabilizador $X$ — aquí no se permiten matrices de Pauli $Y$ ni $Z$.

Como ejemplo, consideremos los tres generadores de estabilizador restantes del código de Steane de 7 qubits:

$$\begin{array}{ccccccc} 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}$$

Siguen exactamente el mismo patrón del código de Hamming $[7,4,3]$ que los generadores de estabilizador $Z$, pero esta vez se usa $X$ en lugar de $Z$ para cada $1$. Solo con estos tres generadores de estabilizador se obtiene un código que contiene los 16 estados que se muestran aquí — se obtienen aplicando operaciones de Hadamard a los estados de la base estándar correspondientes a las cadenas del código de Hamming $[7,4,3]$. (Por supuesto, el espacio de código también contiene combinaciones lineales de estos estados.)

$$\begin{array}{cccc} \vert {+++++++} \rangle \quad & \vert {--++++-} \rangle \quad & \vert {-+-++-+} \rangle \quad & \vert {+--++--} \rangle \\ \vert {+--+-++} \rangle \quad & \vert {-+-+-+-} \rangle \quad & \vert {--++--+} \rangle \quad & \vert {++++---} \rangle \\ \vert {----+++} \rangle \quad & \vert {++--++-} \rangle \quad & \vert {+-+-+-+} \rangle \quad & \vert {-++-+--} \rangle \\ \vert {-++--++} \rangle \quad & \vert {+-+--+-} \rangle \quad & \vert {++----+} \rangle \quad & \vert {-------} \rangle \end{array}$$

Los códigos CSS pueden definirse ahora en términos muy simples.

Definición

Un código CSS es un código estabilizador que puede expresarse exclusivamente con generadores de estabilizador $X$ y $Z$.

Es decir, los códigos CSS son códigos estabilizadores para los cuales existen generadores de estabilizador en los que no aparecen matrices de Pauli $Y$ y en los que $X$ y $Z$ nunca ocurren en el mismo generador de estabilizador.

Para ser claros: según esta definición, un código CSS es aquel en el que es posible elegir exclusivamente generadores de estabilizador $X$ y $Z$ — pero debemos tener en cuenta que en los códigos estabilizadores hay libertad en la elección de los generadores. Por lo tanto, en general habrá diferentes elecciones de generadores de estabilizador para un código CSS que no son generadores de estabilizador $X$ o $Z$ (además de al menos una elección en la que sí lo son).

Aquí hay un ejemplo muy simple de un código CSS que contiene tanto un generador de estabilizador $Z$ como un generador de estabilizador $X$:

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

Es obvio que este es un código CSS: el primer generador de estabilizador es un generador de estabilizador $Z$ y el segundo es un generador de estabilizador $X$. Por supuesto, un código CSS también debe ser un código estabilizador válido — es decir, los generadores de estabilizador deben conmutar, formar un conjunto generador mínimo y fijar al menos un vector de estado cuántico. Estos requisitos son fáciles de verificar para este código. Como se menciónó en la lección anterior, el espacio de código de este código es el espacio unidimensional generado por el estado de Bell $\vert\phi^+\rangle$. Que ambos generadores de estabilizador fijan este estado se deduce de las dos expresiones siguientes para un e-bit y de una interpretación de estos generadores de estabilizador como verificaciones de paridad en la base $\{\vert 0\rangle, \vert 1\rangle\}$ y en la base $\{\vert +\rangle, \vert -\rangle\}$.

$$\vert\phi^+\rangle = \frac{\vert 0\rangle\vert 0\rangle + \vert 1\rangle\vert 1\rangle}{\sqrt{2}} = \frac{\vert +\rangle\vert +\rangle + \vert -\rangle\vert -\rangle}{\sqrt{2}}$$

El código de Steane de 7 qubits es otro ejemplo de un código CSS.

$$\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}$$

Aquí tenemos tres generadores de estabilizador $Z$ y tres generadores de estabilizador $X$, y ya hemos verificado que se trata de un código estabilizador válido.

Y el código de Shor de 9 qubits es otro ejemplo:

$$\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}$$

Esta vez tenemos seis generadores de estabilizador $Z$ y solo dos generadores de estabilizador $X$. Esto está bien — no tiene por qué haber equilibrio o simetría entre los dos tipos de generadores (aunque frecuentemente la hay).

Una vez más, los códigos CSS deben ser códigos estabilizadores válidos; en particular, cada generador de estabilizador $Z$ debe conmutar con cada generador de estabilizador $X$. No toda combinación de generadores de estabilizador $X$ y $Z$ define, por tanto, un código CSS válido.

Detección y corrección de errores

En cuanto a la detección y corrección de errores, los códigos CSS tienen, en general, una propiedad similar a la del código de Shor de 9 qubits: los errores $X$ y $Z$ pueden detectarse y corregirse de forma completamente independiente. Los generadores de estabilizador $Z$ describen un código que protege contra inversiones de bit, y los generadores de estabilizador $X$ describen un código que protege independientemente contra inversiones de fase. Esto funciona porque los generadores de estabilizador $Z$ necesariamente conmutan con los errores $Z$ y las correcciones $Z$ — son por tanto completamente invisibles para ambos — y lo mismo ocurre recíprocamente con los generadores de estabilizador $X$, errores y correcciones.

Como ejemplo, consideremos el código de Steane de 7 qubits:

$$\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}$$

La idea básica de este código es ahora clara: es un código de Hamming $[7,4,3]$ para errores de inversión de bit y un código de Hamming $[7,4,3]$ para errores de inversión de fase. Que los generadores de estabilizador $X$ y $Z$ conmuten es, en cierto modo, una circunstancia afortunada — si no fuera así, no sería un código estabilizador válido. De hecho, sin embargo, hay muchos ejemplos conocidos de códigos lineales clásicos que conducen a un código estabilizador válido de manera similar.

Supongamos que tenemos un código CSS en el que los generadores de estabilizador $Z$ permiten la corrección de hasta $j$ errores de inversión de bit y los generadores de estabilizador $X$ permiten la corrección de hasta $k$ errores de inversión de fase. Para el código de Steane, por ejemplo, $j = 1$ y $k = 1$, ya que el código de Hamming $[7,4,3]$ puede corregir una inversión de bit. Por la discretización de errores, se deduce que este código CSS puede corregir errores arbitrarios en un número de qubits hasta el mínimo de $j$ y $k$. Pues al medir el síndrome, un error arbitrario en ese número de qubits colapsa probabilísticamente en una combinación de errores $X$, errores $Z$ o ambos — y luego los errores $X$ y los errores $Z$ se detectan y corrigen de forma independiente.

En resumen: si tenemos dos códigos lineales clásicos (o dos copias de un solo código lineal clásico) que son compatibles — es decir, definen generadores de estabilizador $X$ y $Z$ que conmutan — entonces el código CSS que obtenemos al combinarlos hereda las propiedades de corrección de errores de esos dos códigos en el sentido descrito.

Sin embargo, hay un precio que pagar: no podemos codificar tantos qubits como bits en los dos códigos clásicos. Esto se debe a que el número total de generadores de estabilizador del código CSS es la suma de las verificaciones de paridad de los dos códigos lineales clásicos, y cada generador de estabilizador reduce a la mitad la dimensión del espacio de código. Por ejemplo, el código de Hamming $[7,4,3]$ permite la codificación de cuatro bits clásicos (ya que solo tiene tres cadenas de verificación de paridad), mientras que el código de Steane de 7 qubits codifica solo un qubit (ya que tiene seis generadores de estabilizador).

Espacios de código de los códigos CSS

Para concluir nuestra discusión sobre los códigos CSS, consideremos los espacios de código de estos códigos. Esto nos da la oportunidad de examinar más de cerca la relación que debe existir entre dos códigos lineales clásicos para que sean compatibles y puedan combinarse en un código CSS.

Consideremos un código CSS arbitrario sobre $n$ qubits y sea $z_1, \ldots, z_s \in \Sigma^n$ el conjunto de las cadenas de verificación de paridad de $n$ bits correspondientes a los generadores de estabilizador $Z$ de este código. El código lineal clásico descrito solo por los generadores de estabilizador $Z$, al que llamamos $\mathcal{C}_Z$, tiene entonces la siguiente forma:

$$\mathcal{C}_Z = \bigl\{ u \in \Sigma^n \,:\, u \cdot z_1 = \cdots = u \cdot z_s = 0 \bigr\}$$

En otras palabras, el código lineal clásico $\mathcal{C}_Z$ contiene exactamente las cadenas cuyo producto escalar binario con cada una de las cadenas de verificación de paridad $z_1, \ldots, z_s$ es cero.

Correspondientemente, sea $x_1,\ldots,x_t\in\Sigma^n$ el conjunto de las cadenas de verificación de paridad de $n$ bits correspondientes a los generadores de estabilizador $X$ de nuestro código. El código lineal clásico de los generadores de estabilizador $X$ tiene entonces esta forma:

$$\mathcal{C}_X = \bigl\{ u \in \Sigma^n \,:\, u \cdot x_1 = \cdots = u \cdot x_t = 0 \bigr\}$$

Los generadores de estabilizador $X$ solos describen, por tanto, un código similar a este, pero en la base $\{\vert {+}\rangle,\vert {-}\rangle\}$ en lugar de la base estándar.

Ahora introducimos dos nuevos códigos lineales clásicos que se derivan de las mismas cadenas $z_1,\ldots,z_s$ y $x_1,\ldots,x_t$, pero esta vez usadas como generadores en lugar de cadenas de verificación de paridad. Obtenemos los siguientes dos códigos:

$$\begin{aligned} \mathcal{D}_Z & = \bigl\{ \alpha_1 z_1 \oplus \cdots \oplus \alpha_s z_s \,:\, \alpha_1,\ldots,\alpha_s \in \{0,1\} \bigr\}\\[1mm] \mathcal{D}_X & = \bigl\{ \alpha_1 x_1 \oplus \cdots \oplus \alpha_t x_t \,:\, \alpha_1,\ldots,\alpha_t \in \{0,1\} \bigr\} \end{aligned}$$

Estos se denominan códigos duales de los códigos definidos anteriormente: $\mathcal{D}_Z$ es el código dual de $\mathcal{C}_Z$ y $\mathcal{D}_X$ es el código dual de $\mathcal{C}_X$. Puede que no sea obvio por el momento por qué estos códigos duales son relevantes, pero desempeñan un papel importante por varias razones, incluyendo las dos explicadas en los párrafos siguientes.

En primer lugar, las condiciones que dos códigos lineales clásicos $\mathcal{C}_Z$ y $\mathcal{C}_X$ deben satisfacer para ser compatibles (es decir, poder combinarse en un código CSS) pueden describirse de forma simple usando los códigos duales. Concretamente, debe cumplirse: $\mathcal{D}_Z\subseteq\mathcal{C}_X$, lo cual es equivalente a $\mathcal{D}_X\subseteq\mathcal{C}_Z$. En otras palabras: el código dual $\mathcal{D}_Z$ contiene las cadenas de los generadores de estabilizador $Z$, y su inclusión en $\mathcal{C}_X$ es equivalente a que el producto escalar binario de cada una de estas cadenas con las de los generadores de estabilizador $X$ sea cero. Esto, a su vez, es equivalente a que cada generador de estabilizador $Z$ conmute con cada generador de estabilizador $X$. Alternativamente, se puede llegar a la misma conclusión intercambiando los roles de los generadores de estabilizador $X$ y $Z$ y partiendo de la inclusión $\mathcal{D}_X\subseteq\mathcal{C}_Z$.

En segundo lugar, usando los códigos duales se pueden describir fácilmente los espacios de código de un código CSS dado. En particular, el espacio de código está generado por vectores de la siguiente forma:

$$\vert u \oplus \mathcal{D}_X\rangle = \frac{1}{\sqrt{2^t}} \sum_{v\in\mathcal{D}_X} \vert u \oplus v\rangle \qquad \text{(para todo $u\in\mathcal{C}_Z$)}$$

En otras palabras, estos vectores son superposiciones equiponderadas sobre las cadenas del código dual $\mathcal{D}_X$ del código correspondiente a los generadores de estabilizador $X$, desplazadas (es decir, XOR bit a bit) con cadenas del código $\mathcal{C}_Z$ de los generadores de estabilizador $Z$. Para aclarar: diferentes elecciones del desplazamiento — representado por la cadena $u$ en esta expresión — pueden conducir al mismo vector. Estos estados no son, por tanto, todos distintos, pero juntos generan todo el espacio de código.

Aquí hay una explicación intuitiva de por qué tales vectores están en el espacio de código y lo generan. Consideremos el estado de la base estándar de $n$ qubits $\vert u\rangle$ para una cadena de $n$ bits arbitraria $u$ y proyectemos este estado sobre el espacio de código. Sea $\Pi$ la proyección sobre el espacio de código de nuestro código CSS y consideremos el vector $\Pi\vert u\rangle$. Hay dos casos:

• Caso 1: $u\in\mathcal{C}_Z.$ Esto significa que cada generador de estabilizador $Z$ de nuestro código CSS actúa trivialmente sobre $\vert u\rangle$. Los generadores de estabilizador $X$, en cambio, invierten ciertos bits de $\vert u\rangle$. En particular, para cada generador $v$ de $\mathcal{D}_X$, el generador de estabilizador $X$ correspondiente transforma $\vert u\rangle$ en $\vert u\oplus v\rangle$. Caracterizando la proyección $\Pi$ como el promedio sobre los elementos del estabilizador (como se vio en la lección anterior), obtenemos la siguiente fórmula:

  $$\Pi \vert u \rangle = \frac{1}{2^t} \sum_{v\in\mathcal{D}_{X}} \vert u \oplus v\rangle = \frac{1}{\sqrt{2^t}} \vert u \oplus \mathcal{D}_X\rangle.$$

• Caso 2: $u\notin\mathcal{C}_Z.$ Esto significa que al menos una de las verificaciones de paridad correspondientes a los generadores de estabilizador $Z$ falla, es decir, $\vert u\rangle$ es un vector propio con valor propio $-1$ de al menos un generador de estabilizador $Z$. El espacio de código del código CSS es la intersección de los espacios propios de valor propio $+1$ de los generadores de estabilizador. Como vector propio de valor propio $-1$ de al menos un generador de estabilizador $Z$, $\vert u\rangle$ es por tanto ortogonal al espacio de código:

  $$\Pi\vert u\rangle = 0.$$

Si ahora recorremos todas las cadenas de $n$ bits $u$, descartamos los casos con $\Pi\vert u\rangle = 0$ y normalizamos los restantes, obtenemos los vectores descritos anteriormente — lo que demuestra que generan el espacio de código.

Usando la simetría entre los generadores de estabilizador $X$ y $Z$, el espacio de código también puede describirse de una forma similar pero diferente. Está generado por vectores de la siguiente forma:

$$H^{\otimes n} \vert u \oplus \mathcal{D}_Z\rangle = \frac{1}{\sqrt{2^s}} \sum_{v\in\mathcal{D}_Z} H^{\otimes n}\vert u \oplus v\rangle \qquad \text{(para $u\in\mathcal{C}_X$)}$$

En esencia, se han intercambiado $X$ y $Z$ en cada aparición — pero también debemos intercambiar la base estándar por la base $\{\vert+\rangle,\vert-\rangle\}$, razón por la cual aparecen las operaciones de Hadamard.

Como ejemplo, consideremos el código de Steane de 7 qubits. Las cadenas de verificación de paridad para los generadores de estabilizador $X$ y $Z$ son las mismas: $1111000$, $1100110$ y $1010101$. Los códigos $\mathcal{C}_X$ y $\mathcal{C}_Z$ son por tanto iguales; ambos son el código de Hamming $[7,4,3]$.

$$\mathcal{C}_X = \mathcal{C}_Z = \{0000000, 0000111, 0011001, 0011110, 0101010, 0101101, 0110011, 0110100, 1001011, 1001100, 1010010, 1010101, 1100001, 1100110, 1111000, 1111111\}$$

Los códigos duales $\mathcal{D}_X$ y $\mathcal{D}_Z$ también son por tanto iguales. Tenemos tres generadores y obtenemos ocho cadenas:

$$\mathcal{D}_X = \mathcal{D}_Z = \{0000000, 0011110, 0101101, 0110011, 1001011, 1010101, 1100110, 1111000\}$$

Todas estas cadenas están contenidas en el código de Hamming $[7,4,3]$, por lo que se satisface la condición CSS: $\mathcal{D}_Z \subseteq \mathcal{C}_X$ o, equivalentemente, $\mathcal{D}_X \subseteq \mathcal{C}_Z$.

Dado que $\mathcal{D}_X$ contiene la mitad de todas las cadenas en $\mathcal{C}_Z$, solo hay dos vectores distintos $\vert u\oplus \mathcal{D}_X\rangle$ que surgen al elegir $u\in\mathcal{C}_Z$. Esto es de esperar, ya que el código de Steane de 7 qubits tiene un espacio de código bidimensional. Podemos usar los dos estados así obtenidos para codificar los estados lógicos $\vert 0\rangle$ y $\vert 1\rangle$ de la siguiente manera:

$$\begin{aligned} \vert 0\rangle & \mapsto \frac{ \vert 0000000\rangle + \vert 0011110\rangle + \vert 0101101\rangle + \vert 0110011\rangle + \vert 1001011\rangle + \vert 1010101\rangle + \vert 1100110\rangle + \vert 1111000\rangle }{\sqrt{8}}\\[4mm] \vert 1\rangle & \mapsto \frac{ \vert 0000111\rangle + \vert 0011001\rangle + \vert 0101010\rangle + \vert 0110100\rangle + \vert 1001100\rangle + \vert 1010010\rangle + \vert 1100001\rangle + \vert 1111111\rangle }{\sqrt{8}} \end{aligned}$$

Como de costumbre, esta elección no es obligatoria — podemos usar el espacio de código a voluntad para codificar qubits. Sin embargo, esta codificación es consistente con el ejemplo de un circuito de codificación para el código de Steane de 7 qubits de la lección anterior.