En una red de código de superficie 2D, hay algunos qubits de datos y algunos qubits de medición. Supongamos que queremos hacer un cálculo de 2 qubits, por ejemplo, digamos, una puerta X en qubit-1 seguida de una puerta CNOT con qubit-1 como bit de control y qubit-2 como bit de destino.

P: ¿Cómo se realiza este cálculo en una computadora cuántica con una disposición de qubits de código de superficie 2D? es decir, ¿qué puertas se aplican y en qué qubits?

Ilustraré cómo se pueden realizar operaciones usando operaciones lógicas en los qubits, y usando cirugía de celosía para operaciones de dos qubit.

En los diagramas a continuación, todos los 'puntos' son qubits de datos: los qubits de medición se omiten para ayudar a demostrar los principios básicos más claramente. Los qubits de medición están ahí para cuando realiza mediciones de estabilizador, y solo están involucrados en mediciones de estabilizador, por lo que la historia trata sobre lo que hace con los qubits de datos, incluidas las medidas de estabilizador que realiza en los qubits de datos.

Códigos de superficie y operaciones lógicas de Pauli de un solo bit

Se pueden usar fragmentos del avión para almacenar qubits. La imagen a continuación muestra cuatro qubits que están codificados como parte de una red más grande: los puntos de luz con contornos negros son qubits que no están involucrados en los qubits codificados y, en principio, pueden estar en cualquier estado que desee, desenredados del resto.
$\qquad\qquad\qquad$

En cada uno de estos fragmentos, el qubit se define por las relaciones estabilizadoras que (idealmente, en ausencia de errores) se mantienen entre los qubits. Para los códigos de superficie con el tipo de condiciones de límite ilustradas aquí, estos son estabilizadores X o Z de 3 qubits alrededor del límite, y estabilizadores X o Z de 4 qubits en el 'volumen' o cuerpo del código. El patrón de estos estabilizadores se ilustra a continuación. Tenga en cuenta que cada estabilizador X que se superpone con un estabilizador Z , lo hace a dos qubits, de modo que se conmutan entre sí. (Disculpas por el tamaño de la imagen: no puedo lograr que se muestre a un tamaño razonable).

$\qquad\qquad\qquad$

Tenga en cuenta que al usar la regularidad de estos estabilizadores, no es necesario que el fragmento de código de superficie sea cuadrado (o incluso en principio rectangular). * Esto será importante más adelante.

Hay varias operaciones de Pauli (producto tensorial) que conmutan con todos estos estabilizadores. Estos pueden usarse para definir operadores lógicos de Pauli, que describen formas en las que puede acceder y transformar los qubits lógicos. Por ejemplo, un producto de operadores Z en cualquier fila de un límite a otro se conmutará con todos los estabilizadores, y se puede considerar que representa un operador Z lógico ; De manera similar, un producto de operadores X en cualquier columna de límite a límite se puede tomar para representar un operador X lógico :

$\qquad$

No importa qué fila o columna use: esto se deduce del hecho de que un producto de cualquiera de las dos filas de operadores Z , o de cualquiera de las dos columnas de operadores X , puede generarse como un producto de estabilizadores y, por lo tanto, se da cuenta de un operación de identidad en el qubit codificado (como los generadores estabilizadores mismos son operadores que realizan la operación de identidad en un estado qubit codificado, por definición). Entonces: si desea aplicar una operación X a un qubit codificado, una forma de hacerlo sería aplicar una operación X lógica , realizando X operadores en cada qubit en una columna que alcanza entre dos límites. **

Mediciones lógicas de Pauli de un solo bit

Una ventaja de pensar en los qubits codificados en términos de operadores lógicos es que le permite determinar también cómo puede realizar una 'medición lógica', es decir, una medición no solo de (algunos de) los qubits en el código, sino de los datos que codifican. Tome el operador lógico X anterior, por ejemplo: el operador X ⊗ X ⊗ ... ⊗ X no solo es unitario, sino Hermitiano, lo que significa que es un observable que puede medir . (La misma idea se usa todo el tiempo con los estabilizadores del código, por supuesto, que medimos para tratar de detectar errores). Esto significa que para realizar una medición X lógica , es suficiente medir la lógica. Xobservable. (Lo mismo ocurre con el Z lógico observable, si desea realizar una medición base estándar en su qubit codificado; y todo lo que digo a continuación también se puede aplicar a las mediciones lógicas Z con las modificaciones apropiadas).

Ahora: medir el observable X lógico no es exactamente lo mismo que medir cada uno de esos operadores X de un solo qubit de uno en uno. El operador X ⊗ X ⊗ ... ⊗ X tiene solo dos valores propios, +1 y −1, por lo que medir ese operador preciso solo puede tener dos resultados, mientras que medir cada uno de n qubits tendrá 2 ⁿ resultados. Además, medir cada uno de esos operadores X de un solo qubit no lo mantendrá en el espacio de código: si desea hacer cálculos en un estado proyectado posterior a la medición, tendría que hacer mucho trabajo de limpieza para restaurar el qubit a un estado codificado correctamente.

Sin embargo: si no le importa hacer ese trabajo de limpieza, o si no le importa trabajar con el estado posterior a la medición, puede simular la medición X lógica haciendo esas mediciones de un solo qubit, obteniendo +1 y -1 resultados, y luego calcular sus productos para obtener cuál fue el resultado de la medición de X ⊗ X ⊗ ... ⊗ X "habría". (Más precisamente: medir todos esos operadores X de un solo qubit es algo que no perturba un estado que resultaría de una medición del operador del producto tensor X ⊗ X ⊗ ... ⊗ X, y el producto de esas mediciones de un solo qubit tendría que producir un resultado consistente con el operador del producto tensor X ⊗ X ⊗ ... ⊗ X , por lo que podemos usar esto como una forma de simular esa medición más complicada si no lo hacemos ' t tenga en cuenta que todos los qubits que se proyectan en estados de base conjugada son un efecto secundario).

Cirugía de celosía para operaciones lógicas de dos qubits

Para realizar una operación de dos qubits, puede usar una técnica conocida como cirugía de red , en la que 'fusiona' y 'divide' diferentes parches de la red 2D para realizar operaciones entre esos parches (consulte [ arXiv: 1111.4022 ], [ arXiv: 1612.07330 ], o [ arXiv: 1704.08670 ] para descripciones completas de estas operaciones. Divulgación: Soy un autor en el tercero de estos artículos.) Esto se puede realizar entre dos parches adyacentes de la red plana (como se ilustra arriba) preparando esos filas y columnas "no involucradas" de qubits en un estado adecuado, y luego midiendo estabilizadores que anteriormente no medíanpara extender la memoria a un sistema más grande. (En el siguiente diagrama, el espacio horizontal entre los segmentos de código y la columna de qubits en los estados | 0⟩ es exagerado para el efecto).

$\qquad$

Esto afectará a los operadores lógicos del sistema de una manera no unitaria, y se usa con mayor frecuencia (ver [ arXiv: 1612.07330 ] por ejemplo) para realizar una medición coherente X ⊗ X o Z ⊗ Z , que se puede componer para realizar una operación CNOT [arXiv: 1612.07330, Fig. 1 (b)]:
$\qquad\qquad\qquad$
De esta manera, puede realizar una operación CNOT entre un par de qubits codificados. ***

Notas al pie

* También puede usar ligeras modificaciones del patrón regular de estabilizadores, como lo demuestra Letinsky [ arXiv: 1808.02892 ], para lograr representaciones de superficie plana más versátiles de qubits codificados.

** En la práctica, en lugar de realizar explícitamente operaciones (un solo qubit imperfecto), aprovecharía el hecho de que el marco de referencia para los qubits codificados es uno que está arreglando por convención y actualizar (o 'transformar') el marco de referencia en lugar del estado en sí mismo cuando desea realizar una operación Pauli. Esta es también la forma inteligente de corregir errores: tratar los errores no como 'errores' que deben ser 'corregidos', sino como una deriva incontrolada pero observable en su marco de referencia como resultado de la interacción con el entorno. Luego espera que esta deriva sea lo suficientemente lenta como para poder seguirla con precisión y compensar el cambio en el marco de referencia cuando realice su cálculo. Particularmente en el contexto de errores de seguimiento,Pauli frame , y su trabajo es describir el marco de referencia en términos de las operaciones de Pauli que se requerirían para poner el sistema en el estado generalmente descrito por un código de corrección de errores sin errores.

*** Muchos autores describirían esta construcción como el punto de la cirugía de celosía, y ciertamente es la aplicación concreta original que se describe en el artículo original [ arXiv: 1111.4022 ]. En principio, es posible realizar operaciones más elaboradas utilizando divisiones y fusiones, tratando las fusiones y divisiones como operaciones primitivas por derecho propio en lugar de solo los componentes de un CNOT, y utilizando transformaciones más versátiles (pero no especialmente de circuito) - este es esencialmente el punto de mi artículo con Dom Horsman [ arXiv: 1704.08670 ], que abre la posibilidad de que el cálculo ZX (una representación algo heterodoxa de la computación cuántica) sea directamente útil en la práctica para las memorias de código de superficie.

Una forma de almacenar qubits en el código de superficie es como pares de "agujeros". Un agujero es un trozo de la superficie donde, en lugar de realizar las medidas del estabilizador utilizadas para detectar si se están produciendo errores, en su lugar no hace nada.

Existen dos tipos diferentes de orificios, dependiendo de si el límite del orificio se desplaza a lo largo de qubits de medición X posibles o a lo largo de qubits de medición Z potenciales. Un CNOT se realiza ciclando un agujero de un tipo alrededor de un agujero del otro tipo.

Diagramáticamente hablando, se ve así:

En el diagrama (b), el tiempo se mueve de izquierda a derecha. Cada barra corresponde a la ubicación de un agujero a lo largo del tiempo. Cada qubit se almacena entre los pares correspondientes de barras blancas. La barra negra representa el agujero que se utiliza para realizar el CNOT. Evita el qubit medio (que no está involucrado), rodea una de las barras del qubit inferior (que es el objetivo) y rodea una 'barra transversal' introducida en el qubit superior (que es el control). Así es como se ve un código de superficie CNOT.

Existen múltiples formas de almacenar información en códigos de superficie. Dependiendo del método que utilice, existen múltiples formas de hacer puertas. ¡Entonces hay mucho que decir sobre este tema!

A pesar de la multiplicidad de métodos, en términos prácticos, todos llegan a ser casi lo mismo: si desea que el código mantenga la tolerancia a fallas, solo puede hacer puertas Clifford (como X, Z, H, CNOT , S). Para otras puertas, deberá invocar mecanismos adicionales para ser tolerantes a fallas, como la destilación de estado mágico.

Pero no pediste nada más que Clifford en tu ejemplo. Solo querías una X y una CNOT. Entonces eso facilita las cosas.

Para un ejemplo concreto, tomemos el código de superficie de 17 qubits que se muestra a continuación (como se muestra en este documento , del cual soy autor).

$n=9$$0$$8$

$\sigma_x$$\sigma_x^0 \otimes \sigma_x^1 \otimes \sigma_x^3 \otimes \sigma_x^4$$\sigma_x^1 \otimes \sigma_x^2$$\sigma_z$

$\sigma_x$$\sigma_x^0 \otimes \sigma_x^3 \otimes \sigma_x^6$$\sigma_x$$\sigma_z^3 \otimes \sigma_z^4 \otimes \sigma_z^5$

$\sigma_x$$sigma_z$$X$$Z$

$X$

$A$$B$$0, 1, 2, \ldots$$0_A$$0$$A$

${\rm CNOT}(A,B)$$A$$B$

$|0\rangle$$|1\rangle$

$| \tilde 0 \rangle = |0\rangle^{\otimes n}$$|0\rangle$$| \tilde 1 \rangle = X | \tilde 0 \rangle$$|1\rangle$$|0\rangle$

$|0\rangle$$| \tilde 0 \rangle$$| \tilde 0 \rangle$$|1\rangle$$| \tilde 1 \rangle$$| \tilde 1 \rangle$

Al pensar en la acción de los CNOT transversales en términos de estos estados, es de esperar que pueda ver cómo actúa como un CNOT en los qubits lógicos.