{ "cells": [ { "cell_type": "markdown", "id": "83596f71-5e63-4aa2-907b-75de8813d85a", "metadata": {}, "source": [ "---\n", "title: \"Dynamische Schaltkreise ausführen\"\n", "description: \"Verwenden Sie den „ IBM Quantum “-Compute-Service für klassische Feedforward- und Steuerungsabläufe, die auch als dynamische Schaltungen bezeichnet werden\"\n", "---\n", "\n", "\n", "\n", "# Dynamische Schaltkreise ausführen\n", "\n" ] }, { "cell_type": "markdown", "id": "2228a8a2-02b7-4a0b-bbe8-0c2933fbe44a", "metadata": {}, "source": [ "Dynamische Schaltkreise sind leistungsstarke Werkzeuge, mit denen man Qubits während der Ausführung eines Quantenschaltkreises messen und anschließend auf der Grundlage der Ergebnisse dieser Messungen innerhalb des Schaltkreises klassische Logikoperationen durchführen kann. Dieser Prozess wird auch als *klassisches Feedforward* bezeichnet. Auch wenn wir erst am Anfang stehen, was das Verständnis dafür angeht, wie dynamische Schaltkreise am besten genutzt werden können, hat die Quantenforschungsgemeinschaft bereits eine Reihe von Anwendungsfällen identifiziert, darunter die folgenden:\n", "\n", "* Effiziente Quantenzustandspräparation, wie beispielsweise [GHZ-Zustände](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339), [W-Zustände](https://arxiv.org/abs/2403.07604) (weitere Informationen zu W-Zuständen finden Sie auch unter [„Zustandspräparation durch flache Schaltungen unter Verwendung von Feed-Forward“](https://arxiv.org/abs/2307.14840) ) sowie eine breite Klasse von [Matrixproduktzuständen](https://arxiv.org/abs/2404.16083)\n", "* [Effiziente Fernverschränkung](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339) zwischen Qubits auf demselben Chip unter Verwendung flacher Schaltkreise\n", "* Effiziente [Abtastung von IQP-ähnlichen Schaltungen](https://arxiv.org/pdf/2505.04705)\n", "\n", "Diese durch dynamische Schaltungen erzielten Verbesserungen sind jedoch mit Kompromissen verbunden. Messungen während des Schaltablaufs und klassische Operationen haben in der Regel eine längere Ausführungszeit als Zwei-Qubit-Gatter, und dieser Zeitaufwand könnte die Vorteile einer geringeren Schaltungstiefe zunichte machen. Daher ist die Verkürzung der Messdauer bei Messungen in der Mitte des Schaltkreises ein Schwerpunkt bei den Verbesserungen, die „ IBM Quantum® “ mit der Veröffentlichung der [neuen Version](/docs/guides/changelog-quantum-compute-service#new-version-dynamic-circuits) der dynamischen Schaltkreise vornimmt. Weitere Einschränkungen bei der Verwendung dynamischer Schaltkreise finden Sie in der Kompatibilitätstabelle für die Funktionen [„Estimator“](/docs/guides/estimator-options#options-compatibility-table) und „[Sampler](/docs/guides/sampler-options#options-compatibility-table) “.\n", "\n", "Die [Spezifikation „ OpenQASM. 3“](https://openqasm.com/language/classical.html#looping-and-branching) definiert eine Reihe von Kontrollflussstrukturen, doch der „ IBM Quantum Compute Service“ unterstützt derzeit nur die bedingte Anweisung `if` . In „ Qiskit SDK “ entspricht dies der Methode [„if\\_test“](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#if_test) unter [QuantumCircuit](/docs/api/qiskit/qiskit.circuit.QuantumCircuit). Diese Methode gibt einen [Kontextmanager](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) zurück und wird in der Regel in einer -Anweisung `with` verwendet. In dieser Anleitung wird beschrieben, wie diese bedingte Anweisung verwendet wird.\n", "\n", "\n", " Die Code-Beispiele in diesem Leitfaden verwenden den Standard-Messbefehl für Messungen während des Betriebs. Es wird jedoch empfohlen, stattdessen die `MidCircuitMeasure` Anweisung zu verwenden, sofern das Backend dies unterstützt. Weitere Informationen finden Sie [im Abschnitt „Messungen in der Mitte des Schaltkreises](#midcircuit) “.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "7e9dc06d-85fa-4425-9bd1-ce5085be9741", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt.\n", " Wir empfehlen, diese Versionen oder neuere zu verwenden.\n", "\n", " ```\n", " qiskit[all]~=2.5.2\n", " qiskit-ibm-runtime~=0.47.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "c4616d43-f296-4a84-a79c-deb37fcdac15", "metadata": {}, "source": [ "\n", "\n", "## Finde Backends, die dynamische Schaltkreise unterstützen\n", "\n", "Um alle Backends zu ermitteln, auf die Ihr Konto zugreifen kann und die dynamische Verbindungen unterstützen, führen Sie einen Code wie den folgenden aus. In diesem Beispiel wird davon ausgegangen, dass Sie [Ihre Anmeldedaten gespeichert](/docs/guides/save-credentials) haben. Sie können [die Anmeldedaten](/docs/guides/initialize-account#explicit) auch explizit angeben, wenn Sie Ihr „ IBM Quantum Compute Service“-Konto initialisieren. Auf diese Weise könnten Sie beispielsweise die auf einer bestimmten Instanz oder für einen bestimmten Tariftyp verfügbaren Backends anzeigen.\n", "\n", "\n", " * Welche Backends für das Konto verfügbar sind, hängt von der in den Anmeldedaten angegebenen Instanz ab.\n", " * Die neue Version von „Dynamic Circuits“ steht nun allen Nutzern auf allen Backends zur Verfügung. Weitere Einzelheiten finden Sie in [der Ankündigung](/docs/guides/changelog-quantum-compute-service#new-dynamic-circuits).\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "a63f07b1-9e8a-4086-ab01-552bd444dc9b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[, , , , ]\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "dc_backends = service.backends(dynamic_circuits=True)\n", "print(dc_backends)" ] }, { "cell_type": "markdown", "id": "1dca7d79-99ea-42bd-86f7-182266907a85", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Messungen während des Betriebs\n", "\n", "Vor der Einführung von „ `qiskit-ibm-runtime`v0.43.0 “ `measure` war dies die einzige Messanweisung in Qiskit. Messungen in der Mitte eines Stromkreises stellen jedoch andere Anforderungen an die Abstimmung als Messungen *an den Anschlüssen* (Messungen, die am Ende eines Stromkreises erfolgen). Beispielsweise müssen Sie bei der Optimierung einer Messung während der Befehlsausführung die Befehlsdauer berücksichtigen, da längere Befehle zu störungsanfälligeren Schaltungen führen. Bei Endmessungen müssen Sie die Befehlsdauer nicht berücksichtigen, da nach den Endmessungen keine Befehle mehr folgen.\n", "\n", "\n", " Der `MidCircuitMeasure` Befehl entspricht dem `measure_2` Befehl, der in der. `supported_instructions`-Datei des Backends angegeben ist. Allerdings wird nicht von allen `measure_2` Backends unterstützt. Verwenden Sie `service.backends(filters=lambda b: \"measure_2\" in b.supported_instructions)` , um Backends zu finden, die dies unterstützen. Möglicherweise werden in Zukunft weitere Messungen hinzugefügt, dies kann jedoch nicht garantiert werden.\n", "\n", "\n", "\n", "\n", "### `MidCircuitMeasure`-Methode\n", "\n", "In `qiskit-ibm-runtime` v0.43.0 wurde die `MidCircuitMeasure` Anleitung veröffentlicht. Wie der Name schon sagt, handelt es sich um einen neuen Befehl, der für die Verarbeitung in der Mitte des Schaltkreises auf QPUs v IBM® s optimiert ist. Zwar können Sie für eine Messung in der Mitte `QuantumCircuit.measure` des Stromkreises verwenden, doch aufgrund seiner Bauweise ist in der Regel die `MidCircuitMeasure` bessere Wahl. Beispielsweise verursacht dies weniger Overhead in Ihrer Schaltung als bei der Verwendung von `QuantumCircuit.measure`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "87dfb9c7-1dc2-4752-bdc1-17b9144369f4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ┌───┐┌────────────┐\n", "q_0: ┤ X ├┤0 ├\n", " └───┘│ │\n", "q_1: ─────┤ Measure_2 ├\n", " │ │\n", "c_0: ═════╡0 ╞\n", " └────────────┘\n", "c_1: ═══════════════════\n", " \n" ] } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_ibm_runtime.circuit import MidCircuitMeasure\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "circ = QuantumCircuit(2, 2)\n", "circ.x(0)\n", "circ.append(MidCircuitMeasure(), [0], [0])\n", "# circ.measure([0], [0])\n", "# circ.measure_all()\n", "print(circ.draw(cregbundle=False))" ] }, { "cell_type": "markdown", "id": "2b603f88-2e0e-4819-8342-8e3662949ff3", "metadata": {}, "source": [ "\n", " * Es muss mindestens ein klassisches Register vorhanden sein, um Messungen nutzen zu können.\n", " * Für die Sampler-Primitive sind Schaltungsmessungen erforderlich. Mit dem Element „Estimator“ können Sie Schaltungsmessungen hinzufügen, diese werden jedoch ignoriert.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "9401a5cc-49e0-48b6-8deb-88e9b7da5a5a", "metadata": {}, "source": [ "\n", "\n", "## `Store`\n", "\n", "Ab `qiskit-ibm-runtime` Version 0.47.0 können Sie den [`store`](/docs/api/qiskit/circuit#store) Befehl verwenden, um das Ergebnis eines klassischen Ausdrucks zu speichern, falls dieser Ausdruck wiederholt verwendet werden soll. Operationen werden automatisch parallelisiert, wodurch Ihr Code zur Laufzeit deutlich effizienter wird.\n", "\n", "Weitere Informationen finden Sie im Leitfaden zu [klassischem Feedforward und Kontrollfluss](/docs/guides/classical-feedforward-and-control-flow#store).\n", "\n", "\n", " Wenn Sie verwenden `store` , um einen Wert in einem klassischen Register auf einem realen Backend zu speichern, wird dieser Wert lediglich während der Ausführung im Speicher abgelegt und nicht kopiert oder im Ergebnis des Jobs zurückgegeben.\n", "\n", " `if_test` Im folgenden Code hat beispielsweise während der Ausführung denselben Wert wie `creg` , `temp` und funktioniert wie erwartet. Nachdem der Job jedoch abgeschlossen **ist**, enthält die `temp` im Job-Ergebnis zurückgegebene `BitArray` nicht den Wert von `creg`. Das heißt, `job.result()[0].data.temp` ist `0`.\n", "\n", " ```python\n", " creg = ClassicalRegister(3, \"c\")\n", " temp = ClassicalRegister(3, \"temp\")\n", " ...\n", " qc.store(temp, creg)\n", " with circuit.if_test((temp, 0b001)):\n", " ...\n", " ```\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "3f374a74-c331-40de-8594-686e471058a2", "metadata": {}, "source": [ "\n", "\n", "## Vollständiges Beispiel\n", "\n", "Der folgende Code erstellt eine dynamische Schaltung und führt sie auf der Hardware „ IBM® “ aus.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "a7a9c998-4031-432f-978b-83edc040798f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>> Job ID: dab7lcbvpcac73ddek2g (DONE)\n" ] } ], "source": [ "from qiskit_ibm_runtime import SamplerV2, QiskitRuntimeService\n", "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(\n", " operational=True, simulator=False, dynamic_circuits=True\n", ")\n", "\n", "# Create a dynamic circuit\n", "\n", "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "qc = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "qc.h(q0)\n", "qc.measure(q0, c0)\n", "with qc.if_test((c0, 1)):\n", " qc.x(q0)\n", "qc.measure(q0, c0)\n", "\n", "\n", "# Convert to an ISA circuit for the given backend\n", "\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n", "isa_circuit = pm.run(qc)\n", "\n", "# Generate samplers for backend targets\n", "sampler = SamplerV2(backend)\n", "\n", "# Submit jobs\n", "sampler_job = sampler.run([isa_circuit])\n", "result = sampler_job.result()\n", "\n", "print(\n", " f\">>> {' Job ID:':<10} {sampler_job.job_id()} ({sampler_job.status()})\"\n", ")" ] }, { "cell_type": "markdown", "id": "c5b14dcf-edf4-4fef-bb49-e6b86f06afb0", "metadata": {}, "source": [ "\n", "\n", "## Einschränkungen bei Quantencomputern\n", "\n", "Beachten Sie die folgenden Einschränkungen, wenn Sie dynamische Schaltkreise in Quantum Compute ausführen.\n", "\n", "* Aufgrund des begrenzten physischen Speichers in der Steuerelektronik gibt es auch eine Begrenzung hinsichtlich der Anzahl der `if` Anweisungen und der Größe ihrer Operanden. Diese Obergrenze hängt von der Anzahl der Übertragungen und der Anzahl der übertragenen Bits in einem Auftrag (nicht in einer Verbindung) ab.\n", "\n", " Bei der Verarbeitung einer `if` Bedingung müssen Messdaten an die Steuerlogik übertragen werden, damit diese die Auswertung vornehmen kann. Eine Übertragung ist die Übertragung eindeutiger klassischer Daten, und die Anzahl der übertragenen Bits entspricht der Anzahl der übertragenen klassischen Bits. Beachten Sie Folgendes:\n", "\n", " ```python\n", " c0 = ClassicalRegister(3)\n", " c1 = ClassicalRegister(5)\n", " ...\n", " with circuit.if_test((c0, 1)) ...\n", " with circuit.if_test((c0, 3)) ...\n", " with circuit.if_test((c1[2], 1)) ...\n", " ```\n", "\n", " Im vorangegangenen Code-Beispiel werden die ersten beiden `if_test` Objekte in `c0` als eine einzige Übertragung betrachtet, da sich der Inhalt `c0` von nicht geändert hat und daher nicht erneut übertragen werden muss. Die Sendung `if_test` um `c1` ist eine Wiederholung. Der erste sendet alle drei Bits, der zweite `c0` sendet nur ein Bit, sodass insgesamt vier Bits gesendet werden.\n", "\n", " Wenn Sie derzeit jeweils 60 Bits übertragen, kann der Auftrag etwa 300 Übertragungen umfassen. Wenn Sie jedoch jedes Mal nur ein Bit senden, kann der Auftrag 2400 Sendungen umfassen.\n", "\n", "* Der in einer `if_test` -Anweisung verwendete Operand darf höchstens 32 Bit lang sein. Wenn Sie also einen ganzen Wert vergleichen `ClassicalRegister`, darf `ClassicalRegister` dessen Größe höchstens 32 Bit betragen. Wenn Sie jedoch nur ein einzelnes Bit aus a vergleichen `ClassicalRegister`, kann `ClassicalRegister` dieses beliebig groß sein (da der Operand nur aus einem Bit besteht).\n", "\n", " Beispielsweise funktioniert der Code-Block „Nicht gültig“ nicht, da mehr `cr` als 32 Bit umfasst. Sie können jedoch ein klassisches Register verwenden, das breiter als 32 Bit ist, wenn Sie nur ein Bit testen, wie im Code-Block „Valid“ gezeigt.\n", "\n", " \n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr, 15)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(50)\n", " qr = QuantumRegister(50)\n", " circuit = QuantumCircuit(qr, cr)\n", " ...\n", " circ.measure(qr, cr)\n", " with circ.if_test((cr[5], 1)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* Verschachtelte Bedingungen sind nicht zulässig. Der folgende Code-Block funktioniert beispielsweise nicht, da er ein `if_test` innerhalb eines anderen enthält `if_test`:\n", "\n", " \n", " \n", " ```python\n", " c1 = ClassicalRegister(1, \"c1\")\n", " c2 = ClassicalRegister(2, \"c2\")\n", " ...\n", " with circ.if_test((c1, 1)):\n", " with circ.if_test(c2, 1)):\n", " ...\n", " ```\n", " \n", "\n", " \n", " ```python\n", " cr = ClassicalRegister(2)\n", " ...\n", " with circuit.if_test((cr, 0b11)):\n", " ...\n", " ```\n", " \n", " \n", "\n", "* Die Verwendung von `reset` oder Messwerten innerhalb von Bedingungen wird nicht unterstützt.\n", "\n", "* Arithmetische Operationen werden nicht unterstützt.\n", "\n", "* In der [Funktionstabelle zu „ OpenQASM](/docs/guides/qasm-feature-table) “ 3 können Sie nachsehen, welche Funktionen von „ OpenQASM “ 3 von Qiskit und Quantum Compute unterstützt werden.\n", "\n", "* Wenn „ OpenQASM “ 3 (anstelle von `QuantumCircuit`) als Eingabeformat verwendet wird, um Schaltungen an „ IBM Quantum “-Primitive zu übergeben, werden nur Anweisungen unterstützt, die in Qiskit geladen werden können. Klassische Operationen werden beispielsweise nicht unterstützt, da sie nicht in Qiskit geladen werden können. Weitere Informationen finden Sie unter „[Importieren eines Programms aus ‚ OpenQASM ‘ 3 in Qiskit](/docs/guides/interoperate-qiskit-qasm3#import-an-openqasm-3-program-into-qiskit) “.\n", "\n", "* Die `for`Befehle `switch` , `while`, und werden nicht unterstützt.\n", "\n" ] }, { "cell_type": "markdown", "id": "ca6e0493-d364-40bf-9f47-2e3feed9f82c", "metadata": {}, "source": [ "\n", "\n", "## Verwenden Sie dynamische Schaltkreise mit Estimator\n", "\n", "Da Estimator keine dynamischen Schaltungen unterstützt, kannst du stattdessen [Sampler](/docs/guides/get-started-with-sampler) verwenden und deine eigenen Messschaltungen erstellen.\n", "\n", "Um das Verhalten von Estimator nachzubilden, gehen Sie wie folgt vor:\n", "\n", "1. Fassen Sie die Terme aller Observablen zu einer Partition zusammen. Dies kann beispielsweise mithilfe von [`PauliList` API](/docs/api/qiskit/qiskit.quantum_info.PauliList#group_qubit_wise_commuting)… erfolgen.\n", " \n", " Mit dem Attribut [`BitArray`](/docs/api/qiskit/qiskit.primitives.BitArray#expectation_values) „primitive“ können Sie die Erwartungswerte der angegebenen Observablen berechnen.\n", " \n", "2. Führen Sie pro Partition einen Basiswechsel-Durchlauf durch (je nachdem, welcher Basiswechsel für die jeweilige Partition erforderlich ist). Weitere Informationen finden Sie [im `measurement_bases` Zusatzmodul](https://qiskit.github.io/qiskit-addon-utils/apidocs/qiskit_addon_utils.exp_vals.html#qiskit_addon_utils.exp_vals.get_measurement_bases) „Measurement bases“. Weitere Informationen finden Sie in der [Dokumentation](https://qiskit.github.io/qiskit-addon-utils/) zum Qiskit-Addon-Utilities-Paket.\n", "3. Addiere die Ergebnisse für jede Partition wieder zusammen.\n", "\n" ] }, { "cell_type": "markdown", "id": "07045397-6db8-4151-a1e4-de24a8f39ab6", "metadata": {}, "source": [ "\n", "\n", "## Einschränkungen\n", "\n", "Sehen Sie sich [die Kompatibilitätsübersicht](/docs/guides/estimator-options#options-compatibility-table) für die Funktionen an, um sich über die Einschränkungen bei der Verwendung dynamischer Schaltkreise zu informieren. Beachten Sie, dass die Kompatibilität der Funktionen nicht von den Primitiven abhängt.\n", "\n" ] }, { "cell_type": "markdown", "id": "6688e2e3-766b-4194-99db-ae097e9b8bc7", "metadata": {}, "source": [ "\n", "\n", "## Nächste Schritte\n", "\n", "\n", " * Erfahren Sie, wie Sie mithilfe von [„Stretch“](/docs/guides/stretch) eine präzise dynamische Entkopplung umsetzen können.\n", " * Lesen Sie den Leitfaden [zu klassischem Feedforward und Kontrollfluss](/docs/guides/classical-feedforward-and-control-flow) durch.\n", " * Nutzen Sie [die Visualisierung von Schaltkreisen,](/docs/guides/qiskit-runtime-circuit-timing) um Ihre dynamischen Schaltkreise zu debuggen und zu optimieren.\n", " * Nicht alle Funktionen sind mit dynamischen Schaltungen kompatibel. Weitere Informationen finden Sie im Abschnitt zur Funktionskompatibilität von [Sampler](/docs/guides/sampler-options#feature-compatibility).\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" } }, "nbformat": 4, "nbformat_minor": 4 }