Sparse kwantumsimulator

De sparse-simulator is de standaard lokale simulator voor Azure Quantum-ontwikkelomgevingen en maakt gebruik van een sparse-weergave van kwantumstatusvectoren. Met deze functie kan de sparse simulator de geheugenvoetafdruk minimaliseren die wordt gebruikt om kwantumstatussen weer te geven, waardoor simulaties via een groter aantal qubits worden ingeschakeld. De sparse-simulator is efficiënt voor het weergeven van kwantumtoestanden die in de rekenkundige basis zijn geparseerd, dat wil gezegd kwantumtoestanden waarvoor de meeste amplitudecoëfficiënten nul zijn in de rekenkundige basis. De sparse-simulator stelt gebruikers in staat om grotere toepassingen te verkennen dan wat kan worden weergegeven met behulp van een volledige-statussimulator die zowel geheugen als tijd verspilt aan een exponentieel groot aantal nul-amplitudes.

Zie Jaques en Häner (arXiv:2105.01533) voor meer informatie over de sparse simulator.

De sparse-simulator aanroepen

De sparse-simulator is de standaard lokale simulator in Visual Studio Code waarop de Azure-extensie Quantum Development Kit is geïnstalleerd.

Pauli-ruis toevoegen aan de sparse simulator

De sparse simulator ondersteunt het toevoegen van Pauli-ruis aan de simulatie. Met deze functie kunt u de effecten van ruis op kwantumbewerkingen en metingen simuleren. Het ruismodel wordt opgegeven met behulp van een woordenlijst van Pauli-ruiskansen, waarbij de sleutels de Pauli-operatoren XYzijn, en , en Zde waarden de waarschijnlijkheid zijn van het toepassen van de bijbehorende Pauli-operator. Het ruismodel kan worden gebruikt in Q# programma's, Python-programma's of geconfigureerd in de VS Code-instellingen.

Pauli-ruis toevoegen met behulp van de VS Code-instellingen

Pauli-ruis kan globaal worden geconfigureerd in Visual Studio Code door de Q#> gebruikersinstelling Simulation:Pauli Noise te configureren.

De instellingen zijn van toepassing op histogramresultaten voor alle Q# programma's die worden uitgevoerd in VS Code en op alle poorten, metingen en qubits waarnaar in het programma wordt verwezen. De instellingen zijn identiek aan het gebruik van de ConfigurePauliNoise() functie.

Het uitvoeren van een histogram van het volgende GHz-voorbeeldprogramma zonder geconfigureerde ruis retourneert $\ket{00000}$ ongeveer de helft van de tijd en $\ket{11111}$ de andere helft.

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

Als je echter 1% bit-flip-ruis toevoegt, zie je dat de toestand begint te diffunderen, en bij 25% ruis is de toestand niet te onderscheiden van ruis.

Pauli-ruis toevoegen aan Q# programma's

U kunt de ConfigurePauliNoise() functie gebruiken om het ruismodel voor afzonderlijke Q# programma's in te stellen of te wijzigen. Met behulp van ConfigurePauliNoise()kunt u nauwkeurig bepalen waar ruis wordt toegepast in uw Q# programma's.

In het vorige programma kunt u bijvoorbeeld direct na de toewijzing van qubits ruis toevoegen:

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

of net vóór de meetbewerking.

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

U kunt ook de ConfigurePauliNoise() configuraties voor ruis opnieuw instellen of wissen. In dit voorbeeld worden de ruisinstellingen ingesteld na de qubittoewijzing en vervolgens onmiddellijk na de Hadamard-bewerking gewist, zodat ruis alleen op de H(); bewerking wordt toegepast.

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

De volgende functies zijn beschikbaar in de Std.Diagnostics bibliotheek voor het configureren van ruis in Q# programma's:

Pauli-ruis toevoegen aan Python-programma's of Jupyter Notebooks

Pauli-ruisconfiguratie is beschikbaar met het qdk.qsharp Python-pakket en de mogelijkheid voor histogrammen met het qdk.widgets pakket. Ruis wordt toegevoegd als parameter aan de qsharp.run methode.

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

In het volgende voorbeeld ziet u het effect van 10% depolariserende ruis op een belstatusmeting.

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

Willekeurige Pauli-ruis kan worden toegevoegd aan het ruismodel door de waarschijnlijkheden van elke Pauli-operator op te geven. Laten we het vorige GHz-voorbeeldprogramma gebruiken:

%%qsharp

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

Deze uitvoering van het programma past ruis toe met 20% waarschijnlijkheid (bit-flip de helft van de tijd en fase-flip de helft van de tijd),

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

en deze uitvoering past Pauli-Y ruis met 10% waarschijnlijkheid toe.

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