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 creux stocke uniquement 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.

L’avantage en matière de performances dépend du fait que l’état quantique reste clairsemé 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 parcimonieux prend en charge Pauli le bruit pour Q# les programmes de 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 Pauli du bruit dans les paramètres VS Code

• Dans VS Code, définissez le bruit global Pauli pour Q# les programmes dans le paramètre utilisateur Q#> Simulation :Pauli Bruit pour 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 Pauli du bruit aux programmes individuels Q#

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 VS Code paramètres appliquent un effet de bruit à tous les Q# programmes, 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 les probabilités des erreurs $X$, $Y$ et $Z$ ou un Pauli modèle de bruit. 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 Pauli des erreurs $X$ avec la probabilité spécifiée.	10% bruit d'inversion de bits : ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise	Retourne un modèle de bruit avec uniquement Pauli des erreurs $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]); ...