Pourquoi les protocoles de correction d'erreurs ne fonctionnent-ils que lorsque les taux d'erreur sont déjà significativement bas au départ?

15

La correction d'erreur quantique est un aspect fondamental du calcul quantique, sans lequel les calculs quantiques à grande échelle sont pratiquement impossibles.

Un aspect de l'informatique quantique à tolérance de pannes qui est souvent mentionné est que chaque protocole de correction d'erreur a associé un seuil de taux d'erreur . Fondamentalement, pour qu'un calcul donné puisse être protégé contre les erreurs via un protocole donné, le taux d'erreur des portes doit être inférieur à un certain seuil.

En d'autres termes, si les taux d'erreur des portes simples ne sont pas suffisamment bas, il n'est pas possible d'appliquer des protocoles de correction d'erreurs pour rendre le calcul plus fiable.

Pourquoi est-ce? Pourquoi n'est-il pas possible de réduire des taux d'erreur qui ne sont pas déjà très bas au départ?

error-correction fault-tolerance

— glS
source

Eh bien, à un moment donné, il n'y a plus que du bruit. Est-il si étrange qu'il y ait un point où la correction d'erreur est plus susceptible de corriger les bonnes pièces en bruit?

— Lézard discret

1

@Discretelizard pas tellement qu'il y en a peut-être un, mais les seuils sont généralement très bas (ou élevés en termes de fidélité). Pourquoi est-ce si?

— glS

4

Nous voulons comparer un état de sortie avec un état idéal, donc normalement, la fidélité, est utilisée car c'est un bon moyen de dire dans quelle mesure la mesure possible les résultats de comparent aux résultats de mesure possibles de , où est l'état de sortie idéal et est l'état atteint (potentiellement mélangé) après un processus de bruit. Lorsque nous comparons des états, il s'agit de $F\left(\left|\psi\right>, \rho\right)$ $\rho$ $\left|\psi\right>$ $\left|\psi\right>$ $\rho$

F (| ψ ⟩, ρ) = \sqrt{⟨ ψ | ρ | ψ ⟩} .

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

Décrivant à la fois les processus de correction de bruit et d' erreur en utilisant les opérateurs Kraus, où est le canal de bruit avec les opérateurs Kraus et est le canal de correction d'erreurs avec les opérateurs Kraus , l'état après le bruit est et l'état après le bruit et la correction d'erreur est $\mathcal N$ $N_i$ $\mathcal E$ $E_j$

ρ^{'} = N (| ψ ⟩ ⟨ ψ |) = \sum_{i} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†}

$\rho' = \mathcal N\left(\left|\psi\rangle\langle\psi\right|\right) = \sum_iN_i\left|\psi\rangle\langle\psi\right|N_i^\dagger$

ρ = E \circ N (| ψ ⟩ ⟨ ψ |) = \sum_{i, j} E_{j} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†} E_{j}^{†} .

$\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 fidélité de ceci est donné par

\begin{aligned} F (| ψ ⟩, ρ) & = \sqrt{⟨ ψ | ρ | ψ ⟩} \\ = \sqrt{\sum_{i, j} ⟨ ψ | E_{j} N_{i} | ψ ⟩ ⟨ ψ | N_{i}^{†} E_{j}^{†} | ψ ⟩} \\ = \sqrt{\sum_{i, j} ⟨ ψ | E_{j} N_{i} | ψ ⟩ ⟨ ψ | E_{j} N_{i} {| ψ ⟩}^{*}} \\ = \sqrt{\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2}} . \end{aligned}

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

Pour que le protocole de correction d'erreur soit utile, nous voulons que la fidélité après correction d'erreur soit supérieure à la fidélité après bruit, mais avant la correction d'erreur, de sorte que l'état corrigé d'erreur soit moins distinct de l'état non corrigé. Autrement dit, nous voulons Cela donne

F (| ψ ⟩, ρ) > F (| ψ ⟩, ρ^{'}) .

$F\left(\left|\psi\right>, \rho\right) > F\left(\left|\psi\right>, \rho'\right).$

Comme fidélité est positif, cela peut être réécrite comme

\sqrt{\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2}} > \sqrt{\sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{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} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} > \sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{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.$

Fractionnement dans la partie corrigible, , pour lequel et la partie non corrigible, , pour lequel . Indiquant la probabilité que l'erreur soit corrigible comme $\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|$ $\mathcal N_{nc}$ $\mathcal E\circ\mathcal N_{nc}\left(\left|\psi\rangle\langle\psi\right|\right) = \sigma$ $\mathbb P_c$ et non corrigeable (c'est-à-dire que trop d'erreurs se sont produites pour reconstruire l'état idéal) car donne où l' égalité sera assumée en supposant $\mathbb P_{nc}$

\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} = P_{c} + P_{n c} ⟨ ψ | σ | ψ ⟩ \geq P_{c},

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

⟨ ψ | σ | ψ ⟩ = 0

$\left<\psi\vert\sigma\vert\psi\right> = 0$ . C'est-à-dire qu'une fausse «correction» se projettera sur un résultat orthogonal au bon.

Pour qubits, avec une probabilité d'erreur (égale) sur chaque qubit comme ( remarque : ce n'est pas le même que le paramètre de bruit, qui devrait être utilisé pour calculer la probabilité d'une erreur), la probabilité d'avoir un erreur corrigible (en supposant que les qubits ont été utilisés pour coder qubits, permettant des erreurs sur jusqu'à qubits, déterminées par la limite singleton ) est $n$ $p$ $n$ $k$ $t$ $n-k\geq 4t$ .

\begin{aligned} P_{c} & = \sum_{j}^{t} (\binom{n}{j}) p^{j} {(1 - p)}^{n - j} \\ = {(1 - p)}^{n} + n p {(1 - p)}^{n - 1} + \frac{1}{2} n (n - 1) p^{2} {(1 - p)}^{n - 2} + O (p^{3}) \\ = 1 - (\binom{n}{t + 1}) p^{t + 1} + O (p^{t + 2}) \end{aligned}

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

Les canaux de bruit peuvent également s'écrire pour une base , qui peut être utilisée pour définir une matrice de processus . Cela donne $N_i = \sum_j\alpha_{i, j}P_j$ $P_j$ $\chi_{j, k} = \sum_i\alpha_{i, j}\alpha^*_{i, k}$ où est la probabilité d'aucuneerreurproduise.

\sum_{i} | ⟨ ψ | N_{i} | ψ ⟩ |^{2} = \sum_{j, k} χ_{j, k} ⟨ ψ | P_{j} | ψ ⟩ ⟨ ψ | P_{k} | ψ ⟩ \geq χ_{0,, 0},

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

χ_{0, 0} = {(1 - p)}^{n}

$\chi_{0, 0} = \left(1-p\right)^n$

Cela signifie que la correction d'erreur a réussi à atténuer (au moins une partie) du bruit lorsque

1 - (\binom{n}{t + 1}) p^{t + 1} ⪆ {(1 - p)}^{n} .

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

ρ ≪ 1

$\rho \ll 1$

p

$p$

p^{t + 1}

$p^{t+1}$

p

$p$

$p$ $p^{t+1}$ $p$ $n=5$ $t=1$ $p\approx 0.29$

Modifier à partir des commentaires:

$\mathbb P_c + \mathbb P_{nc} = 1$

\sum_{i, j} | ⟨ ψ | E_{j} N_{i} | ψ ⟩ |^{2} = ⟨ ψ | σ | ψ ⟩ + P_{c} (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).$

1 - (1 - ⟨ ψ | σ | ψ ⟩) (\binom{n}{t + 1}) p^{t + 1} ⪆ {(1 - p)}^{n},

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

$1$

Cela montre, à une approximation approximative, que la correction d'erreur, ou simplement la réduction des taux d'erreur, n'est pas suffisante pour un calcul tolérant aux pannes , à moins que les erreurs soient extrêmement faibles, selon la profondeur du circuit.

— Mithrandir24601
source

Je pense que vous essayez d'expliquer jusqu'à quel taux d'erreur physique la probabilité d'erreurs non corrigibles est faible? Notez que les seuils de tolérance aux pannes sont plus petits (ordres de grandeur pour de nombreux codes)

— M. Stern

@ M.Stern Il s'agit donc d'une estimation (très approximative) du moment où une correction d'erreur `` diminue l'erreur '' (c'est-à-dire augmente la fidélité d'une certaine quantité après l'application du bruit), donc ce n'est certainement pas un seuil tolérant aux pannes, non. La correction des erreurs peut avoir augmenté la fidélité après le bruit d'une certaine quantité, mais elle ne l'a pas réinitialisé ou quoi que ce soit, de sorte que la fidélité va juste diminuer (et les erreurs) se propagent même si la correction d'erreur est constamment appliquée, montrant la correction d'erreur en soi ne suffit pas pour la tolérance aux pannes

— Mithrandir24601

Hm, glS devra juger si cela répond à la question. En tout cas c'est intéressant et bien écrit. Vous supposez donc que l'état est orthogonal si les erreurs n'étaient pas corrigeables, non? (C'est certainement raisonnable dans de nombreux scénarios.) L'autre extrême serait lorsqu'il y a 50/50 de chance d'erreur logique en cas d'erreurs non corrigibles.

— M. Stern

@ M.Stern Merci! Oui, soit que les états sont orthogonaux, soit en prenant la borne inférieure. Comme comparer une borne inférieure à une autre n'est pas une bonne idée, je suis parti de l'hypothèse qu'ils sont orthogonaux. S'il y a des modifications que vous jugez utiles pour ajouter à la fin de cela, éloignez-vous! Hmm ... Je pense que prendre une chance d'erreur logique de 50/50 conduirait au même résultat, seulement avec des préfacteurs différents à la fin

— Mithrandir24601

4

Il y a déjà une bonne réponse mathématique, je vais donc essayer d'en fournir une facile à comprendre.

La correction d'erreur quantique (QEC) est un (groupe de) algorithme (s) assez complexe (s), qui nécessite beaucoup d'actions (portes) sur et entre les qubits. Dans QEC, vous connectez à peu près deux qubits à un troisième helper-qubit (ancilla) et transférez les informations si les deux autres sont égales (à certains égards spécifiques) dans ce troisième qubit. Ensuite, vous lisez ces informations sur l'ancialla. S'il vous dit qu'ils ne sont pas égaux, vous agissez sur ces informations (appliquez une correction). Alors, comment cela peut-il mal tourner si nos qubits et nos portes ne sont pas parfaits?

QEC peut réduire les informations stockées dans vos qubits. Chacune de ces portes peut altérer les informations qui y sont stockées si elles ne sont pas exécutées parfaitement. Donc, si l'exécution de la QEC détruit plus d'informations qu'elle n'en récupère en moyenne, c'est inutile.

Vous pensez avoir trouvé une erreur, mais vous ne l'avez pas trouvée. Si la comparaison (exécution de portes) ou la lecture des informations (ancilla) est imparfaite, vous pouvez obtenir des informations erronées et ainsi appliquer des "corrections erronées" (lire: introduire des erreurs). De plus, si les informations contenues dans les ancillas se désintègrent (ou sont modifiées par le bruit) avant de pouvoir les lire, vous obtiendrez également une lecture erronée.

Le but de chaque QEC est évidemment d'introduire moins d'erreurs qu'il n'en corrige, vous devez donc minimiser les effets susmentionnés. Si vous faites tout le calcul, vous trouvez des exigences assez strictes sur vos qubits, portes et lectures (selon l'algorithme QEC exact que vous avez choisi).

— 3244611user
source

4

Version classique

0 \mapsto 00000 1 \mapsto 11111

$0\mapsto 00000\qquad 1\mapsto 11111$

01010.

$01010.$

p

$p$

$p>\frac12$

$01010$

Version quantique

$X$ $Z$

$|\psi\rangle$ $N$ $\lceil N/2\rceil$ $\lfloor N/2\rfloor$ $N$ $|\psi\rangle$

— DaftWullie
source

2

Pour moi, il semble y avoir deux parties de cette question (une de plus liée au titre, une de plus liée à la question elle-même):

1) À quelle quantité de bruit les codes de correction d'erreur sont-ils efficaces?
2) Avec quelle quantité d'imperfection dans les portes pouvons-nous implémenter des calculs quantiques tolérants aux pannes?

Permettez-moi d'abord de souligner la différence: les codes de correction d'erreur quantique peuvent être utilisés dans de nombreux scénarios différents, par exemple pour corriger les pertes de transmission. Ici, la quantité de bruit dépend principalement de la longueur de la fibre optique et non de l'imperfection des portes. Cependant, si nous voulons implémenter un calcul quantique tolérant aux pannes, les portes sont la principale source de bruit.

Le 1)

$1/2$ $f(p)=p$

$p$ $1/2$ $p$ $p$ $\mathcal{O}(p)$ $\mathcal{O}(p^2)$

Le 2)

Nous voulons effectuer des calculs quantiques arbitrairement longs avec un ordinateur quantique. Cependant, les portes quantiques ne sont pas parfaites. Afin de faire face aux erreurs introduites par les portes, nous utilisons des codes de correction d'erreurs quantiques. Cela signifie qu'un qubit logique est codé en plusieurs qubits physiques. Cette redondance permet de corriger une certaine quantité d'erreurs sur les qubits physiques, de sorte que les informations stockées dans le qubit logique restent intactes. Des codes plus grands permettent à des calculs plus longs d'être toujours précis . Cependant, des codes plus grands impliquent plus de portes (par exemple plus de mesures de syndrome) et ces portes introduisent du bruit. Vous voyez qu'il y a un compromis ici, et quel code est optimal n'est pas évident.
Si le bruit introduit par chaque porte est inférieur à un certain seuil (le seuil de tolérance aux pannes ou de précision), il est possible d'augmenter la taille du code pour permettre des calculs arbitrairement longs. Ce seuil dépend du code avec lequel nous avons commencé (il est généralement concaténé de manière itérative avec lui-même). Il existe plusieurs façons d'estimer cette valeur. Souvent, cela se fait par simulation numérique: introduisez des erreurs aléatoires et vérifiez si le calcul fonctionne toujours. Cette méthode donne généralement des valeurs de seuil trop élevées. Il existe également des preuves analytiques dans la littérature, par exemple celle d'Aliferis et Cross .

— M. Stern
source

Le deuxième paragraphe touche les bons points, mais il reste très qualitatif. Vous dites que vous avez besoin des portes introduites par le protocole de correction d'erreur pour réduire le taux d'erreur plus qu'il ne l'augmente. Mais comment passer de cette idée intuitive à une véritable estimation quantitative au-delà du seuil? Cela implique-t-il également un seuil inférieur universel qu'aucun protocole de correction d'erreur ne peut battre?

— glS

@glS Je soupçonne qu'il existe un tel "seuil inférieur universel", c'est-à-dire une valeur d'erreur au-dessus de laquelle il n'existe aucun protocole de correction tolérant aux pannes. Cependant, la valeur doit dépendre à la fois de votre jeu de portes et de votre modèle d'erreur. Les gens ont tendance à être plus intéressés par des résultats positifs ici (montrant l'existence d'un bon protocole tolérant aux fautes). Il peut être intéressant de trouver des limites supérieures afin de voir "combien de place il nous reste" pour améliorer nos schémas de tolérance aux pannes. Je suppose qu'il ne reste plus beaucoup de place.

— Jalex Stark

@glS Vous avez raison, certains calculs quantitatifs réels amélioreraient cette réponse. Je pense que ces calculs sont généralement effectués numériquement? Mais je veux aussi savoir à ce sujet

— M. Stern

@JalexStark Qu'est-ce qui vous fait penser qu'il ne reste plus beaucoup de place? Par exemple, le code de surface ne semble pas être optimisé par rapport à ce seuil. Il n'utilise que les interactions entre voisins les plus proches sur un réseau et vous pourriez faire beaucoup plus en général.

— M. Stern

@ M.Stern Je n'ai aucune preuve basée sur un théorème et je ne suis pas un expert dans le domaine. Je devinais simplement en fonction de la quantité de travail effectué et de la taille des meilleurs seuils.

— Jalex Stark

2

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

Cependant, la raison principale est que vous ne pouvez pas utiliser un circuit de détection d'erreurs simple: chaque CNOT (ou chaque autre porte de qubit non triviale 2 ou plus) transmet les erreurs d'un qubit à un autre qubit, ce qui serait désastreux pour le plus trivial. cas d'un seul code correcteur d'erreur qubit et encore très mauvais pour des codes plus sophistiqués. Par conséquent, une mise en œuvre (utile) tolérante aux pannes nécessite encore plus d'efforts qu'on pourrait le croire naïvement.

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

Les erreurs incohérentes sont plus bénignes. Pourtant, si l'on doit donner une seule valeur comme seuil d'erreur, on ne peut pas choisir de ne supposer que des erreurs bénignes!

— pyramides
source

N^{2} ϵ

$N^2 \epsilon$

N ϵ

$N\epsilon$

@glS J'ai considérablement élargi la réponse pour répondre à toutes vos questions. Ai-je réussi à faire ça?

— pyramides