Primeros pasos con QDK para la corrección de errores

La Microsoft Quantum Development Kit (QDK) incluye Python herramientas para desarrollar y probar protocolos de corrección de errores cuánticos (QEC). Use el módulo qdk.ec para analizar códigos de corrección de errores, compilar protocolos ejecutables, validar declaraciones de protocolo y estudiar errores del circuito. Utilice qdk.simulation para ejecutar programas lógicos a través de esos protocolos.

Comprenda las herramientas de corrección de QDK errores

El QDK flujo de trabajo de corrección de errores usa estos paquetes y módulos:

Un qodec es una descripción formal de un protocolo QEC ejecutable. Conecta instrucciones lógicas a circuitos físicos a través de una o varias capas. El qodec paquete define este modelo de datos y su YAML representación. El qdk.ec módulo deriva hechos del modelo y comprueba si sus instrucciones coinciden con sus circuitos lógicos.

Para obtener más información, consulte la qodec información general.

El qdk.qre módulo tiene un propósito diferente. Modela el costo de recursos de un esquema de corrección de errores. No define, audita ni ejecuta qodec dispositivos. Para obtener más información sobre la estimación de recursos cuánticos en el QDK, consulte ¿Qué es el estimador de recursos de Microsoft Quantum?

Comprenda los componentes del protocolo qodec

Los siguientes componentes definen un qodec protocolo y admiten su ejecución.

Un qodec puede contener varias capas. La capa superior puede definir operaciones lógicas en bloques codificados. Los gadgets de la capa superior pueden invocar instrucciones en la siguiente capa inferior. La capa inferior contiene las operaciones físicas que ejecuta el simulador.

Flujo de trabajo del protocolo de ejemplo

Un flujo de trabajo típico tiene seis pasos. En los pasos siguientes se usan funciones y clases del qdk.ec módulo.

1. Definir un código. Cree un qodec.Code con estabilizadores y operadores lógicos Pauli.
2. Analice el código. Utilice la clase CodeProfile para inspeccionar operadores lógicos, calcular síndromes y calcular la distancia del código.
3. Compile o cargue un qodec. Use la build_qodec función para crear un protocolo de línea base o cargar un existente qodec desde YAML.
4. Complete y valide el protocolo. Use la filled función para derivar ecuaciones de comprobación y lectura admitidas. Use la audit función para encontrar declaraciones incoherentes o incompletas.
5. Analice los fallos del circuito. Use la clase GadgetProfile para inspeccionar las acciones lógicas, los efectos de fallo y la distancia del gadget.
6. Ejecute programas lógicos. Compila Q# o OpenQASM código a QIR. Pase QIR y qodec a qdk.simulation.run_qir, a continuación, seleccione un modelo de descodificador y ruido.

En el código siguiente se muestran los objetos principales de este flujo de trabajo:

import qodec
from qdk import ec
from qdk.simulation import run_qir

code = qodec.Code(
    "C4",
    stabilizers=["X_0 X_1 X_2 X_3", "Z_0 Z_1 Z_2 Z_3"],
    x=["X_0 X_1", "X_0 X_2"],
    z=["Z_0 Z_2", "Z_0 Z_1"],
)

code_profile = ec.CodeProfile(code)
print("Code distance:", code_profile.distance())

protocol = ec.build_qodec(code, strategy="bare-css/v1", strict=False)
print(ec.audit(protocol))

# Compile a logical program to QIR before you call run_qir.
# results = run_qir(qir, qodec=protocol, shots=100)

La bare-css/v1 estrategia de este ejemplo crea un protocolo de línea base simple sin cúbits bandera. Le ayuda a inspeccionar el flujo de trabajo, pero no garantiza dispositivos tolerantes a fallos. Utilice el análisis de distancia de gadgets antes de elegir una implementación de protocolo.

Separe la validación del protocolo del análisis de errores

Las auditorías de protocolo y el análisis de distancia evalúan diferentes aspectos de un protocolo QEC.

• Las auditorías de protocolo comprueban si el protocolo declarado coincide con sus circuitos y ecuaciones cuando no se producen fallos.
• El análisis de distancia determina el número mínimo de errores permitidos o fallos de circuito que pueden provocar un fallo lógico no detectado.

Usar la función audit para comprobar la coherencia sin ruido. La auditoría comprueba el álgebra de código, las declaraciones de instrucción, las acciones del dispositivo, las comprobaciones, los valores mostrados, las marcas, las relaciones de marco y las referencias entre objetos qodec.

Una auditoría que informa de que no hay problemas no garantiza la tolerancia a errores. Un circuito puede implementar la acción lógica correcta sin errores y aun así fallar tras un fallo físico. Utilice el método CodeProfile.distance para analizar el código y el método GadgetProfile.distance para analizar cada implementación del circuito.

Antes de usar un protocolo para simulaciones ruidosas, ejecute una auditoría de protocolo y analice las distancias de código y gadgets.

Elección de una estrategia de construcción

La build_qodec función admite dos estrategias de construcción de línea base CSS .

Ambas estrategias intentan crear estas instrucciones lógicas:

• prepare_z_all
• prepare_x_all
• syndrome
• measure_z_all
• measure_x_all
• h_all
• cx_all

No todos los códigos admiten todos los candidatos. Con la configuración strict=Truepredeterminada, build_qodec muestra un error cuando no se puede compilar y comprobar una instrucción. Con strict=False, build_qodec mantiene las instrucciones admitidas y registra cada instrucción omitida en los metadatos de qodec.

Elige tu próxima tarea.

• Para preparar un entorno Python, consulte Cómo instalar QDK para la corrección de errores.
• Para definir un código y crear un protocolo, consulte Desarrollar y validar un protocolo QEC.
• Para compilar, simular y descodificar programas lógicos, consulte Ejecutar y descodificar programas lógicos.

Para obtener un cuaderno completo que siga el flujo de trabajo completo, consulte Desarrollar y probar un protocolo QEC en el QDK repositorio.