O que é 'Código de superfície'? (Correção de erro quântico)

Estou estudando computação quântica e informação. Cruzei com a frase 'Surface Code', mas não consigo encontrar uma breve explicação sobre o que é e como funciona. Espero que vocês possam me ajudar com isso.

Nota: Se você quiser, pode usar matemática complicada, eu estou familiarizado com a mecânica quântica até certo ponto.

error-correction terminology

— Ivanovitch
fonte

Bem vinda! Para esclarecer: as respostas devem assumir que você já examinou os códigos tóricos e estabilizadores no nível da Wikipédia ?

— agaitaarino 19/05/19

Não sei sobre códigos tóricos ou códigos estabilizadores: | Mas vou ler sobre isso #

— Ivanovitch

Agradável! Então isso deve ser um ótimo começo, eu acho. Sugiro que você dê uma rápida olhada nelas e coloque mais alguns detalhes na questão: coisas que você já acha que entende e outras que ainda não fazem muito sentido. Uma vez respondida, pode ser uma pergunta e uma pergunta muito útil para as pessoas que vêm atrás de você: esses são conceitos importantes e a terminologia é realmente um pouco confusa.

— agaitaarino

Relacionado: "Correção de erro quântico: código de superfície vs. código de cores" da SE.Physics.

— Nat

Não sei de nada, mas arxiv.org/abs/1208.0928 é onde eu comecei a aprender sobre o código de superfície.

— Craig Gidney

Respostas:

Os códigos de superfície são uma família de códigos de correção de erros quânticos definidos em uma rede 2D de qubits. Cada código dentro desta família possui estabilizadores que são definidos equivalentemente em massa, mas diferem um do outro em suas condições de contorno.

Às vezes, os membros da família de códigos de superfície também são descritos por nomes mais específicos: o código tórico é um código de superfície com condições de contorno periódicas, o código planar é aquele definido em um plano etc. O termo "código de superfície" também é usado às vezes de forma intercambiável com o 'código planar', já que este é o exemplo mais realista da família de códigos de superfície.

Os códigos de superfície são atualmente uma grande área de pesquisa, por isso vou apontar alguns bons pontos de entrada (além do artigo da Wikipedia vinculado acima).

Os códigos de superfície também podem ser generalizados para qudits. Para mais informações, veja aqui .

— James Wootton
fonte

Os códigos de superfície funcionam apenas para computadores quânticos topológicos?

— Ivanovitch 28/05

Os códigos de superfície funcionariam para qualquer qubits. Em certo sentido, com os códigos de superfície, você está criando um computador quântico topológico usando qubits não topológicos.

— James Wootton

A terminologia do 'código de superfície' é um pouco variável. Pode se referir a toda uma classe de coisas, variantes do código Toric em redes diferentes, ou pode se referir ao código Planar, a variante específica em uma rede quadrada com condições de contorno aberto.

O Código Toric

Vou resumir algumas das propriedades básicas do código Toric. Imagine uma treliça quadrada com condições de contorno periódicas, ou seja, a borda superior é unida à borda inferior e a borda esquerda é unida à borda direita. Se você tentar fazer isso com uma folha de papel, verá uma forma de rosquinha ou toro. Nesta rede, colocamos um qubit em cada extremidade de um quadrado.

Estabilizadores

Em seguida, definimos um monte de operadores. Para cada quadrado na rede (compreendendo 4 qubits no meio de cada aresta), escrevemos atuando uma rotação Pauli- em cada um dos 4 qubits. O rótulo refere-se a 'plaqueta' e é apenas um índice para que possamos contar mais tarde em todo o conjunto de plaquetas. Em cada vértice do retículo (4 rodeada por qubits), definimos refere-se à forma da estrela e, novamente, vamos somar todos esses termos.

B_{p} = X X X X,

$B_p=XXXX,$

X

$X$

p

$p$

{UMA}_{s} = Z Z Z Z .

$A_s=ZZZZ.$

s

$s$

Observamos que todos esses termos se alternam mutuamente. É trivial para porque os operadores Pauli comutam entre si e . É necessário mais cuidado com , note que esses dois termos têm 0 ou 2 sites em comum e pares de diferentes operadores Pauli são comutados, $[A_s,A_{s'}]=[B_p,B_{p'}]=0$ $\mathbb{I}$ $[A_s,B_p]=0$ $[XX,ZZ]=0$ .

Codespace

Como todos esses operadores comutam, podemos definir um auto-estatuto simultâneo de todos eles, um estado tal que $|\psi\rangle$ Isso define o espaço de código do código. Devemos determinar quão grande é.

\forall s : {UMA}_{s} | ψ ⟩ = | ψ ⟩ \forall p : B_{p} | ψ ⟩ = | ψ ⟩ .

$\forall s:A_s|\psi\rangle=|\psi\rangle\qquad\forall p:B_p|\psi\rangle=|\psi\rangle.$

$N\times N$ $N^2$ $2^{N^2}$ $N^2$ $A_s$ $B_p$ $\pm 1$ $A_s^2=B_p^2=\mathbb{I}$

$\prod_sA_s=\prod_pB_p=\mathbb{I}$ $A_s$ $B_p$

Operadores lógicos

$X_{1,L}$ $Z_{1,L}$ $X_{2,L}$ $Z_{2,L}$

[X_{1, eu}, X_{2, eu}] = 0 0 [X_{1, eu}, Z_{2, eu}] = 0 0 [Z_{1, eu}, Z_{2, eu}] = 0 0 [Z_{1, eu}, X_{2, eu}] = 0 0

$[X_{1,L},X_{2,L}]=0\quad [X_{1,L},Z_{2,L}]=0 \quad [Z_{1,L},Z_{2,L}]=0\quad [Z_{1,L},X_{2,L}]=0$

{X_{1, eu}, Z_{1, eu}} = 0 0 {X_{2, eu}, Z_{2, eu}} = 0 0

$\{X_{1,L},Z_{1,L}\}=0\qquad\{X_{2,L},Z_{2,L}\}=0$

Existem algumas convenções diferentes sobre como rotular os diferentes operadores. Eu vou com o meu favorito (que provavelmente é o menos popular):

$Z$ $Z_{1,L}$
$Z$ $X_{2,L}$ $Z_{2,L}$
$X$ $Z_{2,L}$
$X$ $X_{1,L}$

$X$ $Z$

| ψ_{x, y} ⟩ : Z_{1, eu} | ψ_{x, y} ⟩ = (- 1)^{x} | ψ_{x, y} ⟩, Z_{2, eu} | ψ_{x, y} ⟩ = (- 1)^{y} | ψ_{x, y} ⟩

$|\psi_{x,y}\rangle: Z_{1,L}|\psi_{x,y}\rangle=(-1)^x|\psi_{x,y}\rangle,\qquad Z_{2,L}|\psi_{x,y}\rangle=(-1)^y|\psi_{x,y}\rangle$

$N$ $N$

Detecção e correção de erros

$A_s$ $B_p$ $\pm 1$

$X$ $-1$ $+1$ $X$ $X$ $X$

Erro ao corrigir o limite

$N$ $N$ $N$ $X$ $Z$ $p$ $p=0.11$ $11\%$ . Ele também possui um limite tolerante a falhas finito (onde você permite medições e correções com falha com alguma taxa de erro por qubit)

O Código Planar

Os detalhes são muito idênticos ao código Toric, exceto que as condições de contorno da rede estão abertas em vez de periódicas. Isso significa que, nas bordas, os estabilizadores são definidos de maneira ligeiramente diferente. Nesse caso, há apenas um qubit lógico no código em vez de dois.

— DaftWullie
fonte