Em uma estrutura de código de superfície 2D, existem alguns qubits de dados e alguns qubits de medição. Suponha que desejemos fazer um cálculo de 2 qubit, por exemplo, digamos, um X-gate no qubit-1 seguido por um gate CNOT com qubit-1 como o bit de controle e qubit-2 como o bit de destino.

P: Como essa computação é realizada em um computador quântico com um arranjo de código de superfície 2D de qubits? quais portas são aplicadas e em quais qubits?

Ilustrarei como é possível executar operações usando operações lógicas nos qubits e usando a cirurgia de treliça para operações de dois qubit.

Nos diagramas abaixo, todos os 'pontos' são qubits de dados: os qubits de medição são omitidos para ajudar a demonstrar os princípios básicos mais claramente. Os qubits de medição existem para quando você realiza medições do estabilizador e só estão envolvidos nas medições do estabilizador, portanto, a história é sobre o que você faz com os qubits de dados - incluindo itens como as medições do estabilizador que você realiza nos qubits de dados.

Códigos de superfície e operações lógicas de Pauli de qubit único

Pode-se usar fragmentos do avião para armazenar qubits. A imagem abaixo mostra quatro qubits que são codificados como parte de uma rede maior: os pontos de luz com contornos pretos são qubits que não estão envolvidos nos qubits codificados e podem, em princípio, estar em qualquer estado que você desejar, sem se envolver dos demais.
$\qquad\qquad\qquad$

Em cada um desses fragmentos, o qubit é definido pelas relações estabilizadoras que (idealmente, na ausência de erros) se mantêm entre os qubits. Para códigos de superfície com os tipos de condições de contorno ilustradas aqui, esses são estabilizadores X ou Z de 3 qubits ao redor dos limites e estabilizadores X ou Z de 4 qubits no 'volume' ou no corpo do código. O padrão desses estabilizadores é ilustrado abaixo. Observe que cada estabilizador X que se sobrepõe a um estabilizador Z faz isso em dois qubits, para que eles se comuniquem. (Desculpas pelo tamanho da imagem: não consigo exibi-la em um tamanho razoável.)

$\qquad\qquad\qquad$

Observe que, usando a regularidade desses estabilizadores, não é necessário que o fragmento do código de superfície seja quadrado (ou, em princípio, retangular). * Isso se tornará importante mais tarde.

Existem várias operações Pauli (produto tensorial) que são comutadas com todos esses estabilizadores. Eles podem ser usados ​​para definir operadores Pauli lógicos , que descrevem maneiras pelas quais você pode acessar e transformar os qubits lógicos. Por exemplo, um produto de operadores Z em qualquer linha de fronteira a fronteira comuta com todos os estabilizadores e pode ser considerado um operador Z lógico ; um produto de operadores X em qualquer coluna de fronteira a fronteira pode ser similarmente utilizado para representar um operador X lógico :

$\qquad$

Não importa qual linha ou coluna você usa: isso decorre do fato de que um produto de duas linhas de operadores Z ou de duas colunas de operadores X pode ser gerado como um produto de estabilizadores e, portanto, realiza um operação de identidade no qubit codificado (como os próprios geradores estabilizadores são operadores que executam a operação de identidade em um estado de qubit codificado, por definição). Portanto: se você deseja aplicar uma operação X a um qubit codificado, uma maneira de fazer isso seria aplicar uma operação X lógica assim , realizando X operadores em cada qubit em uma coluna atingindo entre dois limites. **

Medições lógicas de Pauli de um qubit

Uma vantagem de pensar nos qubits codificados em termos de operadores lógicos é que ele permite determinar também como é possível executar uma 'medida lógica' - isto é, uma medida não apenas de (alguns) qubits no código, mas também de uma medida. dos dados que eles codificam. Considere o operador X lógico acima, por exemplo: o operador X ⊗ X ⊗ ... ⊗ X não é apenas unitário, mas Hermitiano, o que significa que é um observável que você pode medir . (A mesma idéia é usada o tempo todo com os estabilizadores do código, é claro, que medimos para tentar detectar erros.) Isso significa que, para realizar uma medição lógica do X , basta medir a lógica. Xobservável. (O mesmo vale para o Z lógico observável, se você deseja realizar uma medida de base padrão no seu qubit codificado; e tudo o que digo abaixo também pode ser aplicado às medições de Z lógicas com as modificações apropriadas.)

Agora - medir o X lógico observável não é exatamente o mesmo que medir cada um desses operadores X de qubit único, um de cada vez. O operador X ⊗ X ⊗ ... ⊗ X possui apenas dois autovalores, +1 e -1, medindo que o operador preciso pode ter apenas dois resultados, ao passo que medir cada um dos n qubits terá 2 ⁿ resultados. Além disso, a medição de cada um desses operadores X de qubit único não o manterá no espaço de código: se você quiser fazer cálculos em um estado pós-medição projetado, será necessário fazer muito trabalho de limpeza para restaurar o qubit para um estado codificado corretamente.

No entanto: se você não se importa em fazer esse trabalho de limpeza ou se não se preocupa em trabalhar com o estado pós-medição, pode simular a medição lógica do X fazendo essas medições de qubit único, obtendo +1 e -1 resultados e, em seguida, computando seus produtos para obter qual teria sido o resultado da medição de X ⊗ X ⊗ ... ⊗ X ". (Mais precisamente: medir todos esses operadores X de um qubit único é algo que não perturba um estado que resultaria de uma medição do operador do produto tensorial X ⊗ X ⊗ ... ⊗ X, e o produto dessas medições de qubit único teria que produzir um resultado consistente com o operador do produto tensorial X ⊗ X ⊗ ... ⊗ X , para que possamos usar isso como uma maneira de simular essa medição mais complicada se não usarmos ' lembre-se de que todos os qubits sejam projetados em estados de base conjugada como efeito colateral.)

Cirurgia de treliça para operações lógicas de dois qubit

Para realizar uma operação de dois qubit, você pode usar uma técnica conhecida como cirurgia de treliça , na qual você 'mescla' e 'divide' diferentes patches da treliça 2D para realizar operações entre esses patches (consulte [ arXiv: 1111.4022 ], [ arXiv: 1612.07330 ] ou [ arXiv: 1704.08670 ] para obter descrições completas dessas operações.Classificação: Eu sou um autor no terceiro desses artigos.) Isso pode ser realizado entre duas amostras adjacentes da treliça planar (como ilustrado acima), preparando-as linhas e colunas "não envolvidas" de qubits em um estado adequado e, em seguida, medindo estabilizadores que anteriormente você não estava medindopara estender a memória para um sistema maior. (No diagrama abaixo, o espaçamento horizontal entre os segmentos de código e a coluna de qubits nos estados | 0⟩ é exagerado para efeito.)

$\qquad$

Isso afetará os operadores lógicos do sistema de maneira não unitária e é mais frequentemente usado (consulte [ arXiv: 1612.07330 ] por exemplo) para realizar uma medição coerente X ⊗ X ou Z ⊗ Z , que pode ser composta para realizar uma operação CNOT [arXiv: 1612.07330, Fig. 1 (b)]:
$\qquad\qquad\qquad$
Dessa forma, você pode realizar uma operação CNOT entre um par de qubits codificados. ***

Notas de rodapé

* Você também pode usar pequenas modificações no padrão regular de estabilizadores, como demonstra Letinsky [ arXiv: 1808.02892 ], para obter representações mais versáteis da superfície plana de qubits codificados.

** Na prática, em vez de executar explicitamente operações (um único qubit imperfeito), você tiraria vantagem do fato de que o quadro de referência para os qubits codificados é aquele que você está corrigindo por convenção e atualiza (ou 'transforma') o quadro de referência em vez do próprio estado quando você deseja realizar uma operação Pauli. Esta é também a maneira inteligente de corrigir os erros: tratar os erros não como "erros" que devem ser "corrigidos", mas como um desvio descontrolado mas observável no seu quadro de referência como resultado da interação com o ambiente. Você espera que esse desvio seja lento o suficiente para poder acompanhá-lo com precisão e compensar a alteração no quadro de referência ao fazer o cálculo. Particularmente no contexto de erros de rastreamento,Quadro Pauli , e seu trabalho é descrever o quadro de referência em termos das operações Pauli que seriam necessárias para colocar o sistema no estado geralmente descrito por um código de correção de erros sem erros.

*** Muitos autores descreveriam essa construção como o ponto da cirurgia de treliça, e certamente é a aplicação concreta original descrita no artigo original [ arXiv: 1111.4022 ]. É possível, em princípio, fazer operações mais elaboradas usando divisões e mesclagens, tratando as mesclas e divisões como operações primitivas por si só, em vez de apenas os componentes de um CNOT, e usando transformações mais versáteis (mas não especialmente do tipo circuito) - este é essencialmente o ponto do meu artigo com Dom Horsman [ arXiv: 1704.08670 ], que abre a possibilidade de o cálculo ZX (uma representação um tanto heterodoxa da computação quântica) ser diretamente praticamente útil para memórias de código de superfície.

Uma maneira de armazenar qubits no código de superfície é como pares de "orifícios". Um buraco é um pedaço da superfície onde, em vez de executar as medições do estabilizador usadas para detectar se estão ocorrendo erros, você não faz nada.

Existem dois tipos diferentes de orifícios, dependendo se o limite do orifício se desloca ao longo dos possíveis qubits de medição X ou ao longo dos possíveis qubits de medição Z. Um CNOT é realizado ciclando um orifício de um tipo em torno de um orifício do outro tipo.

Diagramaticamente falando, fica assim:

No diagrama (b), o tempo está passando da esquerda para a direita. Cada barra corresponde à localização de um buraco ao longo do tempo. Cada qubit é armazenado entre os pares correspondentes de barras brancas. A barra preta representa o buraco que está sendo usado para executar o CNOT. Evita o qubit do meio (que não está envolvido), envolve uma das barras do qubit de baixo (que é o alvo) e contorna uma 'barra cruzada' introduzida no qubit de cima (que é o controle). É assim que um código de superfície CNOT se parece.

Existem várias maneiras de armazenar informações em códigos de superfície. Dependendo do método usado, existem várias maneiras de fazer portões. Portanto, há muito a dizer sobre esse assunto!

Apesar da multiplicidade de métodos, em termos práticos, todos eles têm praticamente a mesma coisa: se você deseja que seu portão seja tolerante a falhas pelo código, você só pode usar os portões de Clifford (como X, Z, H, CNOT , S). Para outros portões, você precisará invocar mecanismos adicionais para se tornar tolerante a falhas, como a destilação no estado mágico.

Mas você não pediu nada além de Clifford no seu exemplo. Você só queria um X e um CNOT. Então isso facilita as coisas.

Para um exemplo concreto, vamos pegar o código de superfície de 17 qubit mostrado abaixo (como representado neste artigo , do qual sou autor).

Isso é composto de $n=9$ qubits físicos, numerados de $0$ para $8$. Também há 8 qubits ancilla representados aqui, mas vamos ignorá-los.

As manchas escuras nesta imagem indicam estabilizadores feitos de $\sigma_x$ (então medimos os observáveis $\sigma_x^0 \otimes \sigma_x^1 \otimes \sigma_x^3 \otimes \sigma_x^4$ e $\sigma_x^1 \otimes \sigma_x^2$, por exemplo). As manchas de luz são então as$\sigma_z$ estabilizadores.

Um exemplo de uma operação que comuta com todos os estabilizadores é fazer uma $\sigma_x$ rotação em uma linha de qubits de cima para baixo, como $\sigma_x^0 \otimes \sigma_x^3 \otimes \sigma_x^6$. Outro exemplo é fazer uma linha de$\sigma_x$ rotações da esquerda para a direita, como $\sigma_z^3 \otimes \sigma_z^4 \otimes \sigma_z^5$.

Todas as outras operações que comutam com o estabilizador serão produtos dos próprios estabilizadores (e, portanto, agem trivialmente) ou serão equivalentes a um desses dois exemplos. Portanto, essas operações atuam em nosso qubit lógico. Desde que um é feito de$\sigma_x$s, o outro é feito de $sigma_z$s, e eles anticomutam, parece sensato atribuí-los como operadores Pauli $X$ e $Z$ do qubit lógico

Então, para fazer uma $X$, você acabou de executar a operação acima.

Para um CNOT, uma das muitas maneiras de fazer isso é transversalmente . Para isso, suponha que tenhamos dois qubits lógicos$A$ e $B$. Cada um é composto de muitos qubits físicos, que serão numerados$0, 1, 2, \ldots$. Então vamos$0_A$ denotar qubit físico $0$ de qubit lógico $A$, por exemplo.

Façam ${\rm CNOT}(A,B)$, um CNOT com qubit $A$ como controle e $B$ como alvo, podemos fazer

Para ver como isso funciona, temos que olhar para a lógica $|0\rangle$ e $|1\rangle$ estados quando expressos na base computacional dos qubits físicos.

Vamos usar $| \tilde 0 \rangle = |0\rangle^{\otimes n}$ para indicar o estado em que todos os qubits físicos estão no estado $|0\rangle$e $| \tilde 1 \rangle = X | \tilde 0 \rangle$ um estado com uma linha de $|1\rangle$s de cima para baixo, sobre um fundo de $|0\rangle$s.

Podemos então simplesmente expressar a lógica $|0\rangle$ estado como a superposição de $| \tilde 0 \rangle$ com todo o estado que você pode obter $| \tilde 0 \rangle$aplicando estabilizadores. Lógico$|1\rangle$ é similarmente a superposição de $| \tilde 1 \rangle$ com todo o estado que você pode obter $| \tilde 1 \rangle$ aplicando estabilizadores.

Ao pensar na ação dos CNOTs transversais em termos desses estados, esperamos poder ver como ele funciona como um CNOT nos qubits lógicos.