Geringer Quantensimulator

Der sparse Simulator ist der standardmäßige lokale Simulator für Azure Quantum-Entwicklungsumgebungen und verwendet eine geringe Darstellung von Quantenzustandsvektoren. Mit diesem Feature kann der Sparse-Simulator den Speicherbedarf für die Darstellung von Quantenzuständen minimieren, was Simulationen mit mehr Qubits ermöglicht. Der Sparse-Simulator ist effizient für die Darstellung von Quantenzuständen, die in der Berechnungsbasis dünn besetzt sind (also für Quantenzustände, bei denen die Mehrzahl der Amplitudenkoeffizienten in der Berechnungsbasis null ist). Der sparse Simulator ermöglicht es Benutzern, größere Anwendungen zu erkunden als das, was mit einem Vollzustandssimulator dargestellt werden kann, der sowohl Arbeitsspeicher als auch Zeit für eine exponentielle Anzahl von Null-Amplituden verschwendet.

Weitere Informationen zum Sparse-Simulator finden Sie unter Jaques und Häner (arXiv:2105.01533).

Aufrufen des Sparsesimulators

Der Sparsesimulator ist der lokale Standardsimulator in Visual Studio Code, auf dem die Azure-Erweiterung Quantum Development Kit installiert ist.

Hinzufügen von Pauli-Rauschen zu dem spärlichen Simulator

Der sparse Simulator unterstützt das Hinzufügen von Pauli-Rauschen zur Simulation. Mit diesem Feature können Sie die Auswirkungen von Rauschen auf Quantenvorgänge und Messungen simulieren. Das Rauschmodell wird mithilfe eines Wörterbuchs für Pauli-Rauschwahrscheinlichkeiten spezifiziert, wobei die Schlüssel die Pauli-Operatoren X, Y und Z sind und die Werte die Wahrscheinlichkeiten darstellen, den entsprechenden Pauli-Operator anzuwenden. Das Rauschmodell kann in Q# Programmen, Python-Programmen oder in den VS-Code-Einstellungen genutzt werden.

Hinzufügen von Pauli-Rauschen mithilfe der VS Code-Einstellungen

Pauli-Rauschen können global in Visual Studio Code konfiguriert werden, indem die Q#> Benutzereinstellung Simulation:Pauli Noise konfiguriert wird.

Die Einstellungen gelten für Histogramme für alle Q# Programme, die in VS Code laufen, und für alle Gates, Messungen und Qubits, auf die im Programm verwiesen wird. Die Einstellungen sind identisch mit der Verwendung der ConfigurePauliNoise() Funktion.

Wenn Sie ein Histogramm des folgenden GHz-Beispielprogramms ohne Rauschen ausführen, würde $\ket{00000}$ ungefähr die Hälfte der Zeit und $\ket{11111}$ die andere Hälfte zurückgeben.

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;
}

Das Hinzufügen von 1% Bit-Flip-Rauschen zeigt jedoch, dass der Zustand beginnt, sich zu zerstreuen, und mit 25% Rauschen ist der Zustand nicht mehr von Rauschen zu unterscheiden.

Hinzufügen von Pauli-Rauschen zu Q# Programmen

Sie können die ConfigurePauliNoise() Funktion verwenden, um das Rauschmodell für einzelne Q# Programme festzulegen oder zu ändern. Mithilfe von ConfigurePauliNoise() können Sie detailliert steuern, wo Rauschen in Ihren Q# Programmen angewendet wird.

Zum Beispiel können Sie im vorherigen Programm unmittelbar nach der Qubit-Zuweisung Rauschen hinzufügen:

...
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]);
...

oder direkt vor dem Messvorgang.

    ...
    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);
    ...

Sie können auch ConfigurePauliNoise() zum Zurücksetzen oder Löschen von Geräuschkonfigurationen verwenden. In diesem Beispiel werden die Rauscheinstellungen nach der Qubitzuordnung festgelegt und dann unmittelbar nach dem Hadamard-Vorgang gelöscht, sodass Rauschen nur auf den H(); Vorgang angewendet wird.

...
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
...

Die folgenden Funktionen stehen in der Std.Diagnostics Bibliothek zum Konfigurieren von Rauschen in Q# Programmen zur Verfügung:

Hinzufügen von Pauli-Rauschen zu Python-Programmen oder Jupyter-Notizbüchern

Die Pauli-Rauschkonfiguration ist mit dem qdk.qsharp-Python-Paket verfügbar, und die Histogrammfunktionalität mit dem qdk.widgets-Paket. Rauschen wird der Methode als Parameter qsharp.run hinzugefügt.

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

Das folgende Beispiel zeigt die Wirkung von 10% depolarisierendem Rauschen auf eine Bell-Zustandsmessung.

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

Beliebige Pauli-Rauschen können dem Rauschmodell hinzugefügt werden, indem die Wahrscheinlichkeit jedes Pauli-Operators angegeben wird. Lassen Sie uns das vorherige GHz-Beispielprogramm verwenden:

%%qsharp

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

Diese Ausführung des Programms wendet Rauschen mit 20% Wahrscheinlichkeit an (Bit-Flip die Hälfte der Zeit und Phasenflip die andere Hälfte der Zeit).

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

und bei diesem Durchlauf wird Pauli-Y-Rauschen mit einer Wahrscheinlichkeit von 10 % angewendet.

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