Kwantumcircuitdiagrammen visualiseren met Q#

Artikel
10/23/2024

Kwantumcircuitdiagrammen zijn een visuele weergave van kwantumbewerkingen. Ze tonen de stroom van qubits via 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 of Jupyter Notebooks.

Zie Kwantumcircuitconventies voor meer informatie over de kwantumcircuitconventies.

Vereisten

VS-code

De nieuwste versie van Visual Studio Code of open VS Code op het web.
De nieuwste versie van de Azure Quantum Development Kit-extensie.
De nieuwste Azure Quantum qsharp - en azure-quantum Python-pakketten.
```
python -m pip install --upgrade qsharp azure-quantum
```

Jupyter Notebooks

De nieuwste versie van Visual Studio Code of open VS Code op het web.
VS Code waarop de Azure Quantum Development Kit, Python en Jupyter-extensies zijn 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 Kwantumcircuitconventies voor meer informatie over de kwantumcircuitconventies.

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 Weergave -> Opdrachtpalet en typt u 'circuit' dat de Q#optie Circuit weergeven moet weergeven. U kunt ook klikken op Circuit in de lijst met opdrachten die voorafgaan Main().
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 naar 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 voor één Q# bewerking visualiseren. 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 nadat het programma is opgespoord.

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.

Selecteer de knop Foutopsporing in de lijst met opdrachten voor codelens die voorafgaan Main().
Vouw in de weergave Uitvoeren en foutopsporing aan de linkerkant de sectie Quantum Circuit uit onder het deelvenster Variabelen om het circuit weer te geven terwijl u het programma doorloopt.
U kunt de code doorlopen en onderbrekingspunten instellen op verschillende punten om de circuitupdate te zien terwijl het programma wordt uitgevoerd.
Het huidige kwantumcircuit wordt weergegeven in het Q# deelvenster Circuit. Dit circuitdiagram vertegenwoordigt de huidige status van de simulator, 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 biedt een widget waarmee een kwantumcircuitdiagram wordt weergegeven als een SVG-afbeelding.

Selecteer in Visual Studio Code het opdrachtenpalet Weergeven > en selecteer Maken: Nieuw 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 Q# code in. 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. In het circuitdiagram ziet u bijvoorbeeld twee qubitregisters die zijn geïnitialiseerd naar 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, dat 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 Kwantumcircuitconventies voor meer informatie.
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Circuitdiagrammen voor een vermeldingsexpressie weergeven

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

import Std.Diagnostics.*;
import Std.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. In het diagram ziet u 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 omgaan met klassieke waarden.

Programma's die lussen en voorwaardelijke expressies bevatten die qubitmetingsresultaten gebruiken, zijn echter lastiger om te vertegenwoordigen met een circuitdiagram. Bijvoorbeeld een expressie zoals 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 poorten worden getraceerd als simulatie wordt uitgevoerd.

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

Target profiel

Het geselecteerde target profiel beïnvloedt de wijze waarop circuitdiagrammen worden gegenereerd. Target profielen worden gebruikt om de mogelijkheden van de target hardware op te geven en de beperkingen die worden opgelegd aan het kwantumprogramma.

Wanneer het target profiel is ingesteld op Onbeperkte of QIR Adaptive RI, geven de circuitdiagrammen de kwantumbewerkingen weer 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 het target profiel in VS Code wilt selecteren, selecteert u Weergave -> Opdrachtpalet en selecteert u Q#: Stel het Azure Quantum QIR-profiel target in. U kunt in de vervolgkeuzelijst een optie selecteren QIR baseof QIR Adaptive RIunrestricted selecteren.
Als u het target profiel in Python wilt selecteren, roept qsharp.init(target_profile=qsharp.TargetProfile.Base)u aan qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)of qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

In het bijzonder worden poortdecomposities 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.

Denk bijvoorbeeld aan het volgende Q# programma waarmee een qubit en een matrix van qubits worden gemeten.

import Std.Measurement.*;

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 het profiel is ingesteld op Onbeperkte of QIR Adaptive RI, komen de poorten die op het circuit worden weergegeven exact overeen met de kwantumbewerkingen die in het Q# programma worden aangeroepen.
Wanneer het target profiel de QIR-basis is, ziet het circuit er anders uit. Omdat het basisprofiel targets na meting geen gebruik van qubit toestaat, wordt de meting nu uitgevoerd op een verstrengelde qubit. Omdat Reset de bewerking geen ondersteunde poort in het basisprofiel is, wordt deze verwijderd. Het resulterende circuit komt overeen met wat er op hardware wordt uitgevoerd als dit programma met dit target profiel wordt verzonden naar Azure Quantum.

Delen via