Código estabilizador

En computación cuántica y comunicación cuántica , un código estabilizador es una clase de códigos cuánticos para realizar corrección de errores cuánticos . El código tórico , y los códigos de superficie más generalmente, ^{[ 1 ]} son tipos de códigos estabilizadores considerados muy importantes para la realización práctica del procesamiento de información cuántica. De hecho, el código tórico y los códigos de superficie también pertenecen a una clase especial de códigos estabilizadores, los códigos CSS . Un ejemplo de un código estabilizador que no es un código CSS es el código corrector de errores de cinco cúbits .

Los códigos estabilizadores son sorprendentemente similares a los códigos de bloques lineales clásicos en su funcionamiento y rendimiento. Al igual que un código de bloques lineal clásico se define por su matriz de verificación de paridad , un código estabilizador cuántico también posee una estructura de "verificación de paridad" definida por sus estabilizadores . Sin embargo, los estabilizadores para un código $de n cúbits son$ operadores de Pauli $de n$ cúbits en lugar de cadenas clásicas $de n$ bits, y deben conmutar entre sí para que el código sea válido.

La teoría de los códigos estabilizadores permite importar algunos códigos binarios o cuaternarios clásicos para su uso como códigos cuánticos. Sin embargo, al importar el código clásico, este debe satisfacer la restricción de dualidad (o autoortogonalidad). Los investigadores han encontrado muchos ejemplos de códigos clásicos que satisfacen esta restricción, pero la mayoría no la cumple. No obstante, sigue siendo útil importar códigos clásicos de esta manera. El formalismo de estabilizadores asistido por entrelazamiento también puede superar esta dificultad.

Los códigos de geometría algebraica proporcionan otra fuente de construcciones estabilizadoras. Matsumoto utilizó curvas algebraicas para obtener códigos estabilizadores binarios asintóticamente buenos y para mejorar la cota de Ashikhmin-Litsyn-Tsfasman para códigos cuánticos. ^{[ 2 ]}

Definición

El formalismo del estabilizador se basa en el grupo de Pauli $de n$ qubits $Π n$ , y utiliza ampliamente el hecho de que los operadores hermíticos (aquellos con factores escalares $\pm1$ en lugar de $\pm i$ ) en $Π n$ tienen autovalores. $\pm 1$ y que dos operadores en $Π n$ conmutan o anticonmutan .

Un estabilizador de un código estabilizador con $n$ cúbits físicos es un operador de Pauli $de n$ cúbits $P \in Π n$ tal que todos los estados de código válidos $|\psi \rangle$ se encuentran en el espacio propio +1 $de$ P $,$ es decir , $P|\psi \rangle =|\psi \rangle$ ⁠ . Un código estabilizador se define por sus estabilizadores en el sentido de que lo contrario también es cierto: Un estado $|\psi \rangle$ es un estado de código válido para el código estabilizador si y solo si $P|\psi \rangle =|\psi \rangle$ Esto se cumple para cada estabilizador $P.$ Por lo tanto, el espacio propio simultáneo $+1$ de los estabilizadores constituye el espacio de códigos del código estabilizador.

Cualquier par de estabilizadores $P$ y $Q$ deben conmutar y $PQ$ también debe ser un estabilizador. Por lo tanto, los estabilizadores de un código forman el grupo de estabilizadores. ${\mathcal {S}}$ , un subgrupo abeliano de $Π$ $n$ . Por el contrario, cualquier subgrupo abeliano de $Π$ $n$ que no contenga $-I^{\otimes n}$ ^{[ nota 1 ]} es un grupo de estabilizadores válido que define un código de estabilizador.

El número de cúbits lógicos codificados en un código estabilizador está determinado por el tamaño del espacio de códigos, que a su vez está determinado por el número de cúbits físicos y el tamaño del grupo estabilizador. Para un código estabilizador de $n cúbits que codifica$ $k$ cúbits lógicos (denominado código $[[n, k]]$ ), el espacio de códigos tiene $2 k$ dimensiones y el grupo estabilizador ${\mathcal {S}}$ tiene $2 n - k$ elementos. Dado que todos los elementos hermíticos no unitarios de $Π n$ tienen orden 2, ${\mathcal {S}}$ puede ser generado por $n - k$ generadores independientes:

{\mathcal {S}}=\left\langle g_{1},\ldots ,g_{nk}\right\rangle .

Los generadores deben ser independientes en el sentido de que ninguno de ellos es producto de ningún otro número de generadores, o de su negación (de lo contrario generarían $-I^{\otimes n}$ ). Son análogas a las filas de la matriz de verificación de paridad de un código de bloques lineal clásico .

Ejemplos

Código de repetición clásico

Como ejemplo sencillo, el código de repetición clásico de 3 bits $[3, 1, 3]$ puede considerarse como un código estabilizador cuántico $[[3, 1, 1]]$ . Codifica $k$ $= 1$ cúbit lógico en $n$ $= 3$ cúbits físicos y protege contra un único error de inversión de bit (representado como un operador $X de Pauli$ $X$ $i$ en un contexto de información cuántica). Sin embargo, dado que no protege contra errores de inversión de fase de un solo cúbit $Z$ $i$ , su distancia de código como código cuántico es $d$ $= 1$ .

El grupo estabilizador del código de repetición de 3 cúbits tiene $n - k = 2$ generadores:

{\begin{array}{ccc}g_{1}&=&Z&Z&I\\g_{2}&=&I&Z&Z\\\end{array}}

El estabilizador $g 1$ indica que, si el primer y el segundo cúbit en un estado de código válido se miden en la base $Z$ , los resultados siempre serán los mismos (es decir, el producto de los autovalores $de Z$ siempre será $+1$ ). De manera similar, $g 2$ indica que la medición en la base $Z$ del segundo y tercer cúbit siempre produce el mismo resultado. Como era de esperar, el espacio de código de este código es

{\text{Span}}(|000\rangle ,|111\rangle )

.

Por lo general, el estado físico $|000\rangle$ y $|111\rangle$ se identifican con el $|0\rangle$ y $|1\rangle$ estados del cúbit lógico respectivamente (a menudo escrito como $|{\overline {0}}\rangle$ y $|{\overline {1}}\rangle$ para distinguirlos de los estados físicos). Como código cuántico, el espacio de códigos también incluye superposiciones de $|{\overline {0}}\rangle$ y $|{\overline {1}}\rangle$ , como $|{\overline {+}}\rangle =|000\rangle +|111\rangle$ y $|{\overline {-}}\rangle =|000\rangle -|111\rangle$ . Tenga en cuenta que un error de inversión de fase $Z i$ en cualquier cúbit físico cambiará $|{\overline {+}}\rangle$ a $|{\overline {-}}\rangle$ y viceversa.

Código de cinco cúbits

Un ejemplo de código estabilizador es el código estabilizador de cinco cúbits $[[5, 1, 3]]$ . Codifica $k = 1$ cúbit lógico en $n = 5$ cúbits físicos. Su grupo estabilizador tiene $n - k = 4$ generadores:

{\begin{array}{ccccccc}g_{1}&=&X&Z&Z&X&I\\g_{2}&=&I&X&Z&Z&X\\g_{3}&=&X&I&X&Z&Z\\g_{4}&=&Z&X&I&X&Z\end{array}}

Como mostraremos más adelante, este código protege contra un error arbitrario de un solo qubit y, por lo tanto, tiene una distancia de código $d = 3$ .

Operadores lógicos

Hay muchas maneras de descomponer un espacio de códigos de $2k dimensiones$ en $k$ cúbits lógicos, y una forma de especificar dicha descomposición es dando operadores $Z$ y $X$ de Pauli para cada cúbit lógico. Para los códigos estabilizadores, existen descomposiciones donde estos operadores $Z$ y $X$ lógicos también son elementos de $Π n$ .

Por definición, un operador lógico $P$ debe asignar un estado de código válido. $|\psi \rangle$ en un estado de código válido $P|\psi \rangle$ ⁠ . Esto significa que para cada estabilizador $S$ , $SP|\psi \rangle =P|\psi \rangle =PS|\psi \rangle$ (la segunda igualdad se cumple ya que $|\psi \rangle$ es en sí mismo un estado de código válido), lo cual siempre es verdadero cuando $P$ y $S$ conmutan y nunca verdadero cuando anticonmutan. Por lo tanto, el conjunto de operadores lógicos válidos en $Π n$ es ⁠ $C({\mathcal {S}})$ ⁠ , el centralizador de ${\mathcal {S}}$ (es decir, el subgrupo de elementos que conmutan con todos los miembros de ⁠ ${\mathcal {S}}$ ⁠ , también conocido como el conmutador).

Sin embargo, no todos estos operadores lógicos actúan de manera no trivial sobre el cúbit lógico. En particular, dado que ${\mathcal {S}}$ es un subgrupo abeliano, ${\mathcal {S}}$ También está contenido en $C({\mathcal {S}})$ ⁠ . De hecho, cuando ⁠ $S\in {\mathcal {S}}$ , $S|\psi \rangle =|\psi \rangle$ ⁠ , lo que significa que $S$ implementa el operador de identidad lógica $I^{\otimes k}$ . Además, para cualquier otro operador lógico $P$ , $PS$ actúa de forma idéntica a $P$ sobre el estado del código, y por lo tanto implementan el mismo operador lógico. Factorizando esta equivalencia se obtiene el grupo cociente ⁠ $C({\mathcal {S}})/{\mathcal {S}}$ ⁠ , que es isomorfo a $Π k$ . Por lo tanto, todos $los operadores lógicos de Pauli de k$ qubits pueden elegirse como $operadores físicos de Pauli de n$ qubits.

Para especificar explícitamente la descomposición lógica del cúbit, normalmente se eligen los operadores lógicos $Z 1, X 1, ..., Z k, X k \in Π n$ . Cada uno de estos operadores $Z i$ o $X i$ es un representante de la clase de equivalencia ${\overline {Z_{i}}}{\mathcal {S}}$ o ${\overline {X_{i}}}{\mathcal {S}}$ implementando el mismo operador lógico. Estos operadores deben satisfacer las siguientes condiciones:

$Z 1, X 1, ..., Z k, X k, g 1, ..., g n - k$ sontodosindependientes: El producto de cualquier subconjunto no vacío de estos operadores no puede ser un múltiplo escalar de $I^{\otimes n}$ .
Entre $Z 1, X 1, ..., Z k, X k, g 1, ..., g n - k$ , los únicos pares que anticonmutan son $Z i$ y $X i$ para el mismo $i$ . Otros pares —dos operadores lógicos en diferentes cúbits lógicos, un operador lógico y un generador estabilizador, o dos generadores estabilizadores— conmutan.

Ejemplos

Para el código de repetición de 3 cúbits descrito anteriormente, los generadores estabilizadores (repetidos por conveniencia) y los representantes de operadores lógicos se pueden elegir como:

{\begin{array}{ccc}g_{1}&=&Z&Z&I\\g_{2}&=&I&Z&Z\\{\overline {Z}}&=&Z&I&I\\{\overline {X}}&=&X&X&X\end{array}}

$Otros operadores Z$ de un solo qubit son implementaciones alternativas del operador lógico $Z :$ $Z 2 = Z g 1$ , $Z 3 = Z g 1 g 2$ . Esto es consistente con la observación anterior de que cualquier error de inversión de fase de un solo qubit cambia $|{\overline {+}}\rangle$ a $|{\overline {-}}\rangle$ y viceversa. También es sencillo comprobar que al aplicar $X = XXX$ , es decir, invertir los bits de los tres cúbits, se producen cambios. $|{\overline {0}}\rangle$ a $|{\overline {1}}\rangle$ y viceversa.

Para el código de cinco cúbits, los representantes de los operadores lógicos se suelen elegir de la siguiente manera:

{\begin{array}{ccccccc}g_{1}&=&X&Z&Z&X&I\\g_{2}&=&I&X&Z&Z&X\\g_{3}&=&X&I&X&Z&Z\\g_{4}&=&Z&X&I&X&Z\\{\overline {Z}}&=&Z&Z&Z&Z&Z\\{\overline {X}}&=&X&X&X&X&X\end{array}}

Sin embargo, tenga en cuenta que estos no son los candidatos representativos de operadores lógicos con el menor peso (número de factores de Pauli distintos $de I$ ). Por ejemplo, $Z g 1 = - YIIYZ$ tiene un peso de 3.

Condiciones de corrección de errores del estabilizador

Una de las nociones fundamentales en la teoría de corrección de errores cuánticos es que basta con corregir un conjunto de errores discretos con soporte en el grupo de Pauli. $\Pi ^{n}$ Supongamos que los errores que afectan a un estado cuántico codificado son un subconjunto ${\mathcal {E}}$ del grupo Pauli $\Pi ^{n}$ :

{\mathcal {E}}\subset \Pi ^{n}.

Porque ${\mathcal {E}}$ y ${\mathcal {S}}$ son ambos subconjuntos de $\Pi ^{n}$ , un error $E\in {\mathcal {E}}$ ya sea conmuta o anticonmuta con algún elemento en particular $S\in {\mathcal {S}}$ . Si $E$ anticonmuta con un elemento $S$ , entonces $SE|\psi \rangle =-ES|\psi \rangle =-E|\psi \rangle$ lo que significa que $E|\psi \rangle$ está en el espacio propio −1 $de$ S $en$ lugar del espacio propio +1 $,$ y por lo tanto $E$ es detectable midiendo $S.$ En realidad, basta con medir cada generador estabilizador $g$ , ya que si $E$ conmuta con cada $g$ , entonces $E$ también conmutará con el producto de cualquier número de ellos. En este caso $E\in C({\mathcal {S}})$ es un operador lógico y, por lo tanto, no puede ser detectado por el código.

Sin embargo, $E\in {\mathcal {S}}$ es de nuevo un caso especial, donde $E$ implementa el operador de identidad lógica: aunque no es detectable, tampoco corrompe el estado codificado. Esto también se cumple para cualquier múltiplo escalar de $E\in {\mathcal {S}}$ , ya que una fase global no tiene efecto físico. Definimos un error lógico indetectable $E$ como aquel que es indetectable pero sí corrompe el estado codificado, es decir,

E\in C({\mathcal {S}})\setminus \{+1,+i,-1,-i\}\otimes {\mathcal {S}}=C({\mathcal {S}})\setminus C(C({\mathcal {S}})).

La igualdad anterior proporciona una caracterización alternativa de un error lógico indetectable $E$ : $E$ debe conmutar con todos los estabilizadores, pero no con todos los operadores lógicos. Esta caracterización suele ser más conveniente, ya que solo es necesario comprobar la conmutatividad con los generadores $Z 1, X 1, ..., Z k, X k, g 1, ..., g n - k$ , en lugar de resolver un sistema de ecuaciones lineales para determinar si $E$ es el producto de algún subconjunto de ${g i}$ hasta la fase global.

Operacionalmente, cada generador estabilizador $g$ puede medirse mediante una medición de paridad sin perturbar los estados en el espacio de códigos. La combinación de los resultados de la medición de cada $g$ se conoce como síndrome. $\mathbf {r}$ , representado como un vector binario $\mathbf {r}$ con longitud $n-k$ cuyos elementos indican si el error $E$ conmuta o anticonmuta con cada generador estabilizador $g$ .

Condiciones de Knill-Laflamme

Cuando se utiliza un código estabilizador como código de corrección de errores , también se debe elegir una corrección $E 1 †$ ^{[ nota 2 ]} para cada síndrome. Si existe otro posible error $E 2$ con el mismo síndrome que $E 1$ , entonces después de la corrección puede haber un error residual $E 1 † E 2$ . La condición de que $E 2$ tenga el mismo síndrome que $E 1$ es equivalente a que $E 1 † E 2$ sea indetectable, es decir, $E_{1}^{\dagger }E_{2}\in C({\mathcal {S}})$ Sin embargo, si $E 1 † E 2$ no corrompe los cúbits lógicos, la corrección de errores será exitosa de todos modos. Por lo tanto, un código estabilizador puede corregir perfectamente un conjunto de errores de Pauli. ${\mathcal {E}}$ mientras no exista $E_{1},E_{2}\in {\mathcal {E}}$ de tal manera que $E 1 † E 2$ es un error lógico indetectable. ^{[ nota 3 ]}

Ejemplos

El código de repetición de 3 cúbits puede corregir errores de inversión de bits de un solo cúbit, lo que significa que satisface las condiciones de corrección de errores para ${\mathcal {E}}=\{I,X_{1},X_{2},X_{3}\}$ . De hecho, el único error lógico indetectable que consiste únicamente en $I$ y $X$ es $XXX$ con peso 3, y el producto de dos errores en ${\mathcal {E}}$ Esto también se puede verificar comprobando explícitamente las correcciones correspondientes a cada síndrome:

El código de cinco cúbits puede corregir cualquier error de un solo cúbit, es decir, satisface las condiciones de corrección de errores para ${\mathcal {E}}=\{I,X_{i},Y_{i},Z_{i}\}$ ( $1 + 5 \times 3 = 16$ errores distintos). Esto se puede verificar demostrando que todos los errores lógicos indetectables de este código tienen un peso de al menos 3, o comprobando explícitamente los $24 = 16$ síndromes. Para el código de cinco cúbits, cada síndrome corresponde a un error en ${\mathcal {E}}$ , aunque esto no es típico para los códigos estabilizadores: para códigos como el código de superficie con grandes distancias de código y estabilizadores de peso relativamente bajo, un síndrome generalmente corresponderá a muchos errores corregibles que difieren entre sí por los estabilizadores.

Relación entre el grupo de Pauli y los vectores binarios

El grupo de Pauli tiene una representación vectorial binaria basada en la siguiente correspondencia:

⁠

I\to 00,\;X\to 01,\;Y\to 11,\;Z\to 10.

⁠

Este mapa mapea $\Pi ^{n}$ a vectores en $(\mathbb {Z} _{2})^{2n}$ ⁠ , de tal manera que la multiplicación de operadores de Pauli es equivalente a la suma de vectores binarios salvo una fase global. Además, ⁠ $(\mathbb {Z} _{2})^{2n}$ Se puede equipar con un álgebra simpléctica , de modo que el producto simpléctico de dos vectores binarios indique si los operadores de Pauli correspondientes conmutan.

La representación binaria y el álgebra simpléctica anteriores resultan especialmente útiles para explicitar la relación entre la corrección de errores lineal clásica y los códigos estabilizadores cuánticos. En el lenguaje de los espacios vectoriales simplécticos , un subespacio simpléctico corresponde a una suma directa de álgebras de Pauli (es decir, cúbits codificados), mientras que un subespacio isotrópico corresponde a un conjunto de estabilizadores.

Notas

↑ Esta condición implica que todos los miembros de ${\mathcal {S}}$ son hermíticos, ya que un elemento antihermítico de $Π n$ cuadra a $-I^{\otimes n}$ .
↑ Aunque los errores de Pauli son todos autoadjuntos , aquí utilizamos notaciones que se alinean con la teoría de corrección de errores cuánticos más general.
↑ En la mayoría de los casos, ${\mathcal {E}}$ se define de tal manera que incluye $I^{\otimes n}$ , para ser elegida como la corrección cuando no se ha producido ningún error. De esta forma, el caso sin errores no necesita ser tratado de manera especial.

Referencias

↑ "¿Qué es el "código de superficie" en el contexto de la corrección de errores cuánticos?" . Quantum Computing Stack Exchange . Consultado el 12 de enero de 2024 .
↑ Matsumoto, Ryutaroh (julio de 2002). "Mejora de la cota de Ashikhmin-Litsyn-Tsfasman para códigos cuánticos". IEEE Transactions on Information Theory . 48 (7): 2122– 2124. arXiv : quant-ph/0107129 . doi : 10.1109/TIT.2002.1013156 .

D. Gottesman, "Códigos estabilizadores y corrección de errores cuánticos", quant-ph/9705052, tesis doctoral de Caltech. https://arxiv.org/abs/quant-ph/9705052
Shor, Peter W. (1995-10-01). "Esquema para reducir la decoherencia en la memoria de computadoras cuánticas". Physical Review A . 52 (4). American Physical Society (APS): R2493– R2496. Bibcode : 1995PhRvA..52.2493S . doi : 10.1103/physreva.52.r2493 . ISSN 1050-2947 . PMID 9912632 .
Calderbank, AR; Shor, Peter W. (1996-08-01). "Existen buenos códigos de corrección de errores cuánticos". Physical Review A . 54 (2). American Physical Society (APS): 1098– 1105. arXiv : quant-ph/9512032 . Bibcode : 1996PhRvA..54.1098C . doi : 10.1103/physreva.54.1098 . ISSN 1050-2947 . PMID 9913578 . S2CID 11524969 .
Steane, AM (1996-07-29). "Códigos de corrección de errores en la teoría cuántica". Physical Review Letters . 77 (5). American Physical Society (APS): 793– 797. Bibcode : 1996PhRvL..77..793S . doi : 10.1103/physrevlett.77.793 . ISSN 0031-9007 . PMID 10062908 .
A. Calderbank, E. Rains, P. Shor y N. Sloane, «Corrección de errores cuánticos mediante códigos sobre GF(4)», IEEE Trans. Inf. Theory, vol. 44, págs. 1369–1387, 1998. Disponible en https://arxiv.org/abs/quant-ph/9608006

[3] Esta condición implica que todos los miembros de ${\mathcal {S}}$ son hermíticos, ya que un elemento antihermítico de $Π n$ cuadra a $-I^{\otimes n}$ .

[4] Aunque los errores de Pauli son todos autoadjuntos , aquí utilizamos notaciones que se alinean con la teoría de corrección de errores cuánticos más general.

[5] En la mayoría de los casos, ${\mathcal {E}}$ se define de tal manera que incluye $I^{\otimes n}$ , para ser elegida como la corrección cuando no se ha producido ningún error. De esta forma, el caso sin errores no necesita ser tratado de manera especial.

[1] "¿Qué es el "código de superficie" en el contexto de la corrección de errores cuánticos?" . Quantum Computing Stack Exchange . Consultado el 12 de enero de 2024 .

[2] Matsumoto, Ryutaroh (julio de 2002). "Mejora de la cota de Ashikhmin-Litsyn-Tsfasman para códigos cuánticos". IEEE Transactions on Information Theory . 48 (7): 2122– 2124. arXiv : quant-ph/0107129 . doi : 10.1109/TIT.2002.1013156 .

[ 1 ]

[ 2 ]

[ nota 1 ]

[ nota 2 ]

[ nota 3 ]