Visualisieren von Quantenschaltungsdiagrammen 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 mit Quantenschaltungsdiagrammen mithilfe von Visual Studio Code und Jupyter Notebooks visuell darstellen.

Weitere Informationen zu Quantenschaltungsdiagrammkonventionen finden Sie unter Konventionen für Quantenschaltungen.

Voraussetzungen

Wenn Sie Visual Studio Code zum Visualisieren von Quantenschaltungen verwenden möchten, benötigen Sie Folgendes:

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 Konventionen für Quantenschaltungen.

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 die Quantenschaltung des Q# Programms zu visualisieren, wählen Sie Ansicht –> Befehlspalette aus, und geben Sie "circuit" ein, wodurch die Q#Option : Verbindung anzeigen angezeigt werden soll. Sie können auch in der Liste der Befehle unter @EntryPoint()auf Circuit klicken.

    Screenshot der Q# Datei in Visual Studio Code, die zeigt, wo sich der Codelinsenschaltungsbefehl befindet.

  3. Die Verbindung wird im Q# Verbindungsfenster angezeigt. Die folgende Schaltung entspricht beispielsweise einem Vorgang, der ein Qubit in eine Superposition versetzt und dann misst. Das Schaltkreisdiagramm zeigt ein Qubitregister, das mit dem Zustand |0⟩ initialisiert wird. Anschließend wird das Hadamard-Gate H auf das Qubit angewendet, gefolgt von einem Messvorgang, der durch ein Metersymbol dargestellt wird.

    Screenshot des Leitungsfensters Q# mit dem resultierenden Schaltdiagramm für den Zufälligen Bitvorgang.

Anzeigen von Schaltkreisdiagrammen für Vorgänge

Sie können die Quantenschaltung für einen einzelnen Q# Vorgang visualisieren. Klicken Sie hierzu in der Codelinse, die oberhalb der Vorgangsdeklaration angezeigt wird, auf die Schaltfläche Leitung .

Screenshot von Visual Studio Code, der zeigt, wie die Leitungen im Bereich

Anzeigen von Schaltkreisdiagrammen beim Debuggen

Beim Debuggen eines Q# Programms können Sie die Quantenschaltung basierend auf dem aktuellen Status des Programms visualisieren.

  1. Klicken Sie in der Liste der Codeobjektivbefehle unter @EntryPoint()auf die Schaltfläche Debuggen.

  2. Erweitern Sie in der Ansicht Ausführen und Debuggen auf der linken Seite den Abschnitt Quantenschaltung im Bereich Variablen , um die Verbindung beim Durchlaufen des Programms anzuzeigen.

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

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

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

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

Quantenschaltungen mit Jupyter Notebooks

In Jupyter Notebooks 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 Option Befehlspalette anzeigen > und dann Create: Neue Jupyter Notebook aus.

  2. Führen Sie in der ersten Zelle des Notebooks 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 beispielsweise 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 beispielsweise zwei Qubitregister, die mit dem Zustand |0⟩ initialisiert werden. Anschließend wird das Hadamard-Gate H auf das erste Qubit angewendet. Danach wird ein CNOT-Gate mithilfe des ersten Qubits 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. Sie können Quantenschaltungen mithilfe des qsharp-widgets Pakets als SVG-Image visualisieren. In diesem Fall wird das CNOT-Gate als eine 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 Quantenschaltungskonventionen.

    from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())

    Screenshot eines Jupyter Notebook, der zeigt, wie die Verbindung 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 aufrufen qsharp.circuit() und als Argument übergeben.

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

    %%qsharp

open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.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 die Verbindung 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 Drähte, wie eingabebasiertes Qubit vorhanden ist, sowie alle zusätzlichen Qubits, die innerhalb des Vorgangs zugeordnet werden. Wenn der Vorgang ein Array von Qubits (Qubit[])akzeptiert, zeigt die Leitung 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 Cat-Zustand 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 die Verbindung des PrepareCatState Vorgangs zu visualisieren.

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

Bedingungen, die sich auf Schaltkreisdiagramme auswirken

Beim Visualisieren von Quantenschaltungen können sich die folgenden Bedingungen auf die Visualisierung des Schaltkreisdiagramms auswirken.

Dynamische Leitungen

Schaltkreisdiagramme werden generiert, indem die gesamte klassische Logik innerhalb eines Q# Programms ausgeführt wird und alle zugeordneten Qubits oder angewendeten Gates nachverfolgt werden. Schleifen und Bedingungen werden unterstützt, solange sie sich nur mit klassischen Werten befassen.

Programme, die Schleifen und bedingte Ausdrücke enthalten, die Qubitmessungsergebnisse 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 Gates von einem Messergebnis abhängig sind. Eine solche Leitung wird als dynamische Leitung bezeichnet.

Schaltdiagramme können für dynamische Schaltungen generiert werden, indem das Programm im Quantensimulator ausgeführt wird und die Gates während der Anwendung nachverfolgt werden. Dies wird als Ablaufverfolgungsmodus bezeichnet, da die Qubits und Gates während der Simulation nachverfolgt werden.

Der Nachteil von nachverfolgten Schaltkreisen 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, wird Zerodas X Gate im Diagramm nicht angezeigt. Eine andere Ausführung der Simulation zeigt möglicherweise eine etwas andere Schaltung an.

Zielprofil

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

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

Hinweis

  • Wechseln Sie zum Auswählen des target Profils in VS Code zu Ansicht –> Befehlspalette, und schreiben Q#Sie: Festlegen des Azure Quantum QIR-Profilstarget. Sie können oder QIR Base Profile aus der Dropdownliste auswählenUnrestricted.

  • Um ein Profil in Python auszuwählen target , schreiben qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted) Sie oder qsharp.init(target_profile=qsharp.TargetProfile.Base).

Insbesondere werden Gatezerlegungen angewendet, die die resultierende Leitung mit den Funktionen der target Hardware kompatibel machen. Dabei handelt es sich um die gleichen Analysevorgänge, 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.

    namespace Sample {
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    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 profile auf Unrestricted festgelegt ist, entsprechen die auf der Leitung angezeigten Gates genau den Quantenvorgängen, die Q# im Programm aufgerufen werden.

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

  3. Wenn das target Profil QIR-Basis ist, sieht die Schaltung anders aus. Da das Basisprofil targets die Wiederverwendung von Qubits nach der Messung nicht zulässt, wird die Messung jetzt stattdessen auf einem verschränkten Qubit durchgeführt. Da Reset der Vorgang kein unterstütztes Gate im Basisprofil ist, wird er gelöscht. Die resultierende Leitung entspricht dem, was auf der Hardware ausgeführt wird, wenn dieses Programm mit diesem target Profil an Azure Quantum übermittelt wird.

    Screenshot: Quantenschaltungen, wenn target das Profil QIR-Basis ist