{ "cells": [ { "cell_type": "markdown", "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463", "metadata": {}, "source": [ "---\n", "title: \"Schaltkreise konstruieren\"\n", "description: \"Wie man Quantenschaltungen in Qiskit konstruiert und visualisiert.\"\n", "---\n", "\n", "\n", "\n", "# Schaltkreise konstruieren\n", "\n" ] }, { "cell_type": "markdown", "id": "e11dd8ad-7edc-4cf8-bc13-388fe04e84fa", "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 die Verwendung dieser oder neuerer Versionen.\n", "\n", " ```\n", " qiskit[all]~=2.5.2\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d", "metadata": {}, "source": [ "Diese Seite wirft einen genaueren Blick auf die [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) klasse im Qiskit SDK, einschließlich einiger fortgeschrittener Methoden, die Sie zur Erstellung von Quantenschaltungen verwenden können.\n", "\n" ] }, { "cell_type": "markdown", "id": "2664d407-aa95-43a3-9101-d3ad58c2df58", "metadata": {}, "source": [ "\n", "\n", "## Was ist ein Quantenschaltkreis?\n", "\n", "Ein einfacher Quantenschaltkreis ist eine Sammlung von Qubits und eine Liste von Anweisungen, die auf diese Qubits wirken. Zur Veranschaulichung erstellt die folgende Zelle einen neuen Schaltkreis mit zwei neuen Qubits und zeigt dann das Attribut des Schaltkreises [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) attribut der Schaltung an, das eine Liste von [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) in der Reihenfolge vom niedrigstwertigen Bit $q_0$ bis zum höchstwertigen Bit $q_n$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "b410d397-b67d-4f31-90cf-9c1c34c157c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[, ]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "\n", "qc = QuantumCircuit(2)\n", "qc.qubits" ] }, { "cell_type": "markdown", "id": "392e3d6c", "metadata": {}, "source": [ "Mehrere `QuantumRegister` und `ClassicalRegister` Objekte können kombiniert werden, um einen Stromkreis zu erstellen. Jede [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) und [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) können ebenfalls benannt werden.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "6160e3f7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit import QuantumRegister, ClassicalRegister\n", "\n", "qr1 = QuantumRegister(2, \"qreg1\") # Create a QuantumRegister with 2 qubits\n", "qr2 = QuantumRegister(1, \"qreg2\") # Create a QuantumRegister with 1 qubit\n", "cr1 = ClassicalRegister(3, \"creg1\") # Create a ClassicalRegister with 3 cbits\n", "\n", "combined_circ = QuantumCircuit(\n", " qr1, qr2, cr1\n", ") # Create a quantum circuit with 2 QuantumRegisters and 1 ClassicalRegister\n", "combined_circ.qubits" ] }, { "cell_type": "markdown", "id": "6e7b212f", "metadata": {}, "source": [ "Sie können den Index und das Register eines Qubits finden, indem Sie die [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) methode und deren Attribute.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "faeb3fbc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index: 2\n", "Register: [(QuantumRegister(1, 'qreg2'), 0)]\n" ] } ], "source": [ "desired_qubit = qr2[0] # Qubit 0 of register 'qreg2'\n", "\n", "print(\"Index:\", combined_circ.find_bit(desired_qubit).index)\n", "print(\"Register:\", combined_circ.find_bit(desired_qubit).registers)" ] }, { "cell_type": "markdown", "id": "f5c95cb2-a94f-48f3-b2a6-8ec6c25da5cd", "metadata": {}, "source": [ "Das Hinzufügen einer Anweisung zum Stromkreis fügt die Anweisung an das [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) attribut an. Die folgende Zellenausgabe zeigt: `data` ist eine Liste von [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) objekten, von denen jedes ein Attribut `operation` und ein Attribut `qubits` hat.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "f7b5573c-b2b2-4cbf-ba55-c53c9221ce71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[CircuitInstruction(operation=Instruction(name='x', num_qubits=1, num_clbits=0, params=[]), qubits=(,), clbits=())]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.x(0) # Add X-gate to qubit 0\n", "qc.data" ] }, { "cell_type": "markdown", "id": "17a82d8a-b717-44b8-b3f8-ce89e2588261", "metadata": {}, "source": [ "Am einfachsten lassen sich diese Informationen über die [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) Methode abrufen, die eine Visualisierung des Schaltkreises zurückgibt. Unter [„Schaltkreise visualisieren“](/docs/guides/visualize-circuits) finden Sie verschiedene Möglichkeiten zur Darstellung von Quantenschaltkreisen.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "43a57258-3e33-4071-8a48-2bf127c8a5be", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ab5f4bc9-7d7c-4ee7-b1bc-70a313b4fe29", "metadata": {}, "source": [ "Schaltkreisanweisungsobjekte können \"Definitionsschaltungen\" enthalten, die die Anweisung in Form von grundlegenderen Anweisungen beschreiben. So ist beispielsweise das [X-Gatter](/docs/api/qiskit/qiskit.circuit.library.XGate) als ein Sonderfall des [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate) definiert, einem allgemeineren Ein-Qubit-Gatter.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "653e2427-e301-4d2f-84de-1959185ace8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw definition circuit of 0th instruction in `qc`\n", "qc.data[0].operation.definition.draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ee893af1-db43-449f-bfc4-8f636bd98546", "metadata": {}, "source": [ "Anweisungen und Schaltkreise ähneln sich insofern, als sie beide Operationen mit Bits und Qubits beschreiben, aber sie haben unterschiedliche Zwecke:\n", "\n", "* Anweisungen werden als feststehend behandelt, und ihre Methoden geben normalerweise neue Anweisungen zurück (ohne das ursprüngliche Objekt zu verändern).\n", "* Schaltkreise sind so konzipiert, dass sie über viele Codezeilen aufgebaut werden, und [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) methoden verändern oft das bestehende Objekt.\n", "\n" ] }, { "cell_type": "markdown", "id": "2e451022", "metadata": {}, "source": [ "\n", "\n", "### Was ist die Schaltungstiefe?\n", "\n", "Die [Tiefe()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) eines Quantenschaltkreises ist ein Maß für die Anzahl der \"Schichten\" von Quantengattern, die parallel ausgeführt werden müssen, um die durch den Schaltkreis definierte Berechnung abzuschließen. Da die Implementierung von Quantengattern Zeit in Anspruch nimmt, entspricht die Tiefe eines Schaltkreises in etwa der Zeit, die der Quantencomputer zur Ausführung des Schaltkreises benötigt. So ist die Tiefe eines Schaltkreises eine wichtige Größe, um zu messen, ob ein Quantenschaltkreis auf einem Gerät ausgeführt werden kann.\n", "\n", "Der Rest dieser Seite zeigt, wie man Quantenschaltungen manipulieren kann.\n", "\n" ] }, { "cell_type": "markdown", "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc", "metadata": {}, "source": [ "\n", "\n", "## Schaltungen bauen\n", "\n", "Methoden wie [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) und [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) fügen den Schaltkreisen spezifische Anweisungen hinzu. Um einer Schaltung allgemeinere Anweisungen hinzuzufügen, verwenden Sie die [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) methode. Dieser nimmt eine Anweisung und eine Liste von Qubits entgegen, auf die die Anweisung angewendet werden soll. Eine Liste der unterstützten Anweisungen finden Sie in der [API-Dokumentation der Circuit Library](/docs/api/qiskit/circuit_library).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "66813cae-9841-47ea-96b7-8fd7b82e9759", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import HGate\n", "\n", "qc = QuantumCircuit(1)\n", "qc.append(\n", " HGate(), # New HGate instruction\n", " [0], # Apply to qubit 0\n", ")\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "bbdbef08-07c0-4fb0-ab3e-ed6efb7a3dc3", "metadata": {}, "source": [ "Um zwei Stromkreise zu kombinieren, verwenden Sie die [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) methode. Dies akzeptiert eine weitere [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) und eine optionale Liste von Qubit-Zuordnungen.\n", "\n", "\n", " Die Methode [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) methode gibt einen neuen Schaltkreis zurück und verändert **keinen** der beiden Schaltkreise, auf die sie wirkt. Um den Schaltkreis zu verändern, für den Sie die [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) methode aufrufen, verwenden Sie das Argument `inplace=True`.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "29152dfa-2275-4bc4-aadb-82185b9e0e86", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc_a = QuantumCircuit(4)\n", "qc_a.x(0)\n", "\n", "qc_b = QuantumCircuit(2, name=\"qc_b\")\n", "qc_b.y(0)\n", "qc_b.z(1)\n", "\n", "# keep qubits (0, 1) of qc_a with same index.\n", "# compose qubits (0,1) of qc_b to qubits (1, 3), respectively, of new composite circuit\n", "combined = qc_a.compose(qc_b, qubits=[1, 3])\n", "combined.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "d4529506-8397-4208-9cfd-31e1a1978741", "metadata": {}, "source": [ "Sie können auch Schaltungen in Anweisungen zusammenfassen, um Ihre Schaltungen zu organisieren. Sie können eine Schaltung in eine Anweisung umwandeln, indem Sie die [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) methode in eine Anweisung umwandeln und diese dann wie jede andere Anweisung an eine andere Schaltung anhängen. Die in der folgenden Zelle gezeichnete Schaltung ist funktional äquivalent zu der in der vorherigen Zelle gezeichneten Schaltung.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "81b682dd-45cb-4492-809e-d9e8ebbf5600", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "inst = qc_b.to_instruction()\n", "qc_a.append(inst, [1, 3])\n", "qc_a.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "6e81c46b-a2d2-430e-9d3d-73e5030e3548", "metadata": {}, "source": [ "Wenn Ihre Schaltung einheitlich ist, können Sie sie in eine [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) umwandeln, indem Sie die [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) methode. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) objekte sind spezielle Arten von Anweisungen, die einige zusätzliche Funktionen haben, wie z. B. die [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) methode, die eine Quantenkontrolle hinzufügt.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gate = qc_b.to_gate().control()\n", "qc_a.append(gate, [0, 1, 3])\n", "qc_a.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ae850362-84eb-4998-a2cf-a93a1be4ac2a", "metadata": {}, "source": [ "Um zu sehen, was vor sich geht, können Sie mit der [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) methode verwenden, um jede Anweisung in ihre Definition zu zerlegen.\n", "\n", "\n", " Die Methode [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) methode gibt einen neuen Stromkreis zurück und verändert den Stromkreis, auf den sie wirkt, **nicht**.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "3c0633db-929b-4428-a888-7a3d493bd6dd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc_a.decompose().draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "87f1e053", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Qubits messen\n", "\n", "Messungen dienen dazu, die Zustände einzelner Qubits abzutasten und die Ergebnisse in ein klassisches Register zu übertragen. Beachten Sie, dass bei der Übermittlung von Schaltkreisen an eine [Sampler](/docs/guides/get-started-with-sampler) -Primitive Messungen erforderlich sind. An eine [Estimator](/docs/guides/get-started-with-estimator) -Primitive übergebene Schaltkreise dürfen jedoch keine Messwerte enthalten.\n", "\n", "Qubits können mit drei Methoden gemessen werden: [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) und [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). Informationen zur Darstellung von Messergebnissen finden Sie auf der Seite „[Ergebnisse anzeigen](/docs/guides/visualize-results) “.\n", "\n", "1. `QuantumCircuit.measure` qubit: misst jedes Qubit im ersten Argument auf das klassische Bit, das als zweites Argument angegeben wird. Bei dieser Methode haben Sie die volle Kontrolle darüber, wo das Messergebnis gespeichert wird.\n", "\n", "2. `QuantumCircuit.measure_all` : benötigt kein Argument und kann für Quantenschaltungen ohne vordefinierte klassische Bits verwendet werden. Es erstellt klassische Drähte und speichert die Messergebnisse der Reihe nach. Zum Beispiel wird die Messung des Qubits $q_i$ in cbit $meas_i$ ) gespeichert. Außerdem wird vor der Messung eine Barriere hinzugefügt.\n", "\n", "3. `QuantumCircuit.measure_active` : ähnlich wie `measure_all`, misst aber nur Qubits, die Operationen haben.\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "0cdb2273", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc1 = QuantumCircuit(2, 2)\n", "qc1.measure(0, 1)\n", "qc1.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "code", "execution_count": 13, "id": "6f33698c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc2 = QuantumCircuit(2)\n", "qc2.measure_all()\n", "qc2.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "code", "execution_count": 14, "id": "ca3f225f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc3 = QuantumCircuit(2)\n", "qc3.x(1)\n", "qc3.measure_active()\n", "qc3.draw(\"mpl\", cregbundle=False)" ] }, { "cell_type": "markdown", "id": "649fc3fd-caf1-45f1-ad8e-3b5d26ca859b", "metadata": {}, "source": [ "\n", "\n", "## Parametrisierte Schaltungen\n", "\n", "Bei vielen Quantenalgorithmen, die in naher Zukunft entwickelt werden, werden viele Variationen einer Quantenschaltung ausgeführt. Da die Konstruktion und Optimierung großer Schaltungen rechenintensiv sein kann, unterstützt Qiskit **parametrisierte** Schaltungen. Diese Schaltungen haben undefinierte Parameter, deren Werte erst unmittelbar vor der Ausführung der Schaltung festgelegt werden müssen. Auf diese Weise können Sie die Schaltkreiskonstruktion und -optimierung aus der Hauptprogrammschleife herausnehmen. Mit der folgenden Zelle wird eine parametrisierte Schaltung erstellt und angezeigt.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "a580552c-d585-4047-99f0-32aafd06e4f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit.circuit import Parameter\n", "\n", "angle = Parameter(\"angle\") # undefined number\n", "\n", "# Create and optimize circuit once\n", "qc = QuantumCircuit(1)\n", "qc.rx(angle, 0)\n", "qc = generate_preset_pass_manager(\n", " optimization_level=3, basis_gates=[\"u\", \"cx\"]\n", ").run(qc)\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "a174600b-8f4a-47ca-aa4c-cd16dcbecb7c", "metadata": {}, "source": [ "Die folgende Zelle erzeugt viele Variationen dieser Schaltung und zeigt eine der Variationen an.\n", "\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "85af6231-921a-4130-99d3-f6998f761df8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuits = []\n", "for value in range(100):\n", " circuits.append(qc.assign_parameters({angle: value}))\n", "\n", "circuits[0].draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "ede2ff7c-5e68-4458-87b3-887b5b027ee1", "metadata": {}, "source": [ "Eine Liste der undefinierten Parameter eines Schaltkreises finden Sie in seinem Attribut `parameters` .\n", "\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "0990b840-f8c4-4416-b2b5-9861173a9471", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ParameterView([Parameter(angle)])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.parameters" ] }, { "cell_type": "markdown", "id": "8e415c37", "metadata": {}, "source": [ "\n", "\n", "### Ändern Sie den Namen eines Parameters\n", "\n", "Standardmäßig werden Parameternamen für eine parametrisierte Schaltung mit einem Präfix `x`versehen, beispielsweise. `x[0]` Sie können die Namen nach ihrer Definition ändern, wie im folgenden Beispiel gezeigt.\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "1d3e6424", "metadata": {}, "outputs": [], "source": [ "from qiskit.circuit.library import z_feature_map\n", "from qiskit.circuit import ParameterVector\n", "\n", "# Define a parameterized circuit with default names\n", "# For example, x[0]\n", "circuit = z_feature_map(2)\n", "\n", "# Set new parameter names\n", "# They will now be prefixed by `hi` instead\n", "# For example, hi[0]\n", "training_params = ParameterVector(\"hi\", 2)\n", "\n", "# Assign parameter names to the quantum circuit\n", "circuit = circuit.assign_parameters(parameters=training_params)" ] }, { "cell_type": "markdown", "id": "5af44bc3", "metadata": {}, "source": [ "\n", "\n", "## Nächste Schritte\n", "\n", "\n", " * Wenn Sie mehr über Quantenalgorithmen in naher Zukunft erfahren möchten, besuchen Sie den Kurs [zum Entwurf von Variationsalgorithmen](/learning/courses/variational-algorithm-design).\n", " * Ein Beispiel für die Verwendung von Schaltkreisen finden Sie im Tutorial über [den Grover-Algorithmus](/docs/tutorials/grovers-algorithm).\n", " * Arbeiten Sie mit einfachen Schaltungen mit [IBM Quantum Composer](/docs/guides/composer).\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": 5 }