Simulateur quantique parcimonieux

Le simulateur éparse utilise une représentation éparse des vecteurs d’état quantique. Un état quantique parcimonieux est un état où la plupart des coefficients d’amplitude sont des zéros. Les représentations éparses permettent au simulateur éparse de réduire l’empreinte mémoire requise pour représenter les états quantiques, ce qui permet des simulations sur un plus grand nombre de qubits. Le simulateur clairsemé est efficace pour les programmes avec des états quantiques clairsemés dans la base de calcul. Le simulateur épars permet aux utilisateurs d’explorer de plus grandes applications qu’un simulateur à état complet, car les simulateurs à état complet gaspillent de la mémoire et du temps sur un nombre exponentiellement élevé d’amplitudes nulles.

Pour plus d’informations sur le simulateur épars, consultez Jaques et Häner (arXiv :2105.01533).

Appeler le simulateur partiellement alloué

Le simulateur éparse est le simulateur local par défaut dans l’extension MicrosoftQuantum Development Kit (QDK) pour Visual Studio Code (VS Code). L'utilisation du simulateur épars dépend de votre environnement de développement.

Environnement de développement Comment appeler le simulateur parcimonieux
Dans un Q# ou OpenQASM programme dans VS Code Exécuter le fichier Q# ou OpenQASM
Dans un programme Python avec la bibliothèque qdk qsharp.run
ou
openqasm.run
ou
qiskit.QSharpBackend
Dans une %%qsharp cellule de bloc-notes Appelez l’opération d’entrée de programme, par exemple :
Main()

Ajouter Pauli du bruit au simulateur épars dans VS Code

Le simulateur clairsemé prend en charge l’ajout de Pauli bruit aux simulations de vos Q# programmes avec l’extension VS Code. Cette fonctionnalité vous permet de simuler les effets du bruit sur les opérations quantiques et les mesures. Pour spécifier un modèle de bruit dans votre Q# programme, utilisez la ConfigurePauliNoise fonction. La fonction définit les probabilités pour Pauli les opérateurs X, Yet Z, le bruit doit se produire. Vous pouvez également configurer des modèles de bruit globaux dans les paramètres d’extension.

Ajouter Pauli du bruit à l'aide des réglages VS Code

Pour définir le bruit global Pauli pour les programmes Q# dans VS Code, configurez le paramètre utilisateur Simulation : Bruit Q#> pour l’extension QDK.

Capture d’écran montrant les paramètres de bruit globaux Q# de l’extension QDK dans VS Code.

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.

Par exemple, un histogramme pour l’exemple de programme GHz suivant sans bruit configuré montre un résultat de $\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;
}

Capture d’écran montrant les résultats sans bruit.

Si vous ajoutez même un taux de bruit de bit-flip de 1 %, les résultats commencent à se brouiller. Avec un bruit de flipping de bits de 25 %, l'histogramme est indistinct du bruit pur.

Capture d’écran de QDK dans VS Code qui montre les résultats de l'histogramme pour un programme avec des taux de bruit de retournement de bits de 1 % et 25 %.

Ajouter Pauli du bruit aux programmes individuels Q#

Utilisez la ConfigurePauliNoise fonction pour définir ou modifier le modèle de bruit pour des programmes individuels Q# . La ConfigurePauliNoise fonction vous permet de contrôler quand et où le bruit se produit dans vos Q# programmes.

Note

Si vous configurez le bruit dans les VS Code paramètres, le bruit est appliqué à tous les Q# programmes. Toutefois, la ConfigurePauliNoise fonction remplace les VS Code paramètres de bruit du programme qui appelle la fonction.

Par exemple, dans le programme précédent, vous pouvez ajouter du 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 operations
    ConfigurePauliNoise(0.05, 0.0, 0.0);

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

Capture d’écran montrant les résultats des histogrammes avec du bruit ajouté après l’allocation de qubit.

Vous pouvez également ajouter du bruit à l’opération de mesure uniquement.

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

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

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

Capture d’écran montrant les résultats de l’histogramme avec le bruit ajouté juste avant la mesure.

Pour modifier ou effacer les configurations de bruit à différents points de votre programme, appelez ConfigurePauliNoise plusieurs fois. Par exemple, vous pouvez définir un bruit de basculement binaire de 5 % sur la porte Hadamard et ne pas définir de 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

La ConfigureNoiseFunction fonction est suffisante pour modéliser n’importe quel type de Pauli bruit dans votre programme, mais Q# a d’autres fonctions de bruit que vous pouvez également utiliser. Les fonctions suivantes sont disponibles dans la Std.Diagnostics bibliothèque pour configurer le bruit dans les Q# programmes :

Fonction Descriptif Example
ConfigurePauliNoise Configure le Pauli bruit pour une exécution de simulateur. Les paramètres représentent les probabilités de bruit de porte Pauli X, Y et Z. La configuration du bruit s’applique à toutes les portes, mesures et qubits suivants dans un Q# programme. Remplace les paramètres de bruit de l’extension VS Code . Les appels suivants à ConfigurePauliNoise écrasent le bruit défini par les appels précédents. ConfigurePauliNoise(0.1, 0.0, 0.5)
ou
ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise Configure uniquement le bruit de porte 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 Configure uniquement le bruit de porte 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 Configure le bruit pour être une porte X, Y ou Z avec des probabilités égales. 6% de bruit de dépolarisation
ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.2, 0.2, 0.2)
NoNoise Réinitialise le modèle de bruit pour qu’il n’ait aucun 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]);
...
  • Last updated on