Exécuter des simulations quantiques dans l’extension QDK pour Visual Studio Code

L’extension MicrosoftQuantum Development Kit (QDK) pour Visual Studio Code (VS Code) exécute automatiquement les programmes Q# et OpenQASM sur son simulateur sparse local.

Cet article explique comment exécuter des programmes sur le simulateur local et comment ajouter Pauli du bruit aux Q# simulations. Pour utiliser les autres QDK simulateurs à partir de Python, consultez Exécuter des simulations quantiques avec le QDKPython package.

Fonctionnement du simulateur local

Le simulateur à états creux ne stocke que les amplitudes non nulles d’un état quantique. Lorsque la plupart des amplitudes de base de calcul sont nulles, cette représentation utilise moins de mémoire et peut simuler certains programmes avec plus de qubits qu’un simulateur à état complet, qui stocke toutes les amplitudes.

Le gain de performances dépend du fait que l’état quantique reste creux dans la base de calcul. Pour plus d’informations, consultez Jaques et Häner (arXiv :2105.01533).

Exécuter un programme quantique dans VS Code

1. Installez l’extensionQDK pour VS Code.
2. Ouvrez un fichier Q# (.qs) ou OpenQASM (.qasm).
3. Sélectionnez Exécuter dans CodeLens au début du code ou au-dessus de l’opération Q#Main.

La sortie de simulation s’affiche dans le VS Code terminal. Pour les programmes Q#, sélectionnez Débogage pour inspecter l’état quantique du programme lors de son exécution.

Ajouter Pauli du bruit aux Q# simulations

Le simulateur à états creux prend en charge le bruit de type Pauli noise for Q# pour les programmes dans l’extension QDK. Utilisez ConfigurePauliNoise pour définir les probabilités des erreurs Pauli $X$, $Y$ et $Z$ dans un programme. Les QDK paramètres d’extension prennent également en charge un Pauli modèle de bruit global.

Note

Vous ne pouvez pas ajouter de modèle de bruit à une OpenQASM simulation dans l’extension QDK . Pour générer des modèles de bruit spécifiques à l’opération pour les programmes Q# ou QDK, utilisez le package PythonNoiseConfig et l’API OpenQASM.

Ajouter du bruit Pauli dans les paramètres VS Code

• Dans VS Code, définissez le bruit global de type Pauli pour les programmes Q# dans le paramètre utilisateur Q#> Simulation:Pauli Noise de l’extension QDK.

Les paramètres de bruit s’appliquent aux résultats de l’histogramme pour toutes les portes, mesures et qubits dans tous les Q# programmes dans VS Code.

Sans bruit, un histogramme pour cet GHZ exemple de programme montre $\ket{00000}$ pour environ la moitié des mesures et $\ket{11111}$ pour l’autre moitié.

import Std.Diagnostics.*;
import Std.Measurement.*;

operation Main() : Result[] {
    let num = 5;
    return GHZSample(num);
}

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

À un taux de bruit bit-flip de 1 %, les résultats commencent à se disperser. À 25%, l’histogramme est impossible à distinguer du bruit pur.

Ajouter du bruit Pauli aux programmes Q# individuels

Utilisez ConfigurePauliNoise pour définir ou modifier le modèle de bruit d’un programme Q# et contrôler quand et où le bruit se produit.

Note

Les paramètres VS Code appliquent un effet de bruit à tous les programmes Q#, mais ConfigurePauliNoise remplace ces paramètres pour le programme qui l’appelle.

Dans le programme précédent, ajoutez le bruit immédiatement après l’allocation de qubit :

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    // 5% bit-flip noise applies to all subsequent operations.
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Pour appliquer le bruit uniquement à l’opération de mesure, définissez le modèle de bruit immédiatement avant la mesure et effacez-le ensuite :

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);

    // Noise applies only to the measurement operation.
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Pour modifier ou effacer la configuration du bruit à différents points de votre programme, appelez ConfigurePauliNoise plusieurs fois. Par exemple, appliquez un bruit de retournement de bit de 5 % à la porte Hadamard, puis effacez la configuration du bruit pour le reste du programme.

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    // Noise applies to the H operation.
    ConfigurePauliNoise(0.05, 0.0, 0.0);
    
    H(qs[0]);

    // Clear the noise settings.
    ConfigurePauliNoise(0.0, 0.0, 0.0);
    
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Autres Q# fonctions de bruit

ConfigurePauliNoise prend en charge n’importe quel modèle de bruit Pauli. Utilisez ces fonctions et opérations à partir de l’espace de noms Std.Diagnostics pour configurer ou appliquer le bruit :

Function	Description	Exemple
ConfigurePauliNoise	Définit le bruit Pauli pour une simulation. Transmettez soit les probabilités des erreurs Pauli $X$, $Y$ et $Z$ ou un modèle de bruit Pauli. La configuration s’applique à toutes les portes, mesures et qubits suivants dans un Q# programme et remplace les VS Code paramètres de bruit d’extension. Les appels suivants remplacent les configurations antérieures.	ConfigurePauliNoise(0.1, 0.0, 0.5) ou ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise	Retourne un modèle de bruit avec uniquement des erreurs Pauli $X$ avec la probabilité spécifiée.	Bruit d’inversion de bits de 10 % : ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise	Retourne un modèle de bruit avec uniquement des erreurs Pauli $Z$ avec la probabilité spécifiée.	10 % de bruit de renversement de phase : ConfigurePauliNoise(PhaseFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.1)
DepolarizingNoise	Retourne un modèle de bruit avec des probabilités égales pour Pauli les erreurs $X$, $Y$ et $Z$.	6% de bruit de dépolarisation ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.02, 0.02, 0.02)
NoNoise	Retourne un modèle avec aucune probabilité d’erreur. Transmettez-le à ConfigurePauliNoise pour effacer la configuration actuelle du bruit.	ConfigurePauliNoise(NoNoise()) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.0)
ApplyIdleNoise	Applique le bruit configuré à un qubit unique pendant la simulation.	... use q = Qubit[2]; ConfigurePauliNoise(0.1, 0.0, 0.0); ApplyIdleNoise(q[0]); ...