Collegamento tra generatori di stabilizzatori e matrici di controllo di parità nel codice Steane

Sto lavorando con Mike e Ike (Nielsen e Chuang) per studiare da solo, e sto leggendo dei codici stabilizzatori nel capitolo 10. Sono un ingegnere elettrico con un po 'di conoscenza della teoria dell'informazione classica, ma sono non è affatto un esperto di teoria della codifica algebrica. La mia algebra astratta è essenzialmente solo un po 'più di ciò che è nell'appendice.

Penso di comprendere appieno la costruzione di Calderbank-Shor-Steane, in cui due codici classici lineari sono usati per costruire un codice quantico. Il codice Steane è costruito usando $C_1$ (il codice per i lanci qbit) come il codice di Hamming [7,4,3] e $C_2^{\perp}$ (il codice per i lanci di fase) come lo stesso codice. La matrice di controllo di parità del codice [7,4,3] è:

$$\begin{bmatrix} 0&0&0&1&1&1&1 \\ 0&1&1&0&0&1&1 \\ 1&0&1&0&1&0&1 \end{bmatrix}$$ .

I generatori di stabilizzatori per il codice Steane possono essere scritti come:

$$\begin{array} {|r|r|} \hline Name & Operator \\ \hline g_1 & IIIXXXX \\ \hline g_2 & IXXIIXX \\ \hline g_3 & XIXIXIX \\ \hline g_4 & IIIZZZZ \\ \hline g_5 & IZZIIZZ \\ \hline g_6 & ZIZIZIZ \\ \hline \end{array}$$ dove per la mia sanità mentale$IIIXXXX = I \otimes I\otimes I\otimes X \otimes X \otimes X \otimes X$e così via.

Nel libro viene indicato che le $X$ e le $Z$ sono nelle stesse posizioni degli $1$ nel codice di controllo di parità originale. L'esercizio 10.32 chiede di verificare che le parole in codice per il codice Steane siano stabilizzate da questo set. Potrei ovviamente collegarlo e controllarlo a mano. Tuttavia, si afferma che con l'osservazione delle somiglianze tra la matrice di controllo di parità e il generatore l'esercizio è "evidente".

Ho visto questo fatto notato in altri luoghi ( http://www-bcf.usc.edu/~tbrun/Course/lecture21.pdf ), ma mi manca una sorta di intuizione (probabilmente ovvia). Penso che mi manchi qualche ulteriore collegamento dalle classiche parole in codice ai codici quantici diverso da come vengono utilizzati nell'indicizzazione degli elementi di base nella costruzione del codice (ad es. Sezione 10.4.2).

Ci sono alcune convenzioni e intuizioni qui, che forse aiuterebbe a precisare - $\def\ket#1{\lvert#1\rangle}\def\bra#1{\!\langle#1\rvert}$

• Bit di segno rispetto a {0,1} bit
  
  Il primo passo è creare quello che a volte viene chiamato il "grande spostamento notazionale" e pensare ai bit (anche bit classici) come codificati in segni. Questo è produttivo da fare se ciò che ti interessa di più sono le parità delle stringhe di bit, poiché i bit-flip e il sign-flip agiscono sostanzialmente allo stesso modo. Mappiamo $0 \mapsto +1$ e $1 \mapsto -1$ , in modo che per esempio la sequenza di bit $(0,0,1,0,1)$ sarebbe rappresentato dalla sequenza di segni $(+1,+1,-1,+1,-1)$ .

  Le parità delle sequenze di bit corrispondono quindi ai prodotti delle sequenze di segni. Ad esempio, proprio come riconosceremmo $0 \oplus 0 \oplus 1 \oplus 0 \oplus 1 = 0$ come calcolo di parità, potremmo riconoscere $(+1)\cdot(+1)\cdot(-1)\cdot(+1)\cdot(-1) = +1$ quanto rappresenta lo stesso calcolo di parità usando la convenzione dei segni.
  
  Esercizio.Calcola la 'parità' di $(-1,-1,+1,-1)$ e di $(+1,-1,+1,+1)$ . Sono uguali?
  
  

• Controlli di parità mediante bit di segno
  
  Nella convenzione {0,1} -bit, i controlli di parità hanno una buona rappresentazione come prodotto a punti di due vettori booleani, in modo da poter realizzare complicati calcoli di parità come trasformazioni lineari. Passando ai bit di segno, abbiamo inevitabilmente perso la connessione con l'algebra lineare a livello notazionale , perché stiamo prendendo prodotti invece di somme. A livello computazionale, poiché questo è solo uno spostamento della notazione, non dobbiamo preoccuparci troppo. Ma a livello matematico puro, ora dobbiamo ripensare un po 'a quello che stiamo facendo con le matrici di controllo di parità.

  Quando utilizziamo i bit di segno, possiamo ancora rappresentare una "matrice di controllo di parità" come una matrice di 0 e 1 s, anziché segni ± 1. Perché? Una risposta è che un vettore di riga che descrive un controllo di parità di bit è di tipo diverso rispetto alla sequenza di bit stessi: descrive una funzione sui dati, non i dati stessi. L'array di 0 e 1 ora richiede solo un'interpretazione diversa: invece di coefficienti lineari in una somma, corrispondono agli esponenti di un prodotto. Se abbiamo bit di segno $(s_1, s_2, \ldots, s_n) \in \{-1,+1\}^n$ e vogliamo calcolare un controllo di parità dato da un vettore di riga$(b_1, b_2, \ldots, b_n) \in \{0,1\}$ , il controllo di parità viene quindi calcolato da

  $$(s_1)^{b_1} \cdot (s_2)^{b_2} \cdot [\cdots] \cdot (s_n)^{b_n} \in \{-1,+1\},$$ dove ricorda che $s^0 = 1$ per tutti $s$ . Come con {0,1} -bits, si può pensare di riga $(b_1,b_2,\ldots,b_n)$ come solo rappresenta una 'maschera' che determina quali bit $s_j$ un contributo non banale alla parità calcolo.

  Esercizio. Calcola il risultato del controllo di parità $(0,1,0,1,0,1,0)$ su $(+1,-1,-1,-1,-1,+1,-1)$ .
  
  

• Autovalori come parità.
  
  Il motivo per cui vorremmo codificare bit in segni nella teoria dell'informazione quantistica è dovuto al modo in cui le informazioni sono memorizzate in stati quantistici - o più precisamente, al modo in cui possiamo descrivere l'accesso a tali informazioni. In particolare, possiamo parlare molto della base standard, ma il motivo per cui è significativo è perché possiamo estrarre tali informazioni misurando un osservabile .

  Questo osservabile potrebbe essere solo il proiettore $\ket{1}\bra{1}$, dove$\ket{0}$ ha autovalore 0 e$\ket{1}$ ha autovalore 1, ma è spesso utile preferiscono descrivere le cose in termini di matrici di Pauli. In questo caso, parleremmo della base standard come autofisisdell'operatore$Z$ , nel qual caso abbiamo$\ket{0}$ come il +1-eigenvector di Ze$\ket{1}$ come -1-eigenvector di Z.

  Quindi: abbiamo l'emergere di bit di segno (in questo caso, autovalori) che rappresentano le informazioni memorizzate in un qubit. E ancora meglio, possiamo farlo in un modo che non è specifico alla base standard: possiamo parlare di informazioni memorizzate nella base "coniugata", solo considerando se lo stato è un autigata di $X$ e quale autovalore ha . Ma più di questo, possiamo parlare degli autovalori di un operatore Pauli multi-qubit come codifica di parità di più bit: il prodotto tensore $Z \otimes Z$ rappresenta un modo per accedere al prodotto dei bit di segno, vale a dire la parità, di due qubit nella base standard. In questo senso, l'autovalore di uno stato rispetto a un operatore Pauli multi-qubit - se tale autovalore è definito ( cioè  nel caso in cui lo stato sia un autovalore dell'operatore Pauli) - è in effetti il ​​risultato di un calcolo di parità di informazioni memorizzate in una scelta di base per ciascuno dei qubit.

  Esercizio. Qual è la parità dello stato $\ket{11}$ rispetto alla $Z \otimes Z$ ? Questo stato ha una parità ben definita rispetto a $X \otimes X$ ?
  
  Esercizio. Qual è la parità dello stato $\ket{+-}$ rispetto a $X \otimes X$ ? Questo stato ha una parità ben definita rispetto a?$Z \otimes Z$?
  
  Exercise. What is the parity of $\ket{\Phi^+} = \tfrac{1}{\sqrt 2}\bigl(\ket{00} + \ket{11}\bigr)$rispetto alla$Z \otimes Z$e$X \otimes X$?
  
  

• Generatori di stabilizzatori come controlli di parità.
  
  Ora siamo in grado di apprezzare il ruolo dei generatori di stabilizzatori come analoghi a una matrice di controllo di parità. Considera il caso del codice CSS a 7 qubit, con generatori

  $$\begin{array} {|r|ccccccc|} \hline \scriptstyle\text{Generator} & & & & \!\!\!\!\!\!\!\!\!\scriptstyle\text{Tensor factors}\!\!\!\!\!\!\!\!\! & & & \\[-0.5ex] & \scriptstyle1 & \scriptstyle2 & \scriptstyle3 & \scriptstyle4 & \scriptstyle5 & \scriptstyle6 & \scriptstyle7 \\ \hline \hline g_1 & & & & X & X & X & X \\ \hline g_2 & & X & X & & & X & X \\ \hline \hline g_3 & X & & X & & X & & X \\ \hline g_4 & & & & Z & Z & Z & Z \\ \hline g_5 & & Z & Z & & & Z & Z \\ \hline g_6 & Z & & Z & & Z & & Z \\ \hline \end{array}$$ Ho omesso i fattori del tensore dell'identità sopra, poiché a volte si potrebbe omettere gli 0 da una matrice {0,1}, e per lo stesso motivo: in un dato operatore stabilizzatore, la matrice dell'identità corrisponde a un fattore tensore che non è incluso nella "maschera" dei qubit per i quali stiamo calcolando la parità. Per ogni generatore, siamo interessati solo a quei fattori tensoriali su cui si agisce in qualche modo, perché contribuiscono al risultato di parità.

  Ora, le "parole chiave" (gli stati base codificati standard) del codice CSS a 7 qubit sono date da

  $$\begin{align} \ket{0_L} \propto{}&{} \ket{0000000} + \ket{0001111} + \ket{0110011} + \ket{0111100} \\&+ \ket{1010101} + \ket{1011010} + \ket{1100110} + \ket{1101001} = \sum_{y \in C} \ket{y}, \\[1ex] \ket{1_L} \propto{}&{} \ket{1111111} + \ket{1110000} + \ket{1001100} + \ket{1000011} \\&+ \ket{0101010} + \ket{0100101} + \ket{0011001} + \ket{0010110} = \sum_{y \in C} \ket{y \oplus 1111111}, \end{align}$$ where $C$ is the code generated by the bit-strings $0001111$, $0110011$, and $1010101$. Notably, these bit-strings correspond to the positions of the $X$ operators in the generators $g_1$, $g_2$, and $g_3$. While those are stabilisers of the code (and represent parity checks as I've suggested above), we can also consider their action as operators which permute the standard basis. In particular, they will permute the elements of the code $C$, so that the terms involved in $\ket{0_L}$ and $\ket{1_L}$ will just be shuffled around.

  The generators $g_4$, $g_5$, and $g_6$ above are all describing the parities of information encoded in standard basis states. The encoded basis states you are given are superpositions of codewords drawn from a linear code, and those codewords all have even parity with respect to the parity-check matrix from that code. As $g_4$ through $g_6$ just describe those same parity checks, it follows that the eigenvalue of the encoded basis states is $+1$ (corresponding to even parity).

  This is the way in which

  'with the observation about the similarities between the parity check matrix and the generator the exercise is "self evident"'

  — because the stabilisers either manifestly permute the standard basis terms in the two 'codewords', or manifestly are testing parity properties which by construction the codewords will have.
  
  

• Moving beyond codewords

  The list of generators in the table you provide represent the first steps in a powerful technique, known as the stabiliser formalism, in which states are described using no more or less than the parity properties which are known to hold of them.

  Some states, such as standard basis states, conjugate basis states, and the perfectly entangled states $\ket{\Phi^+} \propto \ket{00} + \ket{11}$ and $\ket{\Psi^-} \propto \ket{01} - \ket{10}$ can be completely characterised by their parity properties. (The state $\ket{\Phi^+}$ is the only one which is a +1-eigenvector of $X \otimes X$ and $Z \otimes Z$; the state $\ket{\Psi^-}$ is the only one which is a −1-eigenvector of both these operators.) These are known as stabiliser states, and one can consider how they are affected by unitary transformations and measurements by tracking how the parity properties themselves transform. For instance, a state which is stabilised by $X \otimes X$ before applying a Hadamard on qubit 1, will be stabilised by $Z \otimes X$ afterwards, because $(H \otimes I)(X \otimes X)(H \otimes I) = Z \otimes X$. Rather than transform the state, we transform the parity property which we know to hold of that state.

  You can use this also to characterise how subspaces characterised by these parity properties will transform. For instance, given an unknown state in the 7-qubit CSS code, I don't know enough about the state to tell you what state you will get if you apply Hadamards on all of the qubits, but I can tell you that it is stabilised by the generators $g_j' = (H^{\otimes 7}) g_j (H^{\otimes 7})$, which consist of

  $$\begin{array} {|r|ccccccc|} \hline \scriptstyle\text{Generator} & & & & \!\!\!\!\!\!\!\!\!\scriptstyle\text{Tensor factors}\!\!\!\!\!\!\!\!\! & & & \\[-0.5ex] & \scriptstyle1 & \scriptstyle2 & \scriptstyle3 & \scriptstyle4 & \scriptstyle5 & \scriptstyle6 & \scriptstyle7 \\ \hline \hline g'_1 & & & & Z & Z & Z & Z \\ \hline g'_2 & & Z & Z & & & Z & Z \\ \hline \hline g'_3 & Z & & Z & & Z & & Z \\ \hline g'_4 & & & & X & X & X & X \\ \hline g'_5 & & X & X & & & X & X \\ \hline g'_6 & X & & X & & X & & X \\ \hline \end{array}$$ This is just a permutation of the generators of the 7-qubit CSS code, so I can conclude that the result is also a state in that same code.

  There is one thing about the stabiliser formalism which might seem mysterious at first: you aren't really dealing with information about the states that tells you anything about how they expand as superpositions of the standard basis. You're just dealing abstractly with the generators. And in fact, this is the point: you don't really want to spend your life writing out exponentially long superpositions all day, do you? What you really want are tools to allow you to reason about quantum states which require you to write things out as linear combinations as rarely as possible, because any time you write something as a linear combination, you are (a) making a lot of work for yourself, and (b) preferring some basis in a way which might prevent you from noticing some useful property which you can access using a different basis.

  Still: it is sometimes useful to reason about 'encoded states' in error correcting codes — for instance, in order to see what effect an operation such as $H^{\otimes 7}$ might have on the codespace of the 7-qubit code. What should one do instead of writing out superpositions?

  The answer is to describe these states in terms of observables — in terms of parity properties — to fix those states. For instance, just as $\ket{0}$ is the +1-eigenstate of $Z$, we can characterise the logical state $\ket{0_L}$ of the 7-qubit CSS code as the +1-eigenstate of

  $$Z_L = Z \otimes Z \otimes Z \otimes Z \otimes Z \otimes Z \otimes Z$$ and similarly, $\ket{1_L}$ as the −1-eigenstate of $Z_L$. (It is important that $Z_L = Z^{\otimes 7}$$\{g_1,\ldots,g_6\}$$Z_L$$X^{\otimes 7}$ anti commutes with $Z^{\otimes 7}$ the same way that $X$ anti commutes with $Z$, and also as $X^{\otimes 7}$ commutes with the generators $g_i$, we can describe $\ket{+_L}$ as being the +1-eigenstate of $$X_L = X \otimes X \otimes X \otimes X \otimes X \otimes X \otimes X,$$ and similarly, $\ket{-_L}$ as the −1-eigenstate of $X_L$. We may say that the encoded standard basis is, in particular, encoded in the parities of all of the qubits with respect to $Z$ operators; and the encoded 'conjugate' basis is encoded in the parities of all of the qubits with respect to $X$ operators.

  By fixing a notion of encoded operators, and using this to indirectly represent encoded states, we may observe that

  $$(H^{\otimes 7}) \,X_L\, (H^{\otimes 7}) = Z_L, \quad (H^{\otimes 7}) \,Z_L\, (H^{\otimes 7}) = X_L,$$ which is the same relation as obtains between $X$ and $Z$ with respect to conjugation by Hadamards; which allows us to conclude that for this encoding of information in the 7-qubit CSS code, $H^{\otimes 7}$ not only preserves the codespace but is an encoded Hadamard operation.
  
  

Thus we see that the idea of observables as a way of describing information about a quantum states in the form of sign bits — and in particular tensor products as a way of representing information about parities of bits — plays a central role in describing how the CSS code generators represent parity checks, and also in how we can describe properties of error correcting codes without reference to basis states.

One way that you could construct what the codeword is is to project on the $+1$ eigenspace of the generators,

$$|C_1\rangle=\frac{1}{2^6}\left(\prod_{i=1}^6(\mathbb{I}+g_i)\right)|0000000\rangle.$$ Concentrate, to start with, one the first 3 generators $$(\mathbb{I}+g_1)(\mathbb{I}+g_2)(\mathbb{I}+g_3).$$ If you expand this out, you'll see that it creates all the terms in the group ($\mathbb{I},g_1,g_2,g_3,g_1g_2,g_1g_3,g_2g_3,g_1g_2g_3)$. Corresponding it to binary strings, the action of multiplying two terms (since $X^2=\mathbb{I}$) is just like addition modulo 2. So, contained within the code are all of the words generated by the parity check matrix (and this is a group, with group operation of addition modulo 2).

Now, if you multiply by one of the $X$ stabilizers, that's like doing the addition modulo 2 on the corresponding bit strings. But, because we've already generated the group, by definition every group element is mapped to another (unique) group element. In other words, if I do

$$g_1\times\{\mathbb{I},g_1,g_2,g_3,g_1g_2,g_1g_3,g_2g_3,g_1g_2g_3\}=\{g_1\mathbb{I},g_1g_2,g_1g_3,g_2,g_3,g_1g_2g_3,g_2g_3\},$$ I get back the set I started with (using $g_1^2=\mathbb{I}$, and the commutation of the stabilizers), and therefore I'm projecting onto the same state. Hence, the state is stabilized by $g_1$ to $g_3$.

You can effectively make the same argument for $g_4$ to $g_6$. I prefer to think about first applying a Hadamard to every qubit, so the Xs are changed to Zs and vice versa. The set of stabilizers are unchanged, so the code is unchanged, but the Z stabilizer is mapped to an X stabilizer, about which we have already argued.

What follows perhaps doesn't exactly answer your question, but instead aims to provide some background to help it become as 'self-evident' as your sources claim.

The $Z$ operator has eigenstates $|0\rangle$ (with eigenvalue $+1$) and $|1\rangle$ (with eigenvalue $-1$). The $ZZ$ operator on two qubits therefore has eigenstates

$$|00\rangle, |01\rangle, |10\rangle, |11\rangle$$ . The eigenvalues for these depend on the parity of the bit strings. For example, with $|00\rangle$ we multiply the $+1$ eigenvalues of the individual $Z$ operators to get $+1$. For $|11\rangle$ we multiply the $-1$ eigenvalues together and also get $+1$ for $ZZ$. So both these even parity bit strings have eigenvalue $+1$, as does any superposition of them. For both odd parity states ($|01\rangle$ and $|10\rangle$) we must multiply a $+1$ with a $-1$, and get a $-1$ eigenvalue for $ZZ$.

Note also that superpositions of bit strings with fixed parity (such as some $\alpha |00\rangle + \beta |00\rangle$) are also eigenstates, and have the eigenvalue associated with their parity. So measuring $ZZ$ would not collapse such a superposition.

This analysis remains valid as we go to higher number of qubits. So if we want to know about the parity of qubits 1, 3, 5, and 7 (to pick a pertinent example), we could use the operator $ZIZIZIZ$. If we measure this and get the outcome $+1$, we know that this subset of qubits has a state represented by an even parity bit string, or a superposition thereof. If we get $-1$, we know that it is an odd parity state.

This allows us to write the [7,4,3] Hamming code using the notation of quantum stabilizer codes. Each parity check is turned into a stabilizer generator which has $I$ on every qubit not involved in the check, and $Z$ on every qubit that is. The resulting code will protect against errors that anticommute with $Z$ (and therefore have the effect of flipping bits).

Of course, qubits do not restrict us to only working in the $Z$ basis. We could encode our qubits for a classical Hamming code in the $|+\rangle$ and $|-\rangle$ states instead. These are the eigenstates of $X$, so you just need to replace $Z$ with $X$ in everything I've said to see how this kind of code works. It would protect against errors that anticommute with $X$ (and so have the effect of flipping phase).

The magic of the Steane code, of course, is that it does both at the same time and protects against everything.