Kwantumcircuitdiagrammen visualiseren met Q#

Artikel
04/30/2024

Kwantumcircuitdiagrammen zijn een visuele weergave van kwantumbewerkingen. Ze tonen de stroom van qubits door het kwantumprogramma, inclusief de poorten en metingen die erop zijn toegepast.

In dit artikel leert u hoe u kwantumalgoritmen visueel kunt weergeven met kwantumcircuitdiagrammen met behulp van Visual Studio Code en Jupyter Notebooks.

Zie Conventies voor kwantumcircuits voor meer informatie over conventies voor kwantumcircuitdiagrammen.

Als u Visual Studio Code wilt gebruiken om kwantumcircuits te visualiseren, hebt u het volgende nodig:

De nieuwste versie van Visual Studio Code of open VS Code op het web.
De nieuwste versie van de Azure Quantum Development Kit-extensie .

Als u Jupyter Notebooks wilt gebruiken om kwantumcircuits te visualiseren, hebt u het volgende nodig:

De nieuwste versie van Visual Studio Code of open VS Code op het web.
VS Code met de Azure Quantum Development Kit, Python en Jupyter-extensies geïnstalleerd.
De nieuwste Azure Quantum qsharp en qsharp-widgets pakketten, en het ipykernel pakket.
```
python -m pip install --upgrade qsharp qsharp-widgets ipykernel
```

Kwantumcircuits met Visual Studio Code

Volg deze stappen om kwantumcircuits van Q# programma's in Visual Studio Code te visualiseren. Zie Conventies voor kwantumcircuits voor meer informatie over conventies voor kwantumcircuitdiagrammen.

Circuitdiagrammen voor een Q# programma weergeven

Open een Q# bestand in Visual Studio Code of laad een van de kwantumvoorbeelden.
Als u het kwantumcircuit van het Q# programma wilt visualiseren, selecteert u Weergeven -> Opdrachtpalet en typt u 'circuit' waarmee de Q#optie : Circuit weergeven wordt weergegeven. U kunt ook klikken op Circuit in de lijst met opdrachten hieronder @EntryPoint().
Het circuit wordt weergegeven in het Q# circuitvenster. Het volgende circuit komt bijvoorbeeld overeen met een bewerking die een qubit in een superpositie plaatst en deze vervolgens meet. In het circuitdiagram ziet u één qubitregister dat is geïnitialiseerd met de status |0⟩. Vervolgens wordt een Hadamard-poort, H, toegepast op de qubit, gevolgd door een meetbewerking, die wordt vertegenwoordigd door een metersymbool.

Circuitdiagrammen voor bewerkingen weergeven

U kunt het kwantumcircuit visualiseren voor één Q# bewerking. Klik hiervoor op de knop Circuit in de codelens die boven de bewerkingsdeclaratie wordt weergegeven.

Schermopname van Visual Studio Code die laat zien hoe u de circuits in het Q# deelvenster Circuits kunt visualiseren na het opsporen van fouten in het programma.

Circuitdiagrammen weergeven bij foutopsporing

Wanneer u fouten in een Q# programma opspoort, kunt u het kwantumcircuit visualiseren op basis van de huidige status van het programma.

Klik op de knop Foutopsporing in de lijst met codelensopdrachten hieronder @EntryPoint().
Vouw in de weergave Uitvoeren en foutopsporing aan de linkerkant de sectie Kwantumcircuit onder het deelvenster Variabelen uit om het circuit weer te geven terwijl u het programma doorloopt.
U kunt de code doorlopen en onderbrekingspunten in verschillende punten instellen om de circuitupdate te zien terwijl het programma wordt uitgevoerd.
Het huidige kwantumcircuit wordt weergegeven in het Q# deelvenster Circuit. Dit circuitdiagram geeft de huidige status van de simulator weer, dat wil gezegd, de poorten die zijn toegepast tot het huidige uitvoeringspunt.

Kwantumcircuits met Jupyter Notebooks

In Jupyter Notebooks kunt u kwantumcircuits visualiseren met behulp van het qsharp-widgets pakket. Dit pakket bevat een widget waarmee een kwantumcircuitdiagram wordt weergegeven als een SVG-afbeelding.

Selecteer in Visual Studio Code het palet Opdrachten weergeven > en selecteer Creatie: Nieuwe Jupyter Notebook.
Voer in de eerste cel van het notebook de volgende code uit om de Q# module te importeren.
```
import qsharp
```
Voeg een nieuwe cel toe en voer de code in Q# . Met de volgende code wordt bijvoorbeeld een klokstatus voorbereid.
```
%%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);
```
U kunt de dump_circuit() functie gebruiken om een kwantumcircuit weer te geven op basis van de huidige status van het programma. Het circuitdiagram toont bijvoorbeeld twee qubitregisters die zijn geïnitialiseerd met de status |0⟩. Vervolgens wordt een Hadamard-poort, H, toegepast op de eerste qubit. Daarna wordt een CNOT-poort toegepast met behulp van de eerste qubit als besturingselement, die wordt weergegeven als een punt, en de tweede qubit als target, die wordt weergegeven als een X.
```
qsharp.dump_circuit()
```
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
U kunt kwantumcircuits visualiseren als een SVG-afbeelding met behulp van het qsharp-widgets pakket. In dit geval wordt de CNOT-poort weergegeven als een lijn die de twee qubits verbindt, met een punt op de controle-qubit en een begrensd kruis op de target qubit. Zie Conventies voor kwantumcircuits voor meer informatie.
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Circuitdiagrammen weergeven voor een vermeldingsexpressie

U kunt een circuitdiagram genereren voor elk programma met een invoerexpressie door de invoerexpressie aan te roepen qsharp.circuit() en door te geven als argument.

Voeg bijvoorbeeld een nieuwe cel toe en kopieer de volgende code, waarmee een GHZ-status wordt voorbereid.

%%qsharp

open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Measurement;

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    H(qs[0]);
    ApplyToEach(CNOT(qs[0], _), qs[1...]);

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

Voeg een nieuwe cel toe en voer de volgende code uit om het circuit te visualiseren. Bereid bijvoorbeeld een GHZ-status voor met 3 qubits.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Circuitdiagrammen weergeven voor bewerkingen met qubits

U kunt circuitdiagrammen genereren voor elke bewerking die qubits of matrices van qubits gebruikt. Het diagram toont net zoveel draden als er invoer-qubits zijn, plus eventuele extra qubits die binnen de bewerking zijn toegewezen. Wanneer de bewerking een matrix van qubits (Qubit[])gebruikt, toont het circuit de matrix als een register van 2 qubits.

Voeg een nieuwe cel toe en kopieer het volgende voorbeeld. Met deze code wordt een cat-status voorbereid.

%%qsharp

operation PrepareCatState(register : Qubit[]) : Unit {
    H(register[0]);
    ApplyToEach(CNOT(register[0], _), register[1...]);
}

Voeg een nieuwe cel toe en voer de volgende code uit om het circuit van de PrepareCatState bewerking te visualiseren.
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Voorwaarden die van invloed zijn op circuitdiagrammen

Bij het visualiseren van kwantumcircuits kunnen de volgende voorwaarden van invloed zijn op de visualisatie van het circuitdiagram.

Dynamische circuits

Circuitdiagrammen worden gegenereerd door alle klassieke logica in een Q# programma uit te voeren en alle qubits bij te houden die zijn toegewezen of poorten die zijn toegepast. Lussen en voorwaarden worden ondersteund zolang ze alleen betrekking hebben op klassieke waarden.

Programma's die lussen en voorwaardelijke expressies bevatten die gebruikmaken van qubitmetingsresultaten, zijn echter lastiger weer te geven met een circuitdiagram. Bijvoorbeeld een expressie als de volgende

if (M(q) == One) {
   X(q)
}

kan niet worden weergegeven met een eenvoudig circuitdiagram, omdat de poorten afhankelijk zijn van een meetresultaat. Een dergelijk circuit wordt een dynamisch circuit genoemd.

Circuitdiagrammen kunnen worden gegenereerd voor dynamische circuits door het programma uit te voeren in de kwantumsimulator en de poorten te traceren terwijl ze worden toegepast. Dit wordt de traceringsmodus genoemd, omdat de qubits en gates worden getraceerd terwijl de simulatie wordt uitgevoerd.

Het nadeel van getraceerde circuits is dat ze alleen het meetresultaat en de daaruit voortvloeiende poorttoepassingen vastleggen voor één simulatie. Als in het bovenstaande voorbeeld het resultaat van de meting is Zero, ziet u de X poort niet in het diagram. Een andere uitvoering van de simulatie kan een iets ander circuit laten zien.

Doelprofiel

Het geselecteerde target profiel is van invloed op de wijze waarop circuitdiagrammen worden gegenereerd. Doelprofielen worden gebruikt om de mogelijkheden van de target hardware en de beperkingen op te geven die worden opgelegd aan het kwantumprogramma.

Wanneer het target profiel is ingesteld op Onbeperkt, tonen de circuitdiagrammen de kwantumbewerkingen die in het Q# programma worden aangeroepen. Wanneer het target profiel is ingesteld op QIR-basis, tonen de circuitdiagrammen de kwantumbewerkingen die op hardware worden uitgevoerd als het programma met dit target profiel naar Azure Quantum wordt verzonden.

Notitie

Als u een profiel wilt selecteren target in VS Code, gaat u naar Weergeven -> Opdrachtpalet en schrijft Q#u : Stel het QIR-profiel target van Azure Quantum in. U kunt of QIR Base Profile selecteren Unrestricted in de vervolgkeuzelijst.
Als u een profiel wilt selecteren target in Python, schrijft qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted) u of qsharp.init(target_profile=qsharp.TargetProfile.Base).

In het bijzonder worden gate-ontledingen toegepast die het resulterende circuit compatibel maken met de mogelijkheden van de target hardware. Dit zijn dezelfde ontledingen die worden toegepast tijdens het genereren en verzenden van code naar Azure Quantum.

Bekijk bijvoorbeeld het volgende Q# programma dat een qubit en een matrix van qubits meet.

namespace Sample {
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation Main() : (Result, Result[]) {
        // The `M` operation performs a measurement of a single qubit in the
        // computational basis, also known as the Pauli Z basis.
        use q = Qubit();
        let result = M(q);
        Reset(q);

        // The `MeasureEachZ` operation measures each qubit in an array in the
        // computational basis and returns an array of `Result` values.
        use qs = Qubit[2];
        let results = MeasureEachZ(qs);

        return (result, results);
    }
}

Wanneer target profiel is ingesteld op Onbeperkt, komen de poorten die op het circuit worden weergegeven precies overeen met de kwantumbewerkingen die in het Q# programma worden aangeroepen.
Wanneer het target profiel een QIR-basis is, ziet het circuit er anders uit. Omdat het basisprofiel targets het hergebruik van qubits na de meting niet toestaat, wordt de meting nu uitgevoerd op een verstrengelde qubit. Omdat Reset de bewerking geen ondersteunde poort is in basisprofiel, wordt deze verwijderd. Het resulterende circuit komt overeen met wat op hardware wordt uitgevoerd als dit programma met dit target profiel wordt verzonden naar Azure Quantum.

Share via