So visualisieren Sie Quantenkreisdiagramme mit dem QDK

Quantenschaltungsdiagramme sind eine visuelle Darstellung von Quantenalgorithmen. Schaltkreisdiagramme zeigen den Fluss von Qubits durch ein Quantenprogramm, einschließlich der Tore und Messungen, die das Programm auf die Qubits anwendet.

In diesem Artikel erfahren Sie, wie Sie Schaltkreisdiagramme für Q#- und OpenQASM-Programme mit dem Microsoft Quantum Development Kit (QDK) unter Verwendung von Visual Studio Code (VS Code) und Jupyter Notebook erstellen.

Weitere Informationen zu Quantenschaltungsdiagrammen finden Sie unter Quantenschaltungsdiagrammkonventionen.

Voraussetzungen

Um Schaltkreisdiagramme aus Q#- und OpenQASM-Dateien zu VS Code erstellen, installieren Sie Folgendes:

• Die neueste Version von VS Code oder VS Code für das Web öffnen.
• Die neueste Version der QDK Erweiterung in VS Code.

Um Schaltkreisdiagramme aus Python-Programmen zu Jupyter Notebook erstellen, installieren Sie Folgendes:

• Die Python-Erweiterung und Jupyter-Erweiterung in VS Code.

• Die neueste Version der qdk Python-Bibliothek mit der jupyter Erweiterung.

  python -m pip install --upgrade "qdk[jupyter]"
  

Visualisieren von Quantenschaltungen in VS Code

Mit der QDK Erweiterung in VS Codekönnen Sie Schaltkreisdiagramme für Q#-Dateien (.qs) und OpenQASM (.qasm) erstellen.

Führen Sie die folgenden Schritte aus, um ein Schaltkreisdiagramm in VS Code anzuzeigen:

1. Öffnen Sie eine Q#- oder OpenQASM-Datei in VS Code, oder laden Sie eines der Quantenbeispiele aus der QDK.
2. Wählen Sie den Schaltkreisbefehl aus der Code-Lens aus, die Ihrem Programm vorausgeht.

Das QDK Schaltkreisfenster wird geöffnet und zeigt das Schaltkreisdiagramm für Ihr Programm an. Beispielsweise entspricht das folgende Schaltkreisdiagramm einem Programm, das ein zufälliges Bit erzeugt. Der Schaltkreis versetzt das Qubit in einen Superpositionszustand und misst dann das Qubit.

Anzeigen von Schaltkreisdiagrammen für einzelne Q#-Vorgänge

Um den Quantenkreis für einen einzelnen Vorgang in einer Q#-Datei zu visualisieren, wählen Sie den Schaltkreisbefehl aus der Codelinse aus, die dem Vorgang vorausgeht.

Anzeigen von Schaltkreisdiagrammen beim Debuggen

Wenn Sie den VS Code Debugger in einem Q#-Programm verwenden, können Sie den Quantenkreis basierend auf dem Zustand des Programms am aktuellen Debugger-Haltepunkt visualisieren.

1. Wählen Sie den Debug-Befehl aus der CodeLinse, die Ihrem Einstiegspunkt vorausgeht.
2. Erweitern Sie im Bereich "Ausführen und Debuggen " die Dropdownliste " Quantum Circuit " im Menü "VARIABLEN ". Das QDK Schaltkreispanel wird geöffnet, in dem der Schaltkreis angezeigt wird, während Sie das Programm durchlaufen.
3. Legen Sie Haltepunkte fest, und durchlaufen Sie Ihren Code, um zu sehen, wie der Schaltkreis während der Ausführung des Programms aktualisiert wird.

Visualisieren von Quantenschaltungen in Jupyter Notebook

In Jupyter Notebook, können Sie Quantenschaltungen für Q#- und OpenQASM-Programme mit den qdk.qsharp Und qdk.widgets Python-Modulen visualisieren. Das widgets Modul stellt ein Widget bereit, das ein Quantenkreisdiagramm als SVG-Bild rendert.

Weitere Beispiele für die Generierung von Schaltkreisdiagrammen finden Sie im Jupyter NotebookBeispielnotizbuch "Circuits" im QDK GitHub-Repository.

Anzeigen von Schaltkreisdiagrammen für Q#-Programme

Führen Sie die folgenden Schritte aus, um ein Schaltkreisdiagramm für ein Q#-Programm anzuzeigen: Jupyter Notebook

1. VS CodeÖffnen Sie im Menü "Ansicht" das Menü "Ansicht", und wählen Sie "Befehlspalette" aus.

2. Geben Sie "Erstellen: Neu" Jupyter Notebookein. Eine leere Jupyter Notebook Datei wird auf einer neuen Registerkarte geöffnet.

3. Führen Sie in der ersten Zelle des Notizbuchs den folgenden Code aus, um das qsharp Modul zu importieren.

   from qdk import qsharp
   

4. Erstellen Sie eine neue Zelle, und geben Sie Ihren Q#-Code ein. Der folgende Code bereitet z. B. einen Bell-Zustand vor:

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

5. Um ein Quantenkreisdiagramm anzuzeigen, übergeben Sie den Q#-Vorgang an die qsharp.circuit Funktion. Führen Sie den folgenden Code in einer neuen Zelle aus:

   qsharp.circuit("BellState()")
   

   Die Ausgabe sieht wie folgt aus:

   q_0    ── H ──── ● ──
   q_1    ───────── X ──
   

6. Verwenden Sie das widgets Modul, um ein SVG-Bild der Quantenschaltung zu rendern. Erstellen Sie eine neue Zelle, und führen Sie dann den folgenden Code aus, um den gleichen Schaltkreis zu visualisieren, den Sie in der vorherigen Zelle erstellt haben.

   from qdk.widgets import Circuit
   
   Circuit(qsharp.circuit("BellState()"))
   

   Das Schaltkreisdiagramm sieht wie folgt aus:

   

Anzeigen von Schaltkreisdiagrammen für Vorgänge, die Qubits als Eingabe übernehmen

Im vorherigen Bell-Zustandsbeispiel verwendet der Vorgang BellState keine Qubits als Eingabe. Wenn der Vorgang Qubits oder Qubit-Arrays als Eingabe verwendet, lassen Sie die Klammern aus, wenn Sie den Vorgang übergeben, um Schaltkreisdiagramme zu zeichnen.

Führen Sie beispielsweise die folgenden Schritte aus, um Schaltkreisdiagramme für einen Vorgang zu zeichnen, der Qubits verwendet:

1. Führen Sie in einer neuen Zelle den folgenden Q#-Code aus. Dieser Code erstellt einen Cat-Zustand.

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

2. Führen Sie den folgenden Code aus, um den Schaltkreis als Textdiagramm zu zeichnen:

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

3. Führen Sie den folgenden Code aus, um das Schaltkreisdiagramm als SVG-Bild zu rendern:

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

Wenn der Vorgang ein Array von Qubits (Qubit[])verwendet, zeigt der Schaltkreis das Array als Register von zwei Qubits an.

Anzeigen von Schaltkreisdiagrammen für OpenQASM-Programme

Führen Sie die folgenden Schritte aus, um ein Schaltkreisdiagramm für ein OpenQASM-Programm in Jupyter Notebook anzuzeigen:

1. VS CodeÖffnen Sie im Menü "Ansicht" das Menü "Ansicht", und wählen Sie "Befehlspalette" aus.

2. Geben Sie "Erstellen: Neu" Jupyter Notebookein. Eine leere Jupyter Notebook Datei wird auf einer neuen Registerkarte geöffnet.

3. Führen Sie in der ersten Zelle des Notizbuchs den folgenden Code aus, um die erforderlichen Objekte zum Erstellen und Aufrufen von OpenQASM-Funktionen mit der QDK Python-Bibliothek zu importieren:

   from qsharp.openqasm import import_openqasm, ProgramType
   

4. Schreiben Sie in einer neuen Zelle Ihr OpenQASM-Programm in eine Python-Zeichenfolge, und übergeben Sie die Zeichenfolge an die import_openqasm Funktion. Um das Programm in Ihrem Python-Code aufzurufen, geben Sie der Funktion einen Namen und setzen Sie program_type auf 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)
   

5. Importieren Sie in einer neuen Zelle das OpenQASM-Programm als Python-Funktion, und rufen Sie das Programm auf, um die Messergebnisse abzurufen.

   from qsharp.code.qasm_import import bell
   
   bell()
   

6. Um den Schaltkreis als Textdiagramm zu zeichnen, führen Sie den folgenden Code in einer neuen Zelle aus:

   from qdk.qsharp import circuit
   
   circuit(bell)
   

   Die Ausgabe sieht wie folgt aus:

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

7. Um das Schaltkreisdiagramm als SVG-Bild zu rendern, führen Sie den folgenden Code in einer neuen Zelle aus:

   from qsharp_widgets import Circuit
   
   Circuit(qsharp.circuit(bell))
   

   Das Schaltkreisdiagramm sieht wie folgt aus:

   

Verwandte Inhalte

• Erkunden Sie Schaltpläne im QDK
• Konventionen für Quantenschaltungsdiagramme