Så här visualiserar du kvantkretsdiagram med QDK

Kvantkretsdiagram är en visuell representation av kvantalgoritmer. Kretsdiagram visar flödet av kvantbitar genom ett kvantprogram, inklusive de portar och mätningar som programmet tillämpar på kvantbitarna.

Den här artikeln lär dig hur du skapar kretsdiagram för Q#- och OpenQASM-program med Microsoft Quantum Development Kit (QDK) med hjälp av Visual Studio Code (VS Code) och Jupyter Notebook.

Mer information om kvantkretsdiagram finns i Konventioner för kvantkretsdiagram.

Förutsättningar

Om du vill skapa kretsdiagram från Q#- och OpenQASM-filer i VS Codeinstallerar du följande:

Den senaste versionen av VS Code, eller öppen VS Code för webben.
Den senaste versionen av QDK tillägget i VS Code.

Om du vill skapa kretsdiagram från Python-program i Jupyter Notebookinstallerar du följande:

Python-tillägget och Jupyter -tillägget i VS Code.
Den senaste versionen av qdk Python-biblioteket med jupyter extra.
```
python -m pip install --upgrade "qdk[jupyter]"
```

Visualisera kvantkretsar i VS Code

QDK Med tillägget i VS Codekan du skapa kretsdiagram för Q#- (.qs) och OpenQASM-filer (.qasm).

Följ dessa steg om du vill visa ett kretsdiagram i VS Code:

Öppna en Q#- eller OpenQASM-fil i VS Codeeller läs in något av kvantexemplen QDKfrån .
Välj kommandot Krets från kodlinsen som föregår programmet.

Fönstret QDK Krets öppnas och visar kretsdiagrammet för ditt program. Följande kretsdiagram motsvarar till exempel ett program som producerar en slumpmässig bit. Kretsen placerar kvantbiten i ett superpositionstillstånd och mäter sedan kvantbiten.

Skärmbild av kretsfönstret QDK som visar kretsdiagrammet för ett slumpmässigt bitprogram.

Tips/Råd

Välj ett element i kretsdiagrammet för att markera koden som skapar kretselementet.

Visa kretsdiagram för enskilda Q#-åtgärder

Om du vill visualisera kvantkretsen för en enskild åtgärd i en Q#-fil väljer du kretskommandot från kodlinsen som föregick åtgärden.

Skärmbild som Visual Studio Code visar hur du visualiserar kretsen för en enda Q#-åtgärd i ett Q#-program.

Visa kretsdiagram när du felsöker

När du använder felsökningsprogrammet VS Code i ett Q#-program kan du visualisera kvantkretsen baserat på programmets tillstånd vid den aktuella felsökningsbrytpunkten.

Välj kommandot Felsöka från kodlinsen som föregår startpunktsåtgärden.
I fönstret Kör och felsök expanderar du listrutan Kvantkrets på MENYN VARIABLER . Kretspanelen öppnas, vilken visar kretsen när du stegar igenom programmet.
Ange brytpunkter och gå igenom koden för att se hur kretsen uppdateras när programmet körs.

Visualisera kvantkretsar i Jupyter Notebook

I Jupyter Notebookkan du visualisera kvantkretsar för Q#- och OpenQASM-program med qdk.qsharp python-modulerna och qdk.widgets . Modulen widgets innehåller en widget som renderar ett kvantkretsdiagram som en SVG-avbildning.

Fler exempel på kretsdiagramgenerering i finns i Jupyter Notebookexempelanteckningsboken Kretsar på QDK GitHub-lagringsplatsen.

Visa kretsdiagram för Q#-program

Följ dessa steg om du vill visa ett kretsdiagram för ett Q#-program i Jupyter Notebook:

I VS Codeöppnar du menyn Visa och väljer Kommandopalett.
Ange Skapa: Ny Jupyter Notebook. En tom Jupyter Notebook fil öppnas på en ny flik.
I den första cellen i notebook-filen kör du följande kod för att importera modulen qsharp .
```
from qdk import qsharp
```

Skapa en ny cell och ange din Q#-kod. Följande kod förbereder till exempel ett Bell-tillstånd:

%%qsharp

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

Om du vill visa ett kvantkretsdiagram skickar du Q#-åtgärden till qsharp.circuit funktionen. Kör följande kod i en ny cell:
```
qsharp.circuit("BellState()")
```
Utdata ser ut så här:
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
Om du vill återge en SVG-bild av kvantkretsen använder du modulen widgets . Skapa en ny cell och kör sedan följande kod för att visualisera samma krets som du skapade i föregående cell.
```
from qdk.widgets import Circuit

Circuit(qsharp.circuit("BellState()"))
```
Kretsdiagrammet ser ut så här:

Visa kretsdiagram för åtgärder som tar kvantbitar som indata

I det föregående belltillståndsexemplet tar åtgärden BellState inte kvantbitar som indata. Om åtgärden tar kvantbitar eller qubitmatriser som indata utelämnar du parenteserna när du skickar åtgärden för att rita kretsdiagram.

Följ till exempel dessa steg för att rita kretsdiagram för en åtgärd som tar kvantbitar:

Kör följande Q#-kod i en ny cell. Den här koden förbereder ett katttillstånd.

%%qsharp

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

Kör följande kod för att rita kretsen som ett textdiagram:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```
Om du vill återge kretsdiagrammet som en SVG-avbildning kör du följande kod:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

När åtgärden tar en matris med kvantbitar (Qubit[])visar kretsen matrisen som ett register med två kvantbitar.

Visa kretsdiagram för OpenQASM-program

Följ dessa steg om du vill visa ett kretsdiagram för ett OpenQASM-program i Jupyter Notebook:

I VS Codeöppnar du menyn Visa och väljer Kommandopalett.
Ange Skapa: Ny Jupyter Notebook. En tom Jupyter Notebook fil öppnas på en ny flik.
I den första cellen i notebook-filen kör du följande kod för att importera de objekt som behövs för att skapa och anropa OpenQASM-funktioner med QDK Python-biblioteket:
```
from qsharp.openqasm import import_openqasm, ProgramType
```
I en ny cell skriver du ditt OpenQASM-program i en Python-sträng och skickar strängen till import_openqasm funktionen. Om du vill anropa programmet i Python-koden ger du funktionen ett namn och anger program_type till 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)
```
I en ny cell importerar du OpenQASM-programmet som en Python-funktion och anropar programmet för att hämta mätresultatet.
```
from qsharp.code.qasm_import import bell

bell()
```

Om du vill rita kretsen som ett textdiagram kör du följande kod i en ny cell:

from qdk.qsharp import circuit

circuit(bell)

Utdata ser ut så här:

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

Om du vill återge kretsdiagrammet som en SVG-avbildning kör du följande kod i en ny cell:
```
from qsharp_widgets import Circuit

Circuit(qsharp.circuit(bell))
```
Kretsdiagrammet ser ut så här:

Anmärkning

För OpenQASM-program kan du inte visa kretsdiagram för enskilda funktioner. Du kan bara visa kretsdiagram för hela programmet.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-01