Premiers pas avec QDK pour la correction des erreurs

Le Microsoft Quantum Development Kit (QDK) inclut des Python outils pour développer et tester des protocoles de correction d’erreur quantique (QEC). Utilisez le module qdk.ec pour analyser les codes de correction d’erreur, générer des protocoles exécutables, valider les déclarations de protocole et étudier les défauts de circuit. Utilisez qdk.simulation pour exécuter des programmes logiques via ces protocoles.

Comprendre les outils de QDK correction des erreurs

Le QDK flux de travail de correction des erreurs utilise ces packages et modules :

Un qodec est une description formelle d’un protocole QEC exécutable. Il connecte des instructions logiques aux circuits physiques via une ou plusieurs couches. Le qodec package définit ce modèle de données et sa YAML représentation. Le module qdk.ec dérive des faits du modèle et vérifie si ses déclarations correspondent à ses circuits.

Pour plus d’informations, consultez la qodec vue d’ensemble.

Le module qdk.qre a un objectif différent. Il modélise le coût des ressources d’un schéma de correction d’erreur. Cela ne définit pas, n’audite pas et n’exécute pas de gadgets qodec. Pour plus d’informations sur l’estimation des ressources quantiques dans le QDK, consultez Qu’est-ce que l’estimateur de ressource quantum Microsoft ?

Comprendre les composants du qodec protocole

Les composants suivants définissent un qodec protocole et prennent en charge son exécution.

Un qodec peut contenir plusieurs couches. La couche supérieure peut définir des opérations logiques sur des blocs encodés. Les gadgets de la couche supérieure peuvent appeler des instructions dans la couche inférieure suivante. La couche inférieure contient les opérations physiques exécutées par le simulateur.

Exemple de workflow de protocole

Un flux de travail classique comporte six étapes. Les étapes suivantes utilisent des fonctions et des classes du qdk.ec module.

1. Définissez un code. Créez un qodec.Code avec des stabilisateurs et des opérateurs logiques Pauli .
2. Analysez le code. Utilisez la classe CodeProfile pour inspecter les opérateurs logiques, calculer les syndromes et calculer la distance du code.
3. Créer ou charger un qodec. Utilisez la fonction build_qodec pour créer un protocole de référence initial, ou charger un qodec existant à partir de YAML.
4. Terminez et validez le protocole. Utilisez la fonction filled pour dériver les équations de vérification et de lecture prises en charge. Utilisez la audit fonction pour rechercher des déclarations incohérentes ou incomplètes.
5. Analyser les défauts du circuit. Utilisez la classe GadgetProfile pour inspecter les actions logiques, les effets des défaillances et la distance des gadgets.
6. Exécutez des programmes logiques. Compilez le code Q# ou OpenQASM pour QIR. Transmettez QIR et qodec à qdk.simulation.run_qir, puis sélectionnez un décodeur et un modèle de bruit.

Le code suivant montre les objets principaux de ce flux de travail :

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 stratégie de cet exemple crée un protocole de référence simple sans qubits drapeau. Il vous aide à inspecter le flux de travail, mais il ne garantit pas des composants tolérants aux pannes. Utilisez l’analyse de distance des gadgets avant de choisir une implémentation de protocole.

Validation de protocole distincte de l’analyse des défauts

Les audits de protocole et l’analyse de distance évaluent différents aspects d’un protocole QEC.

• Les audits de protocole vérifient si le protocole déclaré correspond à ses circuits et équations lorsqu’aucune défaillance ne se produit.
• L’analyse de distance détermine le nombre minimal d’erreurs autorisées ou de pannes de circuit qui peuvent provoquer une défaillance logique non détectée.

Utilisez la fonction audit pour vérifier la cohérence en l’absence de bruit. L’audit vérifie l’algèbre du code, les déclarations d’instruction, les actions de gadget, les vérifications, les lectures, les indicateurs, les relations d’images et les références entre les objets qodec.

Un audit qui signale aucun problème ne garantit pas la tolérance de panne. Un circuit peut implémenter l’action logique correcte sans erreur et pourtant échouer après une erreur physique. Utilisez la CodeProfile.distance méthode pour analyser le code et la GadgetProfile.distance méthode pour analyser chaque implémentation de circuit.

Avant d’utiliser un protocole pour les simulations bruyantes, exécutez un audit de protocole et analysez les distances de code et de gadget.

Choisir une stratégie de construction

La fonction build_qodec prend en charge deux stratégies de construction de ligne de base CSS.

Les deux stratégies tentent de créer ces instructions logiques :

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

Certains codes ne prennent pas en charge tous les candidats. Avec le paramètre strict=Truepar défaut, build_qodec déclenche une erreur lorsqu’elle ne peut pas générer et vérifier une instruction. Avec strict=False, build_qodec conserve les instructions prises en charge et enregistre chaque instruction ignorée dans les qodec métadonnées.

Choisir votre prochaine tâche

• Pour préparer un environnement Python, consultez Comment installer QDK pour la correction des erreurs.
• Pour définir un code et créer un protocole, consultez Développer et valider un protocole QEC.
• Pour compiler, simuler et décoder des programmes logiques, consultez Exécuter et décoder des programmes logiques.

Pour obtenir un notebook complet qui suit le flux de travail complet, consultez Développer et tester un protocole QEC dans le QDK référentiel.