Discretização de erros

Até agora, consideramos erros $X$ e erros $Z$ no contexto do código de Shor de 9 qubits. Nesta seção, vamos considerar erros arbitrários. O que descobriremos é que, para lidar com esses erros, não precisamos fazer nada diferente do que já discutimos; a capacidade de corrigir erros $X$, erros $Z$, ou ambos, implica a capacidade de corrigir erros arbitrários. Esse fenômeno é às vezes chamado de discretização de erros.

Erros unitários em qubits

Vamos começar com erros unitários de qubit único. Por exemplo, esse tipo de erro pode corresponder a uma rotação muito pequena da esfera de Bloch, possivelmente representando um erro causado por um Gate imperfeito, por exemplo. Ou poderia ser qualquer outra operação unitária em um qubit — não necessariamente uma próxima da identidade.

Pode parecer que corrigir esses erros é difícil. Afinal, há infinitos erros possíveis desse tipo, e parece inconcebível que pudéssemos identificar cada erro exatamente e depois desfazê-lo. Porém, desde que possamos corrigir um bit-flip, um phase-flip, ou ambos, teremos sucesso em corrigir um erro unitário arbitrário de qubit único usando os procedimentos descritos anteriormente nesta lição.

Para entender por que isso é verdade, vamos reconhecer primeiro que podemos expressar uma matriz unitária $2 \times 2$ arbitrária $U,$ representando um erro em um único qubit, como uma combinação linear das quatro matrizes de Pauli (incluindo a matriz identidade).

$$U = \alpha \mathbb{I} + \beta X + \gamma Y + \delta Z$$

Como veremos, quando os circuitos de detecção de erros são executados, as medições que nos fornecem os bits de síndrome efetivamente colapsam o estado da codificação de forma probabilística para um estado em que um erro (ou ausência de erro) representado por uma das quatro matrizes de Pauli ocorreu. (Decorre do fato de que $U$ é unitária que os números $\alpha,$ $\beta,$ $\gamma,$ e $\delta$ devem satisfazer $\vert\alpha\vert^2 + \vert\beta\vert^2 + \vert\gamma\vert^2 + \vert\delta\vert^2 = 1,$ e de fato, os valores $\vert\alpha\vert^2,$ $\vert\beta\vert^2,$ $\vert\gamma\vert^2,$ e $\vert\delta\vert^2$ são as probabilidades com as quais o estado codificado colapsa para um estado em que o erro de Pauli correspondente ocorreu.)

Para explicar como isso funciona em mais detalhes, será conveniente usar subscritos para indicar em qual qubit uma dada operação unitária de qubit atua. Por exemplo, usando a convenção de numeração de qubits do Qiskit $(\mathsf{Q}_8,\mathsf{Q}_7,\ldots,\mathsf{Q}_0)$ para numerar os 9 qubits usados no código de Shor, temos estas expressões para várias operações unitárias em qubits únicos, onde em cada caso fazemos o produto tensorial da matriz unitária com a matriz identidade em todos os outros qubits.

$$\begin{aligned} X_0 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes X \\[1.5mm] Z_4 & = \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes Z \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \\[1.5mm] U_7 & = \mathbb{I} \otimes U \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \otimes \mathbb{I} \end{aligned}$$

Portanto, em particular, para uma dada operação unitária de qubit $U,$ podemos especificar a ação de $U$ aplicada ao qubit $k$ pela fórmula a seguir, que é similar à anterior, exceto que cada matriz representa uma operação aplicada ao qubit $k.$

$$U_k = \alpha \mathbb{I}_k + \beta X_k + \gamma Y_k + \delta Z_k$$

Agora suponha que $\vert\psi\rangle$ seja a codificação de 9 qubits de um estado de qubit. Se o erro $U$ ocorrer no qubit $k,$ obtemos o estado $U_k \vert\psi\rangle,$ que pode ser expresso como uma combinação linear de operações de Pauli atuando em $\vert\psi\rangle$ da seguinte forma.

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + \gamma Y_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

Neste ponto, vamos fazer a substituição $Y = iXZ.$

$$U_k \vert\psi\rangle = \alpha \vert\psi\rangle + \beta X_k\vert\psi\rangle + i \gamma X_kZ_k\vert\psi\rangle + \delta Z_k\vert\psi\rangle$$

Agora considere as etapas de detecção e correção de erros descritas anteriormente. Podemos pensar nos resultados das medições para as três verificações de paridade do código interno, junto com a do código externo, coletivamente como uma única síndrome consistindo de 8 bits. Logo antes das medições efetivas na base padrão que produzem esses bits de síndrome, o estado tem a seguinte forma.

$$\begin{gathered} \alpha\,\vert \mathbb{I} \text{ syndrome}\rangle \otimes \vert\psi\rangle \\ + \beta\,\vert X_k \text{ syndrome}\rangle \otimes X_k\vert\psi\rangle \\ + i \gamma\,\vert X_k Z_k \text{ syndrome}\rangle \otimes X_k Z_k\vert\psi\rangle \\ + \delta\,\vert Z_k \text{ syndrome}\rangle \otimes Z_k\vert\psi\rangle \end{gathered}$$

Para ficar claro, temos dois sistemas neste ponto. O sistema à esquerda são os 8 qubits que mediremos para obter a síndrome, onde $\vert \mathbb{I} \text{ syndrome}\rangle,$ $\vert X_k \text{ syndrome}\rangle,$ e assim por diante, referem-se a qualquer estado de base padrão de 8 qubits consistente com o erro correspondente (ou ausência de erro). O sistema à direita são os 9 qubits que estamos usando para a codificação.

Observe que esses dois sistemas estão agora correlacionados (em geral), e esta é a chave para entender por que isso funciona. Ao medir a síndrome, o estado dos 9 qubits à direita efetivamente colapsa para um estado no qual um erro de Pauli consistente com a síndrome medida foi aplicado a um dos qubits. Além disso, a própria síndrome fornece informação suficiente para que possamos desfazer o erro e recuperar a codificação original $\vert\psi\rangle.$

Em particular, se os qubits de síndrome são medidos e as correções apropriadas são feitas, obtemos um estado que pode ser expresso como uma matriz de densidade,

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

onde

$$\begin{aligned} \xi = & \vert\alpha\vert^2 \vert \mathbb{I} \text{ syndrome}\rangle\langle \mathbb{I} \text{ syndrome}\vert \\[1mm] & + \vert\beta\vert^2 \vert X_k \text{ syndrome}\rangle\langle X_k \text{ syndrome}\vert\\[1mm] & + \vert\gamma\vert^2 \vert X_k Z_k \text{ syndrome}\rangle\langle X_k Z_k \text{ syndrome}\vert\\[1mm] & + \vert\delta\vert^2 \vert Z_k \text{ syndrome}\rangle\langle Z_k \text{ syndrome}\vert. \end{aligned}$$

Crucialmente, este é um estado produto: temos nossa codificação original e não corrompida como o fator tensorial à direita, e à esquerda temos uma matriz de densidade $\xi$ que descreve uma síndrome de erro aleatória. Não há mais nenhuma correlação com o sistema à direita, que é o que nos importa, pois os erros foram corrigidos. Neste ponto, podemos descartar os qubits de síndrome ou redefini-los para reutilizá-los. É assim que a aleatoriedade — ou entropia — criada pelos erros é removida do sistema.

Esta é a discretização de erros para o caso especial de erros unitários. Em essência, ao medir a síndrome, efetivamente projetamos o erro para um erro descrito por uma matriz de Pauli.

À primeira vista, pode parecer bom demais para ser verdade que possamos corrigir erros unitários arbitrários dessa forma, até mesmo erros minúsculos e quase imperceptíveis por si só. Mas o que é importante perceber aqui é que este é um erro unitário em um único qubit e, pelo design do código, uma operação de qubit único não pode alterar o estado do qubit lógico que foi codificado. Tudo o que ela pode fazer é mover o estado para fora do subespaço de codificações válidas, mas então as detecções de erro colapsam o estado e as correções o trazem de volta ao ponto inicial.

Erros arbitrários em qubits

Por fim, vamos considerar erros arbitrários que não são necessariamente unitários. Para ser preciso, vamos considerar um erro descrito por um canal de qubit arbitrário $\Phi.$ Por exemplo, este poderia ser um canal de dephasing ou depolarizing, um canal de reset, ou um canal incomum que nunca consideramos antes.

O primeiro passo é considerar qualquer representação de Kraus de $\Phi.$

$$\Phi(\sigma) = \sum_j A_j \sigma A_j^{\dagger}$$

Este é um canal de qubit, portanto cada $A_j$ é uma matriz $2\times 2$, que podemos expressar como uma combinação linear de matrizes de Pauli.

$$A_j = \alpha_j \mathbb{I} + \beta_j X + \gamma_j Y + \delta_j Z$$

Isso nos permite expressar a ação do erro $\Phi$ em um qubit escolhido $k$ em termos de matrizes de Pauli da seguinte forma.

$$\Phi_k \bigl( \vert\psi\rangle\langle\psi\vert\bigr) = \sum_j (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k) \vert\psi\rangle\langle\psi\vert (\alpha_j \mathbb{I}_k + \beta_j X_k + \gamma_j Y_k + \delta_j Z_k)^{\dagger}$$

Em resumo, simplesmente expandimos todas as nossas matrizes de Kraus como combinações lineares de matrizes de Pauli.

Se agora computarmos e medirmos a síndrome de erro, e corrigirmos quaisquer erros que forem revelados, obteremos um estado similar ao que tínhamos no caso do erro unitário:

$$\xi \otimes \vert\psi\rangle\langle\psi\vert,$$

onde desta vez temos

$$\begin{aligned} \xi = & \sum_j \Bigl(\vert\alpha_j\vert^2 \vert \mathbb{I} \text{ syndrome}\rangle\langle \mathbb{I} \text{ syndrome}\vert \\[-3mm] & \qquad + \vert\beta_j\vert^2 \vert X_k \text{ syndrome}\rangle\langle X_k \text{ syndrome}\vert\\[2mm] & \qquad + \vert\gamma_j\vert^2 \vert X_k Z_k \text{ syndrome}\rangle\langle X_k Z_k \text{ syndrome}\vert\\[2mm] & \qquad + \vert\delta_j\vert^2 \vert Z_k \text{ syndrome}\rangle\langle Z_k \text{ syndrome}\vert \Bigr). \end{aligned}$$

Os detalhes são um pouco mais complicados e não são apresentados aqui. Conceitualmente, a ideia é idêntica ao caso unitário.

Generalização

A discretização de erros se generaliza para outros códigos de correção de erros quânticos, incluindo aqueles que podem detectar e corrigir erros em múltiplos qubits. Nesses casos, erros em múltiplos qubits podem ser expressos como produtos tensoriais de matrizes de Pauli, e correspondentemente diferentes síndromes especificam correções de operações de Pauli que podem ser realizadas em múltiplos qubits, em vez de apenas um.

Novamente, ao medir a síndrome, os erros são efetivamente projetados ou colapsados em um conjunto discreto de possibilidades representadas por produtos tensoriais de matrizes de Pauli, e ao corrigir esses erros de Pauli, podemos recuperar o estado codificado original. Enquanto isso, qualquer aleatoriedade gerada no processo é movida para os qubits de síndrome, que são descartados ou redefinidos, removendo assim do sistema a aleatoriedade gerada neste processo que armazena a codificação.