Controlando a propagação de erros

A computação quântica tolerante a falhas é semelhante a uma corrida entre erros e correção de erros. Se o número de erros for pequeno o suficiente, a correção de erros os corrigirá com sucesso; mas se houver erros demais, a correção de erros falhará.

Por essa razão, deve-se ter cuidado suficiente com a forma como as computações quânticas são realizadas em implementações tolerantes a falhas de circuitos, para controlar a propagação de erros. Ou seja, um erro em um qubit pode potencialmente se propagar para múltiplos qubits pela ação de gates em um circuito quântico, o que pode fazer com que o número de erros aumente drasticamente. Essa é uma preocupação primordial, pois se não conseguirmos controlar a propagação de erros, nossos esforços de correção de erros serão rapidamente sobrecarregados. Se, por outro lado, conseguirmos manter a propagação de erros sob controle, então a correção de erros terá uma boa chance de acompanhar, permitindo que os erros sejam corrigidos a uma taxa alta o suficiente para que a computação quântica funcione como pretendido.

O ponto de partida para uma discussão técnica desse problema é o reconhecimento de que gates de dois qubits (ou gates de múltiplos qubits de forma mais geral) podem propagar erros, mesmo quando funcionam perfeitamente. Por exemplo, considere um gate CNOT e suponha que um erro $X$ ocorre no qubit de controle imediatamente antes de o gate CNOT ser executado. Como já observamos na lição "Corrigindo erros quânticos", isso é equivalente a um erro $X$ ocorrendo em ambos os qubits após o CNOT ser executado. E a situação é semelhante para um erro $Z$ atuando no alvo em vez do controle antes de o gate CNOT ser executado.

Isso é uma propagação de erros, porque a localização infeliz de um erro $X$ ou $Z$ antes do gate CNOT efetivamente o transforma em dois erros após o gate CNOT. Isso acontece mesmo quando o gate CNOT é perfeito, e não devemos esquecer que um dado gate CNOT pode ser ruidoso, o que pode criar erros correlacionados em dois qubits.

Adicionando à nossa preocupação está o fato de que gates de dois qubits subsequentes podem propagar esses erros ainda mais, como a figura a seguir sugere.

Em certo sentido, nunca podemos evitar isso; enquanto usarmos gates de múltiplos qubits, haverá potencial para propagação de erros. No entanto, como discutiremos nas subseções a seguir, passos podem ser tomados para limitar o dano causado, permitindo que erros propagados sejam gerenciados.

Implementações transversais de gates

A maneira mais simples conhecida de mitigar a propagação de erros em circuitos quânticos tolerantes a falhas é implementar gates transversalmente, o que significa construir gadgets para eles que tenham uma certa forma simples. Especificamente, os gadgets devem ser um produto tensorial de operações (ou, em outras palavras, um circuito quântico de profundidade um), onde cada operação só pode atuar em uma única posição de qubit dentro de cada bloco de código que toca. Talvez seja mais fácil explicar isso por meio de alguns exemplos.

Exemplos de implementações transversais de gates

Considere a figura a seguir, que sugere uma implementação transversal de um gate CNOT. (Essa implementação específica, onde CNOTs são realizados qubit por qubit, só funciona para códigos CSS — mas de fato funciona para todos os códigos CSS.)

Há dois blocos de código nessa figura, cada um representado como composto de cinco qubits (embora pudesse ser mais, como já foi sugerido). O circuito à direita tem profundidade um, e cada um dos gates CNOT atua em uma única posição de qubit dentro de cada bloco: tanto o controle quanto o alvo do primeiro CNOT é o qubit mais ao topo (isto é, qubit 0 usando a convenção de numeração do Qiskit), tanto o controle quanto o alvo do segundo CNOT é o qubit segundo a partir do topo (isto é, qubit 1), e assim por diante. Portanto, este é um gadget transversal.

Para um segundo exemplo — na verdade uma classe de exemplos — considere qualquer gate de Pauli. Gates de Pauli sempre podem ser implementados transversalmente, para qualquer código estabilizador, construindo gadgets compostos de operações de Pauli. Em particular, toda operação de Pauli em um qubit lógico codificado por um código estabilizador pode ser implementada transversalmente escolhendo uma operação de Pauli apropriada nos qubits físicos usados para a codificação. Isso é consistente com um fato mencionado de passagem na lição "Formalismo estabilizador": a menos de uma fase global, operações de Pauli que comutam com todo gerador estabilizador de um código estabilizador agem como operações de Pauli no qubit ou qubits codificados por esse código.

Como exemplo específico, considere o código Shor de $9$ qubits, para o qual os estados da base padrão podem ser codificados da seguinte forma.

$$\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) \\[3mm] \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}$$

Um gate $X$ no qubit lógico codificado por este código pode ser implementado transversalmente pela operação de Pauli de $9$ qubits

$$Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I}$$

enquanto um gate $Z$ no qubit lógico pode ser implementado transversalmente pela operação de Pauli de $9$ qubits

$$X \otimes X \otimes X \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I}.$$

Ambas essas operações de Pauli têm peso $3,$ que é o peso mínimo necessário. (O código Shor de $9$ qubits tem distância $3,$ portanto qualquer operação de Pauli não identidade de peso $2$ ou menos é detectada como um erro.)

E, para um terceiro exemplo, o código Steane de $7$ qubits (e de fato todo código de cores) permite uma implementação transversal de todos os gates de Clifford. Já vimos como os gates CNOT são implementados transversalmente para qualquer código CSS, então resta considerar os gates $H$ e $S$. Um gate de Hadamard aplicado a todos os $7$ qubits do código Steane é equivalente a $H$ sendo aplicado ao qubit lógico que ele codifica, enquanto um gate $S^{\dagger}$ (em oposição a um gate $S$) aplicado a todos os $7$ qubits é equivalente a um gate $S$ lógico.

Propagação de erros para gadgets transversais

Agora que sabemos o que são implementações transversais de gates, vamos discutir sua relação com a propagação de erros.

Para uma implementação transversal de um gate de qubit único, simplesmente temos um produto tensorial de gates de qubit único em nosso gadget, que atua em um bloco de código de qubits físicos para o código de correção de erros quânticos escolhido. Embora qualquer um desses gates possa falhar e introduzir um erro, não haverá propagação de erros porque nenhum gate de múltiplos qubits está envolvido. Imediatamente após o gadget ser aplicado, a correção de erros é realizada; e se o número de erros introduzidos pelo gadget (ou enquanto o gadget está sendo executado) for suficientemente pequeno, os erros serão corrigidos. Portanto, se a taxa de erros introduzidos por gates defeituosos for suficientemente pequena, a correção de erros tem uma boa chance de ser bem-sucedida.

Para uma implementação transversal de um gate de dois qubits, por outro lado, há o potencial para uma propagação de erros — simplesmente não há como evitar isso, como já observamos. O ponto essencial, no entanto, é que um gadget transversal nunca pode causar uma propagação de erros dentro de um único bloco de código.

Por exemplo, considerando a implementação transversal de um gate CNOT para um código CSS descrita acima, um erro $X$ poderia ocorrer no qubit do topo do bloco de código superior logo antes do gadget ser executado, e o primeiro CNOT dentro do gadget propagará esse erro para o qubit do topo no bloco inferior. No entanto, os dois erros resultantes estão agora em blocos de código separados. Portanto, assumindo que nosso código pode corrigir um erro $X$, os passos de correção de erros que ocorrem após o gadget corrigirão os dois erros $X$ individualmente — porque apenas um único erro ocorre dentro de cada bloco de código. Em contraste, se a propagação de erros ocorresse dentro do mesmo bloco de código, poderia transformar um erro de baixo peso em um erro de alto peso que o código não consegue lidar.

Não-universalidade dos gates transversais

Para dois códigos estabilizadores diferentes, pode ser que um gate específico possa ser implementado transversalmente com um código, mas não com o outro. Por exemplo, embora não seja possível implementar um gate $T$ transversalmente usando o código Steane de $7$ qubits, há outros códigos para os quais isso é possível.

Infelizmente, nunca é possível, para qualquer código de correção de erros quânticos não trivial, implementar um conjunto universal de gates transversalmente. Esse fato é conhecido como o teorema de Eastin-Knill.

Teorema

Teorema de Eastin-Knill: Para qualquer código de correção de erros quânticos com distância pelo menos 2, o conjunto de gates lógicos que podem ser implementados transversalmente gera um conjunto de operações que (a menos de uma fase global) é discreto e, portanto, não é universal.

A prova deste teorema não será explicada aqui. (Não é uma prova complicada, mas requer um conhecimento básico de grupos de Lie e álgebras de Lie, que não estão entre os pré-requisitos da série.) A ideia básica, no entanto, pode ser transmitida em termos intuitivos: Famílias infinitas de operações transversais não podem permanecer dentro do espaço de código de um código não trivial porque pequenas diferenças em operações transversais são bem aproximadas por operações de Pauli de baixo peso, que o código detecta como erros.

Em resumo, os gadgets transversais oferecem uma implementação simples e intrinsecamente tolerante a falhas de gates — mas para qualquer escolha razoável de código de correção de erros quânticos, nunca haverá um conjunto universal de gates que possa ser implementado dessa forma, o que torna necessário o uso de gadgets alternativos.

Estados mágicos

Dado que não é possível, para qualquer escolha não trivial de código de correção de erros quânticos, implementar um conjunto universal de gates quânticos transversalmente, devemos considerar outros métodos para implementar gates de forma tolerante a falhas. Um método bem conhecido é baseado na noção de estados mágicos, que são estados quânticos de qubits que permitem implementações tolerantes a falhas de certos gates.

Implementando gates com estados mágicos

Vamos começar considerando os gates $S$ e $T$, que têm as seguintes descrições matriciais.

$$S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/2} \end{pmatrix} \qquad\text{e}\qquad T = \begin{pmatrix} 1 & 0\\ 0 & \frac{1+i}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 & 0\\ 0 & e^{i\pi/4} \end{pmatrix}$$

Por definição, $S$ é uma operação de Clifford, enquanto $T$ não é; não é possível implementar um gate $T$ com um circuito composto de gates de Clifford (gates $H$, gates $S$ e gates CNOT).

No entanto, é possível implementar um gate $T$ (a menos de uma fase global) com um circuito composto de gates de Clifford se, além disso, tivermos uma cópia do estado

$$T\vert {+} \rangle = \frac{1}{\sqrt{2}} \vert 0 \rangle + \frac{e^{i\pi/4}}{\sqrt{2}} \vert 1\rangle,$$

e permitirmos medições na base padrão e que os gates sejam controlados classicamente. Em particular, o circuito a seguir mostra uma maneira de fazer isso. O fenômeno em exibição aqui é um exemplo um tanto simplificado de teleportação de gate quântico.

Para verificar que este circuito funciona corretamente, podemos primeiro calcular a ação do gate CNOT na entrada.

$$T \vert {+} \rangle \otimes \vert\psi\rangle \stackrel{\text{CNOT}}{\longmapsto} \frac{1}{\sqrt{2}} \vert 0\rangle \otimes T \vert \psi\rangle + \frac{1+i}{2} \vert 1\rangle \otimes T^{\dagger} \vert \psi\rangle$$

A medição, portanto, dá os resultados $0$ e $1$ com probabilidade igual. Se o resultado for $0,$ o gate $S$ não é executado e o estado de saída é $T\vert\psi\rangle;$ e se o resultado for $1,$ o gate $S$ é executado e o estado de saída é $ST^{\dagger}\vert\psi\rangle = T\vert \psi\rangle.$

O estado $T\vert {+}\rangle$ é chamado de estado mágico neste contexto, embora não seja único a esse respeito: outros estados também são chamados de estados mágicos quando podem ser usados de forma semelhante (possivelmente para gates diferentes e usando circuitos diferentes). Por exemplo, trocando o estado $T\vert{+}\rangle$ pelo estado $S\vert{+}\rangle$ e substituindo o gate $S$ no circuito acima por um gate $Z$, implementa-se um gate $S$ — o que é potencialmente útil para computação quântica tolerante a falhas usando um código para o qual os gates $S$ não podem ser implementados transversalmente.

Gadgets tolerantes a falhas a partir de estados mágicos

Pode não ser claro que usar estados mágicos para implementar gates seja útil para a tolerância a falhas. Para a implementação do gate $T$ descrita acima, por exemplo, parece que ainda precisamos aplicar um gate $T$ a um estado $\vert{+}\rangle$ para obter um estado mágico, que então usamos para implementar um gate $T$. Então, qual é a vantagem de usar essa abordagem para tolerância a falhas?

Aqui estão três pontos-chave que fornecem uma resposta a essa pergunta.

1. A criação de estados mágicos não necessita da aplicação do gate que estamos tentando implementar a um estado específico. Por exemplo, aplicar um gate $T$ a um estado $\vert {+} \rangle$ não é a única forma de obter um estado $T\vert{+}\rangle$.

2. A criação de estados mágicos pode ser feita separadamente da computação em que são usados. Isso significa que os erros que surgem no processo de criação do estado mágico não se propagarão para a computação real que está sendo realizada.

3. Se os gates individuais no circuito que implementa um gate escolhido usando um estado mágico puderem ser implementados de forma tolerante a falhas, e assumirmos a disponibilidade de estados mágicos, obtemos uma implementação tolerante a falhas do gate escolhido.

Para simplificar a discussão a seguir, vamos nos concentrar nos gates $T$ especificamente — tendo em mente que a metodologia pode ser estendida a outros gates. Uma implementação tolerante a falhas de um gate $T$ usando estados mágicos tem a forma sugerida pela figura a seguir.

Os qubits no circuito original do gate $T$ correspondem a qubits lógicos neste diagrama, que são codificados pelo código que estamos usando para tolerância a falhas. As entradas e saídas no diagrama devem, portanto, ser entendidas como codificações desses estados. Isso significa, em particular, que na verdade não precisamos apenas de estados mágicos — precisamos de estados mágicos codificados. Os gates no circuito original do gate $T$ são aqui substituídos por gadgets, que assumimos serem tolerantes a falhas.

Esta figura específica, portanto, sugere que já temos gadgets tolerantes a falhas para gates CNOT e gates $S$. Para um código de cores, esses gadgets poderiam ser transversais; para um código de superfície (ou qualquer outro código CSS), o CNOT pode ser executado transversalmente, enquanto o gadget do gate $S$ poderia ser implementado usando estados mágicos, como foi sugerido anteriormente ser possível. (A figura também sugere que temos um gadget tolerante a falhas para realizar uma medição na base padrão, que ignoramos até agora. Isso poderia ser de fato desafiador para alguns códigos selecionados para torná-lo assim, mas para um código CSS é uma questão de medir cada qubit físico seguido de pós-processamento clássico.)

A implementação é, portanto, tolerante a falhas, assumindo que temos uma codificação de um estado mágico $T\vert{+}\rangle.$ Mas ainda não abordamos a questão de como obtemos uma codificação desse estado. Uma forma de obter estados mágicos codificados (ou, talvez mais precisamente, de torná-los melhores) é através de um processo conhecido como destilação de estados mágicos. O diagrama a seguir ilustra como este processo parece no nível mais alto.

Em palavras, uma coleção de estados mágicos codificados ruidosos é alimentada em um tipo especial de circuito conhecido como destilador. Todos os blocos de saída, exceto um, são medidos — o que significa que qubits lógicos são medidos com medições na base padrão. Se qualquer um dos resultados de medição for $1,$ o processo falhou e deve ser reiniciado. Se, no entanto, todos os resultados de medição forem $0,$ o estado resultante do bloco de código do topo será um estado mágico codificado com menos ruído. Esse estado poderia então se juntar a mais quatro como entradas em outro destilador, ou ser usado para implementar um gate $T$ se for considerado suficientemente próximo de um verdadeiro estado mágico codificado. É claro que o processo deve começar em algum lugar, sendo uma possibilidade prepará-los de forma não tolerante a falhas.

Há diferentes formas conhecidas de construir o próprio destilador, mas elas não serão explicadas ou analisadas aqui. Em um nível lógico, a abordagem típica — de forma notável e um tanto coincidente — é executar um circuito de codificação para um código estabilizador ao contrário! Esse poderia, de fato, ser um código estabilizador diferente do usado para correção de erros. Por exemplo, poderia-se potencialmente usar um código de superfície ou de cores para correção de erros, mas executar um codificador para o código de $5$ qubits ao contrário para fins de destilação de estados mágicos. Circuitos de codificação para códigos estabilizadores requerem apenas gates de Clifford, o que simplifica a implementação tolerante a falhas de um destilador. Na prática, os detalhes dependem dos códigos que são usados.

Em resumo, esta seção visou fornecer apenas uma discussão de altíssimo nível sobre estados mágicos, com a intenção de fornecer apenas uma ideia básica de como funciona. Às vezes é afirmado que a sobrecarga para usar estados mágicos para implementar gates de forma tolerante a falhas nesses moldes seria extremamente alta, com a grande maioria do trabalho indo para o processo de destilação. No entanto, isso na verdade não é tão claro — há muitas formas potenciais de otimizar esses processos. Há, além disso, abordagens alternativas para construir gadgets tolerantes a falhas para gates que não podem ser implementados transversalmente. Por exemplo, deformação de código e troca de código são palavras-chave associadas a alguns desses esquemas — e novas formas continuam sendo desenvolvidas e refinadas.

Correção de erros tolerante a falhas

Além da implementação dos vários gadgets necessários para uma implementação tolerante a falhas de um dado circuito quântico, há outro problema importante que deve ser reconhecido: a implementação dos próprios passos de correção de erros. Isso remonta à ideia de que tudo que envolve informação quântica é suscetível a erros — incluindo os próprios circuitos que têm como objetivo corrigir erros.

Considere, por exemplo, o tipo de circuito descrito na lição "O formalismo estabilizador" para medir geradores estabilizadores de forma não destrutiva usando estimação de fase. Esses circuitos claramente não são tolerantes a falhas porque podem fazer com que erros se propaguem dentro do bloco de código em que operam. Isso pode parecer bastante problemático, mas há múltiplas formas conhecidas de realizar a correção de erros de forma tolerante a falhas, sem que erros se propaguem dentro dos blocos de código sendo corrigidos.

Um método é conhecido como correção de erros de Shor, pois foi descoberto pela primeira vez por Peter Shor. A ideia é realizar medições de síndrome usando um chamado estado gato, que é um estado de $n$ qubits da forma

$$\frac{1}{\sqrt{2}} \vert 0^n \rangle + \frac{1}{\sqrt{2}} \vert 1^n \rangle,$$

onde $0^n$ e $1^n$ se referem às cadeias de todos zeros e todos uns de comprimento $n.$ Por exemplo, este é um estado $\vert\phi^+\rangle$ quando $n=2$ e um estado GHZ quando $n=3,$ mas em geral, a correção de erros de Shor requer um estado como esse para $n$ sendo o peso do gerador estabilizador sendo medido.

Como exemplo, o circuito mostrado aqui mede um gerador estabilizador da forma $P_2\otimes P_1 \otimes P_0.$

Isso requer a construção do próprio estado gato e, para fazê-lo funcionar de forma confiável na presença de erros e gates potencialmente defeituosos, o método requer de fato a execução repetida de circuitos como esse para fazer inferências sobre onde diferentes erros podem ter ocorrido durante o processo.

Um método alternativo é conhecido como correção de erros de Steane. Este método funciona de forma diferente e só funciona para códigos CSS. A ideia é que na verdade não realizamos as medições de síndrome nos estados quânticos codificados no circuito que estamos tentando executar, mas em vez disso intencionalmente propagamos erros para um sistema de espaço de trabalho e então medimos esse sistema e classicamente detectamos os erros. Os diagramas de circuito a seguir ilustram como isso pode ser feito para detectar erros $X$ e $Z$, respectivamente.

Um método relacionado conhecido como correção de erros de Knill estende este método a códigos estabilizadores arbitrários usando teleportação.