Códigos CSS

Códigos lineares clássicos

Os códigos de correção de erros clássicos foram estudados pela primeira vez na década de 1940, e hoje se conhecem muitos códigos diferentes. Os mais amplamente estudados e utilizados pertencem a uma categoria conhecida como códigos lineares. Vamos entender em breve o que a palavra "linear" significa nesse contexto, mas uma forma muito simples de descrever os códigos lineares é que eles são códigos estabilizadores que, por acaso, são clássicos. Os códigos CSS são, essencialmente, pares de códigos lineares clássicos combinados para criar um código de correção de erros quânticos. Portanto, para a discussão a seguir, precisamos entender alguns conceitos básicos sobre códigos lineares clássicos.

Seja $\Sigma$ o alfabeto binário para toda esta discussão. Quando nos referimos a um código linear clássico, queremos dizer um conjunto não vazio $\mathcal{C}\subseteq\Sigma^n$ de strings binárias de comprimento $n,$ para algum inteiro positivo $n,$ que deve satisfazer apenas uma propriedade básica: se $u$ e $v$ são strings binárias em $\mathcal{C},$ então a string $u\oplus v$ também está em $\mathcal{C}.$ Aqui, $u\oplus v$ denota o OU exclusivo bit a bit de $u$ e $v,$ como vimos várias vezes no curso "Fundamentos de algoritmos quânticos".

Em essência, quando nos referimos a um código de correção de erros clássico como linear, estamos pensando em strings binárias de comprimento $n$ como vetores de $n$ dimensões, onde as entradas são $0$ ou $1,$ e exigindo que o próprio código forme um subespaço linear. Em vez da adição vetorial ordinária sobre os reais ou os complexos, utilizamos a adição módulo $2,$ que é simplesmente o OU exclusivo. Ou seja, se temos duas palavras-código $u$ e $v,$ significando que $u$ e $v$ são strings binárias em $\mathcal{C},$ então $u + v$ módulo 2, isto é, $u\oplus v,$ também deve ser uma palavra-código em $\mathcal{C}.$ Note, em particular, que essa implicação deve ser verdadeira mesmo quando $u = v.$ Isso implica que $\mathcal{C}$ deve incluir a string de zeros $0^n,$ pois o OU exclusivo bit a bit de qualquer string consigo mesma é a string de zeros.

Exemplo: o código de repetição de 3 bits

O código de repetição de 3 bits é um exemplo de código linear clássico. Em particular, temos $\mathcal{C} = \{000,111\},$ portanto, com relação à condição de linearidade, há apenas duas escolhas possíveis para $u$ e duas para $v.$ É simples verificar os quatro pares possíveis e confirmar que sempre obtemos uma palavra-código ao calcular o OU exclusivo bit a bit:

$$000 \oplus 000 = 000, \quad 000 \oplus 111 = 111, \quad 111 \oplus 000 = 111, \quad 111 \oplus 111 = 000.$$

Exemplo: o código de Hamming $[7,4,3]$

Aqui está outro exemplo de código linear clássico chamado código de Hamming $[7,4,3]$. Foi um dos primeiros códigos de correção de erros clássicos já descobertos, e consiste nestas 16 strings binárias de comprimento 7. (Às vezes, o código de Hamming $[7,4,3]$ é entendido como o código com essas strings invertidas, mas vamos considerá-lo como o código contendo as strings mostradas aqui.)

$$\begin{array}{cccc} 0000000 & 1100001 & 1010010 & 0110011\\[1mm] 0110100 & 1010101 & 1100110 & 0000111\\[1mm] 1111000 & 0011001 & 0101010 & 1001011\\[1mm] 1001100 & 0101101 & 0011110 & 1111111 \end{array}$$

Há uma lógica muito simples por trás da seleção dessas strings, mas ela é secundária ao conteúdo da lição e não será explicada aqui. Por enquanto, basta observar que este é um código linear clássico: calcular o XOR de quaisquer duas dessas strings sempre resultará em outra string do código.

A notação $[7,4,3]$ (entre colchetes simples) tem um significado análogo à notação de colchetes duplos para códigos estabilizadores mencionada na lição anterior, mas aqui se aplica a códigos lineares clássicos. Em particular, as palavras-código têm $7$ bits, podemos codificar $4$ bits usando o código (pois há $16 = 2^4$ palavras-código), e esse é um código de distância $3$, o que significa que quaisquer duas palavras-código distintas diferem em pelo menos $3$ posições — ou seja, pelo menos $3$ bits precisam ser invertidos para transformar uma palavra-código em outra. O fato de ser um código de distância $3$ implica que ele pode corrigir até um erro de inversão de bit.

Descrevendo códigos lineares clássicos

Os exemplos mencionados são exemplos muito simples de códigos lineares clássicos, mas mesmo o código de Hamming $[7,4,3]$ parece um pouco misterioso quando as palavras-código são simplesmente listadas. Existem formas melhores e mais eficientes de descrever códigos lineares clássicos, incluindo as duas a seguir.

1. Geradores. Uma forma de descrever um código linear clássico é com uma lista mínima de palavras-código que geram o código, significando que, ao considerar todos os subconjuntos possíveis dessas palavras-código e calcular seus XORs, obtemos o código inteiro.

   Em maior detalhe, as strings $u_1,\ldots,u_m\in\Sigma^n$ geram o código linear clássico $\mathcal{C}$ se

   $$\mathcal{C} = \bigl\{\alpha_1 u_1 \oplus \cdots \oplus \alpha_m u_m\,:\,\alpha_1,\ldots,\alpha_m\in\{0,1\}\bigr\},$$

   com o entendimento de que $\alpha u = u$ quando $\alpha = 1$ e $\alpha u = 0^n$ quando $\alpha = 0,$ e dizemos que essa lista é mínima se a remoção de uma das strings gera um código menor. Uma forma natural de pensar nessa descrição é que a coleção $\{u_1,\ldots,u_m\}$ forma uma base para $\mathcal{C}$ como subespaço, onde pensamos nas strings como vetores com entradas binárias, lembrando que estamos trabalhando em um espaço vetorial onde a aritmética é feita módulo $2.$

2. Verificações de paridade. Outra forma natural de descrever um código linear clássico é por meio de verificações de paridade — ou seja, uma lista mínima de strings binárias tais que as strings no código são precisamente aquelas cujo produto escalar binário com cada uma dessas strings de verificação de paridade é zero. (Similar ao OU exclusivo bit a bit, o produto escalar binário apareceu várias vezes em "Fundamentos de algoritmos quânticos".)

   Ou seja, as strings $v_1,\ldots,v_r\in\Sigma^n$ são strings de verificação de paridade para o código linear clássico $\mathcal{C}$ se

   $$\mathcal{C} = \bigl\{ u\in \Sigma^n\,:\, u\cdot v_1 = \cdots = u \cdot v_r = 0 \bigr\},$$

   e esse conjunto de strings é mínimo se a remoção de uma resulta em um código maior. Essas são chamadas de strings de verificação de paridade porque $u$ tem produto escalar binário igual a zero com $v$ se e somente se os bits de $u$ nas posições onde $v$ tem 1s têm paridade par. Portanto, para determinar se uma string $u$ está no código $\mathcal{C},$ basta verificar a paridade de certos subconjuntos dos bits de $u.$

   Uma coisa importante a observar é que o produto escalar binário não é um produto interno no sentido formal. Em particular, quando duas strings têm produto escalar binário igual a zero, isso não significa que elas são ortogonais da forma que normalmente pensamos em ortogonalidade. Por exemplo, o produto escalar binário da string $11$ consigo mesma é zero — portanto, é possível que uma string de verificação de paridade de um código linear clássico esteja ela própria no código.

Os códigos lineares clássicos sobre o alfabeto binário sempre incluem um número de strings que é uma potência de $2$ — e para um único código linear clássico descrito das duas formas acima, sempre teremos $n = m + r.$ Em particular, se temos um conjunto mínimo de $m$ geradores, então o código codifica $m$ bits e necessariamente teremos $2^m$ palavras-código; e se temos um conjunto mínimo de $r$ strings de verificação de paridade, então teremos $2^{n-r}$ palavras-código. Portanto, cada gerador dobra o tamanho do espaço do código enquanto cada string de verificação de paridade reduz o tamanho à metade.

Por exemplo, o código de repetição de 3 bits é um código linear, portanto pode ser descrito de ambas as formas. Em particular, há apenas uma escolha de gerador que funciona: $111.$ Como alternativa, podemos descrever o código com duas strings de verificação de paridade, como $110$ e $011$ — que devem parecer familiares das nossas discussões anteriores sobre esse código — ou poderíamos escolher as strings de verificação de paridade $110$ e $101,$ ou $101$ e $011.$ (Geradores e strings de verificação de paridade geralmente não são únicos para um dado código linear clássico.)

Para um segundo exemplo, considere o código de Hamming $[7,4,3]$. Aqui está uma escolha de lista de geradores que funciona.

$$\begin{array}{c} 1111000\\[1mm] 0110100\\[1mm] 1010010\\[1mm] 1100001 \end{array}$$

E aqui está uma escolha de lista de verificações de paridade para esse código.

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Aqui, aliás, observamos que todas as nossas strings de verificação de paridade estão elas próprias no código.

Uma observação final sobre os códigos lineares clássicos, que os conecta ao formalismo estabilizador, é que as strings de verificação de paridade são equivalentes a geradores estabilizadores compostos apenas por matrizes de Pauli $Z$ e identidade. Por exemplo, as strings de verificação de paridade $110$ e $011$ para o código de repetição de 3 bits correspondem precisamente aos geradores estabilizadores $Z\otimes Z\otimes \mathbb{I}$ e $\mathbb{I}\otimes Z\otimes Z,$ o que é consistente com as discussões sobre observáveis de Pauli da lição anterior.

Definição de códigos CSS

Os códigos CSS são códigos estabilizadores obtidos pela combinação de certos pares de códigos lineares clássicos. Isso não funciona para dois códigos lineares clássicos arbitrários — os dois códigos devem ter uma certa relação. Ainda assim, essa construção abre muitas possibilidades para códigos de correção de erros quânticos, com base em mais de 75 anos de teoria de codificação clássica.

No formalismo estabilizador, os geradores estabilizadores contendo apenas matrizes de Pauli $Z$ e identidade são equivalentes a verificações de paridade, como acabamos de observar para o código de repetição de 3 bits. Para outro exemplo, considere as seguintes strings de verificação de paridade para o código de Hamming $[7,4,3]$.

$$\begin{array}{c} 1111000\\[1mm] 1100110\\[1mm] 1010101 \end{array}$$

Essas strings de verificação de paridade correspondem aos seguintes geradores estabilizadores (escritos sem símbolos de produto tensorial), que obtemos substituindo cada $1$ por um $Z$ e cada $0$ por um $\mathbb{I}.$ Esses são três dos seis geradores estabilizadores para o código de Steane de 7 qubits.

$$\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 \end{array}$$

Vamos dar o nome de geradores estabilizadores $Z$ a geradores estabilizadores como esse, ou seja, aqueles que possuem apenas fatores tensoriais Pauli $Z$ e identidade — portanto, as matrizes de Pauli $X$ e $Y$ nunca ocorrem em geradores estabilizadores $Z$.

Também podemos considerar geradores estabilizadores nos quais apenas matrizes de Pauli $X$ e identidade aparecem como fatores tensoriais. Geradores estabilizadores como esse podem ser vistos como análogos aos geradores estabilizadores $Z$, exceto que descrevem verificações de paridade na base $\{\vert+\rangle,\vert-\rangle\}$ em vez da base padrão. Geradores estabilizadores dessa forma são chamados de geradores estabilizadores $X$ — portanto, matrizes de Pauli $Y$ ou $Z$ não são permitidas desta vez.

Por exemplo, considere os três geradores estabilizadores restantes do código de Steane de 7 qubits.

$$\begin{array}{ccccccc} 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}$$

Eles seguem exatamente o mesmo padrão do código de Hamming $[7,4,3]$ que os geradores estabilizadores $Z$, exceto que desta vez substituímos $X$ por $1$ em vez de $Z.$ O que obtemos apenas com esses três geradores estabilizadores é um código que inclui os 16 estados mostrados aqui, que obtemos aplicando operações de Hadamard aos estados da base padrão que correspondem às strings no código de Hamming $[7,4,3]$. (É claro que o espaço do código para este código também inclui combinações lineares desses estados.)

$$\begin{array}{cccc} \vert {+++++++} \rangle \quad & \vert {--++++-} \rangle \quad & \vert {-+-++-+} \rangle \quad & \vert {+--++--} \rangle \\ \vert {+--+-++} \rangle \quad & \vert {-+-+-+-} \rangle \quad & \vert {--++--+} \rangle \quad & \vert {++++---} \rangle \\ \vert {----+++} \rangle \quad & \vert {++--++-} \rangle \quad & \vert {+-+-+-+} \rangle \quad & \vert {-++-+--} \rangle \\ \vert {-++--++} \rangle \quad & \vert {+-+--+-} \rangle \quad & \vert {++----+} \rangle \quad & \vert {-------} \rangle \end{array}$$

Agora podemos definir os códigos CSS em termos muito simples.

Definição

Um código CSS é um código estabilizador que pode ser expresso usando apenas geradores estabilizadores $X$ e $Z$.

Ou seja, os códigos CSS são códigos estabilizadores para os quais temos geradores estabilizadores nos quais nenhuma matriz de Pauli $Y$ aparece, e nos quais $X$ e $Z$ nunca aparecem no mesmo gerador estabilizador.

Para ser claro, por essa definição, um código CSS é aquele para o qual é possível escolher apenas geradores estabilizadores $X$ e $Z$ — mas devemos ter em mente que há liberdade na escolha dos geradores estabilizadores para códigos estabilizadores. Portanto, geralmente haverá diferentes escolhas para os geradores estabilizadores de um código CSS que não são geradores estabilizadores $X$ ou $Z$ (além de pelo menos uma escolha para a qual são).

Aqui está um exemplo muito simples de um código CSS que inclui tanto um gerador estabilizador $Z$ quanto um gerador estabilizador $X$:

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

É evidente que este é um código CSS, pois o primeiro gerador estabilizador é um gerador estabilizador $Z$ e o segundo é um gerador estabilizador $X$. Claro, um código CSS também deve ser um código estabilizador válido — o que significa que os geradores estabilizadores devem comutar, formar um conjunto gerador mínimo e fixar pelo menos um vetor de estado quântico. Esses requisitos são simples de verificar para este código. Como observamos na lição anterior, o espaço do código para este código é o espaço unidimensional gerado pelo estado de Bell $\vert\phi^+\rangle$. O fato de que ambos os geradores estabilizadores fixam esse estado é evidente considerando as duas expressões a seguir de um e-bit, juntamente com uma interpretação desses geradores estabilizadores como verificações de paridade nas bases $\{\vert 0\rangle, \vert 1\rangle\}$ e $\{\vert +\rangle, \vert -\rangle\}$.

$$\vert\phi^+\rangle = \frac{\vert 0\rangle\vert 0\rangle + \vert 1\rangle\vert 1\rangle}{\sqrt{2}} = \frac{\vert +\rangle\vert +\rangle + \vert -\rangle\vert -\rangle}{\sqrt{2}}$$

O código de Steane de 7 qubits é outro exemplo de código CSS.

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

Aqui temos três geradores estabilizadores $Z$ e três geradores estabilizadores $X$, e já verificamos que este é um código estabilizador válido.

E o código de Shor de 9 qubits é outro exemplo.

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

Desta vez, temos seis geradores estabilizadores $Z$ e apenas dois geradores estabilizadores $X$. Isso é válido — não precisa haver equilíbrio ou simetria entre os dois tipos de geradores (embora frequentemente haja).

Mais uma vez, é fundamental que os códigos CSS sejam códigos estabilizadores válidos e, em particular, cada gerador estabilizador $Z$ deve comutar com cada gerador estabilizador $X$. Portanto, nem toda coleção de geradores estabilizadores $X$ e $Z$ define um código CSS válido.

Detecção e correção de erros

Com relação à detecção e correção de erros, os códigos CSS em geral têm uma característica semelhante à do código de Shor de 9 qubits: os erros $X$ e $Z$ podem ser detectados e corrigidos de forma completamente independente; os geradores estabilizadores $Z$ descrevem um código que protege contra inversões de bit, e os geradores estabilizadores $X$ descrevem um código que protege independentemente contra inversões de fase. Isso funciona porque os geradores estabilizadores $Z$ necessariamente comutam com os erros $Z$, bem como com as operações $Z$ aplicadas como correções, portanto são completamente alheios a ambos, e o mesmo vale para os geradores estabilizadores $X$, erros e correções.

Como exemplo, vamos considerar o código de Steane de 7 qubits.

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

A ideia básica para este código é agora evidente: é um código de Hamming $[7,4,3]$ para erros de inversão de bit e um código de Hamming $[7,4,3]$ para erros de inversão de fase. O fato de que os geradores estabilizadores $X$ e $Z$ comutam é talvez uma boa sorte, pois se não comutassem, este não seria um código estabilizador válido. Mas, de fato, existem muitos exemplos conhecidos de códigos lineares clássicos que produzem um código estabilizador válido quando usados de forma semelhante.

Em geral, suponha que temos um código CSS para o qual os geradores estabilizadores $Z$ permitem a correção de até $j$ erros de inversão de bit, e os geradores estabilizadores $X$ permitem a correção de até $k$ erros de inversão de fase. Por exemplo, $j = 1$ e $k = 1$ para o código de Steane, dado que o código de Hamming $[7,4,3]$ pode corrigir uma inversão de bit. Segue-se então, pela discretização de erros, que este código CSS pode corrigir qualquer erro em um número de qubits até o mínimo de $j$ e $k.$ Isso ocorre porque, quando a síndrome é medida, um erro arbitrário nesse número de qubits colapsa probabilisticamente em alguma combinação de erros $X$, erros $Z$, ou ambos — e então os erros $X$ e $Z$ são detectados e corrigidos independentemente.

Em resumo, desde que tenhamos dois códigos lineares clássicos (ou duas cópias de um único código linear clássico) que sejam compatíveis, no sentido de que definem geradores estabilizadores $X$ e $Z$ que comutam, o código CSS que obtemos ao combiná-los herda as propriedades de correção de erros desses dois códigos, no sentido acabado de descrever.

Note que há um preço a ser pago, porém: não podemos codificar tantos qubits quanto poderíamos codificar bits com os dois códigos clássicos. Isso ocorre porque o número total de geradores estabilizadores para o código CSS é a soma do número de verificações de paridade dos dois códigos lineares clássicos, e cada gerador estabilizador reduz a dimensão do espaço do código pela metade. Por exemplo, o código de Hamming $[7,4,3]$ permite a codificação de quatro bits clássicos, pois temos apenas três strings de verificação de paridade para esse código, enquanto o código de Steane de 7 qubits codifica apenas um qubit, pois tem seis geradores estabilizadores.

Espaços de código dos códigos CSS

A última coisa que faremos nesta discussão sobre códigos CSS é considerar os espaços de código desses códigos. Isso nos dará a oportunidade de examinar em maior detalhe a relação que deve existir entre dois códigos lineares clássicos para que sejam compatíveis, no sentido de que podem ser combinados para formar um código CSS.

Considere qualquer código CSS em $n$ qubits, e seja $z_1, \ldots, z_s \in \Sigma^n$ as strings de verificação de paridade de $n$ bits que correspondem aos geradores estabilizadores $Z$ deste código. Isso significa que o código linear clássico descrito apenas pelos geradores estabilizadores $Z$, que chamaremos de $\mathcal{C}_Z,$ tem a seguinte forma.

$$\mathcal{C}_Z = \bigl\{ u \in \Sigma^n \,:\, u \cdot z_1 = \cdots = u \cdot z_s = 0 \bigr\}$$

Em palavras, o código linear clássico $\mathcal{C}_Z$ contém todas as strings cujo produto escalar binário com cada uma das strings de verificação de paridade $z_1, \ldots, z_s$ é zero.

De forma análoga, tomemos $x_1,\ldots,x_t\in\Sigma^n$ como as strings de verificação de paridade de $n$ bits correspondentes aos geradores estabilizadores $X$ do nosso código. Assim, o código linear clássico correspondente aos geradores estabilizadores $X$ tem esta forma.

$$\mathcal{C}_X = \bigl\{ u \in \Sigma^n \,:\, u \cdot x_1 = \cdots = u \cdot x_t = 0 \bigr\}$$

Os geradores estabilizadores $X$ por si sós descrevem, portanto, um código semelhante a este, mas na base $\{\vert {+}\rangle,\vert {-}\rangle\}$ em vez da base padrão.

Agora introduziremos dois novos códigos lineares clássicos derivados das mesmas escolhas de strings, $z_1,\ldots,z_s$ e $x_1,\ldots,x_t,$ mas onde tomamos essas strings como geradores em vez de strings de verificação de paridade. Em particular, obtemos estes dois códigos.

$$\begin{aligned} \mathcal{D}_Z & = \bigl\{ \alpha_1 z_1 \oplus \cdots \oplus \alpha_s z_s \,:\, \alpha_1,\ldots,\alpha_s \in \{0,1\} \bigr\}\\[1mm] \mathcal{D}_X & = \bigl\{ \alpha_1 x_1 \oplus \cdots \oplus \alpha_t x_t \,:\, \alpha_1,\ldots,\alpha_t \in \{0,1\} \bigr\} \end{aligned}$$

Esses são conhecidos como os códigos duais dos códigos definidos anteriormente: $\mathcal{D}_Z$ é o código dual de $\mathcal{C}_Z$ e $\mathcal{D}_X$ é o código dual de $\mathcal{C}_X.$ Pode não estar claro neste ponto por que esses códigos duais são relevantes, mas eles se mostram bastante relevantes por múltiplas razões, incluindo as duas razões explicadas nos parágrafos a seguir.

Primeiro, as condições que devem ser satisfeitas para que dois códigos lineares clássicos $\mathcal{C}_Z$ e $\mathcal{C}_X$ sejam compatíveis, no sentido de que podem ser combinados para formar um código CSS, podem ser descritas em termos simples referindo-se aos códigos duais. Especificamente, deve ser que $\mathcal{D}_Z\subseteq\mathcal{C}_X,$ ou equivalentemente, que $\mathcal{D}_X\subseteq\mathcal{C}_Z.$ Em palavras, o código dual $\mathcal{D}_Z$ inclui as strings correspondentes aos geradores estabilizadores $Z$, e sua contenção em $\mathcal{C}_X$ é equivalente ao produto escalar binário de cada uma dessas strings com as correspondentes aos geradores estabilizadores $X$ ser zero. Isso, por sua vez, é equivalente a cada gerador estabilizador $Z$ comutar com cada gerador estabilizador $X$. Alternativamente, invertendo os papéis dos geradores estabilizadores $X$ e $Z$ e partindo da contenção $\mathcal{D}_X\subseteq\mathcal{C}_Z,$ podemos chegar à mesma conclusão.

Segundo, referindo-nos aos códigos duais, podemos descrever facilmente os espaços de código de um dado código CSS. Em particular, o espaço de código é gerado por vetores da seguinte forma.

$$\vert u \oplus \mathcal{D}_X\rangle = \frac{1}{\sqrt{2^t}} \sum_{v\in\mathcal{D}_X} \vert u \oplus v\rangle \qquad \text{(para todo $u\in\mathcal{C}_Z$)}$$

Em palavras, esses vetores são superposições uniformes sobre as strings no código dual $\mathcal{D}_X$ do código correspondente aos geradores estabilizadores $X$, deslocadas por (em outras palavras, com XOR bit a bit com) strings no código $\mathcal{C}_Z$ correspondente aos geradores estabilizadores $Z$. Para ser claro, diferentes escolhas para o deslocamento — representado pela string $u$ nesta expressão — podem resultar no mesmo vetor. Portanto, esses estados não são todos distintos, mas coletivamente geram todo o espaço de código.

Aqui está uma explicação intuitiva de por que tais vetores estão no espaço de código e o geram. Considere o estado da base padrão de $n$ qubits $\vert u\rangle,$ para alguma string arbitrária de $n$ bits $u,$ e suponha que projetamos esse estado no espaço de código. Ou seja, denotando por $\Pi$ a projeção no espaço de código do nosso código CSS, considere o vetor $\Pi\vert u\rangle.$ Há dois casos:

• Caso 1: $u\in\mathcal{C}_Z.$ Isso implica que cada gerador estabilizador $Z$ do nosso código CSS age trivialmente sobre $\vert u\rangle.$ Os geradores estabilizadores $X$, por outro lado, simplesmente invertem alguns dos bits de $\vert u\rangle.$ Em particular, para cada gerador $v$ de $\mathcal{D}_X,$ o gerador estabilizador $X$ correspondente a $v$ transforma $\vert u\rangle$ em $\vert u\oplus v\rangle.$ Caracterizando a projeção $\Pi$ como a média sobre os elementos do estabilizador (como vimos na lição anterior), obtemos esta fórmula:

  $$\Pi \vert u \rangle = \frac{1}{2^t} \sum_{v\in\mathcal{D}_{X}} \vert u \oplus v\rangle = \frac{1}{\sqrt{2^t}} \vert u \oplus \mathcal{D}_X\rangle.$$

• Caso 2: $u\notin\mathcal{C}_Z.$ Isso implica que pelo menos uma das verificações de paridade correspondentes aos geradores estabilizadores $Z$ falha, ou seja, $\vert u\rangle$ deve ser um autovetor de $-1$ de pelo menos um dos geradores estabilizadores $Z$. O espaço de código do código CSS é a interseção dos autoespaços de $+1$ dos geradores estabilizadores. Portanto, como autovetor de $-1$ de pelo menos um dos geradores estabilizadores $Z$, $\vert u\rangle$ é ortogonal ao espaço de código:

  $$\Pi\vert u\rangle = 0.$$

E agora, ao percorrermos todas as strings $u$ de $n$ bits, descartarmos aquelas para as quais $\Pi\vert u\rangle = 0$ e normalizarmos as demais, obtemos os vetores descritos anteriormente, o que demonstra que eles geram o espaço de código.

Também podemos usar a simetria entre os geradores estabilizadores $X$ e $Z$ para descrever o espaço de código de uma forma semelhante, mas diferente. Em particular, é o espaço gerado por vetores da seguinte forma.

$$H^{\otimes n} \vert u \oplus \mathcal{D}_Z\rangle = \frac{1}{\sqrt{2^s}} \sum_{v\in\mathcal{D}_Z} H^{\otimes n}\vert u \oplus v\rangle \qquad \text{(para $u\in\mathcal{C}_X$)}$$

Em essência, $X$ e $Z$ foram trocados em cada instância em que aparecem — mas também devemos trocar a base padrão pela base $\{\vert+\rangle,\vert-\rangle\}$, razão pela qual as operações de Hadamard estão incluídas.

Como exemplo, vamos considerar o código de Steane de 7 qubits. As strings de verificação de paridade para os geradores estabilizadores $X$ e $Z$ são as mesmas: $1111000,$ $1100110,$ e $1010101.$ Os códigos $\mathcal{C}_X$ e $\mathcal{C}_Z$ são, portanto, os mesmos; ambos são iguais ao código de Hamming $[7,4,3]$.

$$\mathcal{C}_X = \mathcal{C}_Z = \{0000000, 0000111, 0011001, 0011110, 0101010, 0101101, 0110011, 0110100, 1001011, 1001100, 1010010, 1010101, 1100001, 1100110, 1111000, 1111111\}$$

Os códigos duais $\mathcal{D}_X$ e $\mathcal{D}_Z$ são, portanto, também os mesmos. Temos três geradores, portanto obtemos oito strings.

$$\mathcal{D}_X = \mathcal{D}_Z = \{0000000, 0011110, 0101101, 0110011, 1001011, 1010101, 1100110, 1111000\}$$

Essas strings estão todas contidas no código de Hamming $[7,4,3]$, portanto a condição CSS é satisfeita: $\mathcal{D}_Z \subseteq \mathcal{C}_X,$ ou equivalentemente, $\mathcal{D}_X \subseteq \mathcal{C}_Z.$

Dado que $\mathcal{D}_X$ contém metade de todas as strings em $\mathcal{C}_Z,$ há apenas dois vetores distintos $\vert u\oplus \mathcal{D}_X\rangle$ que podem ser obtidos escolhendo $u\in\mathcal{C}_Z.$ Isso é esperado, pois o código de Steane de 7 qubits tem um espaço de código bidimensional. Podemos usar os dois estados que obtemos dessa forma para codificar o estado lógico $\vert 0\rangle$ e $\vert 1\rangle$ da seguinte maneira.

$$\begin{aligned} \vert 0\rangle & \mapsto \frac{ \vert 0000000\rangle + \vert 0011110\rangle + \vert 0101101\rangle + \vert 0110011\rangle + \vert 1001011\rangle + \vert 1010101\rangle + \vert 1100110\rangle + \vert 1111000\rangle }{\sqrt{8}}\\[4mm] \vert 1\rangle & \mapsto \frac{ \vert 0000111\rangle + \vert 0011001\rangle + \vert 0101010\rangle + \vert 0110100\rangle + \vert 1001100\rangle + \vert 1010010\rangle + \vert 1100001\rangle + \vert 1111111\rangle }{\sqrt{8}} \end{aligned}$$

Como de costume, essa escolha não é obrigatória — somos livres para usar o espaço de código para codificar qubits como quisermos. Essa codificação é, no entanto, consistente com o exemplo de um circuito de codificação para o código de Steane de 7 qubits apresentado na lição anterior.