Kody stabilizatorowe

Teraz zdefiniujemy kody stabilizatorowe w sposób ogólny. Omówimy również niektóre z ich podstawowych własności oraz sposób ich działania, w tym sposób kodowania stanów oraz wykrywania i korekcji błędów za pomocą tych kodów.

Definicja kodów stabilizatorowych

$n$-kubitowy kod stabilizatorowy jest określony przez listę operacji Pauliego na $n$ kubitach, $P_1,\ldots,P_r.$ Operacje te nazywane są w tym kontekście generatorami stabilizatora i muszą spełniać następujące trzy warunki.

1. Wszystkie generatory stabilizatora komutują ze sobą nawzajem.

   $$P_j P_k = P_k P_j \qquad \text{(dla wszystkich $j,k\in\{1,\ldots,r\}$)}$$

2. Generatory stabilizatora tworzą minimalny zbiór generujący.

   $$P_k \notin \langle P_1,\ldots,P_{k-1},P_{k+1},\ldots,P_r\rangle \qquad \text{(dla wszystkich $k\in\{1,\ldots,r\}$)}$$

3. Co najmniej jeden wektor stanu kwantowego jest ustalony przez wszystkie generatory stabilizatora.

   $$-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle$$

   (Nie jest oczywiste, że istnienie wektora stanu kwantowego $\vert\psi\rangle$ ustalonego przez wszystkie generatory stabilizatora, czyli takiego, że $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ jest równoważne warunkowi $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ ale w istocie tak jest, a zobaczymy dlaczego nieco później w tej lekcji.)

Zakładając, że mamy taką listę $P_1,\ldots,P_r,$ przestrzeń kodowa zdefiniowana przez te generatory stabilizatora to podprzestrzeń $\mathcal{C}$ zawierająca każdy $n$-kubitowy wektor stanu kwantowego ustalony przez wszystkie $r$ tych generatorów stabilizatora.

$$\mathcal{C} = \bigl\{ \vert\psi\rangle \,:\, P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle \bigr\}$$

Wektory stanu kwantowego w tej podprzestrzeni to dokładnie te, które można uznać za poprawne kodowania stanów kwantowych. Omówimy sam proces kodowania później.

Wreszcie, stabilizator kodu zdefiniowanego przez generatory stabilizatora $P_1, \ldots, P_r$ to zbiór generowany przez te operacje:

$$\langle P_1,\ldots,P_r\rangle.$$

Naturalnym sposobem myślenia o kodzie stabilizatorowym jest postrzeganie generatorów stabilizatora jako obserwabli i łączne interpretowanie wyników pomiarów związanych z tymi obserwablami jako syndromu błędu. Poprawne kodowania to $n$-kubitowe wektory stanu kwantowego, dla których wyniki pomiarów, jako wartości własne, są wszystkie z pewnością równe $+1.$ Dowolny inny syndrome, w którym wystąpi co najmniej jeden wynik pomiaru $-1$, sygnalizuje wykrycie błędu.

Wkrótce przyjrzymy się kilku przykładom, ale najpierw kilka uwag na temat trzech warunków dotyczących generatorów stabilizatora jest na miejscu.

Pierwszy warunek jest naturalny w świetle interpretacji generatorów stabilizatora jako obserwabli, ponieważ oznacza, że nie ma znaczenia, w jakiej kolejności wykonywane są pomiary: obserwable komutują, więc pomiary komutują. Naturalnie nakłada to pewne ograniczenia algebraiczne na kody stabilizatorowe, które są istotne dla sposobu ich działania.

Drugi warunek wymaga, aby generatory stabilizatora tworzyły minimalny zbiór generujący, co oznacza, że usunięcie któregokolwiek z nich skutkowałoby mniejszym stabilizatorem. Ściśle rzecz biorąc, warunek ten nie jest tak naprawdę istotny dla sposobu działania kodów stabilizatorowych w sensie operacyjnym — i, jak zobaczymy w następnej lekcji, czasami sensowne jest rozważanie zbiorów generatorów stabilizatora dla kodów, które w rzeczywistości nie spełniają tego warunku. Jednak na potrzeby analizy kodów stabilizatorowych i wyjaśniania ich własności będziemy zakładać, że warunek ten jest spełniony. Krótko mówiąc, warunek ten gwarantuje, że każda obserwabla, którą mierzymy, aby uzyskać syndrome błędu, dodaje informację o możliwych błędach, a nie jest redundantna i nie daje wyników, które można by wywnioskować z pomiarów pozostałych generatorów stabilizatora.

Trzeci warunek wymaga, aby co najmniej jeden niezerowy wektor był ustalony przez wszystkie generatory stabilizatora, co jest równoważne temu, że $-\mathbb{I}^{\otimes n}$ nie jest zawarte w stabilizatorze. Potrzeba tego warunku wynika z faktu, że faktycznie możliwe jest wybranie minimalnego zbioru generującego operacji Pauliego na $n$ kubitach, które wszystkie komutują ze sobą nawzajem, a mimo to żaden niezerowy wektor nie jest ustalony przez każdą z tych operacji. Nie interesują nas "kody", dla których nie istnieją poprawne kodowania, więc wykluczamy tę możliwość, wymagając tego warunku jako części definicji.

Przykłady

Oto kilka przykładów stabilizer codes dla małych wartości $n.$ Więcej przykładów, w tym takich, dla których $n$ może być znacznie większe, zobaczymy w następnej lekcji.

3-kubitowy kod powtórzeniowy

3-kubitowy kod powtórzeniowy jest przykładem stabilizer code, w którym naszymi generatorami stabilizer są $Z \otimes Z \otimes \mathbb{I}$ oraz $\mathbb{I} \otimes Z \otimes Z.$

Możemy łatwo sprawdzić, że te dwa generatory stabilizer spełniają wymagane warunki. Po pierwsze, oba generatory stabilizer $Z \otimes Z \otimes \mathbb{I}$ oraz $\mathbb{I} \otimes Z \otimes Z$ komutują ze sobą.

$$(Z \otimes Z \otimes \mathbb{I})(\mathbb{I} \otimes Z \otimes Z) = Z \otimes \mathbb{I} \otimes Z = (\mathbb{I} \otimes Z \otimes Z)(Z \otimes Z \otimes \mathbb{I})$$

Po drugie, mamy minimalny zbiór generujący (w tym przypadku raczej trywialnie).

$$\begin{aligned} Z \otimes Z \otimes \mathbb{I} \notin \langle\mathbb{I} \otimes Z \otimes Z\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, \mathbb{I} \otimes Z \otimes Z\}\\[1mm] \mathbb{I} \otimes Z \otimes Z \notin \langle Z \otimes Z \otimes \mathbb{I}\rangle & = \{\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z \otimes Z \otimes \mathbb{I}\} \end{aligned}$$

A po trzecie, wiemy już, że $\vert 000\rangle$ oraz $\vert 111\rangle,$ jak również dowolna kombinacja liniowa tych wektorów, są niezmiennicze względem zarówno $Z \otimes Z \otimes \mathbb{I}$, jak i $\mathbb{I} \otimes Z \otimes Z.$ Alternatywnie możemy to stwierdzić, korzystając z równoważnego warunku z definicji.

$$-\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\notin \langle Z \otimes Z \otimes \mathbb{I}, \mathbb{I} \otimes Z \otimes Z\rangle = \{ \mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}, Z\otimes Z\otimes\mathbb{I}, Z\otimes\mathbb{I}\otimes Z, \mathbb{I}\otimes Z\otimes Z \}$$

Warunki te mogą być znacznie trudniejsze do sprawdzenia w przypadku bardziej skomplikowanych stabilizer codes.

Zmodyfikowany 3-kubitowy kod powtórzeniowy

W poprzedniej lekcji zobaczyliśmy, że możliwe jest zmodyfikowanie 3-kubitowego kodu powtórzeniowego tak, aby chronił przed błędami phase-flip zamiast błędów bit-flip. Jako stabilizer code, ten nowy kod jest łatwy do opisania: jego generatorami stabilizer są $X \otimes X \otimes \mathbb{I}$ oraz $\mathbb{I} \otimes X \otimes X.$

Tym razem generatory stabilizer reprezentują obserwable $X\otimes X$ zamiast obserwabli $Z\otimes Z$, więc są to zasadniczo testy parzystości w bazie plus/minus zamiast w bazie standardowej. Trzy wymagane warunki dotyczące generatorów stabilizer są łatwe do zweryfikowania, podobnie jak w przypadku zwykłego 3-kubitowego kodu powtórzeniowego.

9-kubitowy Shor code

Oto 9-kubitowy Shor code, który również jest stabilizer code, wyrażony przez generatory stabilizer.

$$\begin{gathered} Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes Z\\[1mm] X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\\[1mm] \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}\otimes X \otimes X \otimes X \otimes X \otimes X \otimes X \end{gathered}$$

W tym przypadku mamy w zasadzie trzy kopie 3-kubitowego kodu powtórzeniowego, po jednej dla każdego z trzech bloków trzech kubitów, a także dwa ostatnie generatory stabilizer, które przyjmują postać przypominającą obwód służący do wykrywania phase flips dla tego kodu.

Alternatywny sposób myślenia o dwóch ostatnich generatorach stabilizer polega na tym, że przyjmują one tę samą postać co w 3-kubitowym kodzie powtórzeniowym dla phase flips, z tym że $X\otimes X\otimes X$ zastępuje $X,$ co jest spójne z faktem, że $X\otimes X\otimes X$ odpowiada operacji $X$ na logical qubits zakodowanych przy użyciu 3-kubitowego kodu powtórzeniowego.

Zanim przejdziemy do innych przykładów, warto zauważyć, że symbole iloczynu tensorowego są często pomijane przy opisywaniu stabilizer codes za pomocą list generatorów stabilizer, ponieważ zwykle ułatwia to ich czytanie i dostrzeganie wzorców. Na przykład te same generatory stabilizer co powyżej dla 9-kubitowego Shor code wyglądają tak, gdy symbole iloczynu tensorowego nie są zapisane jawnie.

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

7-qubit Steane code

Oto kolejny przykład stabilizer code, znany jako 7-qubit Steane code. Ma on kilka niezwykłych cech i będziemy do niego wracać od czasu do czasu w pozostałych lekcjach tego kursu.

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

Na razie po prostu zauważmy, że jest to poprawny stabilizer code. Pierwsze trzy generatory stabilizer wyraźnie komutują ze sobą, ponieważ $Z$ komutuje ze sobą, a identyczność komutuje ze wszystkim; sytuacja jest analogiczna dla ostatnich trzech generatorów stabilizer. Pozostaje sprawdzić, że jeśli weźmiemy jeden z generatorów stabilizer typu $Z$ (czyli jeden z pierwszych trzech) i jeden z generatorów stabilizer typu $X$ (czyli jeden z ostatnich trzech), to te dwa generatory komutują — można przejść przez wszystkie 9 możliwych par i to zweryfikować. We wszystkich tych przypadkach macierze Pauli $X$ i $Z$ zawsze ustawiają się w tej samej pozycji parzystą liczbę razy, więc oba generatory będą komutować, podobnie jak komutują $X\otimes X$ i $Z\otimes Z$. Jest to również minimalny zbiór generujący i definiuje nietrywialną przestrzeń kodową — te fakty pozostawiamy do przemyślenia.

7-qubit Steane code jest podobny do 9-qubit Shor code w tym, że koduje pojedynczy qubit i umożliwia korekcję dowolnego błędu na jednym qubicie, ale wymaga tylko 7 qubitów zamiast 9.

5-qubit code

Siedem to nie jest najmniejsza liczba qubitów potrzebna do zakodowania jednego qubitu i ochrony go przed dowolnym błędem na jednym qubicie — oto stabilizer code, który realizuje to przy użyciu jedynie 5 qubitów.

$$\begin{array}{ccccc} X & Z & Z & X & \mathbb{I} \\[1mm] \mathbb{I} & X & Z & Z & X \\[1mm] X & \mathbb{I} & X & Z & Z \\[1mm] Z & X & \mathbb{I} & X & Z \\[1mm] \end{array}$$

Ten code jest zazwyczaj nazywany the 5-qubit code. Jest to najmniejsza liczba qubitów w kwantowym code korygującym błędy, która pozwala na korekcję dowolnego błędu pojedynczego qubitu.

One-dimensional stabilizer codes

Oto kolejny przykład stabilizer code, choć w rzeczywistości nie koduje on żadnych qubitów: przestrzeń kodowa jest jednowymiarowa. Zgodnie z definicją jest to jednak nadal poprawny stabilizer code.

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

Konkretnie, przestrzeń kodowa jest jednowymiarową przestrzenią rozpiętą przez e-bit $\vert\phi^+\rangle.$

Oto pokrewny przykład stabilizer code, którego przestrzeń kodowa jest jednowymiarową przestrzenią rozpiętą przez stan GHZ $(\vert 000\rangle + \vert 111\rangle)/\sqrt{2}.$

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

Wymiar przestrzeni kodu

Przypuśćmy, że mamy kod stabilizatorowy opisany przez $n$-kubitowe generatory stabilizatora $P_1,\ldots,P_r.$ Być może pierwsze pytanie, które przychodzi na myśl w związku z tym kodem, brzmi: „Ile kubitów on koduje?”

Pytanie to ma prostą odpowiedź. Zakładając, że $n$-kubitowe generatory stabilizatora $P_1, \ldots, P_r$ spełniają trzy wymagania definicji (mianowicie, że wszystkie generatory stabilizatora komutują ze sobą, że jest to minimalny zbiór generujący, oraz że przestrzeń kodu jest niepusta), musi wtedy być tak, że przestrzeń kodu dla tego kodu stabilizatorowego ma wymiar $2^{n-r},$ a więc przy użyciu tego kodu można zakodować $n-r$ kubitów.

Intuicyjnie mówiąc, mamy $n$ kubitów do wykorzystania w tym kodowaniu, a każdy generator stabilizatora efektywnie „zabiera jeden kubit” pod względem liczby kubitów, które możemy zakodować. Zauważ, że nie dotyczy to tego, które lub ile błędów może zostać wykrytych lub skorygowanych — jest to jedynie stwierdzenie dotyczące wymiaru przestrzeni kodu.

Na przykład, zarówno dla 3-bitowego kodu powtórzeniowego, jak i dla zmodyfikowanej wersji tego kodu dla błędów odwrócenia fazy, mamy $n=3$ kubity oraz $r=2$ generatory stabilizatora, a zatem każdy z tych kodów może zakodować 1 kubit. Jako inny przykład rozważmy kod 5-kubitowy: mamy 5 kubitów i 4 generatory stabilizatora, więc ponownie przestrzeń kodu ma wymiar 2, co oznacza, że przy użyciu tego kodu można zakodować jeden kubit. Jako ostatni przykład, kod, którego generatorami stabilizatora są $X\otimes X$ oraz $Z\otimes Z$, ma jednowymiarową przestrzeń kodu, rozpiętą przez stan $\vert\phi^+\rangle,$ co jest zgodne z posiadaniem $n=2$ kubitów oraz $r=2$ generatorów stabilizatora.

Zobaczmy teraz, jak można udowodnić ten fakt. Pierwszym krokiem jest zaobserwowanie, że ponieważ generatory stabilizatora komutują, a każda operacja Pauliego jest swoją własną odwrotnością, każdy element stabilizatora może być wyrażony jako iloczyn

$$P_1^{a_1} \cdots P_r^{a_r},$$

gdzie $a_1,\ldots,a_r\in\{0,1\}.$ Równoważnie, każdy element stabilizatora otrzymuje się przez pomnożenie pewnego podzbioru generatorów stabilizatora. W istocie, każdy element stabilizatora może być wyrażony w ten sposób jednoznacznie, ze względu na warunek, że $\{P_1,\ldots,P_r\}$ jest minimalnym zbiorem generującym.

Następnie zdefiniujmy $\Pi_k$ jako rzut na przestrzeń wektorów własnych operatora $P_k$ odpowiadających wartości własnej $+1$, dla każdego $k\in\{1,\ldots,r\}.$ Rzuty te można uzyskać przez uśrednienie odpowiednich operacji Pauliego z operacją tożsamościową w następujący sposób.

$$\Pi_k = \frac{\mathbb{I}^{\otimes n} + P_k}{2}$$

Przestrzeń kodu $\mathcal{C}$ jest podprzestrzenią wszystkich wektorów ustalanych przez wszystkie $r$ generatorów stabilizatora $P_1,\ldots,P_r,$ lub równoważnie, przez wszystkie $r$ rzutów $\Pi_1,\ldots,\Pi_r.$

Biorąc pod uwagę, że wszystkie generatory stabilizatora komutują ze sobą, rzuty $\Pi_1,\ldots,\Pi_r$ również muszą komutować. Pozwala nam to skorzystać z faktu z algebry liniowej, mianowicie że iloczyn tych rzutów jest rzutem na przecięcie podprzestrzeni odpowiadających poszczególnym rzutom. To znaczy, iloczyn $\Pi_1\cdots\Pi_r$ jest rzutem na przestrzeń kodu $\mathcal{C}.$

Możemy teraz rozwinąć iloczyn $\Pi_1\cdots\Pi_r$ korzystając ze wzorów na te rzuty, otrzymując następujące wyrażenie.

$$\Pi_1\cdots\Pi_r = \biggl(\frac{\mathbb{I}^{\otimes n} + P_1}{2}\biggr)\cdots\biggl(\frac{\mathbb{I}^{\otimes n} + P_r}{2}\biggr) = \frac{1}{2^r}\sum_{a_1,\ldots,a_r \in \{0,1\}} P_1^{a_1}\cdots P_r^{a_r}$$

Innymi słowy, rzut na przestrzeń kodu kodu stabilizatorowego jest równy, jako macierz, średniej po wszystkich elementach stabilizatora tego kodu.

Wreszcie, możemy obliczyć wymiar przestrzeni kodu, korzystając z faktu, że wymiar dowolnej podprzestrzeni jest równy śladowi rzutu na tę podprzestrzeń. Zatem wymiar przestrzeni kodu $\mathcal{C}$ jest dany następującym wzorem.

$$\operatorname{dim}(\mathcal{C}) = \operatorname{Tr}(\Pi_1\cdots\Pi_r) = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r})$$

Możemy ocenić to wyrażenie, korzystając z kilku podstawowych faktów.

• Mamy $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ a zatem

  $$\operatorname{Tr}(P_1^{0}\cdots P_r^{0}) = 2^n.$$

• Dla $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ iloczyn $P_1^{a_1}\cdots P_r^{a_r}$ musi być równy $\pm 1$ razy pewna operacja Pauliego — ale nie możemy otrzymać $\mathbb{I}^{\otimes n}$, ponieważ byłoby to sprzeczne z minimalnością zbioru $\{P_1,\ldots,P_r\},$ i nie możemy otrzymać $-\mathbb{I}^{\otimes n}$, ponieważ trzeci warunek nałożony na generatory stabilizatora tego zabrania. Dlatego, ponieważ ślad każdej nietożsamościowej operacji Pauliego jest równy zero, otrzymujemy

  $$\operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) = 0.$$

Wymiar przestrzeni kodu wynosi zatem $2^{n-r}$ zgodnie z tezą:

$$\begin{aligned} \operatorname{dim}(\mathcal{C}) & = \frac{1}{2^r} \sum_{a_1,\ldots,a_r \in \{0,1\}} \operatorname{Tr}(P_1^{a_1}\cdots P_r^{a_r}) \\ & = \frac{1}{2^r} \operatorname{Tr}(P_1^{0}\cdots P_r^{0}) \\ & = 2^{n-r}. \end{aligned}$$

Na marginesie, możemy teraz zauważyć, że założenie, iż $-\mathbb{I}^{\otimes n}$ nie należy do stabilizatora, implikuje, że przestrzeń kodu musi zawierać co najmniej jeden wektor stanu kwantowego. Wynika to z tego, że — jak właśnie zweryfikowaliśmy — założenie to implikuje, że przestrzeń kodu ma wymiar $2^{n-r},$ który nie może być zerem. Implikacja odwrotna jest trywialna: jeśli $-\mathbb{I}^{\otimes n}$ należy do stabilizatora, to przestrzeń kodu nie może zawierać żadnych wektorów stanu kwantowego, ponieważ żadne niezerowe wektory nie są ustalane przez tę operację.

Operacje Clifforda i kodowania

Następnie krótko omówimy, w jaki sposób kubity mogą być kodowane przy użyciu kodów stabilizatorowych, ale aby to zrobić, musimy najpierw wprowadzić operacje Clifforda.

Operacje Clifforda

Operacje Clifforda to operacje unitarne, na dowolnej liczbie kubitów, które mogą zostać zaimplementowane przez obwody kwantowe z ograniczonym zestawem bramek:

• bramki Hadamarda
• bramki $S$
• bramki CNOT

Zauważ, że bramki $T$ nie są uwzględnione, podobnie jak bramki Toffoliego i bramki Fredkina. Te bramki nie tylko nie znajdują się na liście, ale w rzeczywistości nie da się ich zaimplementować przy użyciu tych wymienionych tutaj; nie są to operacje Clifforda. Operacje Pauliego są natomiast operacjami Clifforda, ponieważ można je zaimplementować za pomocą sekwencji bramek Hadamarda i bramek $S$.

Jest to prosty sposób zdefiniowania operacji Clifforda, ale nie wyjaśnia on, dlaczego są one zdefiniowane w ten sposób ani co jest szczególnego w tym konkretnym zbiorze bramek. Prawdziwy powód, dla którego operacje Clifforda definiuje się w ten sposób, polega na tym, że — z dokładnością do globalnych czynników fazowych — operacje Clifforda to dokładnie te operacje unitarne, które poprzez sprzężenie zawsze przekształcają operacje Pauliego w operacje Pauliego. Precyzyjniej, $n$-kubitowa operacja unitarna $U$ jest równoważna operacji Clifforda z dokładnością do czynnika fazowego wtedy i tylko wtedy, gdy dla każdej $n$-kubitowej operacji Pauliego $P$ zachodzi

$$U P U^{\dagger} = \pm Q$$

dla pewnej $n$-kubitowej operacji Pauliego $Q.$

(Zauważ, że nie jest możliwe, aby $U P U^{\dagger} = \alpha Q$ dla $\alpha\notin\{+1,-1\}$, gdy $U$ jest unitarna, a $P$ i $Q$ są operacjami Pauliego. Wynika to z faktu, że macierz po lewej stronie powyższego równania jest zarówno unitarna, jak i hermitowska, a $+1$ i $-1$ są jedynymi wyborami dla $\alpha$, przy których prawa strona również może być unitarna i hermitowska.)

Łatwo zweryfikować właśnie opisaną własność sprzężenia, gdy $U$ jest bramką Hadamarda, bramką $S$ lub bramką CNOT. W szczególności jest to proste dla bramek Hadamarda,

$$H X H^{\dagger} = Z, \qquad H Y H^{\dagger} = -Y, \qquad H Z H^{\dagger} = X,$$

oraz bramek $S$,

$$S X S^{\dagger} = Y, \qquad S Y S^{\dagger} = -X, \qquad S Z S^{\dagger} = Z.$$

W przypadku bramek CNOT do sprawdzenia jest 15 nietożsamościowych operacji Pauliego na dwóch kubitach. Oczywiście można je sprawdzać pojedynczo — ale relacje między bramkami CNOT oraz bramkami $X$ i $Z$ przedstawione (w postaci obwodów) w poprzedniej lekcji, wraz z regułami mnożenia macierzy Pauliego, oferują skrót do tego samego wniosku.

Gdy wiemy już, że ta własność sprzężenia jest prawdziwa dla bramek Hadamarda, $S$ i CNOT, możemy od razu wywnioskować, że jest ona prawdziwa dla obwodów złożonych z tych bramek — czyli dla wszystkich operacji Clifforda.

Trudniej jest udowodnić, że relacja działa w drugą stronę — że jeśli dana operacja unitarna $U$ spełnia własność sprzężenia dla operacji Pauliego, to musi istnieć możliwość jej zaimplementowania (z dokładnością do fazy globalnej) przy użyciu wyłącznie bramek Hadamarda, $S$ i CNOT. Nie będzie to wyjaśniane w tej lekcji, ale jest to prawdą.

Operacje Clifforda nie są uniwersalne dla obliczeń kwantowych; w przeciwieństwie do uniwersalnych zbiorów bramek kwantowych, przybliżanie dowolnych operacji unitarnych z żądaną dokładnością za pomocą operacji Clifforda nie jest możliwe. Istotnie, dla danej wartości $n$ istnieje tylko skończenie wiele $n$-kubitowych operacji Clifforda (z dokładnością do czynników fazowych). Wykonywanie operacji Clifforda na stanach bazy standardowej, a następnie pomiarów w bazie standardowej, również nie pozwala nam wykonywać obliczeń, które są poza zasięgiem algorytmów klasycznych — ponieważ możemy efektywnie symulować klasycznie obliczenia tej postaci. Fakt ten znany jest jako twierdzenie Gottesmana-Knilla.

Kodery dla kodów stabilizatorowych

Kod stabilizatorowy definiuje przestrzeń kodową o pewnym wymiarze i mamy swobodę wykorzystania tej przestrzeni kodowej w dowolny sposób — nic nie zmusza nas do kodowania kubitów w tej przestrzeni kodowej w określony sposób. Zawsze jednak można, jeśli taki wybór uczynimy, użyć operacji Clifforda jako kodera. Precyzyjniej, dla każdego kodu stabilizatorowego, który pozwala zakodować $m$ kubitów w $n$ kubitach, istnieje $n$-kubitowa operacja Clifforda $U$ taka, że dla dowolnego $m$-kubitowego wektora stanu kwantowego $\vert\phi\rangle,$ mamy

$$\vert\psi\rangle = U \bigl(\vert 0^{n-m} \rangle \otimes \vert \phi\rangle\bigr)$$

jest wektorem stanu kwantowego w przestrzeni kodowej naszego kodu, który możemy interpretować jako zakodowanie $\vert\phi\rangle.$

Jest to korzystne, ponieważ operacje Clifforda są stosunkowo proste w porównaniu z dowolnymi operacjami unitarnymi, a istnieją sposoby optymalizacji ich implementacji przy użyciu technik podobnych do tych, które znajdują się w dowodzie twierdzenia Gottesmana-Knilla. W rezultacie obwody do kodowania stanów przy użyciu kodów stabilizatorowych nigdy nie muszą być zbyt duże. W szczególności zawsze można wykonać kodowanie dla $n$-kubitowego kodu stabilizatorowego przy użyciu operacji Clifforda, która wymaga $O(n^2/\log(n))$ bramek. Wynika to z faktu, że każdą operację Clifforda na $n$ kubitach można zaimplementować za pomocą obwodu o takim rozmiarze.

Na przykład oto koder dla 7-kubitowego kodu Steane'a. Jest to faktycznie operacja Clifforda i, jak się okazuje, ten koder nie potrzebuje nawet bramek $S$.

Wykrywanie błędów

W przypadku $n$-kubitowego kodu stabilizatorowego opisanego przez generatory stabilizatora $P_1,\ldots, P_r,$ wykrywanie błędów działa w następujący sposób.

Aby wykryć błędy, wszystkie generatory stabilizatora są mierzone jako obserwable. Mamy $r$ generatorów stabilizatora, a zatem $r$ wyników pomiarów, z których każdy wynosi $+1$ lub $-1$ (lub jest wartością binarną, jeśli zdecydujemy się skojarzyć $0$ z $+1$ oraz $1$ z $-1$). Interpretujemy te $r$ wyników łącznie, jako wektor lub ciąg, jako syndrom. Syndrom $(+1,\ldots,+1)$ oznacza, że nie wykryto żadnego błędu, natomiast wystąpienie co najmniej jednej $-1$ gdzieś w syndromie oznacza, że wykryto błąd.

Załóżmy w szczególności, że $E$ jest $n$-kubitową operacją Pauli reprezentującą hipotetyczny błąd. (Przy okazji rozważamy tylko operacje Pauli jako błędy, ponieważ dyskretyzacja błędów działa tak samo dla dowolnych kodów stabilizatorowych, jak dla 9-kubitowego kodu Shora.) Istnieją trzy przypadki, które określają, czy $E$ zostanie wykryty jako błąd, czy nie.

Przypadki wykrywania błędów

1. Operacja $E$ jest proporcjonalna do elementu w stabilizatorze.

   $$E = \pm Q \; \text{dla pewnego}\; Q \in \langle P_1,\ldots,P_r\rangle$$

   W tym przypadku $E$ musi komutować z każdym generatorem stabilizatora, więc otrzymujemy syndrom $(+1,\ldots,+1).$ Oznacza to, że $E$ nie jest wykrywany jako błąd.

2. Operacja $E$ nie jest proporcjonalna do elementu w stabilizatorze, ale mimo to komutuje z każdym generatorem stabilizatora.

   $$E\neq \pm Q\; \text{dla} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{ale}\; E P_k = P_k E \;\text{dla każdego}\; k\in\{1,\ldots,r\}$$

   Jest to błąd, który zmienia wektory w przestrzeni kodu w pewien nietrywialny sposób. Ale ponieważ $E$ komutuje z każdym generatorem stabilizatora, syndrom wynosi $(+1,\ldots,+1),$ więc $E$ pozostaje niewykryty przez kod.

3. Operacja $E$ antykomutuje z co najmniej jednym z generatorów stabilizatora.

   $$P_k E = -E P_k \; \text{dla co najmniej jednego} \; k\in\{1,\ldots,r\}$$

   Syndrom różni się od $(+1,\ldots,+1),$ więc błąd $E$ jest wykrywany przez kod.

W pierwszym przypadku błąd $E$ nie stanowi problemu, ponieważ ta operacja nie wpływa na wektory w przestrzeni kodu, poza ewentualnym wprowadzeniem nieistotnej fazy globalnej: $E \ket{\psi} = \pm\ket{\psi}$ dla każdego zakodowanego stanu $\ket{\psi}.$ W istocie nie jest to tak naprawdę błąd — jakiekolwiek nietrywialne działanie $E$ ma miejsce poza przestrzenią kodu — więc dobrze jest, że $E$ nie jest wykrywany jako błąd, ponieważ nic nie trzeba z nim robić.

Drugi przypadek, intuicyjnie rzecz biorąc, jest tym złym przypadkiem. To właśnie antykomutacja błędu z generatorem stabilizatora powoduje pojawienie się $-1$ gdzieś w syndromie, sygnalizując błąd, ale w tym przypadku to się nie dzieje. Mamy więc błąd $E,$ który zmienia wektory w przestrzeni kodu w pewien nietrywialny sposób, ale pozostaje niewykryty przez kod. Na przykład w 3-bitowym kodzie powtórzeniowym operacja $E = X\otimes X\otimes X$ należy do tej kategorii.

To, że taki błąd $E$ musi zmieniać niektóre wektory w przestrzeni kodu w nietrywialny sposób, można uzasadnić w następujący sposób. Z założenia, że $E$ komutuje z $P_1,\ldots,P_r,$ ale nie jest proporcjonalny do elementu stabilizatora, możemy wywnioskować, że otrzymalibyśmy nowy, prawidłowy kod stabilizatorowy, dołączając $E$ jako generator stabilizatora wraz z $P_1,\ldots,P_r.$ Przestrzeń kodu dla tego nowego kodu ma jednak tylko połowę wymiaru oryginalnej przestrzeni kodu, z czego możemy wywnioskować, że działanie $E$ na oryginalnej przestrzeni kodu nie może być proporcjonalne do operacji identyczności.

W ostatnim z trzech przypadków, w którym błąd $E$ antykomutuje z co najmniej jednym generatorem stabilizatora, syndrom zawiera gdzieś co najmniej jedną $-1,$ co wskazuje, że coś jest nie tak. Jak już omówiliśmy, syndrom na ogół nie zidentyfikuje $E$ jednoznacznie, więc nadal konieczne jest wybranie operacji korekcyjnej dla każdego syndromu, która może, ale nie musi, skorygować błąd $E.$ Omówimy ten krok niebawem, w ostatniej części lekcji.

Odległość kodu stabilizatorowego

Jako kwestię terminologii, kiedy mówimy o odległości kodu stabilizatorowego, mamy na myśli minimalną wagę operacji Pauli $E,$ która należy do drugiej kategorii powyżej — czyli zmienia przestrzeń kodu w pewien nietrywialny sposób, ale kod tego nie wykrywa. Gdy mówimy, że dany kod stabilizatorowy jest kodem stabilizatorowym $[[n,m,d]],$ używając podwójnych nawiasów kwadratowych, oznacza to, co następuje:

1. Kodowania mają długość $n$ kubitów,
2. kod pozwala na zakodowanie $m$ kubitów oraz
3. odległość kodu wynosi $d.$

Jako przykład rozważmy 7-kubitowy kod Steane'a. Oto generatory stabilizatora dla tego kodu:

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

Ten kod ma odległość 3, co możemy uzasadnić w następujący sposób.

Najpierw rozważmy dowolną operację Pauli $E$ o wadze co najwyżej 2 i załóżmy, że ta operacja komutuje ze wszystkimi sześcioma generatorami stabilizatora. Wywnioskujemy, że $E$ musi być operacją identyczności, która (jak zawsze) jest elementem stabilizatora. Pokaże to, że odległość kodu jest ściśle większa niż 2. Załóżmy w szczególności, że $E$ ma postać

$$E = P \otimes Q \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}$$

dla $P$ i $Q$ będących możliwie nieidentycznościowymi macierzami Pauli. Jest to tylko jeden przypadek i konieczne jest powtórzenie poniższego rozumowania dla wszystkich pozostałych możliwych położeń nieidentycznościowych macierzy Pauli wśród czynników tensorowych $E,$ ale rozumowanie jest zasadniczo takie samo dla wszystkich możliwych położeń.

Operacja $E$ komutuje ze wszystkimi sześcioma generatorami stabilizatora, więc komutuje w szczególności z tymi dwoma:

$$\begin{gathered} Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes Z\\[1mm] X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \otimes \mathbb{I} \otimes X \end{gathered}$$

Czynnik tensorowy $Q$ w naszym błędzie $E$ pokrywa się z macierzą identyczności w obu tych generatorach stabilizatora (dlatego właśnie zostały wybrane). Biorąc pod uwagę, że mamy macierze identyczności na 5 najbardziej wysuniętych na prawo pozycjach $E,$ wnioskujemy, że $P$ musi komutować z $X$ i $Z,$ w przeciwnym razie $E$ antykomutowałby z jednym z dwóch generatorów. Jednakże jedyną macierzą Pauli, która komutuje zarówno z $X,$ jak i z $Z,$ jest macierz identyczności, więc $P = \mathbb{I}.$

Teraz, gdy to wiemy, możemy wybrać dwa kolejne generatory stabilizatora, które mają $X$ i $Z$ na drugiej pozycji od lewej, i wyciągamy podobny wniosek: $Q = \mathbb{I}.$ Tak więc $E$ jest operacją identyczności.

Zatem nie ma sposobu, aby błąd o wadze co najwyżej 2 pozostał niewykryty przez ten kod, chyba że błąd jest operacją identyczności (która znajduje się w stabilizatorze, a zatem nie jest w rzeczywistości błędem). Z drugiej strony, istnieją operacje Pauli o wadze 3, które komutują ze wszystkimi sześcioma tymi generatorami stabilizatora, ale nie są proporcjonalne do elementów stabilizatora, takie jak $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ oraz $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ To dowodzi, że ten kod ma odległość 3, jak twierdziliśmy.

Korekcja błędów

Ostatnim tematem omawianym w tej lekcji jest korekcja błędów dla kodów stabilizatorowych. Jak zwykle, zakładamy, że mamy kod stabilizatorowy określony przez n-kubitowe generatory stabilizatora $P_1, \ldots, P_r.$

$n$-kubitowe operacje Pauliego, traktowane jako błędy, które mogą wpływać na stany zakodowane za pomocą tego kodu, są podzielone na równoliczne zbiory zgodnie z tym, jaki syndrom powodują. Istnieje $2^r$ różnych syndromów i $4^n$ operacji Pauliego, co oznacza, że dla każdego syndromu istnieje $4^n/2^r$ operacji Pauliego, które go powodują. Każdy z tych błędów mógłby być odpowiedzialny za odpowiadający mu syndrom.

Jednakże wśród $4^n/2^r$ operacji Pauliego powodujących każdy syndrom istnieją takie, które powinny być uważane za równoważne. W szczególności, jeśli iloczyn dwóch operacji Pauliego jest proporcjonalny do elementu stabilizatora, to te dwie operacje są efektywnie równoważne jako błędy.

Innymi słowy, jeśli zastosujemy operację korekcji $C$ w celu skorygowania błędu $E,$ to ta korekcja powiedzie się tak długo, jak długo złożenie $CE$ jest proporcjonalne do elementu stabilizatora. Biorąc pod uwagę, że w stabilizatorze jest $2^r$ elementów, wynika z tego, że każda operacja korekcji $C$ koryguje $2^r$ różnych błędów Pauliego. Pozostawia to $4^{n-r}$ nierównoważnych klas operacji Pauliego, traktowanych jako błędy, które są zgodne z każdym możliwym syndromem.

Oznacza to, że chyba że $n=r$ (w którym to przypadku mamy trywialną, jednowymiarową przestrzeń kodu), nie jesteśmy w stanie skorygować każdego błędu wykrytego przez kod stabilizatorowy. Zamiast tego musimy wybrać tylko jedną operację korekcji dla każdego syndromu, w nadziei na skorygowanie tylko jednej klasy równoważnych błędów powodujących ten syndrom.

Jedną z naturalnych strategii wyboru, którą operację korekcji wykonać dla każdego syndromu, jest wybranie operacji Pauliego o najniższej wadze, która jako błąd powoduje ten syndrom. W rzeczywistości może istnieć wiele operacji, które mają jednakową najniższą wagę błędu zgodną z danym syndromem, a w takim przypadku można wybrać dowolną z nich. Idea polega na tym, że operacje Pauliego o niższej wadze reprezentują bardziej prawdopodobne wyjaśnienia zmierzonego syndromu. Faktycznie może to nie być prawdą dla niektórych modeli szumu, a jedną z alternatywnych strategii jest obliczenie najbardziej prawdopodobnego błędu powodującego dany syndrom, w oparciu o wybrany model szumu. W tej lekcji jednak zachowamy prostotę i rozważymy tylko korekcje o najniższej wadze.

Dla kodu stabilizatorowego o odległości $d,$ ta strategia wyboru operacji korekcji jako operacji Pauliego o najniższej wadze zgodnej ze zmierzonym syndromem zawsze pozwala na korekcję błędów o wadze ściśle mniejszej niż połowa $d,$ czyli innymi słowy, o wadze co najwyżej $(d-1)/2.$ Pokazuje to, na przykład, że 7-kubitowy kod Steane'a może korygować dowolny błąd Pauliego o wadze jeden, a dzięki dyskretyzacji błędów oznacza to, że kod Steane'a może korygować dowolny błąd na jednym kubicie.

Aby zobaczyć, jak to działa, rozważmy poniższy diagram. Okrąg po lewej stronie reprezentuje wszystkie operacje Pauliego, które dają syndrom $(+1,\ldots,+1),$ czyli syndrom sugerujący, że nie wystąpiły żadne błędy i wszystko jest w porządku. Wśród tych operacji mamy elementy stabilizatora (lub, mówiąc dokładniej, operacje, które są proporcjonalne do elementów stabilizatora), a także nietrywialne błędy, które w jakiś sposób zmieniają przestrzeń kodu, ale nie są wykrywane przez kod. Z definicji odległości, każda operacja Pauliego w tej kategorii musi mieć wagę co najmniej $d,$ ponieważ $d$ jest zdefiniowane jako minimalna waga tych operacji.

Okrąg po prawej stronie reprezentuje operacje Pauliego, które dają inny syndrom $s\neq(+1,\ldots,+1),$ w tym błąd $E$ o wadze ściśle mniejszej niż $d/2,$ który rozważymy.

Operacja korekcji $C$ wybrana dla syndromu $s$ to operacja Pauliego o najniższej wadze w zbiorze reprezentowanym przez okrąg po prawej stronie diagramu (lub dowolna z nich w przypadku remisu). Mogłoby więc być tak, że $C = E,$ ale niekoniecznie. To, co możemy jednak stwierdzić z pewnością, to że $C$ nie może mieć wagi większej niż waga $E,$ ponieważ $C$ ma minimalną wagę spośród operacji w tym zbiorze — a zatem $C$ ma wagę ściśle mniejszą niż $d/2.$

Teraz rozważmy, co się stanie, gdy operacja korekcji $C$ zostanie zastosowana do stanu, który otrzymaliśmy po wystąpieniu błędu $E.$ Zakładając, że oryginalne kodowanie to $\vert\psi\rangle,$ pozostajemy ze stanem $CE\vert\psi\rangle.$ Naszym celem będzie wykazanie, że $CE$ jest proporcjonalne do elementu stabilizatora, co implikuje, że korekcja jest udana i (z dokładnością do fazy globalnej) pozostajemy z oryginalnym zakodowanym stanem $\vert\psi\rangle.$

Po pierwsze, ponieważ $E$ i $C$ powodują ten sam syndrom, złożenie $CE$ musi komutować z każdym generatorem stabilizatora. W szczególności, jeśli $P_k$ jest dowolnym z generatorów stabilizatora, to musimy mieć

$$P_k E = \alpha E P_k \quad\text{and}\quad P_k C = \alpha C P_k$$

dla tej samej wartości $\alpha\in\{+1,-1\},$ ponieważ jest to $k$-ty wpis w syndromie $s,$ który generują zarówno $C,$ jak i $E.$ Zatem mamy

$$P_k (CE) = \alpha C P_k E = \alpha^2 (CE) P_k = (CE) P_k,$$

więc $P_k$ komutuje z $CE.$ Pokazaliśmy zatem, że $CE$ należy do okręgu po lewej stronie diagramu, ponieważ generuje syndrom $(+1,\ldots,+1).$

Po drugie, złożenie $CE$ musi mieć wagę co najwyżej równą sumie wag $C$ i $E$ — co wynika z chwili zastanowienia nad iloczynami operacji Pauliego — a zatem waga $CE$ jest ściśle mniejsza niż $d.$ To implikuje, że $CE$ jest proporcjonalne do elementu stabilizatora naszego kodu, co chcieliśmy pokazać. Wybierając nasze operacje korekcji jako reprezentantów o najniższej wadze zbioru błędów generujących każdy syndrom, mamy zatem gwarancję skorygowania dowolnych błędów Pauliego o wadze mniejszej niż połowa odległości kodu.

Jest jednak pewien problem. Dla kodów stabilizatorowych w ogólności, obliczenie operacji Pauliego o najniższej wadze powodującej dany syndrom jest problemem trudnym obliczeniowo. (W istocie, jest to prawdą nawet dla kodów klasycznych, które w tym kontekście możemy traktować jako kody stabilizatorowe, w których jako czynniki tensorowe w generatorach stabilizatora występują tylko macierze $\mathbb{I}$ i $Z.$) Zatem, w przeciwieństwie do kroku kodowania, operacje Clifforda tym razem nie przyjdą nam z pomocą.

Rozwiązaniem jest wybór konkretnych kodów, dla których dobre korekcje mogą być obliczone efektywnie, dla czego nie ma prostej recepty. Mówiąc prosto, projektowanie kodów stabilizatorowych, dla których dobre operacje korekcji mogą być obliczone efektywnie, jest częścią artyzmu projektowania kodów kwantowych.