Códigos estabilizadores

Agora vamos definir os códigos estabilizadores de forma geral. Também discutiremos algumas de suas propriedades básicas e como eles funcionam, incluindo como os estados podem ser codificados e como os erros são detectados e corrigidos usando esses códigos.

Definição de códigos estabilizadores

Um código estabilizador de $n$ qubits é especificado por uma lista de operações de Pauli em $n$ qubits, $P_1,\ldots,P_r.$ Essas operações são chamadas de geradores estabilizadores neste contexto, e devem satisfazer as três propriedades a seguir.

1. Os geradores estabilizadores todos comutam uns com os outros.

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

2. Os geradores estabilizadores formam um conjunto gerador minimal.

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

3. Pelo menos um vetor de estado quântico é fixado por todos os geradores estabilizadores.

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

   (Não é óbvio que a existência de um vetor de estado quântico $\vert\psi\rangle$ fixado por todos os geradores estabilizadores, ou seja, $P_1 \vert\psi\rangle = \cdots = P_r \vert\psi\rangle = \vert\psi\rangle,$ seja equivalente a $-\mathbb{I}^{\otimes n} \notin \langle P_1,\ldots, P_r\rangle,$ mas isso é de fato o caso, e veremos o porquê um pouco mais adiante na lição.)

Supondo que tenhamos uma lista $P_1,\ldots,P_r$ como essa, o espaço de código definido por esses geradores estabilizadores é o subespaço $\mathcal{C}$ que contém todo vetor de estado quântico de $n$ qubits fixado pelos $r$ geradores estabilizadores.

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

Os vetores de estado quântico nesse subespaço são precisamente os que podem ser vistos como codificações válidas de estados quânticos. Discutiremos o processo real de codificação mais adiante.

Por fim, o estabilizador do código definido pelos geradores estabilizadores $P_1, \ldots, P_r$ é o conjunto gerado por essas operações:

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

Uma maneira natural de pensar sobre um código estabilizador é ver os geradores estabilizadores como observáveis e interpretar coletivamente os resultados das medições associadas a esses observáveis como uma síndrome de erro. As codificações válidas são vetores de estado quântico de $n$ qubits para os quais os resultados das medições, como autovalores, são todos garantidamente iguais a $+1.$ Qualquer outra síndrome, onde ocorre pelo menos um resultado de medição $-1$, sinaliza que um erro foi detectado.

Vamos dar uma olhada em vários exemplos em breve, mas primeiro apenas algumas observações sobre as três condições para os geradores estabilizadores são pertinentes.

A primeira condição é natural, à luz da interpretação dos geradores estabilizadores como observáveis, pois implica que não importa em que ordem as medições são realizadas: os observáveis comutam, então as medições também comutam. Isso naturalmente impõe certas restrições algébricas aos códigos estabilizadores que são importantes para o seu funcionamento.

A segunda condição exige que os geradores estabilizadores formem um conjunto gerador minimal, ou seja, que a remoção de qualquer um deles resultaria em um estabilizador menor. Falando estritamente, essa condição não é realmente essencial para o funcionamento dos códigos estabilizadores em um sentido operacional — e, como veremos na próxima lição, às vezes faz sentido pensar em conjuntos de geradores estabilizadores para códigos que de fato não satisfazem essa condição. Para efeitos de análise dos códigos estabilizadores e explicação de suas propriedades, no entanto, assumiremos que essa condição está em vigor. Em resumo, essa condição garante que cada observável que medimos para obter a síndrome de erro acrescenta informações sobre possíveis erros, em vez de ser redundante e produzir resultados que poderiam ser inferidos das outras medições dos geradores estabilizadores.

A terceira condição exige que pelo menos um vetor não nulo seja fixado por todos os geradores estabilizadores, o que é equivalente a $-\mathbb{I}^{\otimes n}$ não estar contido no estabilizador. A necessidade dessa condição vem do fato de que é efetivamente possível escolher um conjunto gerador minimal de operações de Pauli em $n$ qubits que todas comutam entre si, e ainda assim nenhum vetor não nulo é fixado por todas as operações. Não estamos interessados em "códigos" para os quais não há codificações válidas, então descartamos essa possibilidade ao exigir essa condição como parte da definição.

Exemplos

Aqui estão alguns exemplos de códigos estabilizadores para valores pequenos de $n.$ Veremos mais exemplos, incluindo aqueles para os quais $n$ pode ser muito maior, na próxima lição.

Código de repetição de 3 bits

O código de repetição de 3 bits é um exemplo de código estabilizador, onde os geradores estabilizadores são $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z.$

Podemos verificar facilmente que esses dois geradores estabilizadores satisfazem as condições exigidas. Primeiro, os dois geradores estabilizadores $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z$ comutam entre si.

$$(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})$$

Segundo, temos um conjunto gerador minimal (de forma bastante trivial neste caso).

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

E terceiro, já sabemos que $\vert 000\rangle$ e $\vert 111\rangle,$ assim como qualquer combinação linear desses vetores, são fixados por $Z \otimes Z \otimes \mathbb{I}$ e $\mathbb{I} \otimes Z \otimes Z.$ Alternativamente, podemos concluir isso usando a condição equivalente da definição.

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

Essas condições podem ser muito mais difíceis de verificar para códigos estabilizadores mais complexos.

Código de repetição de 3 bits modificado

Na lição anterior, vimos que é possível modificar o código de repetição de 3 bits para que ele proteja contra erros de inversão de fase em vez de erros de inversão de bit. Como código estabilizador, esse novo código é fácil de descrever: seus geradores estabilizadores são $X \otimes X \otimes \mathbb{I}$ e $\mathbb{I} \otimes X \otimes X.$

Desta vez os geradores estabilizadores representam observáveis $X\otimes X$ em vez de observáveis $Z\otimes Z$, portanto são essencialmente verificações de paridade na base mais/menos em vez da base padrão. As três condições exigidas para os geradores estabilizadores são facilmente verificadas, de maneira semelhante ao código de repetição de 3 bits comum.

Código de Shor de 9 qubits

Aqui está o código de Shor de 9 qubits, que também é um código estabilizador, expresso por geradores estabilizadores.

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

Nesse caso, basicamente temos três cópias do código de repetição de 3 bits, uma para cada um dos três blocos de três qubits, bem como os dois últimos geradores estabilizadores, que têm uma forma que lembra o circuito de detecção de inversões de fase para este código.

Uma forma alternativa de pensar sobre os dois últimos geradores estabilizadores é que eles têm a mesma forma do código de repetição de 3 bits para inversões de fase, exceto que $X\otimes X\otimes X$ é substituído por $X,$ o que é consistente com o fato de que $X\otimes X\otimes X$ corresponde a uma operação $X$ sobre qubits lógicos codificados usando o código de repetição de 3 bits.

Antes de passarmos para outros exemplos, deve-se notar que os símbolos de produto tensorial são frequentemente omitidos ao descrever códigos estabilizadores por listas de geradores estabilizadores, pois isso tende a torná-los mais fáceis de ler e ver seus padrões. Por exemplo, os mesmos geradores estabilizadores acima para o código de Shor de 9 qubits ficam assim sem os símbolos de produto tensorial escritos explicitamente.

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

Código de Steane de 7 qubits

Aqui está outro exemplo de código estabilizador, conhecido como código de Steane de 7 qubits. Ele tem algumas características notáveis, e voltaremos a este código de tempos em tempos ao longo das lições restantes do curso.

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

Por enquanto, vamos simplesmente observar que este é um código estabilizador válido. Os três primeiros geradores estabilizadores claramente comutam entre si, pois $Z$ comuta consigo mesmo e a identidade comuta com tudo, e a situação é semelhante para os três últimos geradores estabilizadores. Resta verificar que, ao tomar um dos geradores $Z$-estabilizadores (ou seja, um dos três primeiros) e um dos geradores $X$-estabilizadores (ou seja, um dos três últimos), esses dois geradores comutam, e pode-se percorrer os 9 pares possíveis para verificar isso. Em todos esses casos, uma matriz de Pauli $X$ e uma $Z$ sempre se alinham na mesma posição um número par de vezes, de modo que os dois geradores comutarão, assim como $X\otimes X$ e $Z\otimes Z$ comutam. Isso também é um conjunto gerador minimal, e define um espaço de código não trivial, fatos deixados para você contemplar.

O código de Steane de 7 qubits é semelhante ao código de Shor de 9 qubits no sentido de que codifica um único qubit e permite a correção de um erro arbitrário em um qubit, mas requer apenas 7 qubits em vez de 9.

Código de 5 qubits

Sete não é o menor número de qubits necessário para codificar um qubit e protegê-lo contra um erro arbitrário em um qubit — aqui está um código estabilizador que faz isso usando apenas 5 qubits.

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

Este código é tipicamente chamado de o código de 5 qubits. Este é o menor número de qubits em um código de correção de erros quânticos que pode permitir a correção de um erro arbitrário em um único qubit.

Códigos estabilizadores unidimensionais

Aqui está outro exemplo de código estabilizador, embora ele não codifique nenhum qubit de fato: o espaço de código é unidimensional. No entanto, ainda é um código estabilizador válido pela definição.

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

Especificamente, o espaço de código é o espaço unidimensional gerado por um e-bit $\vert\phi^+\rangle.$

Aqui está um exemplo relacionado de código estabilizador cujo espaço de código é o espaço unidimensional gerado por um estado 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}$$

Dimensão do espaço de código

Suponha que temos um código estabilizador descrito por geradores estabilizadores de $n$ qubits $P_1,\ldots,P_r.$ Talvez a primeira pergunta que venha à mente sobre este código seja: "Quantos qubits ele codifica?"

Essa pergunta tem uma resposta simples. Supondo que os geradores estabilizadores de $n$ qubits $P_1, \ldots, P_r$ satisfaçam os três requisitos da definição (a saber, que os geradores estabilizadores todos comutam entre si, que este é um conjunto gerador minimal e que o espaço de código é não vazio), então o espaço de código para este código estabilizador deve ter dimensão $2^{n-r},$ de modo que $n-r$ qubits podem ser codificados usando este código.

Intuitivamente, temos $n$ qubits para usar nessa codificação, e cada gerador estabilizador efetivamente "retira um qubit" em termos de quantos qubits podemos codificar. Note que isso não se refere a quais ou quantos erros podem ser detectados ou corrigidos, é apenas uma afirmação sobre a dimensão do espaço de código.

Por exemplo, tanto para o código de repetição de 3 bits quanto para a versão modificada desse código para erros de inversão de fase, temos $n=3$ qubits e $r=2$ geradores estabilizadores, e portanto esses códigos podem cada um codificar 1 qubit. Como outro exemplo, considere o código de 5 qubits: temos 5 qubits e 4 geradores estabilizadores, portanto novamente o espaço de código tem dimensão 2, o que significa que um qubit pode ser codificado usando este código. Como um último exemplo, o código cujos geradores estabilizadores são $X\otimes X$ e $Z\otimes Z$ tem um espaço de código unidimensional, gerado pelo estado $\vert\phi^+\rangle,$ o que é consistente com ter $n=2$ qubits e $r=2$ geradores estabilizadores.

Agora vamos ver como esse fato pode ser provado. O primeiro passo é observar que, como os geradores estabilizadores comutam, e como toda operação de Pauli é sua própria inversa, todo elemento do estabilizador pode ser expresso como um produto

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

onde $a_1,\ldots,a_r\in\{0,1\}.$ Equivalentemente, cada elemento do estabilizador é obtido multiplicando algum subconjunto dos geradores estabilizadores. De fato, cada elemento do estabilizador pode ser expresso de forma única desta maneira, devido à condição de que $\{P_1,\ldots,P_r\}$ é um conjunto gerador minimal.

Em seguida, defina $\Pi_k$ como a projeção sobre o espaço dos autovetores de $+1$ de $P_k,$ para cada $k\in\{1,\ldots,r\}.$ Essas projeções podem ser obtidas calculando a média das operações de Pauli correspondentes com a operação identidade da seguinte forma.

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

O espaço de código $\mathcal{C}$ é o subespaço de todos os vetores que são fixados pelos $r$ geradores estabilizadores $P_1,\ldots,P_r,$ ou equivalentemente, por todas as $r$ projeções $\Pi_1,\ldots,\Pi_r.$

Dado que os geradores estabilizadores todos comutam entre si, as projeções $\Pi_1,\ldots,\Pi_r$ também devem comutar. Isso nos permite usar um fato da álgebra linear, que é que o produto dessas projeções é a projeção sobre a interseção dos subespaços correspondentes às projeções individuais. Ou seja, o produto $\Pi_1\cdots\Pi_r$ é a projeção sobre o espaço de código $\mathcal{C}.$

Podemos agora expandir o produto $\Pi_1\cdots\Pi_r$ usando as fórmulas para essas projeções para obter a seguinte expressão.

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

Em palavras, a projeção sobre o espaço de código de um código estabilizador é igual, como uma matriz, à média sobre todos os elementos no estabilizador desse código.

Por fim, podemos calcular a dimensão do espaço de código usando o fato de que a dimensão de qualquer subespaço é igual ao traço da projeção sobre esse subespaço. Assim, a dimensão do espaço de código $\mathcal{C}$ é dada pela fórmula a seguir.

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

Podemos avaliar essa expressão fazendo uso de alguns fatos básicos.

• Temos $P_1^0 \cdots P_r^0 = \mathbb{I}^{\otimes n}$ e portanto

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

• Para $(a_1,\ldots,a_r) \neq (0,\ldots,0),$ o produto $P_1^{a_1}\cdots P_r^{a_r}$ deve ser $\pm 1$ vezes uma operação de Pauli — mas não podemos obter $\mathbb{I}^{\otimes n}$ porque isso contrariaria a minimalidade do conjunto $\{P_1,\ldots,P_r\},$ e não podemos obter $-\mathbb{I}^{\otimes n}$ porque a terceira condição sobre os geradores estabilizadores proíbe isso. Portanto, como o traço de toda operação de Pauli não identidade é zero, obtemos

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

A dimensão do espaço de código é portanto $2^{n-r}$ como afirmado:

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

Como observação adicional, agora podemos ver que a suposição de que $-\mathbb{I}^{\otimes n}$ não está contido no estabilizador implica que o espaço de código deve conter pelo menos um vetor de estado quântico. Isso ocorre porque, como acabamos de verificar, essa suposição implica que o espaço de código tem dimensão $2^{n-r},$ que não pode ser zero. A implicação conversa é trivial: se $-\mathbb{I}^{\otimes n}$ está contido no estabilizador, então o espaço de código não pode conter nenhum vetor de estado quântico, pois nenhum vetor não nulo é fixado por essa operação.

Operações de Clifford e codificações

A seguir, discutiremos brevemente como os qubits podem ser codificados usando códigos estabilizadores, mas para isso primeiro precisamos introduzir as operações de Clifford.

Operações de Clifford

As operações de Clifford são operações unitárias, em qualquer número de qubits, que podem ser implementadas por circuitos quânticos com um conjunto restrito de gates:

• Gates Hadamard
• Gates $S$
• Gates CNOT

Observe que os gates $T$ não estão incluídos, nem os gates Toffoli e Fredkin. Não apenas esses gates não estão na lista, mas de fato não é possível implementá-los usando os gates listados aqui; eles não são operações de Clifford. As operações de Pauli, por outro lado, são operações de Clifford porque podem ser implementadas com sequências de gates Hadamard e $S$.

Essa é uma forma simples de definir operações de Clifford, mas não explica por que são definidas assim ou o que há de especial nessa coleção específica de gates. A razão real pelas quais as operações de Clifford são definidas dessa forma é que, a menos de fatores de fase global, as operações de Clifford são precisamente as operações unitárias que sempre transformam operações de Pauli em operações de Pauli por conjugação. Para ser mais preciso, uma operação unitária $U$ de $n$ qubits é equivalente a uma operação de Clifford a menos de um fator de fase se, e somente se, para toda operação de Pauli $P$ de $n$ qubits, temos

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

para alguma operação de Pauli $Q$ de $n$ qubits.

(Note que não é possível ter $U P U^{\dagger} = \alpha Q$ para $\alpha\notin\{+1,-1\}$ quando $U$ é unitário e $P$ e $Q$ são operações de Pauli. Isso decorre do fato de que a matriz no lado esquerdo da equação em questão é ao mesmo tempo unitária e hermitiana, e $+1$ e $-1$ são as únicas escolhas para $\alpha$ que permitem que o lado direito seja também unitário e hermitiano.)

É direto verificar a propriedade de conjugação descrita acima quando $U$ é um gate Hadamard, $S$ ou CNOT. Em particular, isso é simples para gates Hadamard,

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

e gates $S$,

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

Para gates CNOT, há 15 operações de Pauli não identidade em dois qubits para verificar. Naturalmente, elas podem ser verificadas individualmente — mas as relações entre gates CNOT e gates $X$ e $Z$ listadas (na forma de circuito) na lição anterior, juntamente com as regras de multiplicação para matrizes de Pauli, oferecem um atalho para a mesma conclusão.

Uma vez que sabemos que essa propriedade de conjugação é verdadeira para gates Hadamard, $S$ e CNOT, podemos concluir imediatamente que ela é verdadeira para circuitos compostos por esses gates — ou seja, todas as operações de Clifford.

É mais difícil provar que a relação funciona na direção oposta, que é que se uma dada operação unitária $U$ satisfaz a propriedade de conjugação para operações de Pauli, então deve ser possível implementá-la (a menos de uma fase global) usando apenas gates Hadamard, $S$ e CNOT. Isso não será explicado nesta lição, mas é verdade.

As operações de Clifford não são universais para computação quântica; ao contrário de conjuntos universais de gates quânticos, não é possível aproximar operações unitárias arbitrárias com qualquer nível desejado de precisão usando operações de Clifford. De fato, para um dado valor de $n,$ há apenas finitas operações de Clifford de $n$ qubits (a menos de fatores de fase). Realizar operações de Clifford em estados da base padrão seguidas de medições na base padrão também não nos permite realizar computações fora do alcance dos algoritmos clássicos — pois podemos simular eficientemente computações dessa forma classicamente. Esse fato é conhecido como o teorema de Gottesman-Knill.

Codificadores para códigos estabilizadores

Um código estabilizador define um espaço de código de certa dimensão, e temos a liberdade de usar esse espaço de código como quisermos — nada nos obriga a codificar qubits nesse espaço de código de uma forma específica. No entanto, é sempre possível usar uma operação de Clifford como codificador, se optarmos por isso. Para ser mais preciso, para qualquer código estabilizador que permita que $m$ qubits sejam codificados em $n$ qubits, existe uma operação de Clifford $U$ de $n$ qubits tal que, para qualquer vetor de estado quântico $\vert\phi\rangle$ de $m$ qubits, temos que

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

é um vetor de estado quântico no espaço de código do nosso código que podemos interpretar como uma codificação de $\vert\phi\rangle.$

Isso é bom porque as operações de Clifford são relativamente simples em comparação com operações unitárias arbitrárias, e há maneiras de otimizar sua implementação usando técnicas semelhantes às encontradas na prova do teorema de Gottesman-Knill. Como resultado, os circuitos para codificar estados usando códigos estabilizadores nunca precisam ser muito grandes. Em particular, é sempre possível realizar uma codificação para um código estabilizador de $n$ qubits usando uma operação de Clifford que requer $O(n^2/\log(n))$ gates. Isso ocorre porque toda operação de Clifford em $n$ qubits pode ser implementada por um circuito desse tamanho.

Por exemplo, aqui está um codificador para o código de Steane de 7 qubits. É de fato uma operação de Clifford e, como se vê, este não precisa nem de gates $S$.

Detectando erros

Para um código estabilizador de $n$ qubits descrito por geradores estabilizadores $P_1,\ldots, P_r,$ a detecção de erros funciona da seguinte maneira.

Para detectar erros, todos os geradores estabilizadores são medidos como observáveis. Há $r$ geradores estabilizadores e, portanto, $r$ resultados de medição, cada um sendo $+1$ ou $-1$ (ou um valor binário se optarmos por associar $0$ a $+1$ e $1$ a $-1,$ respectivamente). Interpretamos os $r$ resultados coletivamente, como um vetor ou string, como uma síndrome. A síndrome $(+1,\ldots,+1)$ indica que nenhum erro foi detectado, enquanto pelo menos um $-1$ em algum lugar na síndrome indica que um erro foi detectado.

Suponha, em particular, que $E$ é uma operação de Pauli de $n$ qubits, representando um erro hipotético. (Estamos considerando apenas operações de Pauli como erros, aliás, porque a discretização de erros funciona da mesma forma para códigos estabilizadores arbitrários como para o código de Shor de 9 qubits.) Há três casos que determinam se $E$ é ou não detectado como um erro.

Casos de detecção de erros

1. A operação $E$ é proporcional a um elemento do estabilizador.

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

   Neste caso, $E$ deve comutar com todo gerador estabilizador, então obtemos a síndrome $(+1,\ldots,+1).$ Isso significa que $E$ não é detectado como um erro.

2. A operação $E$ não é proporcional a um elemento do estabilizador, mas ainda assim comuta com todo gerador estabilizador.

   $$E\neq \pm Q\; \text{for} \; Q \in \langle P_1,\ldots,P_r\rangle, \;\text{but}\; E P_k = P_k E \;\text{for every}\; k\in\{1,\ldots,r\}$$

   Este é um erro que muda os vetores no espaço de código de alguma maneira não trivial. Mas, como $E$ comuta com todo gerador estabilizador, a síndrome é $(+1,\ldots,+1),$ então $E$ passa despercebido pelo código.

3. A operação $E$ anti-comuta com pelo menos um dos geradores estabilizadores.

   $$P_k E = -E P_k \; \text{for at least one} \; k\in\{1,\ldots,r\}$$

   A síndrome é diferente de $(+1,\ldots,+1),$ portanto o erro $E$ é detectado pelo código.

No primeiro caso, o erro $E$ não é uma preocupação porque essa operação não faz nada com os vetores no espaço de código, exceto possivelmente injetar uma fase global irrelevante: $E \ket{\psi} = \pm\ket{\psi}$ para todo estado codificado $\ket{\psi}.$ Em essência, isso não é realmente um erro — qualquer ação não trivial que $E$ possa ter acontece fora do espaço de código — então é bom que $E$ não seja detectado como um erro, porque nada precisa ser feito a respeito.

O segundo caso, falando intuitivamente, é o caso ruim. É a anti-comutação de um erro com um gerador estabilizador que faz com que um $-1$ apareça em algum lugar na síndrome, sinalizando um erro, mas isso não acontece neste caso. Portanto, temos um erro $E$ que de fato muda os vetores no espaço de código de alguma maneira não trivial, mas passa despercebido pelo código. Por exemplo, para o código de repetição de 3 bits, a operação $E = X\otimes X\otimes X$ se enquadra nesta categoria.

O fato de que tal erro $E$ deve mudar alguns vetores no espaço de código de uma maneira não trivial pode ser argumentado da seguinte forma. Pela suposição de que $E$ comuta com $P_1,\ldots,P_r$ mas não é proporcional a um elemento estabilizador, podemos concluir que obteríamos um novo código estabilizador válido incluindo $E$ como um gerador estabilizador junto com $P_1,\ldots,P_r.$ O espaço de código para esse novo código, no entanto, tem apenas metade da dimensão do espaço de código original, do que podemos concluir que a ação de $E$ sobre o espaço de código original não pode ser proporcional à operação identidade.

Para o último dos três casos, que é que o erro $E$ anti-comuta com pelo menos um gerador estabilizador, a síndrome tem pelo menos um $-1$ em algum lugar, o que indica que algo está errado. Como já discutimos, a síndrome não identificará $E$ de forma única em geral, portanto ainda é necessário escolher uma operação de correção para cada síndrome, que pode ou não corrigir o erro $E.$ Discutiremos essa etapa em breve, na última parte da lição.

Distância de um código estabilizador

Como questão de terminologia, quando nos referimos à distância de um código estabilizador, queremos dizer o peso mínimo de uma operação de Pauli $E$ que se enquadra na segunda categoria acima — ou seja, que muda o espaço de código de alguma maneira não trivial, mas o código não detecta isso. Quando se diz que um código estabilizador é um código estabilizador $[[n,m,d]],$ usando colchetes duplos, isso significa o seguinte:

1. As codificações têm $n$ qubits de comprimento,
2. o código permite a codificação de $m$ qubits, e
3. a distância do código é $d.$

Como exemplo, consideremos o código de Steane de 7 qubits. Aqui estão os geradores estabilizadores para este código:

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

Este código tem distância 3, e podemos argumentar isso da seguinte forma.

Primeiro, considere qualquer operação de Pauli $E$ com peso de no máximo 2, e suponha que essa operação comuta com todos os seis geradores estabilizadores. Concluiremos que $E$ deve ser a operação identidade, que (como sempre) é um elemento do estabilizador. Isso mostrará que a distância do código é estritamente maior que 2. Suponha, em particular, que $E$ tem a forma

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

para $P$ e $Q$ sendo matrizes de Pauli possivelmente não identidade. Esse é apenas um caso, e é necessário repetir o argumento a seguir para todas as outras localizações possíveis de matrizes de Pauli não identidade entre os fatores tensoriais de $E,$ mas o argumento é essencialmente o mesmo para todas as localizações possíveis.

A operação $E$ comuta com todos os seis geradores estabilizadores, portanto comuta com estes dois em particular:

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

O fator tensorial $Q$ em nosso erro $E$ se alinha com a matriz identidade em ambos os geradores estabilizadores (é por isso que foram selecionados). Dado que temos matrizes identidade nas 5 posições mais à direita de $E,$ concluímos que $P$ deve comutar com $X$ e $Z,$ caso contrário $E$ anti-comutaria com um dos dois geradores. No entanto, a única matriz de Pauli que comuta com $X$ e $Z$ é a matriz identidade, então $P = \mathbb{I}.$

Agora que sabemos disso, podemos escolher mais dois geradores estabilizadores que têm um $X$ e um $Z$ na segunda posição da esquerda, e chegamos a uma conclusão semelhante: $Q = \mathbb{I}.$ Portanto, $E$ é a operação identidade.

Assim, não há como um erro de peso de no máximo 2 passar despercebido por este código, a menos que o erro seja a operação identidade (que está no estabilizador e, portanto, não é realmente um erro). Por outro lado, há operações de Pauli de peso 3 que comutam com todos os seis geradores estabilizadores, mas não são proporcionais a elementos do estabilizador, como $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes X\otimes X\otimes X$ e $\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes\mathbb{I}\otimes Z\otimes Z\otimes Z.$ Isso estabelece que este código tem distância 3, como afirmado.

Corrigindo erros

O último tópico de discussão desta lição é a correção de erros para códigos estabilizadores. Como de costume, assuma que temos um código estabilizador especificado por geradores estabilizadores de $n$ qubits $P_1, \ldots, P_r.$

As operações de Pauli de $n$ qubits, como erros que poderiam afetar os estados codificados usando este código, são particionadas em coleções de tamanho igual de acordo com qual síndrome elas fazem aparecer. Há $2^r$ síndromes distintas e $4^n$ operações de Pauli, o que significa que há $4^n/2^r$ operações de Pauli causando cada síndrome. Qualquer um desses erros poderia ser responsável pela síndrome correspondente.

No entanto, entre as $4^n/2^r$ operações de Pauli que causam cada síndrome, há algumas que devem ser consideradas equivalentes. Em particular, se o produto de duas operações de Pauli é proporcional a um elemento do estabilizador, então essas duas operações são efetivamente equivalentes como erros.

Outra forma de dizer isso é que se aplicarmos uma operação de correção $C$ para tentar corrigir um erro $E,$ então essa correção é bem-sucedida desde que a composição $CE$ seja proporcional a um elemento do estabilizador. Dado que há $2^r$ elementos no estabilizador, segue-se que cada operação de correção $C$ corrige $2^r$ erros de Pauli diferentes. Isso deixa $4^{n-r}$ classes inequivalentes de operações de Pauli, consideradas como erros, que são consistentes com cada síndrome possível.

Isso significa que, a menos que $n=r$ (caso em que temos um espaço de código trivial e unidimensional), não podemos possivelmente corrigir todos os erros detectados por um código estabilizador. O que devemos fazer em vez disso é escolher apenas uma operação de correção para cada síndrome, na esperança de corrigir apenas uma classe de erros equivalentes que causam essa síndrome.

Uma estratégia natural para escolher qual operação de correção realizar para cada síndrome é escolher a operação de Pauli de menor peso que, como erro, causa essa síndrome. Pode de fato haver múltiplas operações que empatam como o erro de menor peso consistente com uma dada síndrome, caso em que qualquer uma delas pode ser selecionada. A ideia é que operações de Pauli de menor peso representam explicações mais prováveis para qualquer síndrome que tenha sido medida. Isso pode de fato não ser o caso para alguns modelos de ruído, e uma estratégia alternativa é calcular o erro mais provável que causa a síndrome dada, com base no modelo de ruído escolhido. Para esta lição, no entanto, manteremos as coisas simples e consideraremos apenas correções de menor peso.

Para um código estabilizador de distância $d,$ essa estratégia de escolher a operação de correção como a operação de Pauli de menor peso consistente com a síndrome medida sempre permite a correção de erros com peso estritamente menor que metade de $d,$ ou em outras palavras, peso de no máximo $(d-1)/2.$ Isso mostra, por exemplo, que o código de Steane de 7 qubits pode corrigir qualquer erro de Pauli de peso 1 e, pela discretização de erros, isso significa que o código de Steane pode corrigir um erro arbitrário em um qubit.

Para ver como isso funciona, considere o diagrama abaixo. O círculo à esquerda representa todas as operações de Pauli que resultam na síndrome $(+1,\ldots,+1),$ que é a síndrome que sugere que nenhum erro ocorreu e nada está errado. Entre essas operações temos elementos do estabilizador (ou operações que são proporcionais a elementos do estabilizador, para ser mais preciso) e também erros não triviais que mudam o espaço de código de alguma forma mas não são detectados pelo código. Pela definição de distância, toda operação de Pauli nesta categoria deve ter peso de pelo menos $d,$ porque $d$ é definido como o peso mínimo dessas operações.

O círculo à direita representa as operações de Pauli que resultam em uma síndrome diferente $s\neq(+1,\ldots,+1),$ incluindo um erro $E$ com peso estritamente menor que $d/2$ que consideraremos.

A operação de correção $C$ escolhida para a síndrome $s$ é a operação de Pauli de menor peso na coleção representada pelo círculo à direita no diagrama (ou qualquer uma delas em caso de empate). Portanto, pode ser que $C = E,$ mas não necessariamente. O que podemos afirmar com certeza, no entanto, é que $C$ não pode ter peso maior do que o peso de $E,$ porque $C$ tem peso mínimo entre as operações nesta coleção — e, portanto, $C$ tem peso estritamente menor que $d/2.$

Agora considere o que acontece quando a operação de correção $C$ é aplicada ao estado que obtivemos após o erro $E$ ocorrer. Assumindo que a codificação original era $\vert\psi\rangle,$ ficamos com $CE\vert\psi\rangle.$ Nosso objetivo será mostrar que $CE$ é proporcional a um elemento do estabilizador, implicando que a correção é bem-sucedida e (a menos de uma fase global) ficamos com o estado codificado original $\vert\psi\rangle.$

Primeiro, como $E$ e $C$ causam a mesma síndrome, a composição $CE$ deve comutar com todo gerador estabilizador. Em particular, se $P_k$ é qualquer um dos geradores estabilizadores, então devemos ter

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

para o mesmo valor de $\alpha\in\{+1,-1\},$ porque este é o $k$-ésimo elemento na síndrome $s$ que tanto $C$ quanto $E$ geram. Portanto, temos

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

então $P_k$ comuta com $CE.$ Portanto, mostramos que $CE$ pertence ao círculo à esquerda no diagrama, pois gera a síndrome $(+1,\ldots,+1).$

Segundo, a composição $CE$ deve ter peso de no máximo a soma dos pesos de $C$ e $E$ — o que decorre de uma breve reflexão sobre produtos de operações de Pauli — e, portanto, o peso de $CE$ é estritamente menor que $d.$ Isso implica que $CE$ é proporcional a um elemento do estabilizador do nosso código, que é o que queríamos mostrar. Ao escolher nossas operações de correção como representantes de menor peso do conjunto de erros que geram cada síndrome, garantimos portanto a correção de quaisquer erros de Pauli com peso menor que metade da distância do código.

Há um problema, no entanto. Para códigos estabilizadores em geral, é um problema computacionalmente difícil calcular a operação de Pauli de menor peso que causa uma dada síndrome. (De fato, isso é verdade mesmo para códigos clássicos, que neste contexto podemos pensar como códigos estabilizadores onde apenas matrizes $\mathbb{I}$ e $Z$ aparecem como fatores tensoriais dentro dos geradores estabilizadores.) Portanto, ao contrário da etapa de codificação, as operações de Clifford não virão em nosso socorro desta vez.

A solução é escolher códigos específicos para os quais boas correções podem ser calculadas eficientemente, para os quais não há uma receita simples. Em resumo, desenvolver códigos estabilizadores para os quais boas operações de correção podem ser calculadas eficientemente faz parte da arte do design de códigos quânticos. Veremos essa arte em ação na próxima lição.