Corrección de errores cuánticos

La corrección de errores cuánticos (QEC) se utiliza en la computación cuántica para proteger la información cuántica de errores debidos a la decoherencia y otros ruidos cuánticos. Se teoriza que la corrección de errores cuánticos es esencial para lograr una computación cuántica tolerante a fallas que pueda reducir los efectos del ruido en la información cuántica almacenada, puertas cuánticas defectuosas, preparación cuántica defectuosa y mediciones defectuosas. Esto permitiría algoritmos de mayor profundidad de circuito.

La corrección de errores clásica emplea redundancia. El enfoque más simple, aunque ineficiente, es el código de repetición. La idea es almacenar la información varias veces y, si luego se descubre que estas copias no están de acuerdo, obtener una votación mayoritaria; p.ej. supongamos que copiamos un bit en un estado tres veces. Supongamos además que un error ruidoso corrompe el estado de los tres bits de modo que uno de los bits copiados es igual a cero pero los otros dos son iguales a uno. Suponiendo que los errores ruidosos son independientes y ocurren con una probabilidad p suficientemente baja, lo más probable es que el error sea un error de un solo bit y el mensaje transmitido sea de tres unos. Es posible que se produzca un error de doble bit y el mensaje transmitido sea igual a tres ceros, pero este resultado es menos probable que el resultado anterior. En este ejemplo, la información lógica era un solo bit en un estado, la información física son los tres bits copiados y determinar qué estado lógico está codificado en el estado físico se llama decodificación. Al igual que la corrección de errores clásica, los códigos QEC no siempre decodifican correctamente los qubits lógicos, pero su uso reduce el efecto del ruido.

No es posible copiar información cuántica debido al teorema de no clonación. Este teorema parece presentar un obstáculo para formular una teoría de corrección de errores cuánticos. Pero es posible difundir la información (lógica) de un qubit en un estado altamente entrelazado de varios qubits (físicos). Peter Shor descubrió por primera vez este método de formular un código de corrección de errores cuánticos almacenando la información de un qubit en un estado altamente entrelazado de nueve qubits.

Los códigos de corrección de errores clásicos utilizan una medición de síndrome para diagnosticar qué error corrompe un estado codificado. Luego se puede revertir un error aplicando una operación correctiva basada en el síndrome. La corrección de errores cuánticos también emplea mediciones de síndromes. Realiza una medición de múltiples qubits que no altera la información cuántica en el estado codificado pero recupera información sobre el error. Dependiendo del código QEC utilizado, la medición del síndrome puede determinar la ocurrencia, ubicación y tipo de errores. En la mayoría de los códigos QEC, el tipo de error es un cambio de bit, un cambio de signo (de fase), o ambos (correspondientes a las matrices de Pauli X, Z e Y). La medición del síndrome tiene el efecto proyectivo de una medición cuántica, por lo que incluso si el error debido al ruido fuera arbitrario, se puede expresar como una combinación de operaciones básicas denominada base de error (que viene dada por las matrices de Pauli y las matrices de Pauli). identidad). Para corregir el error, se utiliza el operador Pauli correspondiente al tipo de error en el qubit dañado para revertir el efecto del error.

La medición del síndrome proporciona información sobre el error ocurrido, pero no sobre la información almacenada en el qubit lógico, ya que de lo contrario la medición destruiría cualquier superposición cuántica de este qubit lógico con otros qubits en la computadora cuántica, lo que impediría que se utilizara para transmitir información cuántica.

Código de inversión de bits

El código de repetición funciona en un canal clásico, porque los bits clásicos son fáciles de medir y repetir. Este enfoque no funciona para un canal cuántico en el que, debido al teorema de no clonación, no es posible repetir un solo qubit tres veces. Para superar esto, se debe utilizar un método diferente, como el código de inversión de bits de tres qubits propuesto por primera vez por Asher Peres en 1985. Esta técnica utiliza mediciones de entrelazamiento y síndrome y es comparable en rendimiento con la código de repetición.

Considere la situación en la que queremos transmitir el estado de un solo qubit ${displaystyle vert psi rangle }$ a través de un canal ruidoso ${displaystyle {fnMithcal}}$. Asumamos, además, que este canal gira el estado del qubit, con probabilidad ${displaystyle p}$, o lo deja sin cambios. La acción de ${displaystyle {fnMithcal}}$ sobre una aportación general ${displaystyle rho }$ puede ser escrito como ${displaystyle {mathcal {}(rho)=(1-p)rho +p Xrho X}$.

Vamos. ${displaystyle tenciónpsi rangle =alpha _{0} sobrevivir0rangle +alpha _{1}$ ser el estado cuántico para ser transmitido. Sin protocolo de corrección de errores en su lugar, el estado transmitido será transmitido correctamente con probabilidad ${displaystyle 1-p}$. Sin embargo, podemos mejorar este número codificación el estado en un mayor número de codos, de tal manera que los errores en los codos lógicos correspondientes pueden ser detectados y corregidos. En el caso del simple código de repetición de tres codos, la codificación consiste en los mapas ${displaystyle vert 0rangle rightarrow vert 0_{rm {L}rangle equiv vert 000rangle }$ y ${displaystyle vert 1rangle rightarrow vert 1_{rm {L}rangle equiv vert 111rangle }$. El estado de entrada ${displaystyle vert psi rangle }$ está codificado en el estado ${displaystyle vert psi 'rangle =alpha _{0}vert 000rangle +alpha _{1}vert 111rangle }$. Este mapeo se puede realizar por ejemplo utilizando dos puertas CNOT, entangling el sistema con dos codos auxiliares inicializados en el estado ${displaystyle vert 0rangle }$. El estado codificado ${displaystyle vert psi 'rangle }$ es lo que pasa ahora por el canal ruidoso.

El canal actúa en ${displaystyle vert psi 'rangle }$ girando algún subconjunto (posiblemente vacío) de sus codos. No qubit se voltea con probabilidad ${displaystyle (1-p)^{3}$, un solo qubit se voltea con probabilidad ${displaystyle 3p(1-p)}{2}$, dos qubits son volteados con probabilidad ${displaystyle 3p^{2}(1-p)}$, y los tres cuartos son volteados con probabilidad ${displaystyle p^{3}$. Tenga en cuenta que una suposición adicional sobre el canal se hace aquí: suponemos que ${displaystyle {fnMithcal}}$ actúa por igual e independiente en cada uno de los tres codos en los que el estado está ahora codificado. El problema es ahora cómo detectar y corregir tales errores, mientras que no corromper el estado transmitido.

Supongamos por simplicidad que ${displaystyle p}$ es lo suficientemente pequeño que la probabilidad de que más de un solo qubit sea volteado es insignificante. Uno puede entonces detectar si un qubit fue volteado, sin también preguntar por los valores que se transmiten, preguntando si uno de los qubits difiere de los otros. Esto equivale a realizar una medición con cuatro resultados diferentes, correspondientes a las siguientes cuatro mediciones proyectivas:

$${displaystyle {begin{aligned}P_{0} langle 000 duración+ Anterior111rangle langle 111 imper,\P_{1} {0}= perpetua100rangle langle 100 sobrevivir+011rangle langle 011 sobrevivir,P_{2} {010rangle langle 010langlelangle1101langlelangle$$

${displaystyle P_{0}$

${displaystyle P_{i}$

${displaystyle i}$

$${fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif}=P_{0}rho P_{0}+sum ¿Qué? Uh, P_{i}X_{i}$$

Tenga en cuenta que, mientras que este procedimiento corrige perfectamente la salida cuando cero o una vuelta son introducidos por el canal, si más de un cuarto se voltea entonces la salida no es correctamente corregido. Por ejemplo, si se voltean los codos primero y segundo, la medición del síndrome da el resultado ${displaystyle P_{3}$, y el tercer codo es volteado, en lugar de los dos primeros. Para evaluar el desempeño de este esquema de corrección de errores para una entrada general podemos estudiar la fidelidad ${displaystyle F(psi ')}$ entre la entrada ${displaystyle vert psi 'rangle }$ y la producción ${displaystyle rho _{operatorname {out}equiv {mathcal {E}_{operatorname {corr} }({mathcal {E} {vert psi 'rangle langle psi 'vert)}}}} {fnMitcal {fnMitcal {fnMicrosoft}}}}$. Siendo el estado de salida ${displaystyle rho _{operatorname {out}$ correcto cuando no más de un qubit es volteado, que sucede con probabilidad ${displaystyle (1-p)^{3}+3p(1-p)^{2}$Podemos escribirlo como ${displaystyle [(1-p)^{3}+3p(1-p)^{2}]vert psi 'rangle langle psi 'vert +(...)}$, donde los puntos denotan componentes de ${displaystyle rho _{operatorname {out}$ resultante de errores no correctamente corregidos por el protocolo. De ello se desprende que

$${displaystyle F(psi ')=langle psi 'vert rho _{operatorname {out} }vert psi 'rangle geq (1-p)^{3}+3p(1-p)^{2}=1-3p^{2}+2p^{3}$$

${displaystyle {1-p}$

${displaystyle p<1/2}$

${displaystyle p}$

Firmar código invertido

Los bits alimentados son el único tipo de error en la computadora clásica, pero hay otra posibilidad de un error con ordenadores cuánticos, el cambio de signo. A través de la transmisión en un canal el signo relativo entre ${displaystyle Silencioso$ y ${displaystyle ← }$ puede ser invertido. Por ejemplo, un cuarto en el estado ${displaystyle TEN-rangle =(Antes0rangle - sobrevivir1rangle)/{sqrt {2}}$ puede tener su cambio de signo ${displaystyle tención+rangle =(Primer0rangle + sobreviviente1rangle)/{sqrt {2}}.}$

El estado original del qubit

$${displaystyle tenciónpsi rangle =alpha _{0} sobrevivir0rangle +alpha _{1}$$

$${displaystyle TENED\\cH00\cH00\cH00\cH00\\cH00\cH009\cH009cH003n\cH004\cH00\\cH00\\cH004cH004\cH004\\\\cH004\\\\cH004\\\\\cH004\\\\cH004\\cH004\cH00\\\\\\\\\\cH004\\\\cH004cH004cH004cH004\\\\cH004\\\\\\\\cH004\\cH004 ¿Qué? +alfa ¿Qué?$$

En la base de Hadamard, las volteretas de bits se convierten en volteretas de señal y se convierten en volteretas de bits. Vamos. ${displaystyle E_{text{phase}}$ ser un canal cuántico que puede causar en la mayoría de una fase flip. Entonces el código de la vuelta bit de arriba puede recuperar ${displaystyle Нpsi rangle }$ transformándose en la base de Hadamard antes y después de la transmisión por ${displaystyle E_{text{phase}}$.

Código corto

El canal de error puede inducir un cambio de bit, un cambio de signo (es decir, un cambio de fase) o ambos. Es posible corregir ambos tipos de errores en cualquier qubit utilizando un código QEC, lo que se puede hacer utilizando el código Shor publicado en 1995. Esto equivale a decir que el código Shor corrige errores arbitrarios de un solo qubit.

Vamos. ${displaystyle E}$ ser un canal cuántico que puede corromper arbitrariamente un solo qubit. Los 1o, 4o y 7o qubits son para el código de cambio de signo, mientras que los tres grupos de qubits (1,2,3), (4,5,6), y (7,8,9) están diseñados para el código bit flip. Con el código Shor, un estado de qubit ${displaystyle tenciónpsi rangle =alpha _{0} sobrevivir0rangle +alpha _{1}$ se transformará en el producto de 9 codos ${displaystyle TENED\\cH00\cH00\cH00\cH00\\cH00\cH009\cH009cH003n\cH004\cH00\\cH00\\cH004cH004\cH004\\\\cH004\\\\cH004\\\\\cH004\\\\cH004\\cH004\cH00\\\\\\\\\\cH004\\\\cH004cH004cH004cH004\\\\cH004\\\\\\\\cH004\\cH004 _{0}viv0_{S}rangle +alpha _{1}Sobrevivir$, donde

$${displaystyle {S}}rangle ={frac {1}{2{sqrt {2}}}(Sobrevivir000rangle + sobrevivir111rangle)otimes (sobrevivir000rangle + sobrevivir111rangle)otimes (últimas milrangle + perpetua111rangle)}$$

$${displaystyle ← {S}}rangle ={frac {1}{2{sqrt {2}}}(Sobrevivir000rangle - sobrevivir111rangle)otimes (sobrevivir000rangle - perpetua111rangle)otimes (último000rangle - perpetua111rangle)}$$

Si se produce un error de inversión de bit en un qubit, el análisis del síndrome se realizará en cada bloque de qubits (1,2,3), (4,5,6) y (7,8,9) para detectar y corregir como máximo un error de inversión de un bit en cada bloque.

Si el grupo de inversión de tres bits (1,2,3), (4,5,6) y (7,8,9) se consideran tres entradas, entonces el circuito de código Shor se puede reducir como un signo. código invertido. Esto significa que el código Shor también puede reparar un error de cambio de signo para un solo qubit.

El código Shor también puede corregir cualquier error arbitrario (ambos bit flip y sign flip) a un solo qubit. Si un error es modelado por un U de transformación unitaria, que actuará en un qubit ${displaystyle Нpsi rangle }$Entonces ${displaystyle U}$ se puede describir en el formulario

$${displaystyle U=c_{0}I+c_{1}X+c_{2}Y+c_{3}Z}$$

${displaystyle c_{0}$

${displaystyle C_{1}$

${displaystyle c_{2}$

${displaystyle C_{3}$

$${begin {begin{aligned}X limit={begin{pmatrix}0 tarde11 punto {pmatrix}}\\\\\begin{pmatrix}0 tarde 0ii}i}m0pmatrix}}}mcH0trix}$$

Si U es igual a I, entonces no se produce ningún error. Si ${displaystyle U=X}$, se produce un error de voltereta. Si ${displaystyle U=Z!$, se produce un error de cambio de signo. Si ${displaystyle U=iY.$ entonces se produce un error de voltear un poco y un error de voltereta de signos. En otras palabras, el código Shor puede corregir cualquier combinación de errores de bit o fase en un solo qubit.

Códigos bosónicos

Se han hecho varias propuestas para almacenar información cuántica con corrección de errores en modos bosónicos. A diferencia de un sistema de dos niveles, un oscilador armónico cuántico tiene infinitos niveles de energía en un solo sistema físico. Los códigos para estos sistemas incluyen cat, Gottesman-Kitaev-Preskill (GKP) y códigos binomiales. Una idea que ofrecen estos códigos es aprovechar la redundancia dentro de un solo sistema, en lugar de duplicar muchos qubits de dos niveles.

Código binomial

Escrito en la base de Fock, la codificación binomial más simple es

$${displaystyle {L}rangle ={frac {Sobrevivir0rangle + sobrevivir4rangle }{sqrt {2}}}},quad ← {L}rangle = resist2rangle}$$

${displaystyle {hat {a}}}$

${displaystyle ← }$

${displaystyle Новальных}$

Código de gato

Schrödinger cat states, superposiciones de estados coherentes, también se pueden utilizar como estados lógicos para los códigos de corrección de errores. Código de gato, realizado por Ofek et al. en 2016, definió dos conjuntos de estados lógicos: ${displaystyle ################################################################################################################################################################################################################################################################ {}}$ y ${displaystyle ################################################################################################################################################################################################################################################################ {}}$, donde cada uno de los estados es una superposición de estado coherente como sigue

$${displaystyle {begin{aligned}Prince {fnK}{+}rangle < > > > > > > > > > 'equiv ialpha rangle + preserve-ialpha ################################################################################################################################################################################################################################################################ 'equiv alpha rangle - arrest-alpha rangle\\Primero1_{L}^{-}rangle 'equiv ialpha rangle - WordPress-ialpha rangle.end{aligned}}$$

Esos dos conjuntos de estados difieren de la paridad del número de fotones, como estados denotados con ${displaystyle ^{+}$ sólo ocupan estados y estados con número de fotones ${displaystyle ^{-}$ indican que tienen paridad extraña. Similar al código binomio, si el mecanismo de error dominante del sistema es la aplicación estocástica del operador de reducción bosónico ${displaystyle {hat {a}}}$, el error toma los estados lógicos desde el subespacial de paridad hasta el extraño, y viceversa. Por lo tanto, se pueden detectar errores de pérdida de un solo fotón midiendo el operador de paridad del número de fotones ${displaystyle exp(ipi {hat {ha} {dgger}{hat {a}}}} {f} {f}} {fn}} {f}}}}} {fn}}}}} {fn}}}}}} {f}}}}}}$ usando un qubit auxiliar dispersivamente unido.

Sin embargo, los cubitos de gato no están protegidos contra la pérdida de dos fotones ${displaystyle {hat {}} {2}}}$, ruido desafiante ${fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif} {f}} {fnMicrosoft Sans Serif} {fnMicrosoft}} {fnMicrosoft}}} {fnMicrosoft}} {fnKfnMicrosoft}}f}}}}}}}f}}}}}}}}}}}}}}\\\\\\fnMinKf}}}}}f}}}}}}}}}}}}}}}}}}}}}}}}\\\\\\\\\\\\\\\\\\\\\\\\\fnMinMinMinMinMinMinMinMinMinMinMinMinMinMinMinMinMinMi } {hat {a}}$, error foton-gain ${displaystyle {hat {fn} {fnK}} {fnMicrosoft}} {fn}} {fn}} {fnMicrosoft}}}}$, etc.

Códigos generales

En general, a código cuántico para un canal cuántico ${displaystyle {fnMithcal}}$ es un subespacio ${displaystyle {Mathcal {}subseteq {Mathcal}} {}}}$, donde ${displaystyle {Mathcal {H}}$ es el espacio del estado Hilbert, tal que existe otro canal cuántico ${displaystyle {fnMithcal}}$ con

$${fnMicrosoft Sans Serif} {fnMitcal {})=rho quad forall rho =P_{mathcal {C}rho P_{mthcal {cH} {fnMitcal {}}}}} {f} {f}$$

${displaystyle P_{mátcal {C}}$

${displaystyle {fnMithcal}}$

${displaystyle {fnMithcal}}$

Un código no degenerado es aquel en el que diferentes elementos del conjunto de errores corregibles producen resultados linealmente independientes cuando se aplican a elementos del código. Si distintos del conjunto de errores corregibles producen resultados ortogonales, el código se considera puro.

Modelos

Con el tiempo, los investigadores han ideado varios códigos:

• El código de Peter Shor de 9 codos, a.k.a. el código Shor, codifica 1 qubit lógico en 9 codos físicos y puede corregir errores arbitrarios en un solo codo.
• Andrew Steane encontró un código que hace lo mismo con 7 en lugar de 9 codos, vea el código Steane.
• Raymond Laflamme y colaboradores encontraron una clase de códigos de 5 codos que hacen lo mismo, que también tienen la propiedad de ser tolerantes a la culpa. Un código de 5 codos es el código más pequeño posible que protege un único qubit lógico contra errores de un solo codo.
• Una generalización de la técnica utilizada por Steane, para desarrollar el código de 7 codos del código clásico [7, 4] Hamming, llevó a la construcción de una importante clase de códigos llamados los códigos CSS, nombrados para sus inventores: Robert Calderbank, Peter Shor y Andrew Steane. Según el límite de Hamming cuántico, la codificación de un único qubit lógico y la provisión de corrección arbitraria de error en un solo qubit requiere un mínimo de 5 qubits físicos.
• Una clase más general de códigos (componiendo al primero) son los códigos estabilizadores descubiertos por Daniel Gottesman, y por Robert Calderbank, Eric Rains, Peter Shor, y N. J. A. Sloane; estos también se llaman códigos aditivos.
• Dos códigos dimensionales Bacon–Shor son una familia de códigos parametizados por enteros m y n. Hay nm Codos en una rejilla cuadrada.
• Una idea más reciente es los códigos cuánticos topológicos de Alexei Kitaev y la idea más general de una computadora cuántica topológica.
• Todd Brun, Igor Devetak y Min-Hsiu Hsieh también construyeron el formalismo estabilizador asistido por el enredo como una extensión del formalismo estabilizador estándar que incorpora el enredamiento cuántico compartido entre un remitente y un receptor.

Que estos códigos permiten cálculos cuánticos de longitud arbitraria es el contenido del teorema del umbral cuántico, encontrado por Michael Ben-Or y Dorit Aharonov, que afirma que se pueden corregir todos los errores si se concatenan códigos cuánticos como el Códigos CSS, es decir volver a codificar cada qubit lógico con el mismo código nuevamente, y así sucesivamente, en muchos niveles logarítmicamente, siempre que la tasa de error de las puertas cuánticas individuales esté por debajo de un cierto umbral; de lo contrario, los intentos de medir el síndrome y corregir los errores introducirían más errores nuevos de los que corrigen.

A finales de 2004, las estimaciones para este umbral indican que podría alcanzar entre el 1% y el 3%, siempre que haya suficientes qubits disponibles.

Realización experimental

Ha habido varias realizaciones experimentales de códigos basados en CSS. La primera demostración fue con qubits de resonancia magnética nuclear. Posteriormente se han realizado demostraciones con óptica lineal, iones atrapados y qubits superconductores (transmon).

En 2016, por primera vez se prolongó la vida útil de un bit cuántico mediante el empleo de un código QEC. La demostración de corrección de errores se realizó en estados del gato de Schrodinger codificados en un resonador superconductor y empleó un controlador cuántico capaz de realizar operaciones de retroalimentación en tiempo real, incluida la lectura de la información cuántica, su análisis y la corrección de los errores detectados.. El trabajo demostró cómo el sistema con corrección de errores cuánticos alcanza el punto de equilibrio en el que la vida útil de un qubit lógico excede la vida útil de los componentes subyacentes del sistema (los qubits físicos).

También se han implementado otros códigos de corrección de errores, como uno destinado a corregir la pérdida de fotones, la fuente de error dominante en los esquemas de qubit fotónicos.

En 2021, se creó por primera vez una puerta entrelazada entre dos qubits lógicos codificados en códigos topológicos de corrección de errores cuánticos utilizando 10 iones en una computadora cuántica de iones atrapados. En 2021 también se realizó la primera demostración experimental de código Bacon-Shor tolerante a fallas en un único qubit lógico de un sistema de iones atrapados, es decir, una demostración en la que la adición de corrección de errores puede suprimir más errores de los que introduce la sobrecarga requerida. para implementar la corrección de errores, así como el código Steane tolerante a fallas.

En 2022, investigadores de la Universidad de Innsbruck demostraron un conjunto de puertas universales tolerantes a fallas en dos qubits lógicos en una computadora cuántica de iones atrapados. Han realizado una puerta NO controlada lógica de dos qubits entre dos instancias del código de color de siete qubits y han preparado un estado mágico lógico con tolerancia a fallos.

En febrero de 2023, investigadores de Google afirmaron haber disminuido los errores cuánticos al aumentar el número de qubits en experimentos. Utilizaron un código de superficie tolerante a fallas que midió una tasa de error del 3,028 % y del 2,914 % para una matriz de qubits de distancia y una distancia -Matriz de 5 qubits respectivamente.

Corrección de errores cuánticos sin codificación ni comprobaciones de paridad

También en 2022, una investigación de la Universidad de Ingeniería y Tecnología de Lahore demostró la cancelación de errores mediante la inserción de puertas de rotación del eje Z de un solo qubit en ubicaciones estratégicamente elegidas de los circuitos cuánticos superconductores. Se ha demostrado que el esquema corrige eficazmente errores que, de otro modo, se acumularían rápidamente bajo la interferencia constructiva de ruido coherente. Se trata de un esquema de calibración a nivel de circuito que rastrea desviaciones (por ejemplo, caídas pronunciadas o muescas) en la curva de decoherencia para detectar y localizar el error coherente, pero no requiere codificación ni mediciones de paridad. Sin embargo, se necesita más investigación para establecer la eficacia de este método para el ruido incoherente.