¿Por qué los protocolos de corrección de errores solo funcionan cuando las tasas de error ya son significativamente bajas para empezar?

La corrección de errores cuánticos es un aspecto fundamental del cálculo cuántico, sin el cual los cálculos cuánticos a gran escala son prácticamente inviables.

Un aspecto de la computación cuántica tolerante a fallas que a menudo se menciona es que cada protocolo de corrección de errores ha asociado un umbral de tasa de error . Básicamente, para que un cálculo dado sea protegido contra errores a través de un protocolo dado, la tasa de error de las puertas debe estar por debajo de cierto umbral.

En otras palabras, si las tasas de error de las compuertas individuales no son lo suficientemente bajas, entonces no es posible aplicar protocolos de corrección de errores para hacer que el cálculo sea más confiable.

¿Por qué es esto? ¿Por qué no es posible reducir las tasas de error que ya no son muy bajas para empezar?

Queremos comparar un estado de salida con algún estado ideal, por lo que normalmente, la fidelidad, $F\left(\left|\psi\right>, \rho\right)$ se utiliza como esta es una buena manera de decir qué tan bien los posibles resultados de medición de $\rho$ se comparan con los posibles resultados de medición de $\left|\psi\right>$ , donde es el estado de la salida ideal y es el estado alcanzado (potencialmente mixta) después de un proceso de ruido. Como estamos comparando estados, esto es$\left|\psi\right>$$\rho$

$$F\left(\left|\psi\right>, \rho\right) = \sqrt{\left<\psi\right|\rho\left|\psi\right>}.$$

Describiendo los procesos de corrección de ruido y error utilizando operadores Kraus, donde es el canal de ruido con los operadores Kraus y es el canal de corrección de error con los operadores Kraus , el estado después del ruido es y el estado después de la corrección de ruido y error isN i E E j ρ ' = N ( | Psi ⟩ ⟨ Psi | ) = Σ i N i | Psi ⟩ ⟨ Psi | N † i ρ = E ∘ N ( | Psi ⟩ ⟨ Psi | ) = Σ i , j E j N i | Psi ⟩ ⟨ Psi | $\mathcal N$$N_i$$\mathcal E$$E_j$

$$\rho' = \mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_iN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger$$ $$\rho = \mathcal E\circ\mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_{i, j}E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger.$$

La fidelidad de esto viene dada por

$$\begin{align}F\left(\left|\psi\right>, \rho\right) &= \sqrt{\left<\psi\right|\rho\left|\psi\right>} \\ &= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger E_j^\dagger\left|\psi\right>} \\&= \sqrt{\sum_{i, j}\left<\psi\right|E_jN_i\left|\psi\rangle\langle\psi\right|E_jN_i\left|\psi\right>^*} \\ &= \sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2}.\end{align}$$

Para que el protocolo de corrección de errores sea de alguna utilidad, queremos que la fidelidad después de la corrección de errores sea mayor que la fidelidad después del ruido, pero antes de la corrección de errores, de modo que el estado corregido por error sea menos distinguible del estado no corregido. Es decir, queremosEsto proporcionaComo la fidelidad es positiva, esto puede reescribirse como

$$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$$ ∑i,j| ⟨Psi| EjNi| Psi⟩| 2>∑i| ⟨Psi| Ni| Psi⟩| 2 $$\sqrt{\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2} > \sqrt{\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2}.$$ $$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 > \sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2.$$

División de en la parte corregible, , para lo cualy la parte no corregible, , para la cual . Denotando la probabilidad de que el error sea corregible como y no corregible (es decir, se han producido demasiados errores para reconstruir el estado ideal) como daN c E ∘ N c ( | Psi ⟩ ⟨ Psi | ) = | Psi ⟩ ⟨ Psi | $\mathcal N$$\mathcal N_c$$\mathcal E\circ\mathcal N_c\left(\left|\psi\rangle\langle\psi\right|\right) = \left|\psi\rangle\langle\psi\right|$ E ∘ N n c ( | Psi ⟩ ⟨ Psi | ) =σ P c P n c Σ i , j | ⟨ Psi | E j N i | Psi ⟩ $\mathcal N_{nc}$$\mathcal E\circ\mathcal N_{nc}\left(\left|\psi\rangle\langle\psi\right|\right) = \sigma$$\mathbb P_c$$\mathbb P_{nc}$⟨ Psi | σ | Psi ⟩ =

$$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \mathbb P_c + \mathbb P_{nc}\left<\psi\vert\sigma\vert\psi\right> \geq \mathbb P_c,$$ donde se asumirá la igualdad asumiendo . Esa es una falsa 'corrección' que se proyectará en un resultado ortogonal al correcto.$\left<\psi\vert\sigma\vert\psi\right> = 0$

Para qubits, con una probabilidad (igual) de error en cada qubit como ( nota : esto no es lo mismo que el parámetro de ruido, que debería usarse para calcular la probabilidad de un error), la probabilidad de tener un error corregible (suponiendo que los qubits se han utilizado para codificar qubits, lo que permite errores en hasta qubits, determinado por el enlace Singleton ) esp n k t n - k ≥ 4 t P$n$$p$$n$$k$$t$$n-k\geq 4t$

$$\begin{align} \mathbb P_c &=\sum_j^t {n\choose j}p^j\left(1-p\right)^{n-j}\\ &= \left(1-p\right)^n + np\left(1-p\right)^{n-1} + \frac 12n\left(n-1\right)p^2\left(1-p\right)^{n-2} + \mathcal O\left(p^3\right) \\ &= 1 - {n\choose{t+1}}p^{t+1} + \mathcal O\left(p^{t + 2}\right)\end{align}$$ .

Los canales de ruido también se pueden escribir como para una base , que se puede usar para definir una matriz de proceso . Esto da donde es la probabilidad de que no ocurra ningún error.P j χ j , k = ∑ i α i , j α $N_i = \sum_j\alpha_{i, j}P_j$$P_j$ ∑i| ⟨Psi| Ni| Psi⟩| 2=Σj,kχj,k⟨Psi| Pj| Psi⟩⟨$\chi_{j, k} = \sum_i\alpha_{i, j}\alpha^*_{i, k}$χ 0 , 0 = ( 1 - p )

$$\sum_i\lvert\left<\psi\right|N_i\left|\psi\right\rangle\rvert^2 = \sum_{j, k}\chi_{j, k}\left<\psi\right|P_j\left|\psi\right\rangle\left<\psi\right|P_k\left|\psi\right\rangle\geq\chi_{0, ,0},$$ $\chi_{0, 0} = \left(1-p\right)^n$

Esto da que la corrección de errores ha sido exitosa en la mitigación (al menos algo de) el ruido cuandoSi bien esto solo es válido para y, como se ha utilizado un límite más débil, puede dar resultados inexactos de cuándo la corrección de errores ha sido exitosa, esto muestra que la corrección de errores es buena para pequeñas probabilidades de error ya que crece más rápido que cuando es pequeño.ρ≪1ppt+1

$$1 - {n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n.$$ $\rho \ll 1$$p$$p^{t+1}$$p$

Sin embargo, a medida que hace un poco más grande, crece más rápido que y, dependiendo de los prefactores, que depende del tamaño del código y del número de qubits para corregir, hará que la corrección de errores se 'corrija' incorrectamente los errores que han ocurrido y comienza a fallar como un código de corrección de errores. En el caso de , dando , esto sucede en , aunque esto es solo una estimación.p t + 1 p n = 5 t = 1 p ≈ $p$$p^{t+1}$$p$$n=5$$t=1$$p\approx 0.29$

Editar de comentarios:

Como , esto da$\mathbb P_c + \mathbb P_{nc} = 1$

$$\sum_{i, j}\lvert\left<\psi\right|E_jN_i\left|\psi\right\rangle\rvert^2 = \left<\psi\vert\sigma\vert\psi\right> + \mathbb P_c\left(1-\left<\psi\vert\sigma\vert\psi\right>\right).$$

Al conectar esto como se indica arriba, se obtiene que es el mismo comportamiento que antes, solo que con una constante diferente.

$$1-\left(1-\left<\psi\vert\sigma\vert\psi\right>\right){n\choose{t+1}}p^{t+1} \gtrapprox\left(1-p\right)^n,$$

Esto también muestra que, aunque la corrección de errores puede aumentar la fidelidad, no puede aumentar la fidelidad a , especialmente porque habrá errores (por ejemplo, errores de compuerta por no poder implementar perfectamente ninguna compuerta en la realidad) que surgen de la implementación del error corrección. Como cualquier circuito razonablemente profundo requiere, por definición, un número razonable de puertas, la fidelidad después de cada puerta será menor que la fidelidad de la puerta anterior (en promedio) y el protocolo de corrección de errores será menos efectivo. Luego habrá un número límite de puertas en cuyo punto el protocolo de corrección de errores disminuirá la fidelidad y los errores se agravarán continuamente.$1$

Esto muestra, en una aproximación aproximada, que la corrección de errores, o simplemente la reducción de las tasas de error, no es suficiente para el cálculo tolerante a fallas , a menos que los errores sean extremadamente bajos, dependiendo de la profundidad del circuito.

Ya hay una buena respuesta matemática, así que intentaré proporcionar una fácil de entender.

La corrección de errores cuánticos (QEC) es un (grupo de) algoritmo (s) bastante complejo (s), que requiere muchas acciones (compuertas) en y entre qubits. En QEC, prácticamente conecta dos qubits a un tercer qubit auxiliar (ancilla) y transfiere la información si los otros dos son iguales (en algún aspecto específico) a ese tercer qubit. Luego lees esa información de la ancialla. Si le dice que no son iguales, usted actúa sobre esa información (aplique una corrección). Entonces, ¿cómo puede salir mal si nuestros qubits y puertas no son perfectos?

QEC puede hacer que la información almacenada en sus qubits decaiga. Cada una de estas puertas puede descomponer la información almacenada en ellas, si no se ejecutan perfectamente. Entonces, si solo ejecutar el QEC destruye más información de la que recupera en promedio, es inútil.

Cree que encontró un error, pero no lo hizo. Si la comparación (ejecución de compuertas) o la lectura de la información (ancilla) es imperfecta, puede obtener información incorrecta y, por lo tanto, aplicar "correcciones incorrectas" (léase: introducir errores). Además, si la información en las ancillas decae (o cambia por ruido) antes de que pueda leerla, también obtendrá una lectura incorrecta.

El objetivo de cada QEC es, obviamente, introducir menos errores de los que corrige, por lo que debe minimizar los efectos antes mencionados. Si hace todos los cálculos, encontrará requisitos bastante estrictos en sus qubits, puertas y lecturas (dependiendo del algoritmo QEC exacto que elija).

Versión clásica

Piense en una estrategia simple de corrección de errores clásica. Tienes un solo bit que quieres codificar, He elegido codificarlo en 5 bits, pero cualquier número impar funcionaría (cuanto más mejor). Ahora, supongamos que se han producido algunos errores de cambio de bits, así que lo que tenemos es ¿Era originalmente el 0 o 1 codificado? Si suponemos que la probabilidad de error por bit, , es menor que la mitad, entonces esperamos que menos de la mitad de los bits tengan errores. Entonces, miramos el número de 0s y el número de 1s. Cualquiera que haya más es el que asumimos que es con el que comenzamos. Esto se llama voto mayoritario. Hay alguna probabilidad de que estemos equivocados, pero cuantos más bits codificamos,

$$0\mapsto 00000\qquad 1\mapsto 11111$$ $$01010.$$ $p$

Por otro lado, si sabemos que , aún podemos hacer la corrección. ¡Simplemente implementaría un voto minoritario! El punto, sin embargo, es que tienes que hacer completamente la operación opuesta. Aquí hay un umbral agudo que muestra, al menos, que necesitas saber en qué régimen estás trabajando.$p>\frac12$

Para la tolerancia a fallas, las cosas se vuelven más desordenadas: la cadena que obtuviste podría no ser el estado en realidad . Puede ser algo diferente, aún con algunos errores que debe corregir, pero las mediciones que ha realizado al leer los bits también son ligeramente defectuosas. Crudamente, puede imaginar que esto convierte la transición brusca en una región ambigua donde realmente no sabe qué hacer. Aún así, si las probabilidades de error son lo suficientemente bajas o altas, puede corregirlas, solo necesita saber cuál es el caso.$01010$

Versión cuántica

En general, las cosas empeoran en el régimen cuántico porque tienes que lidiar con dos tipos de errores: errores de cambio de bit ( ) y errores de cambio de fase ( ), y eso tiende a agrandar la región ambigua. No entraré más en detalles aquí. Sin embargo, hay un argumento lindo en el régimen cuántico que puede ser esclarecedor.$X$$Z$

Imagine que tiene el estado de un solo qubit lógico almacenado en un código de corrección de error cuántico en qubits físicos. No importa cuál sea ese código, este es un argumento completamente general. Ahora imagine que hay tanto ruido que destruye el estado cuántico en qubits ("tanto ruido" en realidad significa que los errores ocurren con una probabilidad de 50:50, no cerca del 100%, lo cual, como ya lo hemos hecho dicho, se puede corregir). Es imposible corregir ese error. ¿Cómo sé eso? Imagina que tengo una versión completamente silenciosa y mantengo qubits y te doy los qubits restantes. Cada uno de nosotros introduce suficientes qubits en blanco para que tengamos$|\psi\rangle$$N$$\lceil N/2\rceil$$\lfloor N/2\rfloor$$N$qubits en total, y ejecutamos corrección de errores en ellos. Si fuera posible realizar esa corrección de error, el resultado sería que ambos tendríamos el estado original . ¡Hubiéramos clonado el qubit lógico! Pero la clonación es imposible, por lo que la corrección de errores debe haber sido imposible.$|\psi\rangle$

Para mí, parece haber dos partes de esta pregunta (una más relacionada con el título, una más relacionada con la pregunta en sí):

1) ¿A qué cantidad de ruido son efectivos los códigos de corrección de errores?
2) ¿Con qué cantidad de imperfección en las puertas podemos implementar cálculos cuánticos tolerantes a fallas?

Permítanme enfatizar la diferencia: los códigos de corrección de errores cuánticos se pueden usar en muchos escenarios diferentes, por ejemplo, para corregir las pérdidas en las transmisiones. Aquí, la cantidad de ruido depende principalmente de la longitud de la fibra óptica y no de la imperfección de las puertas. Sin embargo, si queremos implementar el cálculo cuántico tolerante a fallas, las puertas son la principal fuente de ruido.

En 1)

La corrección de errores funciona para tasas de error grandes (más pequeñas que ). Tomemos, por ejemplo, el código simple de repetición de 3 qubits. La tasa de error lógico es solo la probabilidad de que el voto mayoritario sea incorrecto (la línea naranja es para comparación): $1/2$$f(p)=p$

Entonces, siempre que la tasa de error físico sea ​​inferior a , la tasa de error lógico es menor que . Sin embargo, tenga en cuenta que eso es particularmente efectivo para pequeñas , porque el código cambia la velocidad de a un comportamiento . $p$$1/2$$p$$p$$\mathcal{O}(p)$$\mathcal{O}(p^2)$

En 2)

Queremos realizar cálculos cuánticos arbitrariamente largos con una computadora cuántica. Sin embargo, las puertas cuánticas no son perfectas. Para hacer frente a los errores introducidos por las puertas, utilizamos códigos de corrección de errores cuánticos. Esto significa que un qubit lógico está codificado en muchos qubits físicos. Esta redundancia permite corregir una cierta cantidad de errores en los qubits físicos, de modo que la información almacenada en el qubit lógico permanezca intacta. Los códigos más grandes permiten que los cálculos más largos sigan siendo precisos . Sin embargo, los códigos más grandes implican más compuertas (por ejemplo, más mediciones de síndrome) y estas compuertas introducen ruido. Verá que hay una compensación aquí, y qué código es óptimo no es obvio.
Si el ruido introducido por cada puerta está por debajo de algún umbral (la tolerancia a fallas o el umbral de precisión), entonces es posible aumentar el tamaño del código para permitir cálculos arbitrariamente largos. Este umbral depende del código con el que comenzamos (generalmente se concatena iterativamente consigo mismo). Hay varias formas de estimar este valor. A menudo se realiza mediante simulación numérica: introduzca errores aleatorios y verifique si el cálculo aún funcionó. Este método generalmente proporciona valores de umbral que son demasiado altos. También hay algunas pruebas analíticas en la literatura, por ejemplo esta de Aliferis y Cross .

$XIIII$$YIIII$$ZIIII$$IXIII$$IYIII$$IZIII$$IIXII$$IIYII$$IIZII$$IIIXI$$IIIYI$$IIIZI$$IIIIX$$IIIIY$$IIIIZ$$IIIII$$X$$Y$$Z$$I$

La parte principal de la razón es, sin embargo, que no puede utilizar circuitos de detección de errores directos: cada CNOT (o cualquier otra puerta no trivial de 2 o más qubit) reenvía errores en un qubit a otro qubit, lo que sería desastroso para los más triviales. caso de un solo error de qubit que corrige el código y sigue siendo muy malo para códigos más sofisticados Por lo tanto, una implementación tolerante a fallas (útil) de las necesidades requiere aún más esfuerzo del que uno podría pensar ingenuamente.

$\epsilon$$N \epsilon$$N^2 \epsilon$

$G$$G$$G + \sqrt{\epsilon} X$$\epsilon$$\sqrt{\epsilon}$$X$$N$$G^N + N \sqrt{\epsilon} G^N X$$N$$\sqrt{\epsilon}$$N^2 \epsilon$

Los errores incoherentes son más benignos. Sin embargo, si se debe dar un valor único como umbral de error, ¡entonces no se puede elegir asumir solo errores benignos!