Freigeben über

Visualisieren von Quantenkreisdiagrammen mit Q#

  • Artikel

Quantenschaltungsdiagramme sind eine visuelle Darstellung von Quantenvorgängen. Sie zeigen den Fluss von Qubits durch das Quantenprogramm, einschließlich der Tore und Messungen, die auf sie angewendet werden.

In diesem Artikel erfahren Sie, wie Sie Quantenalgorithmen mithilfe von Visual Studio Code oder Jupyter-Notizbüchern visuell darstellen.

Weitere Informationen zu Quantenschaltungsdiagrammkonventionen finden Sie unter Quantenschaltungskonventionen.

Voraussetzungen

VS-Code

Jupyter-Notebooks

Quantenschaltungen mit Visual Studio Code

Führen Sie die folgenden Schritte aus, um Quantenschaltungen von Q# Programmen in Visual Studio Code zu visualisieren. Weitere Informationen zu Quantenschaltungsdiagrammkonventionen finden Sie unter Quantenschaltungskonventionen.

Anzeigen von Schaltkreisdiagrammen für ein Q# Programm

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

  2. Um den Quantenkreis des Q# Programms zu visualisieren, wählen Sie "Ansicht -> Befehlspalette " aus, und geben Sie "Schaltkreis" ein, der die Q#Option "Schaltkreis anzeigen" anzeigen soll. Sie können auch auf " Circuit" aus der Liste der vorherigen Main()Befehle klicken.

    Screenshot der Datei in Visual Studio Code, in der Q# gezeigt wird, wo der Codelinsenschaltungsbefehl gefunden werden soll.

  3. Der Schaltkreis wird im Q# Schaltkreisfenster angezeigt. Beispielsweise entspricht der folgende Schaltkreis einem Vorgang, der ein Qubit in eine Superposition versetzt und dann misst. Das Schaltkreisdiagramm zeigt ein Qubit-Register, das in den Zustand |0⟩ initialisiert wird. Anschließend wird ein Hadamard-Tor , H, auf das Qubit angewendet, gefolgt von einem Messvorgang, der durch ein Metersymbol dargestellt wird.

    Screenshot des Q# Schaltkreisfensters mit dem resultierenden Schaltkreisdiagramm für den zufälligen Bit-Vorgang.

Anzeigen von Schaltkreisdiagrammen für Vorgänge

Sie können den Quantenkreis für einen einzelnen Q# Vorgang visualisieren. Klicken Sie hierzu in der Codelinse, die oberhalb der Vorgangsdeklaration angezeigt wird, auf die Schaltschaltfläche.To do this, click on the Circuit button in the code lens that appears above the operation declaration.

Screenshot von Visual Studio Code, der zeigt, wie die Schaltkreise im Q# Schaltkreisbereich nach dem Debuggen des Programms dargestellt werden.

Anzeigen von Schaltkreisdiagrammen beim Debuggen

Beim Debuggen eines Q# Programms können Sie den Quantenkreis basierend auf dem aktuellen Zustand des Programms visualisieren.

  1. Wählen Sie die Schaltfläche "Debuggen " aus der Liste der vorherigen Main()Codelinsenbefehle aus.

  2. Erweitern Sie in der Ansicht "Ausführen und Debuggen " auf der linken Seite den Abschnitt "Quantum Circuit " unter "Variablen ", um den Schaltkreis anzuzeigen, während Sie das Programm durchlaufen.

    Screenshot von Visual Studio Code, der zeigt, wie die Schaltung beim Debuggen eines Programms visualisiert wird.

  3. Sie können den Code schrittweise durchlaufen und Haltepunkte in verschiedenen Punkten festlegen, um die Schaltkreisaktualisierung während der Ausführung des Programms anzuzeigen.

  4. Der aktuelle Quantenkreis wird im Q# Schaltkreisbereich angezeigt. Dieses Schaltkreisdiagramm stellt den aktuellen Zustand des Simulators dar, d. h. die Tore, die bis zum aktuellen Ausführungspunkt angewendet wurden.

    Screenshot von Visual Studio Code, der zeigt, wie die Schaltung für einen einzelnen Q# Vorgang visualisiert wird.

Quantenschaltungen mit Jupyter-Notizbüchern

In Jupyter-Notizbüchern können Sie Quantenschaltungen mithilfe des qsharp-widgets Pakets visualisieren. Dieses Paket stellt ein Widget bereit, das ein Quantenschaltungsdiagramm als SVG-Bild rendert.

  1. Wählen Sie in Visual Studio Code die Optionen Ansicht > Befehlspalette und dann Erstellen: Verwenden von Jupyter Notebook.

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

    import qsharp

  3. Fügen Sie eine neue Zelle hinzu, und geben Sie den Code ein Q# . Der folgende Code bereitet z. B. einen Glockenzustand vor.

    %%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);

  4. Sie können die dump_circuit() Funktion verwenden, um eine Quantenschaltung basierend auf dem aktuellen Zustand des Programms anzuzeigen. Das Schaltkreisdiagramm zeigt z. B. zwei Qubit-Register an, die in den Zustand |0⟩ initialisiert werden. Anschließend wird ein Hadamard-Tor , H, auf das erste Qubit angewendet. Danach wird ein CNOT-Gate mit dem ersten Qubit als Steuerelement angewendet, das als Punkt dargestellt wird, und das zweite Qubit als target, das als X dargestellt wird.

    qsharp.dump_circuit()

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

  5. Mithilfe des qsharp-widgets Pakets können Sie Quantenschaltungen als SVG-Bild visualisieren. In diesem Fall wird das CNOT-Gate als Linie dargestellt, die die beiden Qubits verbindet, mit einem Punkt auf dem Steuerqubit und einem umschriebenen Kreuz auf dem target Qubit. Weitere Informationen finden Sie unter Quantum Circuits Conventions.

    from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())

    Screenshot eines Jupyter-Notizbuchs, das zeigt, wie der Schaltkreis für einen Q# Vorgang visualisiert wird.

Anzeigen von Schaltkreisdiagrammen für einen Eintragsausdruck

Sie können ein Schaltkreisdiagramm für jedes Programm mit einem Eintragsausdruck generieren, indem Sie den Eintragsausdruck als Argument aufrufen qsharp.circuit() und übergeben.

  1. Fügen Sie beispielsweise eine neue Zelle hinzu, und kopieren Sie den folgenden Code, der einen GHZ-Zustand vorbereitet.

    %%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;
}

  2. Fügen Sie eine neue Zelle hinzu, und führen Sie den folgenden Code aus, um den Schaltkreis zu visualisieren. Bereiten Sie beispielsweise einen GHZ-Zustand mit 3 Qubits vor.

    Circuit(qsharp.circuit("GHZSample(3)"))

Anzeigen von Schaltkreisdiagrammen für Vorgänge mit Qubits

Sie können Schaltkreisdiagramme für jeden Vorgang generieren, der Qubits oder Arrays von Qubits verwendet. Das Diagramm zeigt so viele Kabel wie ein Eingabe-Qubit sowie alle zusätzlichen Qubits, die innerhalb des Vorgangs zugeordnet sind. 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, und kopieren Sie das folgende Beispiel. 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"))

Bedingungen, die sich auf Schaltkreisdiagramme auswirken

Bei der Visualisierung von Quantenschaltungen können sich die folgenden Bedingungen auf die Visualisierung des Schaltkreisdiagramms auswirken.

Dynamische Schaltkreise

Schaltkreisdiagramme werden generiert, indem alle klassischen Logiken in einem Q# Programm ausgeführt werden und alle qubits nachverfolgt werden, die zugewiesen wurden oder Tore angewendet wurden. Schleifen und Bedingungen werden unterstützt, solange 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. Beispiel: Ein Ausdruck wie der folgende

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

kann nicht mit einem einfachen Schaltkreisdiagramm dargestellt werden, da die Tore von einem Messergebnis abhängig sind. Ein solcher Schaltkreis wird als dynamischer Schaltkreis bezeichnet.

Schaltkreisdiagramme können für dynamische Schaltkreise generiert werden, indem sie das Programm im Quantensimulator ausführen und die Tore verfolgen, sobald sie angewendet werden. Dies wird als Ablaufverfolgungsmodus bezeichnet, da die Qubits und Tore bei der Ausführung 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, wird das X Tor im Diagramm nicht angezeigt. Eine andere Ausführung der Simulation kann einen etwas anderen Schaltkreis zeigen.

Target-Profile

Das aktuell ausgewählte target Profil beeinflusst, wie Schaltkreisdiagramme generiert werden. Target Profile werden verwendet, um die Funktionen der target Hardware und die Einschränkungen anzugeben, die für das Quantumprogramm auferlegt werden.

Wenn das Profil auf "Uneingeschränkt" oder "QIR Adaptive RI" festgelegt ist, zeigen die target Schaltkreisdiagramme die Quantenvorgänge an, die Q# im Programm aufgerufen werden. Wenn das Profil auf QIR-Basis festgelegt ist, zeigen die target Schaltkreisdiagramme die Quantenvorgänge an, die auf Hardware ausgeführt werden würden, wenn das Programm mit diesem target Profil an Azure Quantum übermittelt wird.

Hinweis

  • Um das target Profil in VS Code auszuwählen, wählen Sie "Ansicht -> Befehlspalette" und dann folgendesQ# aus: Legen Sie das Azure Quantum QIR-Profil target fest. Sie können in der Dropdownliste auswählen, QIR Adaptive RIoder unrestricted sie können sie auswählenQIR base.

  • Zum Auswählen des target Profils in Python, aufrufen qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)qsharp.init(target_profile=qsharp.TargetProfile.Base)oder qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

Insbesondere werden Gate-Zersetzungen angewendet, die den resultierenden Schaltkreis mit den Funktionen der target Hardware kompatibel machen würden. Dies sind die gleichen Analysepositionen, die während der Codegenerierung und Übermittlung an Azure Quantum angewendet werden.

  1. Betrachten Sie beispielsweise das folgende Q# Programm, das ein Qubit und ein Array von Qubits misst.

    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);
}

  2. Wenn target das Profil auf "Unrestricted" oder "QIR Adaptive RI" festgelegt ist, entsprechen die auf dem Schaltkreis angezeigten Tore genau den Quantenvorgängen, die Q# im Programm aufgerufen werden.

    Screenshot von Quantenschaltungen, wenn target das Profil uneingeschränkt ist.

  3. Wenn das Profil QIR-Basis ist, sieht der target Schaltkreis anders aus. Da das Basisprofil targets nach der Messung keine Wiederverwendung von Qubits zulässt, erfolgt die Messung jetzt stattdessen auf einem verangten Qubit. Da Reset der Vorgang kein unterstütztes Gate in Base Profile ist, wird er gelöscht. Die resultierende Schaltung stimmt mit der Hardware überein, wenn dieses Programm mit diesem target Profil an Azure Quantum übermittelt wird.

    Screenshot von Quantenschaltungen, wenn target das Profil QIR-Basis ist.