Freigeben über

Visualisieren von Quantenkreisdiagrammen mit Q#

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

In diesem Artikel erfahren Sie, wie Sie Quantenalgorithmen visuell mit Quantenkreisdiagrammen in Azure Quantum Development Kit, verwendet mit QDK (Visual Studio Code) und VS Code (Jupyter Notebook), darstellen.

Weitere Informationen zu Quantenschaltungsdiagrammen finden Sie unter Quantum-Schaltkreiskonventionen.

Voraussetzungen

Visualisieren von Quantenschaltungen in VS Code

Um Quantenschaltungen von Q#-Programmen in VS Code zu visualisieren, führen Sie die folgenden Schritte durch.

Anzeigen von Schaltkreisdiagrammen für ein Q#-Programm

  1. Öffnen Sie eine Q#-Datei in VS Code, oder laden Sie eines der Quantenbeispiele.

  2. Wählen Sie den Schaltkreisbefehl aus der Codelinse aus, die dem Einstiegspunktvorgang vorausgeht.

    Screenshot einer Q#-Datei in Visual Studio Code, der zeigt, wo der „Code Lens“-Befehl zu finden ist.

Das Q#-Schaltkreisfenster wird angezeigt und zeigt das Schaltkreisdiagramm für Ihr Programm an. Beispielsweise entspricht der folgende Schaltkreis einem Vorgang, der ein Qubit in einen Superpositionszustand versetzt und dann den Qubit misst. Das Schaltkreisdiagramm zeigt ein Qubit-Register, das in den Zustand $\ket{0}$ initialisiert ist. Anschließend wird ein Hadamard-Tor auf das Qubit angewendet, gefolgt von einem Messvorgang, der durch ein Metersymbol dargestellt wird. In diesem Fall ist das Messergebnis null.

Screenshot des Q#-Schaltkreisfensters, das das Schaltkreisdiagramm für den zufälligen Bitvorgang zeigt.

Tipp

Wählen Sie in Q#- und OpenQASM-Dateien ein Element im Schaltkreisdiagramm aus, um den Code hervorzuheben, der das Schaltkreiselement erstellt.

Anzeigen von Schaltkreisdiagrammen für einzelne 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.

Screenshot von Visual Studio Code, der zeigt, wie Sie den Schaltplan einer einzelnen Q#-Operation in einem Q#-Programm visualisieren.

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.

Quantenschaltungen in Jupyter Notebook

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

Schaltpläne für einen Eingabeausdruck anzeigen

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

  2. Geben Sie die Eingabetaste ein, und wählen Sie "Erstellen: Neu" Jupyter Notebookaus.

  3. Führen Sie in der ersten Zelle des Notizbuchs den folgenden Code aus, um das qsharp Paket 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 eine einfache Quantenschaltung basierend auf dem aktuellen Zustand Ihres Programms anzuzeigen, übergeben Sie einen Einstiegspunktausdruck an die qsharp.circuit-Funktion. Das Schaltkreisdiagramm des vorherigen Codes zeigt z. B. zwei Qubit-Register an, die in den Zustand $\ket{0}$ initialisiert werden. Anschließend wird ein Hadamard-Tor auf das erste Qubit angewendet. Schließlich wird ein CNOT-Gate angewendet, bei dem das erste Qubit das Steuerelement ist, dargestellt durch einen Punkt, und das zweite Qubit ist das Ziel, dargestellt durch ein X.

    qsharp.circuit("BellState()")

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

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

    from qdk.widgets import Circuit

Circuit(qsharp.circuit("BellState()"))

    Screenshot eines Jupyter Notebook, der zeigt, wie Sie den Schaltkreis für eine Q#-Operation visualisieren.

Anzeigen von Schaltkreisdiagrammen für Vorgänge mit Qubits

Sie können Schaltkreisdiagramme von Vorgängen generieren, die Qubits oder Arrays von Qubits als Eingabe verwenden. Das Diagramm zeigt eine Draht für jeden Eingabe-Qubit sowie Kabel für zusätzliche Qubits, die Sie innerhalb des Vorgangs zuordnen. Wenn der Vorgang ein Array von Qubits (Qubit[])verwendet, zeigt der Schaltkreis das Array als Register von 2 Qubits an.

  1. Fügen Sie eine neue Zelle hinzu, kopieren Sie den folgenden Q#-Code und führen Sie ihn aus. Dieser Code bereitet einen Katzenzustand vor.

    %%qsharp

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

  2. Fügen Sie eine neue Zelle hinzu, und führen Sie den folgenden Code aus, um den Schaltkreis des PrepareCatState Vorgangs zu visualisieren.

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

Schaltkreisdiagramme für dynamische Schaltkreise

Schaltkreisdiagramme werden generiert, indem die klassische Logik in einem Q#-Programm ausgeführt wird und alle zugeordneten und angewendeten Gatter nachverfolgt werden. Schleifen und Bedingungen werden unterstützt, wenn sie nur mit klassischen Werten umgehen.

Programme, die Schleifen und bedingte Ausdrücke enthalten, die Qubit-Messergebnisse verwenden, sind jedoch schwieriger, mit einem Schaltkreisdiagramm darzustellen. Betrachten Sie beispielsweise den folgenden Ausdruck:

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

Dieser Ausdruck kann nicht mit einem einfachen Schaltkreisdiagramm dargestellt werden, da die Tore auf einem Messergebnis basieren. Schaltkreise mit Toren, die von Messergebnissen abhängen, werden als dynamische Schaltkreise bezeichnet.

Sie können Diagramme für dynamische Schaltkreise generieren, indem Sie das Programm im Quantensimulator ausführen und die Gatter verfolgen, während sie angewendet werden. Dies wird als Ablaufverfolgungsmodus bezeichnet, da die Qubits und Gatter während der Simulation nachverfolgt werden.

Der Nachteil verfolgter Schaltkreise besteht darin, dass sie nur das Messergebnis und die daraus resultierenden Gate-Anwendungen für eine einzelne Simulation erfassen. Wenn das Messergebnis im obigen Beispiel lautet Zero, befindet sich das X Tor nicht im Diagramm. Wenn Sie die Simulation erneut ausführen, erhalten Sie möglicherweise einen anderen Schaltkreis.

  • Last updated on