Código tórico

A seguir, discutiremos um código CSS específico conhecido como o código tórico, que foi descoberto por Alexei Kitaev em 1997. Na verdade, o código tórico não é um único código, mas sim uma família de códigos, um para cada inteiro positivo a partir de 2. Esses códigos possuem algumas propriedades fundamentais:

• Os geradores do estabilizador têm peso baixo, e em particular todos têm peso 4. No jargão da teoria de codificação, o código tórico é um exemplo de código de verificação de paridade de baixa densidade quântico, ou código LDPC quântico (onde baixo significa 4 neste caso). Isso é conveniente porque cada medição de gerador do estabilizador não precisa envolver muitos qubits.

• O código tórico tem localidade geométrica. Isso significa que não apenas os geradores do estabilizador têm peso baixo, mas também é possível arranjar os qubits espacialmente de modo que cada uma das medições dos geradores do estabilizador envolva apenas qubits que estão próximos entre si. Em princípio, isso torna essas medições mais fáceis de implementar do que se envolvessem qubits espacialmente distantes.

• Os membros da família do código tórico têm distância crescente e podem tolerar uma taxa de erros relativamente alta.

Descrição do código tórico

Seja $L\geq 2$ um inteiro positivo, e considere uma malha $L\times L$ com as chamadas fronteiras periódicas. Por exemplo, esta figura representa uma malha $L\times L$ para $L=9.$

Observe que as linhas à direita e na parte inferior são linhas pontilhadas. Isso indica que a linha pontilhada à direita é a mesma linha que a linha do lado esquerdo, e, da mesma forma, a linha pontilhada na parte inferior é a mesma linha que a do topo.

Para realizar esse tipo de configuração fisicamente, são necessárias três dimensões. Em particular, poderíamos formar a malha em um cilindro juntando primeiro os lados esquerdo e direito, e depois dobrar o cilindro de modo que os círculos nas extremidades — que antes eram as bordas superior e inferior da malha — se encontrem. Ou poderíamos juntar primeiro o topo e a base e depois os lados; funciona dos dois jeitos e não importa qual escolhemos para os fins desta discussão.

O que obtemos é um toro — ou seja, uma rosquinha (embora pensar nele como uma câmara de ar de pneu seja talvez uma imagem mais adequada, pois isso não é um sólido: a malha se tornou apenas a superfície de um toro). É daí que vem o nome "código tórico".

A forma como se pode "se mover" em um toro como este, entre pontos adjacentes na malha, provavelmente será familiar para quem jogou videogames de geração antiga, nos quais sair pelo topo da tela faz você aparecer na parte inferior, e o mesmo vale para as bordas esquerda e direita da tela. É assim que visualizaremos essa malha com fronteiras periódicas, em vez de falar especificamente sobre um toro no espaço tridimensional.

Em seguida, os qubits são dispostos nas arestas dessa malha, como ilustrado na figura a seguir, em que os qubits são indicados por círculos azuis sólidos.

Observe que os qubits colocados nas linhas pontilhadas não são sólidos porque já estão representados nas linhas mais acima e mais à esquerda da malha. No total, há $2L^2$ qubits: $L^2$ qubits em linhas horizontais e $L^2$ qubits em linhas verticais.

Para descrever o código tórico em si, resta descrever os geradores do estabilizador:

• Para cada célula formada pelas linhas da malha, há um gerador do estabilizador $Z$, obtido pelo produto tensorial de matrizes $Z$ nos quatro qubits que tocam essa célula, junto com matrizes identidade em todos os outros qubits.

• Para cada vértice formado pelas linhas da malha, há um gerador do estabilizador $X$, obtido pelo produto tensorial de matrizes $X$ nos quatro qubits adjacentes a esse vértice, junto com matrizes identidade em todos os outros qubits.

Em ambos os casos, obtemos uma operação de Pauli de peso 4. Individualmente, esses geradores do estabilizador podem ser ilustrados da seguinte forma.

Aqui está uma ilustração com alguns exemplos de geradores do estabilizador no contexto da própria malha. Observe que os geradores do estabilizador que atravessam as fronteiras periódicas estão incluídos. Esses geradores que contornam as fronteiras periódicas não são especiais nem de qualquer forma distintos dos que não o fazem.

Os geradores do estabilizador devem comutar para que este seja um código estabilizador válido. Como de costume, os geradores do estabilizador $Z$ comutam entre si, pois $Z$ comuta consigo mesmo e a identidade comuta com tudo, e o mesmo vale para os geradores do estabilizador $X$. Os geradores do estabilizador $Z$ e $X$ claramente comutam quando atuam de forma não trivial em conjuntos disjuntos de qubits, como nos exemplos mostrados na figura anterior. A possibilidade restante é que um gerador do estabilizador $Z$ e um gerador do estabilizador $X$ se sobreponham nos qubits sobre os quais atuam de forma não trivial, e sempre que isso acontece, os geradores devem se sobrepor em exatamente dois qubits, como na próxima figura.

Consequentemente, dois geradores do estabilizador como esses comutam, assim como $Z\otimes Z$ e $X\otimes X$ comutam. Os geradores do estabilizador, portanto, comutam entre si.

A segunda condição necessária sobre os geradores do estabilizador para um código estabilizador é que eles formem um conjunto gerador mínimo. Essa condição de fato não é satisfeita por essa coleção: se multiplicarmos todos os geradores do estabilizador $Z$ juntos, obtemos a operação identidade, e o mesmo vale para os geradores do estabilizador $X$. Portanto, qualquer um dos geradores do estabilizador $Z$ pode ser expresso como o produto de todos os restantes, e, de forma semelhante, qualquer um dos geradores do estabilizador $X$ pode ser expresso como o produto dos demais geradores do estabilizador $X$. Se removermos qualquer um dos geradores do estabilizador $Z$ e qualquer um dos geradores do estabilizador $X$, no entanto, obtemos um conjunto gerador mínimo.

Para deixar isso claro, na prática nos importamos igualmente com todos os geradores do estabilizador, e em sentido estritamente operacional não há necessidade de selecionar um gerador do estabilizador de cada tipo para remover. Mas, para fins de análise do código — e de contagem dos geradores em particular — podemos imaginar que um gerador do estabilizador de cada tipo foi removido, de modo a obter um conjunto gerador mínimo, tendo em mente que sempre poderíamos inferir os resultados desses geradores removidos (pensando neles como observáveis) a partir dos resultados de todos os outros observáveis do gerador do estabilizador do mesmo tipo.

Isso deixa $L^2 - 1$ geradores do estabilizador de cada tipo, ou $2L^2 - 2$ no total, em um conjunto gerador mínimo (hipotético). Dado que há $2L^2$ qubits no total, isso significa que o código tórico codifica $2L^2 - 2 (L^2 - 1) = 2$ qubits.

A condição final exigida dos geradores do estabilizador é que pelo menos um vetor de estado quântico seja fixado por todos os geradores do estabilizador. Veremos que isso é o caso à medida que prosseguimos com a análise do código, mas também é possível raciocinar que não há como gerar $-1$ vezes a identidade em todos os $2L^2$ qubits a partir dos geradores do estabilizador.

Detecção de erros

O código tórico tem uma descrição simples e elegante, mas suas propriedades de correção de erros quânticos podem não ser nada óbvias à primeira vista. Acontece que é um código incrível! Para entender por que e como funciona, vamos começar considerando diferentes erros e as síndromes que eles geram.

O código tórico é um código CSS, porque todos os nossos geradores do estabilizador são geradores do estabilizador $Z$ ou $X$. Isso significa que erros $X$ e erros $Z$ podem ser detectados (e possivelmente corrigidos) separadamente. Na verdade, há uma simetria simples entre os geradores do estabilizador $Z$ e $X$ que nos permite analisar erros $X$ e erros $Z$ essencialmente da mesma forma. Portanto, vamos nos concentrar nos erros $X$, que são possivelmente detectados pelos geradores do estabilizador $Z$ — mas toda a discussão a seguir pode ser traduzida de erros $X$ para erros $Z$, que são detectados de forma análoga pelos geradores do estabilizador $X$.

O diagrama a seguir representa o efeito de um erro $X$ em um único qubit. Aqui, a suposição é que nossos $2L^2$ qubits estavam anteriormente em um estado contido no espaço de código do código tórico, fazendo com que todas as medições dos geradores do estabilizador produzissem $+1.$ Os geradores do estabilizador $Z$ detectam erros $X$, e há um desses geradores para cada célula da figura, então podemos indicar o resultado da medição do gerador do estabilizador correspondente com a cor dessa célula: resultados $+1$ são indicados por células brancas e resultados $-1$ são indicados por células cinzas. Se um erro de inversão de bit ocorrer em um dos qubits, o efeito é que as medições dos geradores do estabilizador correspondentes às duas células que tocam o qubit afetado passam a produzir $-1.$

Isso é intuitivo quando consideramos os geradores do estabilizador $Z$ e como eles se comportam. Em essência, cada gerador do estabilizador $Z$ mede a paridade dos quatro qubits que tocam a célula correspondente (em relação à base padrão). Assim, um resultado $+1$ não indica que nenhum erro $X$ ocorreu nesses quatro qubits, mas sim que um número par de erros $X$ ocorreu nesses qubits, enquanto um resultado $-1$ indica que um número ímpar de erros $X$ ocorreu. Um único erro $X$, portanto, inverte a paridade dos quatro bits nas duas células que ele toca, fazendo com que as medições dos geradores do estabilizador produzam $-1.$

A seguir, vamos introduzir múltiplos erros $X$ para ver o que acontece. Em particular, consideraremos uma cadeia de erros $X$ adjacentes, onde dois erros $X$ são adjacentes se afetam qubits que tocam a mesma célula.

Os dois geradores do estabilizador $Z$ nas extremidades da cadeia produzem o resultado $-1$ neste caso, pois um número ímpar de erros $X$ ocorreu nessas duas células correspondentes. Todos os outros geradores do estabilizador $Z$, por outro lado, produzem o resultado $+1,$ incluindo os que tocam a cadeia mas não estão nas extremidades, pois um número par de erros $X$ ocorreu nos qubits que tocam as células correspondentes.

Assim, desde que tenhamos uma cadeia de erros $X$ com extremidades, o código tórico detectará que ocorreram erros, resultando em resultados de medição $-1$ para os geradores do estabilizador $Z$ correspondentes às extremidades da cadeia. Observe que a cadeia real de erros não é revelada, apenas as extremidades! Tudo bem — na próxima subseção veremos que não precisamos saber exatamente quais qubits foram afetados por erros $X$ para corrigi-los. (O código tórico é um exemplo de código altamente degenerado, no sentido de que geralmente não identifica de forma única os erros que corrige.)

É, no entanto, possível que uma cadeia de erros $X$ adjacentes não tenha extremidades, ou seja, uma cadeia de erros pode formar um laço fechado, como na figura a seguir.

Nesse caso, um número par de erros $X$ ocorreu em cada célula, portanto toda medição do gerador do estabilizador resulta em um resultado $+1.$ Laços fechados de erros $X$ adjacentes, portanto, não são detectados pelo código.

Isso pode parecer decepcionante, pois precisamos de apenas quatro erros $X$ para formar um laço fechado (e esperamos algo muito melhor do que um código de distância 4). No entanto, um laço fechado de erros $X$ da forma mostrada na figura anterior não é na verdade um erro — pois está no estabilizador! Lembre-se de que, além dos geradores do estabilizador $Z$, também temos um gerador do estabilizador $X$ para cada vértice da malha. E se multiplicarmos geradores do estabilizador $X$ adjacentes, o resultado é que obtemos laços fechados de operações $X$. Por exemplo, o laço fechado na figura anterior pode ser obtido multiplicando os geradores do estabilizador $X$ indicados na figura a seguir.

Este, no entanto, não é o único tipo de laço fechado de erros $X$ que podemos ter — e não é verdade que todo laço fechado de erros $X$ está incluído no estabilizador. Em particular, os diferentes tipos de laços podem ser caracterizados da seguinte forma.

1. Laços fechados de erros $X$ com um número par de erros $X$ em cada linha horizontal e em cada linha vertical de qubits. (O exemplo mostrado acima se enquadra nessa categoria.) Laços dessa forma estão sempre contidos no estabilizador, pois podem ser efetivamente reduzidos a nada multiplicando-os por geradores do estabilizador $X$.

2. Laços fechados de erros $X$ com um número ímpar de erros $X$ em pelo menos uma linha horizontal ou em pelo menos uma linha vertical de qubits. Laços dessa forma nunca estão contidos no estabilizador e, portanto, representam erros não triviais que passam despercebidos pelo código.

Um exemplo de laço fechado de erros $X$ da segunda categoria é mostrado no diagrama a seguir.

Uma cadeia de erros como essa não está contida no estabilizador porque todo gerador do estabilizador $X$ coloca um número par de operações $X$ em cada linha horizontal e em cada linha vertical de qubits. Este é, portanto, um exemplo real de um erro não trivial que o código não consegue detectar.

O ponto-chave é que a única forma de formar um laço do segundo tipo é contornar o toro, seja ao redor do buraco no meio do toro, atravessando-o, ou ambos. Intuitivamente, uma cadeia de erros $X$ como essa não pode ser reduzida a nada multiplicando-a por geradores do estabilizador $X$ porque a topologia de um toro o proíbe. O código tórico é às vezes categorizado como um código de correção de erros quânticos topológico por esse motivo. O comprimento mínimo de um laço desse tipo é $L,$ e portanto essa é a distância do código tórico: qualquer laço fechado de erros $X$ com comprimento menor que $L$ deve se enquadrar na primeira categoria e, portanto, está contido no estabilizador; e qualquer cadeia de erros $X$ com extremidades é detectada pelo código.

Dado que o código tórico usa $2L^2$ qubits para codificar $2$ qubits e tem distância $L,$ segue-se que é um código estabilizador $[[2L^2,2,L]]$.

Correção de erros

Discutimos a detecção de erros para o código tórico, e agora discutiremos brevemente como corrigir erros. O código tórico é um código CSS, portanto erros $X$ e erros $Z$ podem ser detectados e corrigidos de forma independente. Mantendo nosso foco nos geradores do estabilizador $Z$, que detectam erros $X$, vamos considerar como uma cadeia de erros $X$ pode ser corrigida. (Erros $Z$ são corrigidos de forma simétrica.)

Se uma síndrome diferente da síndrome $(+1,\ldots,+1)$ aparecer quando os geradores do estabilizador $Z$ são medidos, os resultados $-1$ revelam as extremidades de uma ou mais cadeias de erros $X$. Podemos tentar corrigir esses erros emparelhando os resultados $-1$ e formando uma cadeia de correções $X$ entre eles. Ao fazer isso, faz sentido escolher os caminhos mais curtos ao longo dos quais as correções são realizadas.

Por exemplo, considere o diagrama a seguir, que representa uma síndrome com dois resultados $-1$, indicados por células cinzas, causada por uma cadeia de erros $X$ ilustrada pela linha e círculos magenta. Como já observamos, a cadeia em si não é revelada pela síndrome; apenas as extremidades são visíveis.

Para tentar corrigir essa cadeia de erros, seleciona-se o caminho mais curto entre os resultados de medição $-1$ e aplicam-se gates $X$ como correções aos qubits ao longo desse caminho (indicado em amarelo na figura). Embora as correções possam não corresponder exatamente à cadeia real de erros, os erros e as correções juntos formam um laço fechado de operações $X$ contido no estabilizador do código. A correção é, portanto, bem-sucedida nessa situação, pois o efeito combinado dos erros e das correções é não fazer nada a um estado codificado.

Essa estratégia nem sempre será bem-sucedida. Por exemplo, uma explicação diferente para a mesma síndrome da figura anterior é mostrada na figura a seguir.

Desta vez, a mesma cadeia de correções de antes falha em corrigir essa cadeia de erros, pois o efeito combinado dos erros e das correções é que obtemos um laço fechado de operações $X$ que contorna o toro e, portanto, tem um efeito não trivial no espaço de código. Portanto, não há garantia de que a estratégia descrita acima — de escolher o caminho mais curto de correções $X$ entre dois resultados de síndrome $-1$ — corrija adequadamente o erro que causou essa síndrome.

Talvez mais provável, dependendo do modelo de ruído, seja que uma síndrome com mais de duas entradas $-1$ seja medida, como sugere a figura a seguir.

Nesse caso, existem diferentes estratégias de correção conhecidas. Uma estratégia natural é tentar emparelhar os resultados de medição $-1$ e realizar correções ao longo dos caminhos mais curtos que conectam os pares, como indicado em amarelo na figura. Em particular, pode-se computar um emparelhamento perfeito de peso mínimo entre os resultados de medição $-1$, e então os pares são conectados por caminhos mais curtos de correções $X$. O cálculo de um emparelhamento perfeito de peso mínimo pode ser feito de forma eficiente com um algoritmo clássico conhecido como algoritmo blossom, descoberto por Edmonds na década de 1960.

Essa abordagem geralmente não é ótima para os modelos de ruído mais comumente estudados, mas com base em simulações numéricas funciona muito bem na prática abaixo de uma taxa de ruído de aproximadamente 10%, assumindo erros de Pauli independentes onde $X,$ $Y,$ e $Z$ são igualmente prováveis. Aumentar $L$ não tem um efeito significativo no ponto de equilíbrio em que o código começa a ajudar, mas leva a uma diminuição mais rápida na probabilidade de um erro lógico à medida que a taxa de erros cai abaixo desse ponto de equilíbrio.