O código Shor de 9 qubits

Agora vamos estudar o código Shor de 9 qubits, que é um código de correção de erros quânticos obtido pela combinação dos dois códigos considerados na seção anterior: o código de repetição de 3 bits para qubits, que permite a correção de um único erro de inversão de bit, e a versão modificada desse código, que permite a correção de um único erro de inversão de fase.

Descrição do código

O código Shor de 9 qubits é o código que obtemos ao concatenar os dois códigos da seção anterior. Isso significa que primeiro aplicamos uma codificação, que codifica um qubit em três, e depois aplicamos a outra codificação a cada um dos três qubits usados na primeira codificação, resultando em nove qubits no total.

Para ser mais preciso, embora neste caso específico pudéssemos aplicar os dois códigos em qualquer ordem, vamos optar por aplicar primeiro a versão modificada do código de repetição de 3 bits (que detecta erros de inversão de fase), e então codificar cada um dos três qubits resultantes de forma independente usando o código de repetição de 3 bits original (que detecta erros de inversão de bit). A seguir está uma representação em diagrama de circuito dessa codificação.

Como a figura sugere, vamos pensar nos nove qubits do código Shor como agrupados em três blocos de três qubits cada, onde cada bloco é obtido a partir da segunda etapa de codificação (que é o código de repetição de 3 bits ordinário). O código de repetição de 3 bits ordinário, que aqui é aplicado três vezes de forma independente, é chamado de código interno nesse contexto, enquanto o código externo é o código usado na primeira etapa de codificação, que é a versão modificada do código de repetição de 3 bits que detecta erros de inversão de fase.

Também podemos especificar o código descrevendo como os dois estados da base padrão do nosso qubit original são codificados.

$$\begin{aligned} \vert 0\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \otimes (\vert 000\rangle + \vert 111\rangle) \\[4mm] \vert 1\rangle & \:\mapsto\: \frac{1}{2\sqrt{2}} (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \otimes (\vert 000\rangle - \vert 111\rangle) \end{aligned}$$

Sabendo disso, podemos determinar por linearidade como um vetor de estado de qubit arbitrário é codificado.

Corrigindo erros de inversão de bit e de fase

Erros e portas CNOT

Para analisar como os erros $X$ e $Z$ afetam as codificações de qubits, tanto para o código Shor de 9 qubits quanto para outros códigos, será útil observar algumas relações simples entre esses erros e as portas CNOT. Ao começarmos a analisar o código Shor de 9 qubits, este é um momento razoável para fazer uma pausa e examinar isso.

Os diagramas de circuito a seguir ilustram três relações básicas entre portas $X$ e portas CNOT. Especificamente, aplicar uma porta $X$ ao qubit alvo antes de um CNOT é equivalente a inverter a ordem e realizar o CNOT primeiro; mas aplicar uma porta $X$ ao qubit de controle antes de um CNOT é equivalente a aplicar portas $X$ a ambos os qubits após o CNOT. Por fim, aplicar portas $X$ a ambos os qubits antes de um CNOT é equivalente a aplicar o CNOT primeiro e então aplicar uma porta $X$ ao qubit de controle. Essas relações podem ser verificadas realizando as multiplicações matriciais necessárias ou calculando o efeito dos circuitos sobre os estados da base padrão.

A situação é semelhante para portas $Z$, exceto que os papéis dos qubits de controle e alvo se invertem. Em particular, temos as três relações representadas pelos seguintes circuitos quânticos.

Corrigindo erros de inversão de bit

Agora vamos considerar como os erros podem ser detectados e corrigidos usando o código Shor de 9 qubits, começando pelos erros de inversão de bit — que daqui em diante chamaremos de erros $X$ para abreviar.

Para detectar e corrigir erros $X$, podemos simplesmente tratar cada um dos três blocos da codificação separadamente. Cada bloco é uma codificação de um qubit usando o código de repetição de 3 bits, que protege contra erros $X$ — portanto, ao realizar as medições de síndrome e as correções de erros $X$ descritas anteriormente em cada bloco, podemos detectar e corrigir até um erro $X$ por bloco. Em particular, se houver no máximo um erro $X$ nos nove qubits da codificação, esse erro será detectado e corrigido por esse procedimento.

Em resumo, corrigir erros de inversão de bit é algo simples para este código, devido ao fato de o código interno corrigir erros de inversão de bit.

Corrigindo erros de inversão de fase

A seguir vamos considerar os erros de inversão de fase, ou erros $Z$ para abreviar. Desta vez não é tão claro o que devemos fazer, pois é o código externo que detecta erros $Z$, mas o código interno parece estar de alguma forma "no caminho", tornando a detecção e a correção desses erros um pouco mais difícil.

Suponha que um erro $Z$ ocorra em um dos 9 qubits do código Shor, como o indicado neste diagrama.

Já observamos o que acontece quando um erro $Z$ ocorre ao usarmos o código de repetição de 3 bits — é equivalente a um erro $Z$ ocorrendo antes da codificação. No contexto do código Shor de 9 qubits, isso significa que um erro $Z$ em qualquer um dos três qubits dentro de um bloco sempre tem o mesmo efeito, que é equivalente a um erro $Z$ ocorrendo no qubit correspondente antes da aplicação do código interno.

Por exemplo, o diagrama de circuito acima é equivalente ao diagrama a seguir. Isso pode ser raciocínado usando as relações entre portas $Z$ e CNOT descritas acima, ou simplesmente avaliando os circuitos em um estado de qubit arbitrário $\vert\psi\rangle.$

Isso sugere uma opção para detectar e corrigir erros $Z$, que é decodificar o código interno, deixando-nos com os três qubits usados para a codificação externa juntamente com seis qubits de espaço de trabalho inicializados. Podemos então verificar esses três qubits do código externo em busca de erros $Z$ e, por fim, recodificar usando o código interno, para voltarmos à codificação de 9 qubits que obtemos do código Shor. Se detectarmos um erro $Z$, podemos corrigi-lo antes de recodificar com o código interno ou após a recodificação, aplicando uma porta $Z$ a qualquer um dos qubits desse bloco.

Aqui está um diagrama de circuito que inclui o circuito de codificação e o erro sugerido acima junto com as etapas descritas (mas não a etapa de correção em si).

Neste exemplo específico, a medição de síndrome é $11,$ que localiza o erro $Z$ como tendo ocorrido em um dos qubits do bloco do meio.

Uma vantagem de corrigir erros $Z$ após a etapa de recodificação, em vez de antes, é que podemos simplificar o circuito acima. O circuito a seguir é equivalente, mas requer quatro portas CNOT a menos.

Mais uma vez, a síndrome não indica qual qubit foi afetado por um erro $Z$, mas sim qual bloco sofreu um erro $Z$, sendo o efeito o mesmo independentemente de qual qubit dentro do bloco foi afetado. Podemos então corrigir o erro aplicando uma porta $Z$ a qualquer um dos três qubits do bloco que foi afetado.

A propósito, aqui vemos um exemplo de degenerescência em um código de correção de erros quânticos, onde somos capazes de corrigir certos erros (erros $Z$ neste caso) sem conseguir identificá-los de forma única.

Erros simultâneos de inversão de bit e de fase

Já vimos como tanto os erros $X$ quanto os erros $Z$ podem ser detectados e corrigidos usando o código Shor de 9 qubits, e em particular como no máximo um erro $X$ ou no máximo um erro $Z$ pode ser detectado e corrigido. Agora vamos supor que tanto um erro de inversão de bit quanto um erro de inversão de fase ocorram, possivelmente no mesmo qubit. Como se verifica, nessa situação não é necessário fazer nada diferente do que já foi discutido — o código é capaz de detectar e corrigir até um erro $X$ e um erro $Z$ simultaneamente, sem modificações adicionais.

Para ser mais específico, os erros $X$ são detectados pela aplicação da medição de síndrome do código de repetição de 3 bits ordinário, que é realizada separadamente em cada um dos três blocos de três qubits; e os erros $Z$ são detectados pelo procedimento descrito logo acima, que é equivalente a decodificar o código interno, realizar a medição de síndrome para o código de repetição de 3 bits modificado para inversões de fase, e então recodificar. Essas duas etapas de detecção de erros — assim como as correções correspondentes — podem ser realizadas de forma completamente independente uma da outra, e de fato não importa em qual ordem são realizadas.

Para entender por quê, considere o exemplo representado no diagrama de circuito a seguir, onde tanto um erro $X$ quanto um erro $Z$ afetaram o qubit inferior do bloco do meio.

Vamos primeiro observar que a ordem dos erros não importa, no sentido de que inverter a posição dos erros $X$ e $Z$ produz um circuito equivalente. Para ser claro, $X$ e $Z$ não comutam, eles anti-comutam:

$$XZ = \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} = \begin{pmatrix} 0 & -1\\[1mm] 1 & 0 \end{pmatrix} = - \begin{pmatrix} 1 & 0\\[1mm] 0 & -1 \end{pmatrix} \begin{pmatrix} 0 & 1\\[1mm] 1 & 0 \end{pmatrix} = -ZX.$$

Isso implica que o circuito a seguir é equivalente ao anterior a menos de um fator de fase global de $-1.$

Agora podemos mover o erro $Z$ como antes para obter outro circuito equivalente.

Neste ponto fica evidente que, se o procedimento para detectar e corrigir erros $X$ for realizado primeiro, o erro $X$ será corrigido, após o que o procedimento para detectar e corrigir erros $Z$ pode ser realizado para eliminar o erro $Z$ como antes.

Alternativamente, o procedimento para detectar e corrigir erros $Z$ pode ser realizado primeiro. O fato de que esse procedimento funciona como esperado, mesmo na presença de um ou mais erros $X$, decorre do fato de que portas $X$ em qualquer um dos nove qubits usados para a codificação comutam com todas as portas em nosso circuito simplificado para medir a síndrome de erros $Z$. Portanto, essa medição de síndrome ainda identificará corretamente qual bloco foi afetado por um erro $Z$. O fato de que um erro $Z$ em qualquer bloco é corrigido pela aplicação de uma porta $Z$ a qualquer qubit desse bloco, mesmo que um erro $X$ também tenha ocorrido, decorre do mesmo argumento acima sobre a ordenação das portas $X$ e $Z$ nos fornecendo circuitos equivalentes a menos de uma fase global.

Conclui-se que o código Shor de 9 qubits pode corrigir um erro $X$, um erro $Z$, ou ambos, em qualquer um dos nove qubits usados para este código. Na verdade, podemos corrigir mais erros do que isso, incluindo múltiplos erros $X$ (desde que estejam em blocos diferentes) ou múltiplos erros $Z$ (desde que no máximo um bloco experiencie um número ímpar deles) — mas daqui em diante, o que será mais relevante para os propósitos desta lição é que podemos corrigir um erro $X$, um erro $Z$, ou ambos em qualquer qubit.

Redução de erros para erros aleatórios

Antes de passarmos para a última seção da lição, que trata de erros quânticos arbitrários, vamos considerar brevemente o desempenho do código Shor de 9 qubits quando erros representados por matrizes de Pauli ocorrem aleatoriamente nos qubits.

Para ser mais concreto, vamos considerar um modelo de ruído simples onde os erros ocorrem independentemente nos qubits, com cada qubit sofrendo um erro com probabilidade $p$, e sem correlação entre os erros em qubits diferentes — de forma semelhante a um canal simétrico binário para bits clássicos. Poderíamos atribuir probabilidades diferentes para a ocorrência de erros $X,$ $Y$ e $Z$, mas para manter as coisas o mais simples possível, vamos considerar o cenário de pior caso para o código Shor de 9 qubits, que é a ocorrência de um erro $Y$ em cada um dos qubits afetados. Um erro $Y$, a propósito, é equivalente (a menos de um fator de fase global irrelevante) tanto a um erro $X$ quanto a um erro $Z$ ocorrendo no mesmo qubit, dado que $Y = iXZ.$ Isso explica nosso aparente descaso com os erros $Y$ até este ponto.

Agora, supondo que $\mathsf{Q}$ seja um qubit em algum estado particular que gostaríamos de proteger contra erros, podemos considerar a opção de usar o código Shor de 9 qubits. Uma pergunta natural é: "Devemos usá-lo?"

A resposta não é necessariamente "sim." Se houver muito ruído, o que neste contexto significa que $p$ é muito grande, usar o código Shor pode na verdade piorar as coisas — assim como o código de repetição de 3 bits é pior do que nenhum código quando $p$ é maior do que um meio. Mas, se $p$ for pequeno o suficiente, então a resposta é "sim", devemos usar o código, pois ele diminuirá a probabilidade de o estado codificado ser corrompido. Vamos entender por que isso ocorre e o que significa $p$ ser muito grande ou pequeno o suficiente para este código.

O código Shor corrige qualquer erro de Pauli em um único qubit, incluindo um erro $Y$ naturalmente, mas não corrige adequadamente dois ou mais erros $Y$. Para ser claro, estamos assumindo que estamos usando as correções de erros $X$ e $Z$ descritas anteriormente na seção. (É claro que, se soubéssemos de antemão que só precisaríamos nos preocupar com erros $Y$, naturalmente escolheríamos nossas correções de forma diferente — mas isso seria trapacear o modelo de ruído, e sempre poderíamos mudar o modelo selecionando diferentes erros de Pauli para fazer essa nova escolha de correções falhar sempre que dois ou mais qubits fossem afetados por erros.)

Portanto, o código protege $\mathsf{Q}$ desde que no máximo um dos nove qubits seja afetado por um erro, o que ocorre com probabilidade

$$(1-p)^9 + 9 p (1-p)^8.$$

Caso contrário, com probabilidade

$$1 - (1-p)^9 - 9 p (1-p)^8,$$

o código falha em proteger $\mathsf{Q}.$

Especificamente, o que isso significa neste contexto é que, a menos de uma fase global, uma operação de Pauli não identidade será aplicada ao nosso qubit $\mathsf{Q}$ (como qubit lógico). Ou seja, se os erros $X$ e $Z$ forem detectados e corrigidos para o código Shor conforme descrito anteriormente na lição, ficaremos com a codificação de um estado que é equivalente, a menos de uma fase global, à codificação de uma operação de Pauli não identidade aplicada ao estado original de $\mathsf{Q}.$ Uma forma mais sucinta de dizer isso é que um erro lógico terá ocorrido. Isso pode ou não ter efeito sobre o estado original de $\mathsf{Q}$ — ou em outras palavras, o qubit lógico que codificamos com nove qubits físicos — mas, para fins desta análise, consideramos esse evento como falha.

Por outro lado, se não nos dessemos ao trabalho de usar o código, nosso único qubit sofreria um destino semelhante (de ser sujeito a uma operação de Pauli não identidade) com probabilidade $p.$ O código ajuda quando a primeira probabilidade é menor do que a segunda:

$$1 - (1-p)^9 - 9 p (1-p)^8 < p.$$

Aqui está um gráfico que ilustra, para valores muito pequenos de $p,$ que o código oferece uma vantagem, com o ponto de equilíbrio ocorrendo em torno de $0.0323.$

Se $p$ for menor do que esse ponto de equilíbrio, o código ajuda; no ponto de equilíbrio as probabilidades são iguais, portanto estamos apenas desperdiçando nosso tempo além de 8 qubits se usarmos o código; e além do ponto de equilíbrio definitivamente não devemos usar esse código porque ele está aumentando a chance de um erro lógico em $\mathsf{Q}.$

Três e um quarto por cento ou assim pode não parecer um ponto de equilíbrio muito bom, especialmente quando comparado a $50\%,$ que é o ponto de equilíbrio análogo para o código de repetição de 3 bits para informação clássica. Essa diferença se deve, em grande parte, ao fato de que a informação quântica é mais delicada e mais difícil de proteger do que a informação clássica. Mas também — reconhecendo que o código Shor de 9 qubits representa uma descoberta brilhante, sendo o primeiro código de correção de erros quânticos do mundo — deve-se reconhecer que ele não é um código muito bom em termos práticos.