Kwantumcircuitdiagrammen visualiseren met de QDK

Kwantumcircuitdiagrammen zijn een visuele weergave van kwantumalgoritmen. Circuitdiagrammen tonen de stroom van qubits via een kwantumprogramma, inclusief de poorten en metingen die het programma op de qubits toepast.

In dit artikel leert u hoe u circuitdiagrammen maakt voor Q#- en OpenQASM-programma's met de Microsoft Quantum Development Kit (QDK) met behulp van Visual Studio Code (VS Code) en Jupyter Notebook.

Zie de kwantumcircuitschemaconventies voor meer informatie over kwantumcircuitdiagrammen.

Vereisten

Als u circuitdiagrammen wilt maken op basis van Q#- en OpenQASM-bestanden, VS Codeinstalleert u het volgende:

De nieuwste versie van VS Code, of open VS Code voor het web.
De nieuwste versie van de QDK extensie in VS Code.

Als u circuitdiagrammen wilt maken vanuit Python-programma's, Jupyter Notebookinstalleert u het volgende:

De Python-extensie en Jupyter-extensie in VS Code.
De nieuwste versie van de qdk Python-bibliotheek met de jupyter extra.
```
python -m pip install --upgrade "qdk[jupyter]"
```

Kwantumcircuits visualiseren in VS Code

Met de QDK extensie kunt VS Codeu circuitdiagrammen maken voor Q# (.qs) en OpenQASM-bestanden (.qasm).

Om een circuitdiagram in VS Code te bekijken, volgt u deze stappen:

Open een Q#- of OpenQASM-bestand in VS Codeof laad een van de kwantumvoorbeelden uit de QDK.
Kies de Circuit-opdracht in de codelens die voorafgaat aan uw programma.

Het QDK circuitvenster wordt geopend en geeft het circuitdiagram voor uw programma weer. Het volgende circuitdiagram komt bijvoorbeeld overeen met een programma dat een willekeurige bit produceert. Het circuit plaatst de qubit in een superpositiestatus en meet vervolgens de qubit.

Schermopname van het QDK circuitvenster met het circuitdiagram voor een willekeurig bitprogramma.

Aanbeveling

Selecteer een element in het circuitdiagram om de code te markeren waarmee het circuitelement wordt gemaakt.

Circuitdiagrammen weergeven voor afzonderlijke Q#-bewerkingen

Als u het kwantumcircuit voor een afzonderlijke bewerking in een Q#-bestand wilt visualiseren, kiest u de Circuit-opdracht in de codelens die voor de bewerking staat.

Schermopname van Visual Studio Code die laat zien hoe je het circuit van een enkele Q#-bewerking in een Q#-programma kunt visualiseren.

Circuitdiagrammen weergeven wanneer u foutopsporing uitvoert

Wanneer u het VS Code foutopsporingsprogramma in een Q#-programma gebruikt, kunt u het kwantumcircuit visualiseren op basis van de status van het programma op het huidige onderbrekingspunt van het foutopsporingsprogramma.

Kies de opdracht debuggen uit de codelens die voorafgaat aan de bewerking van het invoerpunt.
Vouw in het deelvenster Uitvoeren en foutopsporing de vervolgkeuzelijst Quantum Circuit uit in het menu VARIABELEN . Het QDK circuitvenster wordt geopend, waarin het circuit wordt weergegeven terwijl u het programma doorloopt.
Stel onderbrekingspunten in en doorloop uw code om te zien hoe het circuit wordt bijgewerkt terwijl uw programma wordt uitgevoerd.

Kwantumcircuits visualiseren in Jupyter Notebook

In Jupyter Notebookkunt u kwantumcircuits voor Q# en OpenQASM-programma's visualiseren met de qdk.qsharp en qdk.widgets Python-modules. De widgets module biedt een widget waarmee een kwantumcircuitdiagram wordt weergegeven als een SVG-afbeelding.

Zie het Jupyter Notebook in de QDK GitHub-opslagplaats voor meer voorbeelden van het genereren van circuitdiagrammen.

Circuitdiagrammen voor Q#-programma's weergeven

Voer de volgende stappen uit om een circuitdiagram voor een Q# programma weer te geven in Jupyter Notebook:

Open VS Codehet menu Beeld en kies Opdrachtpalet.
Voer Creëren: Nieuw Jupyter Notebook in. Er wordt een leeg Jupyter Notebook bestand geopend op een nieuw tabblad.
Voer in de eerste cel van het notebook de volgende code uit om de qsharp module te importeren.
```
from qdk import qsharp
```

Maak een nieuwe cel en voer uw Q#-code in. Met de volgende code wordt bijvoorbeeld een Bell-toestand voorbereid:

%%qsharp

// Prepare a Bell State.
operation BellState() : Unit {
    use register = Qubit[2];
    H(register[0]);
    CNOT(register[0], register[1]);
}

Als u een kwantumcircuitdiagram wilt weergeven, geeft u de Q#-bewerking door aan de qsharp.circuit functie. Voer de volgende code uit in een nieuwe cel:
```
qsharp.circuit("BellState()")
```
De uitvoer ziet er als volgt uit:
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
Als u een SVG-afbeelding van het kwantumcircuit wilt weergeven, gebruikt u de widgets module. Maak een nieuwe cel en voer vervolgens de volgende code uit om hetzelfde circuit te visualiseren dat u in de vorige cel hebt gemaakt.
```
from qdk.widgets import Circuit

Circuit(qsharp.circuit("BellState()"))
```
Het circuitdiagram ziet er als volgt uit:

Circuitdiagrammen weergeven voor bewerkingen die qubits als invoer gebruiken

In het vorige voorbeeld van de Bell-status neemt de bewerking BellState geen qubits als invoer. Als de bewerking qubits of qubitmatrices als invoer gebruikt, laat u de haakjes weg wanneer u de bewerking doorgeeft om circuitdiagrammen te tekenen.

Volg bijvoorbeeld deze stappen om circuitdiagrammen te tekenen voor een bewerking die qubits gebruikt:

Voer in een nieuwe cel de volgende Q#-code uit. Met deze code wordt een cat-status voorbereid.

%%qsharp

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

Als u het circuit wilt tekenen als een tekstdiagram, voert u de volgende code uit:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```
Voer de volgende code uit om het circuitdiagram weer te geven als een SVG-afbeelding:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Wanneer de bewerking een matrix van qubits (Qubit[])gebruikt, toont het circuit de matrix als een register van twee qubits.

Circuitdiagrammen weergeven voor OpenQASM-programma's

Voer de volgende stappen uit om een circuitdiagram voor een OpenQASM-programma in Jupyter Notebook weer te geven:

Open VS Codehet menu Beeld en kies Opdrachtpalet.
Voer Creëren: Nieuw Jupyter Notebook in. Er wordt een leeg Jupyter Notebook bestand geopend op een nieuw tabblad.
Voer in de eerste cel van het notebook de volgende code uit om de benodigde objecten te importeren om OpenQASM-functies te maken en aan te roepen met de QDK Python-bibliotheek:
```
from qsharp.openqasm import import_openqasm, ProgramType
```
Schrijf in een nieuwe cel uw OpenQASM-programma in een Python-tekenreeks en geef de tekenreeks door aan de import_openqasm functie. Als u het programma in uw Python-code wilt aanroepen, geeft u de functie een naam en stelt u deze in program_type op ProgramType.File.
```
source = """
    include "stdgates.inc";
    bit[2] c;
    qubit[2] q;
    h q[0];
    cx q[0], q[1];
    c = measure q;
"""

import_openqasm(source, name="bell", program_type=ProgramType.File)
```
Importeer in een nieuwe cel het OpenQASM-programma als een Python-functie en roep het programma aan om de meetresultaten op te halen.
```
from qsharp.code.qasm_import import bell

bell()
```

Als u het circuit wilt tekenen als een tekstdiagram, voert u de volgende code uit in een nieuwe cel:

from qdk.qsharp import circuit

circuit(bell)

De uitvoer ziet er als volgt uit:

q_0    ── H ──── ● ──── M ──
             │      ╘═══
q_1    ───────── X ──── M ──
                    ╘═══

Als u het circuitdiagram wilt weergeven als een SVG-afbeelding, voert u de volgende code uit in een nieuwe cel:
```
from qsharp_widgets import Circuit

Circuit(qsharp.circuit(bell))
```
Het circuitdiagram ziet er als volgt uit:

Opmerking

Voor OpenQASM-programma's kunt u geen circuitdiagrammen voor afzonderlijke functies weergeven. U kunt circuitdiagrammen alleen voor het hele programma weergeven.

Feedback

Is deze pagina nuttig?

Last updated on 2026-04-01