Symulator kwantowy rozrzednia

Symulator rozrzedny jest domyślnym lokalnym symulatorem środowisk deweloperskich usługi Azure Quantum i wykorzystuje rozrzedliwą reprezentację wektorów stanu kwantowego. Ta funkcja umożliwia symulatorowi rozrzedżenia zminimalizowanie ilości pamięci używanej do reprezentowania stanów kwantowych, co umożliwia symulacje większej liczby kubitów. Symulator rozrzedzonych jest wydajny do reprezentowania stanów kwantowych, które są rozrzedzonych w podstawie obliczeniowej, czyli stanów kwantowych, dla których większość współczynników amplitudy wynosi zero w podstawie obliczeniowej. W związku z tym, rozrzedzony symulator umożliwia użytkownikom eksplorowanie większych aplikacji w porównaniu do tego, co jest możliwe do przedstawienia za pomocą symulatora pełnego stanu, marnując zarówno pamięć, jak i czas na wykładniczo dużą liczbę amplitud zerowych.

Aby uzyskać więcej informacji na temat symulatora rozrzedliwego, zobacz Jaques i Häner (arXiv:2105.01533).

Wywoływanie symulatora rozrzednia

Symulator Sparse jest domyślnym symulatorem lokalnym w programie Visual Studio Code z zainstalowanym rozszerzeniem Azure Quantum Development Kit.

Dodawanie szumu Pauli do rozrzedliwego symulatora

Symulator rozrzedliwy obsługuje dodanie szumu Pauli do symulacji. Ta funkcja umożliwia symulowanie wpływu szumu na operacje kwantowe i pomiary. Model szumu jest określany przy użyciu słownika prawdopodobieństwa szumu Pauli, gdzie klucze są operatorami XPauli , Yi Z, a wartości są prawdopodobieństwem zastosowania odpowiedniego operatora Pauli. Model szumu może być używany w Q# programach, programach w języku Python lub ustawieniach skonfigurowanych w programie VS Code.

Dodawanie szumu Pauli przy użyciu ustawień programu VS Code

Szum Pauli można skonfigurować globalnie w programie Visual Studio Code, konfigurując Q#> ustawienie użytkownika Symulacja:Pauli Noise .

Ustawienia mają zastosowanie do wyników histogramu dla wszystkich programów uruchamianych w programie VS Code oraz do wszystkich Q# bram, pomiarów i kubitów, do których odwołuje się program. Ustawienia są identyczne z użyciem ConfigurePauliNoise() funkcji .

Uruchomienie histogramu z następującego programu próbkującego GHz bez skonfigurowanego szumu zwróci wartość $\ket{00000}$ mniej więcej w połowie przypadków, a $\ket{11111}$ w pozostałej połowie przypadków.

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

Jednak dodanie 1% szumu bit-flipowego pokazuje, że stan zaczyna się rozpraszać, a przy 25% szumu stan jest nie do odróżnienia od szumu.

Dodawanie szumu Pauli do Q# programów

Za pomocą ConfigurePauliNoise() funkcji można ustawić lub zmodyfikować model szumu dla poszczególnych Q# programów. Za pomocą ConfigurePauliNoise() można szczegółowo kontrolować, gdzie szum jest stosowany w programach Q#.

Na przykład w poprzednim programie można dodać szum natychmiast po alokacji kubitu:

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

lub tuż przed operacją pomiaru.

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

Można również użyć ConfigurePauliNoise() polecenia , aby zresetować lub wyczyścić konfiguracje szumu. W tym przykładzie ustawienia szumu są skonfigurowane po alokacji kubitu, a następnie czyszczone natychmiast po operacji Hadamard, tak aby szum był stosowany tylko do H(); operacji.

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

Następujące funkcje są dostępne w bibliotece Std.Diagnostics do konfigurowania szumu w programach Q#:

Dodawanie szumu Pauli do programów w języku Python lub notatników Jupyter

Konfiguracja szumu Pauli jest dostępna w pakiecie qdk.qsharp Python, a zdolność histogramu w pakiecie qdk.widgets. Szum jest dodawany jako parametr do qsharp.run metody .

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

Poniższy przykład przedstawia wpływ 10% depolaryzującego szumu na pomiar stanu Bella.

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

Dowolny szum Pauli można dodać do modelu szumu, określając prawdopodobieństwo każdego operatora Pauli. Użyjmy poprzedniego przykładowego programu GHz:

%%qsharp

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

Ten przebieg programu stosuje szum z prawdopodobieństwem 20% (połowę przypadków bit-flip, a połowę przypadków zamiana fazy).

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

ten przebieg stosuje szum Pauli-Y z prawdopodobieństwem 10%.

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