Simulateur quantique partiellement alloué

Le simulateur éparse est le simulateur local par défaut pour les environnements de développement Azure Quantum, et utilise une représentation éparse des vecteurs d’état quantique. Cette fonctionnalité permet au simulateur de parcimonie de minimiser l’empreinte mémoire utilisée pour représenter les états quantiques, ce qui permet d’effectuer simulations sur un plus grand nombre de qubits. Le simulateur de parcimonie est efficace pour représenter des états quantiques qui sont parcimonieux dans la base de calcul, c’est-à-dire des états quantiques pour lesquels la plupart des coefficients d’amplitude sont nuls dans la base de calcul. Par conséquent, le simulateur éparse permet aux utilisateurs d’explorer des applications plus volumineuses que ce qui peut être représenté à l’aide d’un simulateur à état complet qui gaspille à la fois de la mémoire et du temps sur un nombre exponentiellement élevé d’amplitudes nulles.

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

Appel du simulateur partiellement alloué

Le simulateur clairsemé est le simulateur local par défaut dans Visual Studio Code, avec l’extension Azure Quantum Development Kit installée.

Ajout du bruit Pauli au simulateur éparse

Le simulateur sparse prend en charge l'intégration du bruit de Pauli dans la simulation. Cette fonctionnalité vous permet de simuler les effets du bruit sur les opérations quantiques et les mesures. Le modèle de bruit est spécifié à l’aide d’un dictionnaire de probabilités de bruit Pauli, où les clés sont les opérateurs XPauli, Yet Zles valeurs sont les probabilités d’appliquer l’opérateur Pauli correspondant. Le modèle de bruit peut être utilisé dans les programmes Q#, les programmes Python ou configuré dans les paramètres VS Code.

Ajout de bruit Pauli à l’aide des paramètres VS Code

Le bruit Pauli peut être configuré globalement dans Visual Studio Code en configurant le Q#> paramètre utilisateur Simulation :Pauli Noise .

Les paramètres s'appliquent aux résultats des histogrammes pour tous les programmes exécutés dans VS Code, ainsi qu'à toutes les portes, mesures et qubits référencés dans le programme. Les paramètres sont identiques à l’utilisation de la ConfigurePauliNoise() fonction.

L’exécution d’un histogramme de l’exemple GHz suivant sans bruit configuré retournerait $\ket{00000}$ environ la moitié du temps et $\ket{11111}$ 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;
}

Toutefois, l’ajout de 1% de bruit de renversement de bits montre que l’état commence à se diffuser, et avec 25% de bruit, l’état est indistinguable du bruit.

Ajout de bruit Pauli à Q# des programmes

Vous pouvez utiliser la ConfigurePauliNoise() fonction pour définir ou modifier le modèle de bruit pour des programmes individuels Q# . En utilisant ConfigurePauliNoise(), vous pouvez contrôler de manière granulaire l’endroit où le bruit est appliqué dans vos Q# programmes.

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];
    ConfigurePauliNoise(0.05, 0.0, 0.0); // 5% bit-flip noise applies to all operations
    H(qs[0]);
...

ou juste avant l’opération de mesure.

    ...
    use qs = Qubit[n];
    H(qs[0]);

    ApplyCNOTChain(qs);
    ConfigurePauliNoise(0.05, 0.0, 0.0); // noise applies only to measurement operation 
    let results = MeasureEachZ(qs);
    ...

Vous pouvez également utiliser ConfigurePauliNoise() pour réinitialiser ou effacer les configurations de bruit. Dans cet exemple, les paramètres de bruit sont définis après l’allocation de qubit, puis effacés immédiatement après l’opération Hadamard, afin que le bruit soit appliqué uniquement à l’opération H(); .

...
operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];
    ConfigurePauliNoise(0.05, 0.0, 0.0); // noise applies to H() operation
    H(qs[0]);
    ConfigurePauliNoise(0.0, 0.0, 0.0); // clear noise settings
...

Les fonctions suivantes sont disponibles dans la Std.Diagnostics bibliothèque pour configurer le bruit dans les Q# programmes :

Ajout de bruit Pauli aux programmes Python ou aux notebooks Jupyter

La configuration du bruit Pauli est disponible avec le qdk.qsharp package Python et la fonctionnalité d’histogramme avec le qdk.widgets package. Le bruit est ajouté en tant que paramètre à la qsharp.run méthode.

• qsharp.BitFlipNoise
• qsharp.PhaseFlipNoise
• qsharp.DepolarizingNoise

L’exemple suivant montre l’effet de 10% dépolarisation du bruit sur une mesure de l’état bell.

from qdk import qsharp
from qdk import widgets

%%qsharp

operation BellPair() : Result[] {
    use q = Qubit[2];
    H(q[0]);
    CNOT(q[0], q[1]);
    MResetEachZ(q)
}

results = qsharp.run("BellPair()", 20, noise=qsharp.DepolarizingNoise(0.1))
results

Le bruit de Pauli arbitraire peut être ajouté au modèle de bruit en spécifiant les probabilités de chaque opérateur Pauli. Utilisons le programme d'exemple GHz précédent :

%%qsharp

operation GHzSample() : Result[] {
    use q = Qubit[5];
    H(q[0]);
    ApplyCNOTChain(q);
    MResetEachZ(q)
}

Cette exécution du programme applique un bruit avec une probabilité de 20% (inversion de bit la moitié du temps et inversion de phase l'autre moitié).

result = qsharp.run("GHzSample()", 20, noise=(0.1, 0.0, 0.1))
display(widgets.Histogram(result))

et cette exécution applique un bruit Pauli-Y avec une probabilité de 10%.

result = qsharp.run("GHzSample()", 20, noise=(0.0, 0.1, 0.0))
display(widgets.Histogram(result))