{ "cells": [ { "cell_type": "markdown", "id": "b97a7e0a-66a6-46b2-b33f-47feeefad60d", "metadata": {}, "source": [ "---\n", "title: \"Dienstprogramm II\"\n", "description: \"Dieses Notizbuch folgt den Methoden und Techniken aus Lektion 7. Unser Ziel ist es, die zeitabhängige Schrödinger-Gleichung numerisch zu lösen.\"\n", "---\n", "\n", "{/* cspell:ignore sharex */}\n", "\n", "\n", "\n", "# Großtechnisches Experiment II\n", "\n", "\n", " Yukio Kawashima (12. Juli 2024)\n", "\n", " [Laden Sie die PDF-Datei](https://ibm.ent.box.com/s/bipgoms7gr6b6vhkoc1uw6oi4wsanfoq) der Originalvorlesung herunter. Beachten Sie, dass einige Codeschnipsel veraltet sein könnten, da es sich um statische Bilder handelt.\n", "\n", " *Die ungefähre QPU-Zeit für die Durchführung dieses Experiments beträgt 2 m 30 s.*\n", "\n", " (Beachten Sie, dass dieses Notizbuch Texte, Illustrationen und Codes aus einem inzwischen veralteten [Tutorial-Notizbuch](https://github.com/qiskit-community/qiskit-algorithms/blob/main/docs/tutorials/13_trotterQRTE.ipynb) für Qiskit-Algorithmen verwendet)\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "76421ffc-f47f-46a4-8198-af3bc21e3c5d", "metadata": {}, "source": [ "\n", "\n", "## 1. Einführung und Überblick über die zeitliche Entwicklung\n", "\n", "Dieses Heft folgt den Methoden und Techniken von Lektion 7. Unser Ziel ist es, die zeitabhängige Schrödinger-Gleichung numerisch zu lösen. Wie in Lektion 7 erläutert, besteht die Trotterisierung in der sukzessiven Anwendung eines Quantengatters oder mehrerer Quantengatter, die so gewählt werden, dass sie die zeitliche Entwicklung eines Systems für einen Zeitabschnitt annähern. Der Einfachheit halber wiederholen wir diese Diskussion hier. Wenn Sie Lektion 7 bereits gelesen haben, können Sie zu den unten stehenden Code-Zellen übergehen.\n", "\n", "Ausgehend von der Schrödingergleichung hat die zeitliche Entwicklung eines Systems, das sich zunächst im Zustand $\\vert\\psi(0)\\rangle$ befindet, die Form:\n", "\n", "$$\n", "\\vert \\psi(t) \\rangle = e^{-i H t} \\vert \\psi(0) \\rangle \\text{,}\n", "$$\n", "\n", "wobei $H$ der zeitunabhängige Hamiltonian ist, der das System steuert. Wir betrachten einen Hamiltonian, der als eine gewichtete Summe von Pauli-Termen $H=\\sum_j a_j P_j$ geschrieben werden kann, wobei $P_j$ ein Tensorprodukt von Pauli-Termen darstellt, die auf $n$ Qubits wirken. Insbesondere können diese Pauli-Terme miteinander pendeln oder auch nicht. Wie erhält man bei einem Zustand zum Zeitpunkt $t=0$ den Zustand des Systems zu einem späteren Zeitpunkt $|\\psi(t)\\rangle$ mit Hilfe eines Quantencomputers? Das Exponential eines Operators lässt sich am einfachsten durch seine Taylor-Reihe verstehen:\n", "\n", "$$\n", "e^{-i H t} = 1-iHt-\\frac{1}{2}H^2t^2+...\n", "$$\n", "\n", "Einige sehr einfache Exponentiale, wie $e^{iZ}$, können auf Quantencomputern mit einer kompakten Menge von Quantengattern leicht implementiert werden. Die meisten Hamiltonianer, die von Interesse sind, haben nicht nur einen einzigen Term, sondern viele Terme. Beachten Sie, was passiert, wenn $H = H_1+H_2$ :\n", "\n", "$$\n", "e^{-i H t} = 1-i(H_1+H_2)t-\\frac{1}{2}(H_1+H_2)^2t^2+...\n", "$$\n", "\n", "Wenn $H_1$ und $H_2$ kommutieren, haben wir den bekannten Fall (der auch für Zahlen und die Variablen $a$ und $b$ unten gilt):\n", "\n", "$$\n", "e^{-i (a+b) t} = e^{-i a t}e^{-i b t}\n", "$$\n", "\n", "Wenn die Operatoren jedoch nicht kommutieren, können die Terme in der Taylor-Reihe nicht umgeordnet werden, um sie auf diese Weise zu vereinfachen. Daher ist es eine Herausforderung, komplizierte Hamiltonianer in Quantengattern auszudrücken.\n", "\n", "Eine Lösung besteht darin, eine sehr kleine Zeit $t$ zu betrachten, so dass der Term erster Ordnung in der Taylor-Erweiterung dominiert. Unter dieser Annahme:\n", "\n", "$$\n", "e^{-i (H_1+H_2) t} \\approx 1-i(H_1+H_2)t \\approx (1-i H_1 t)(1-i H_2 t) \\approx e^{-i H_1 t}e^{-i H_2 t}\n", "$$\n", "\n", "Natürlich kann es sein, dass wir unseren Zustand über einen längeren Zeitraum hinweg weiterentwickeln müssen. Dies wird durch viele kleine Schritte in der Zeit erreicht. Dieser Prozess wird als Trotterisierung bezeichnet:\n", "\n", "$$\n", "\\vert \\psi(t) \\rangle \\approx \\left(\\prod_j e^{-i a_j P_j t/r} \\right)^r \\vert\\psi(0) \\rangle \\text{,}\n", "$$\n", "\n", "Hier ist $t/r$ der Zeitabschnitt (Evolutionsschritt), den wir wählen. Dadurch wird ein Tor geschaffen, das $r$ mal angewendet werden kann. Ein kleinerer Zeitschritt führt zu einer genaueren Annäherung. Dies führt jedoch auch zu tieferen Schaltkreisen, was in der Praxis zu einer größeren Fehlerakkumulation führt (ein nicht zu vernachlässigendes Problem bei Quantengeräten in naher Zukunft).\n", "\n", "Heute werden wir die zeitliche Entwicklung des [Ising-Modells](https://en.wikipedia.org/wiki/Ising_model) auf linearen Gittern mit den Seiten $N=2$ und $N=6$ untersuchen. Diese Gitter bestehen aus einer Reihe von Spins $\\sigma_i$, die nur mit ihren nächsten Nachbarn wechselwirken. Diese Spins können zwei Ausrichtungen haben: $\\uparrow$ und $\\downarrow$, was einer Magnetisierung von $+1$ bzw. $-1$ entspricht.\n", "\n", "$$\n", "H = - J \\sum_{i=0}^{N-2} Z_i Z_{i+1} - h \\sum_{i=0}^{N-1} X_i \\text{,}\n", "$$\n", "\n", "wobei $J$ die Wechselwirkungsenergie und $h$ die Stärke eines externen Feldes (in x-Richtung, wie oben beschrieben, aber wir werden dies ändern) beschreibt. Wir schreiben diesen Ausdruck unter Verwendung von Pauli-Matrizen und unter der Annahme, dass das äußere Feld einen Winkel $\\alpha$ zur Querrichtung hat,\n", "\n", "$$\n", "H = -J \\sum_{i=0}^{N-2} Z_i Z_{i+1} -h \\sum_{i=0}^{N-1} (\\sin\\alpha Z_i + \\cos\\alpha X_i) \\text{.}\n", "$$\n", "\n", "Dieser Hamiltonian ist insofern nützlich, als er es uns ermöglicht, die Auswirkungen eines externen Feldes zu untersuchen. In der Berechnungsgrundlage wird das System wie folgt kodiert:\n", "\n", "| Quantenzustand | Spin-Darstellung |\n", "| :----------------------: | :----------------------------------------: |\n", "| $\\lvert 0 0 0 0 \\rangle$ | $\\uparrow\\uparrow\\uparrow\\uparrow$ |\n", "| $\\lvert 1 0 0 0 \\rangle$ | $\\downarrow\\uparrow\\uparrow\\uparrow$ |\n", "| $\\ldots$ | $\\ldots$ |\n", "| $\\lvert 1 1 1 1 \\rangle$ | $\\downarrow\\downarrow\\downarrow\\downarrow$ |\n", "\n", "Wir werden damit beginnen, die zeitliche Entwicklung eines solchen Quantensystems zu untersuchen. Genauer gesagt werden wir die zeitliche Entwicklung bestimmter Eigenschaften des Systems, wie z. B. der Magnetisierung, visualisieren.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "81aff7b3-67e5-453b-9f5b-68baf5209560", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'2.0.2'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check the version of Qiskit\n", "import qiskit\n", "\n", "qiskit.__version__" ] }, { "cell_type": "code", "execution_count": 2, "id": "c88eda88-da8a-4e5e-9b8b-53ac0d0ed91b", "metadata": { "scrolled": true, "tags": [] }, "outputs": [], "source": [ "# Import the qiskit library\n", "\n", "import numpy as np\n", "import warnings\n", "\n", "from qiskit import QuantumCircuit, QuantumRegister\n", "from qiskit.circuit.library import PauliEvolutionGate\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.synthesis import LieTrotter\n", "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", "\n", "from qiskit_aer import AerSimulator\n", "from qiskit_ibm_runtime import QiskitRuntimeService, Estimator\n", "\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "id": "ed6c1602-d994-46d6-9426-d38272a63d56", "metadata": {}, "source": [ "\n", "\n", "## 2. Definition des transversalen Ising-Hamilton-Operators\n", "\n", "Wir betrachten hier das 1-D-Transversalfeld-Ising-Modell.\n", "\n", "Zunächst werden wir eine Funktion erstellen, die die Systemparameter $N$, $J$ und $h$ aufnimmt und unseren Hamiltonian als `SparsePauliOp` zurückgibt. A [SparsePauliOp](/docs/api/qiskit/qiskit.quantum_info.SparsePauliOp) ist eine spärliche Darstellung eines Operators in Form von gewichteten [Pauli-Termen](/docs/api/qiskit/qiskit.quantum_info.Pauli).\n", "\n" ] }, { "cell_type": "markdown", "id": "b3137f47-640a-4382-95b6-6bb9e760bc96", "metadata": {}, "source": [ "\n", "\n", "### 2.1 Aktivität 1\n", "\n", "Konstruieren Sie eine Funktion zum Aufbau eines Ising-Hamiltonianers mit transversalem Feld (siehe die obige Gleichung) mit den Argumenten \"Anzahl der Qubits\", \"J-Parameter\" und \"h-Parameter\". Versuchen Sie dies anhand der vorherigen Beispiele selbst. Scrollen Sie nach unten, um die Lösung zu finden.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "3de92af7-7504-4dca-b0b4-0d934f0c2069", "metadata": {}, "outputs": [], "source": [ "def get_hamiltonian(nqubits, J, h):\n", " # List of Hamiltonian terms as 3-tuples containing\n", " # (1) the Pauli string,\n", " # (2) the qubit indices corresponding to the Pauli string,\n", " # (3) the coefficient.\n", " ZZ_tuples = [(\"ZZ\", [i, i + 1], -J) for i in range(0, nqubits - 1)]\n", " X_tuples = [(\"X\", [i], -h) for i in range(0, nqubits)]\n", "\n", " # We create the Hamiltonian as a SparsePauliOp, via the method\n", " # `from_sparse_list`, and multiply by the interaction term.\n", " hamiltonian = SparsePauliOp.from_sparse_list(\n", " [*ZZ_tuples, *X_tuples], num_qubits=nqubits\n", " )\n", " return hamiltonian.simplify()" ] }, { "cell_type": "markdown", "id": "8b147fb0-6c3e-4eaf-8553-8850b53ff121", "metadata": {}, "source": [ "Wir werden mit der Untersuchung der zeitlichen Entwicklung eines Quantensystems beginnen und dabei die Magnetisierung im Auge behalten.\n", "Wir vergleichen hier die Ergebnisse der Statevector- und Matrix Product State-Simulatoren.\n", "\n", "\n", "\n", "#### Definieren Sie den Hamilton-Operator\n", "\n", "Das System, das wir jetzt betrachten, hat eine Größe von $N=20$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "56764f93-3851-4b1c-b9e2-ea34161ddd85", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SparsePauliOp(['IIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIZZI', 'IIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIZZIIIII', 'IIIIIIIIIIIIZZIIIIII', 'IIIIIIIIIIIZZIIIIIII', 'IIIIIIIIIIZZIIIIIIII', 'IIIIIIIIIZZIIIIIIIII', 'IIIIIIIIZZIIIIIIIIII', 'IIIIIIIZZIIIIIIIIIII', 'IIIIIIZZIIIIIIIIIIII', 'IIIIIZZIIIIIIIIIIIII', 'IIIIZZIIIIIIIIIIIIII', 'IIIZZIIIIIIIIIIIIIII', 'IIZZIIIIIIIIIIIIIIII', 'IZZIIIIIIIIIIIIIIIII', 'ZZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIX', 'IIIIIIIIIIIIIIIIIIXI', 'IIIIIIIIIIIIIIIIIXII', 'IIIIIIIIIIIIIIIIXIII', 'IIIIIIIIIIIIIIIXIIII', 'IIIIIIIIIIIIIIXIIIII', 'IIIIIIIIIIIIIXIIIIII', 'IIIIIIIIIIIIXIIIIIII', 'IIIIIIIIIIIXIIIIIIII', 'IIIIIIIIIIXIIIIIIIII', 'IIIIIIIIIXIIIIIIIIII', 'IIIIIIIIXIIIIIIIIIII', 'IIIIIIIXIIIIIIIIIIII', 'IIIIIIXIIIIIIIIIIIII', 'IIIIIXIIIIIIIIIIIIII', 'IIIIXIIIIIIIIIIIIIII', 'IIIXIIIIIIIIIIIIIIII', 'IIXIIIIIIIIIIIIIIIII', 'IXIIIIIIIIIIIIIIIIII', 'XIIIIIIIIIIIIIIIIIII'],\n", " coeffs=[-1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n_qubits = 20\n", "hamiltonian = get_hamiltonian(nqubits=n_qubits, J=1.0, h=-5.0)\n", "hamiltonian" ] }, { "cell_type": "markdown", "id": "eb075fee-fdb5-4016-bea2-643b444062b8", "metadata": {}, "source": [ "\n", "\n", "#### Legen Sie die Parameter für die Zeitverlaufssimulation fest\n", "\n", "Hier werden wir den Lie-Trotter (erster Ordnung) betrachten.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "3a5af3d3-015b-4a5c-86cd-52830067a1e2", "metadata": {}, "outputs": [], "source": [ "num_timesteps = 20\n", "evolution_time = 2.0\n", "dt = evolution_time / num_timesteps\n", "product_formula_lt = LieTrotter()" ] }, { "cell_type": "markdown", "id": "e5fc52a2-15af-464f-aac2-890417745c82", "metadata": {}, "source": [ "\n", "\n", "#### Quantenschaltung vorbereiten (Ausgangszustand)\n", "\n", "Erstellen Sie einen Ausgangszustand. Wir gehen vom Grundzustand aus, der ein ferromagnetischer Zustand ist (ganz oben oder ganz unten). Hier verwenden wir ein Beispiel für alle Aufwärtsbewegungen (die alle \"0\" sind).\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "64f622f2-6e1c-4b42-b548-dd3e5aa32786", "metadata": { "scrolled": true, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "initial_circuit = QuantumCircuit(n_qubits)\n", "initial_circuit.prepare_state(\"00000000000000000000\")\n", "# Change reps and see the difference when you decompose the circuit\n", "initial_circuit.decompose(reps=1).draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "dab0957f-186f-475f-bdee-907469b54174", "metadata": {}, "source": [ "\n", "\n", "#### Bereiten Sie den Quantenschaltkreis 2 vor (Einzelschaltkreis für die Zeitentwicklung)\n", "\n", "Wir konstruieren hier eine Schaltung für einen einzigen Zeitschritt mit Lie-Trotter.\n", "Die Lie-Produkt-Formel (erster Ordnung) ist in der [LieTrotter](/docs/api/qiskit/qiskit.synthesis.LieTrotter) klasse implementiert. Eine Formel erster Ordnung besteht aus der in der Einleitung genannten Annäherung, bei der das Matrixexponential einer Summe durch ein Produkt von Matrixexponentialen angenähert wird:\n", "\n", "$$\n", "e^{H_1+H_2} \\approx e^{H_1} e^{H_2}\n", "$$\n", "\n", "Zählen wir die Operationen für diese Schaltung.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "b812f4b6-fb83-4c89-a8bc-ac0d85784720", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: 58\n", "Gate count: 77\n", "Nonlocal gate count: 38\n", "Gate breakdown: CX: 38, U3: 20, U1: 19\n", "\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "single_step_evolution_gates_lt = PauliEvolutionGate(\n", " hamiltonian, dt, synthesis=product_formula_lt\n", ")\n", "single_step_evolution_lt = QuantumCircuit(n_qubits)\n", "single_step_evolution_lt.append(\n", " single_step_evolution_gates_lt, single_step_evolution_lt.qubits\n", ")\n", "\n", "print(\n", " f\"\"\"\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: {single_step_evolution_lt.decompose(reps=3).depth()}\n", "Gate count: {len(single_step_evolution_lt.decompose(reps=3))}\n", "Nonlocal gate count: {single_step_evolution_lt.decompose(reps=3).num_nonlocal_gates()}\n", "Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in single_step_evolution_lt.decompose(reps=3).count_ops().items()])}\n", "\"\"\"\n", ")\n", "single_step_evolution_lt.decompose(reps=3).draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "474e7a29-82bc-470e-8556-87e88195f213", "metadata": {}, "source": [ "\n", "\n", "#### Die zu messenden Operatoren einstellen\n", "\n", "Definieren wir einen *Magnetisierungsoperator* $\\sum_i Z_i / N$.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "2488d18d-70f0-43a2-9675-4d34562e47ce", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "magnetization : SparsePauliOp(['IIIIIIIIIIIIIIIIIIIZ', 'IIIIIIIIIIIIIIIIIIZI', 'IIIIIIIIIIIIIIIIIZII', 'IIIIIIIIIIIIIIIIZIII', 'IIIIIIIIIIIIIIIZIIII', 'IIIIIIIIIIIIIIZIIIII', 'IIIIIIIIIIIIIZIIIIII', 'IIIIIIIIIIIIZIIIIIII', 'IIIIIIIIIIIZIIIIIIII', 'IIIIIIIIIIZIIIIIIIII', 'IIIIIIIIIZIIIIIIIIII', 'IIIIIIIIZIIIIIIIIIII', 'IIIIIIIZIIIIIIIIIIII', 'IIIIIIZIIIIIIIIIIIII', 'IIIIIZIIIIIIIIIIIIII', 'IIIIZIIIIIIIIIIIIIII', 'IIIZIIIIIIIIIIIIIIII', 'IIZIIIIIIIIIIIIIIIII', 'IZIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIII'],\n", " coeffs=[0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j,\n", " 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j,\n", " 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j, 0.05+0.j])\n" ] } ], "source": [ "magnetization = (\n", " SparsePauliOp.from_sparse_list(\n", " [(\"Z\", [i], 1.0) for i in range(0, n_qubits)], num_qubits=n_qubits\n", " )\n", " / n_qubits\n", ")\n", "print(\"magnetization : \", magnetization)" ] }, { "cell_type": "markdown", "id": "308ed03d-432d-4113-9c06-2ce10c02ecd5", "metadata": {}, "source": [ "\n", "\n", "#### Zeitverlaufssimulation durchführen\n", "\n", "Wir werden die Magnetisierung überwachen (Erwartungswert des Magnetisierungsoperators). Wir werden Statevector- und MPS-Simulatoren verwenden und die Ergebnisse vergleichen.\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "25bd2824-009e-4d76-be83-a906bf8b0d44", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Step 1. Map the problem\n", "# Initiate the circuit\n", "evolved_state = QuantumCircuit(initial_circuit.num_qubits)\n", "# Start from the initial spin configuration\n", "evolved_state.append(initial_circuit, evolved_state.qubits)\n", "\n", "# Define backend (simulator)\n", "# MPS\n", "backend_mps = AerSimulator(method=\"matrix_product_state\")\n", "# Statevector\n", "backend_sv = AerSimulator(method=\"statevector\")\n", "\n", "# Set Runtime Estimator\n", "# MPS\n", "estimator_mps = Estimator(mode=backend_mps)\n", "# Statevector\n", "estimator_sv = Estimator(mode=backend_sv)\n", "\n", "# Step 2. Optimize\n", "# Set pass manager\n", "# MPS\n", "pm_mps = generate_preset_pass_manager(optimization_level=3, backend=backend_mps)\n", "# Statevector\n", "pm_sv = generate_preset_pass_manager(optimization_level=3, backend=backend_sv)\n", "\n", "# Transpile initial circuit\n", "# MPS\n", "evolved_state_mps = pm_mps.run(evolved_state)\n", "# Statevector\n", "evolved_state_sv = pm_sv.run(evolved_state)\n", "\n", "# Apply layout to the operator\n", "# MPS\n", "magnetization_mps = magnetization.apply_layout(evolved_state_mps.layout)\n", "# Statevector\n", "magnetization_sv = magnetization.apply_layout(evolved_state_sv.layout)\n", "\n", "mag_mps_list = []\n", "mag_sv_list = []\n", "\n", "# Step 3. Run the circuit\n", "# Estimate expectation values for t=0.0: MPS\n", "job = estimator_mps.run([(evolved_state_mps, [magnetization_mps])])\n", "# Get estimated expectation values: MPS\n", "evs = job.result()[0].data.evs\n", "# Collect data: MPS\n", "mag_mps_list.append(evs[0])\n", "\n", "# Estimate expectation values for t=0.0: Statevector\n", "job = estimator_sv.run([(evolved_state_sv, [magnetization_sv])])\n", "# Get estimated expectation values: Statevector\n", "evs = job.result()[0].data.evs\n", "# Collect data: Statevector\n", "mag_sv_list.append(evs[0])\n", "\n", "# Start time evolution\n", "for n in range(num_timesteps):\n", " # Step 1. Map the problem\n", " # Expand the circuit to describe delta-t\n", " evolved_state.append(single_step_evolution_lt, evolved_state.qubits)\n", " # Step 2. Optimize\n", " # Transpile the circuit: MPS\n", " evolved_state_mps = pm_mps.run(evolved_state)\n", " # Apply the physical layout of the qubits to the operator: MPS\n", " magnetization_mps = magnetization.apply_layout(evolved_state_mps.layout)\n", " # Step 3. Run the circuit\n", " # Estimate expectation values at delta-t: MPS\n", " job = estimator_mps.run([(evolved_state_mps, [magnetization_mps])])\n", " # Get estimated expectation values: MPS\n", " evs = job.result()[0].data.evs\n", " # Collect data: MPS\n", " mag_mps_list.append(evs[0])\n", "\n", " # Step 2. Optimize\n", " # Transpile the circuit: Statevector\n", " evolved_state_sv = pm_sv.run(evolved_state)\n", " # Apply the physical layout of the qubits to the operator: Statevector\n", " magnetization_sv = magnetization.apply_layout(evolved_state_sv.layout)\n", " # Step 3. Run the circuit\n", " # Estimate expectation values at delta-t: Statevector\n", " job = estimator_sv.run([(evolved_state_sv, [magnetization_sv])])\n", " # Get estimated expectation values: Statevector\n", " evs = job.result()[0].data.evs\n", " # Collect data: Statevector\n", " mag_sv_list.append(evs[0])\n", "\n", "# Transform the list of expectation values (at each time step) to arrays\n", "mag_mps_array = np.array(mag_mps_list)\n", "mag_sv_array = np.array(mag_sv_list)" ] }, { "cell_type": "markdown", "id": "046df34e-4cc8-455a-a3e8-f6b345c9249a", "metadata": {}, "source": [ "\n", "\n", "#### Zeichnen Sie die zeitliche Entwicklung der Beobachtungsgrößen auf\n", "\n", "Wir zeichnen die von uns gemessenen Erwartungswerte gegen die Zeit auf. Bestätigen Sie, dass die Ergebnisse der Zustandsvektor- und Matrixproduktraumsimulatoren übereinstimmen.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "1762b191-c234-4acc-a6ea-8433a59ef3f8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0.98, 'Observable evolution')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Step 4. Post-processing\n", "fig, axes = plt.subplots(2, sharex=True)\n", "times = np.linspace(0, evolution_time, num_timesteps + 1) # includes initial state\n", "axes[0].plot(\n", " times, mag_mps_array, label=\"MPS\", marker=\"x\", c=\"darkmagenta\", ls=\"-\", lw=0.8\n", ")\n", "axes[1].plot(\n", " times, mag_sv_array, label=\"SV\", marker=\"x\", c=\"darkmagenta\", ls=\"-\", lw=0.8\n", ")\n", "\n", "axes[0].set_ylabel(\"MPS\")\n", "axes[1].set_ylabel(\"Statevector\")\n", "axes[1].set_xlabel(\"Time\")\n", "fig.suptitle(\"Observable evolution\")" ] }, { "cell_type": "markdown", "id": "4a4a4efa-de95-470e-8030-1b842e63f904", "metadata": {}, "source": [ "Wir werden damit beginnen, die zeitliche Entwicklung eines Quantensystems zu untersuchen, wobei wir die Eigenschaften im Auge behalten.\n", "Wir vergleichen hier die Ergebnisse des Matrix-Produktzustands-Simulators mit denen des tatsächlichen Quantengeräts.\n", "\n", "\n", "\n", "### 2.2 Aktivität 2\n", "\n", "\n", "\n", "#### Definieren Sie den Hamilton-Operator\n", "\n", "Das System, das wir jetzt betrachten, hat eine Größe von $N=70$. Beachten Sie, dass die anderen Bedingungen die gleichen sind wie beim 20-Qubit-Problem. Probieren Sie es selbst aus; die Lösung finden Sie weiter unten.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "b8ee438b-69ac-438d-a8c9-a2055c347f0e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIX', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'XIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'],\n", " coeffs=[-1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j,\n", " -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, -1.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j, 5.+0.j,\n", " 5.+0.j, 5.+0.j, 5.+0.j])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set the number of qubits\n", "n_qubits2 = 70\n", "# Construct the Hamiltonian by calling the function you made in Activity 1\n", "hamiltonian2 = get_hamiltonian(nqubits=n_qubits2, J=1.0, h=-5.0)\n", "hamiltonian2" ] }, { "cell_type": "markdown", "id": "8bcad10c-1ad8-4d62-ba05-6c3d4792e4b9", "metadata": {}, "source": [ "\n", "\n", "### 2.3 Aktivität 3\n", "\n", "Erstellen Sie einen Ausgangszustand. Wir gehen vom Grundzustand aus, der ein ferromagnetischer Zustand ist (ganz oben oder ganz unten). Hier verwenden wir ein Beispiel für alle Aufwärtsbewegungen (die alle \"0\" sind). Probieren Sie es selbst aus; die Lösung finden Sie weiter unten.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "b7bfecd3-cc23-4005-89d5-61754b72ac7d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Initiate the (quantum)circuit\n", "initial_circuit2 = QuantumCircuit(n_qubits2)\n", "# Use QuantumCircuit.prepare_state() to define the initial state\n", "initial_circuit2.prepare_state(\n", " \"0000000000000000000000000000000000000000000000000000000000000000000000\"\n", ")\n", "# Change reps and see the difference when you decompose the circuit\n", "initial_circuit2.decompose(reps=1).draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "d3699dfb-5f77-4c2b-b4c7-13ca873b032b", "metadata": {}, "source": [ "\n", "\n", "### 2.4 Aktivität 4\n", "\n", "\n", "\n", "#### Bereiten Sie den Quantenschaltkreis 2 (Einzelschaltkreis für die Zeitentwicklung) für das 70-Qubit-Problem vor\n", "\n", "Wir konstruieren hier eine Schaltung für einen einzigen Zeitschritt mit Lie-Trotter.\n", "Genau wie im 20-Qubit-Fall ist die Lie-Produkt-Formel (erster Ordnung) in der [LieTrotter](/docs/api/qiskit/qiskit.synthesis.LieTrotter) klasse implementiert. Auch hier besteht die Formel erster Ordnung aus der oben genannten Näherung:\n", "\n", "$$\n", "e^{H_1+H_2} \\approx e^{H_1} e^{H_2}\n", "$$\n", "\n", "Versuchen Sie es selbst, ausgehend vom Beispiel des 20-Qubit-Falls. Zählen Sie wie zuvor die Operationen für diese Schaltung.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "adb8395b-478a-4db0-b85e-456be61c9e69", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: 208\n", "Gate count: 277\n", "Nonlocal gate count: 138\n", "Gate breakdown: CX: 138, U3: 70, U1: 69\n", "\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Construct the gates using PauliEvolutionGate()\n", "single_step_evolution_gates_lt2 = PauliEvolutionGate(\n", " hamiltonian2, dt, synthesis=LieTrotter()\n", ")\n", "# Initiate the quantum circuit\n", "single_step_evolution_lt2 = QuantumCircuit(n_qubits2)\n", "# Append the gates defined above\n", "single_step_evolution_lt2.append(\n", " single_step_evolution_gates_lt2, single_step_evolution_lt2.qubits\n", ")\n", "\n", "print(\n", " f\"\"\"\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: {single_step_evolution_lt2.decompose(reps=3).depth()}\n", "Gate count: {len(single_step_evolution_lt2.decompose(reps=3))}\n", "Nonlocal gate count: {single_step_evolution_lt2.decompose(reps=3).num_nonlocal_gates()}\n", "Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in single_step_evolution_lt2.decompose(reps=3).count_ops().items()])}\n", "\"\"\"\n", ")\n", "single_step_evolution_lt2.decompose(reps=3).draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "acede2cd-d3d8-45b8-8bc5-b307fc1f32fe", "metadata": {}, "source": [ "\n", "\n", "### 2.5 Aktivität 5\n", "\n", "\n", "\n", "#### Die zu messenden Operatoren einstellen\n", "\n", "Wir definieren einen *Magnetisierungsoperator*, der genau demjenigen aus dem 20-Qubit-Fall entspricht: $\\sum_i Z_i / N$. Probieren Sie es selbst aus, indem Sie die 20-Qubit-Lösung abändern.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "9cac351a-b15c-4aff-87f1-c877946664d3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "magnetization : SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'],\n", " coeffs=[0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j, 0.01428571+0.j,\n", " 0.01428571+0.j, 0.01428571+0.j])\n" ] } ], "source": [ "# Define the magnetization operator in SparsePauliOp\n", "magnetization2 = (\n", " SparsePauliOp.from_sparse_list(\n", " [(\"Z\", [i], 1.0) for i in range(0, n_qubits2)], num_qubits=n_qubits2\n", " )\n", " / n_qubits2\n", ")\n", "print(\"magnetization : \", magnetization2)" ] }, { "cell_type": "markdown", "id": "91f92286-acb7-4946-9f5f-150587e7f4d0", "metadata": {}, "source": [ "\n", "\n", "### 2.6 Aktivität 6\n", "\n", "\n", "\n", "#### Zeitverlaufssimulation durchführen\n", "\n", "Wir werden die Magnetisierung überwachen (Erwartungswert des Magnetisierungsoperators). Wir werden den MPS-Simulator verwenden, um den Referenzwert für den Vergleich der von der Hardware berechneten Ergebnisse zu erhalten. Sie haben den MPS-Simulator bereits in diesem Lernprogramm verwendet. Ändern Sie das Beispiel, wenn nötig, um es an die neue Berechnung anzupassen.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "7e7b754c-deff-40fd-9250-8b4deafa18d6", "metadata": {}, "outputs": [], "source": [ "# Step 1. Map the problem\n", "# Initiate the circuit\n", "evolved_state2 = QuantumCircuit(initial_circuit2.num_qubits)\n", "# Start from the initial spin configuration\n", "evolved_state2.append(initial_circuit2, evolved_state2.qubits)\n", "# Define backend (MPs simulator)\n", "backend_mps2 = AerSimulator(method=\"matrix_product_state\")\n", "# Initiate Runtime Estimator\n", "estimator_mps2 = Estimator(mode=backend_mps2)\n", "# Step 2. Optimize\n", "# Initiate pass manager\n", "pm_mps2 = generate_preset_pass_manager(optimization_level=3, backend=backend_mps2)\n", "# Transpile\n", "evolved_state_mps2 = pm_mps2.run(evolved_state2)\n", "# Apply qubit layout to the observable to measure\n", "magnetization_mps2 = magnetization2.apply_layout(evolved_state_mps2.layout)\n", "# Initiate list\n", "mag_mps_list2 = []\n", "# Step 3. Run the circuit\n", "# Estimate expectation values for t=0.0\n", "job = estimator_mps2.run([(evolved_state_mps2, [magnetization_mps2])])\n", "# Get estimated expectation values\n", "evs = job.result()[0].data.evs\n", "# Append to list\n", "mag_mps_list2.append(evs[0])\n", "\n", "# Start time evolution\n", "for n in range(num_timesteps):\n", " # Step 1. Map the problem\n", " # Expand the circuit to describe delta-t\n", " evolved_state2.append(single_step_evolution_lt2, evolved_state2.qubits)\n", " # Step 2. Optimize\n", " # Transpile the circuit\n", " evolved_state_mps2 = pm_mps2.run(evolved_state2)\n", " # Apply the physical layout of the qubits to the operator\n", " magnetization_mps2 = magnetization2.apply_layout(evolved_state_mps2.layout)\n", " # Step 3. Run the circuit\n", " # Estimate expectation values at delta-t\n", " job = estimator_mps2.run([(evolved_state_mps2, [magnetization_mps2])])\n", " # Get estimated expectation values\n", " evs = job.result()[0].data.evs\n", " # Append to list\n", " mag_mps_list2.append(evs[0])\n", "# Transform the list of expectation values (at each time step) to arrays\n", "mag_mps_array2 = np.array(mag_mps_list2)" ] }, { "cell_type": "markdown", "id": "c8612280-d29b-4952-826f-16a686a051dd", "metadata": {}, "source": [ "Wie in allen vorherigen Lektionen werden wir das Qiskit-Muster-Framework implementieren. Die bisherige Lektion konzentrierte sich auf die Erstellung der richtigen Quantenschaltungen zur Beschreibung unseres Problems. Dies ist praktisch Schritt 1.\n", "\n", "\n", "\n", "#### Schritt 2: Für die Zielhardware optimieren\n", "\n", "Wir beginnen mit der Definition des Ziel-Backends.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "610ecd2c-9a47-43c1-872b-a4038fb83817", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'ibm_kingston'" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "service = QiskitRuntimeService()\n", "backend = service.least_busy(operational=True, simulator=False)\n", "backend.name" ] }, { "cell_type": "markdown", "id": "ba36b8f4-9fae-4151-b3fa-8f848eb77a0d", "metadata": {}, "source": [ "Wir transpilieren die Schaltkreise und sammeln sie in einer Liste. Dies kann einige Minuten dauern.\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "116e914e-8fa4-4e60-9980-af71d9bcc2f9", "metadata": {}, "outputs": [], "source": [ "pm_hw = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", "circuit_isa = []\n", "# Step 1. Map the problem\n", "evolved_state_hw = QuantumCircuit(initial_circuit2.num_qubits)\n", "evolved_state_hw.append(initial_circuit2, evolved_state_hw.qubits)\n", "# Step 2. Optimize\n", "circuit_isa.append(pm_hw.run(evolved_state_hw))\n", "\n", "for n in range(num_timesteps):\n", " # Step 1. Map the problem\n", " evolved_state_hw.append(single_step_evolution_lt2, evolved_state_hw.qubits)\n", " # Step 2. Optimize\n", " circuit_isa.append(pm_hw.run(evolved_state_hw))" ] }, { "cell_type": "markdown", "id": "60c95c4c-9eab-4c14-b17d-c710beecb2ce", "metadata": {}, "source": [ "\n", "\n", "#### Schritt 3: Auf der Zielhardware ausführen\n", "\n", "Wir werden den Runtime Estimator definieren und die Liste der PUBs erstellen. Wir müssen das Layout auch auf die zu messenden Betreiber anwenden.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "3da4db25-5e78-4a86-b740-75fdacbdb831", "metadata": {}, "outputs": [], "source": [ "# Step 2. Optimize\n", "estimator_hw = Estimator(mode=backend)\n", "pub_list = []\n", "for circuit in circuit_isa:\n", " temp = (circuit, magnetization2.apply_layout(circuit.layout))\n", " pub_list.append(temp)" ] }, { "cell_type": "markdown", "id": "2433f80e-5ed8-4e73-8adb-c4c688a79775", "metadata": {}, "source": [ "Wir sind nun bereit, den Auftrag auszuführen.\n", "\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "ba037ca8-dd6f-4962-a7f4-65f0bde66f8b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "d147hfdqf56g0081sxs0\n" ] } ], "source": [ "job = estimator_hw.run(pub_list)\n", "job_id = job.job_id()\n", "print(job_id)" ] }, { "cell_type": "code", "execution_count": 28, "id": "efcb2851-3529-4e76-8a0f-1b65be8f4818", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'DONE'" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# check job status\n", "job.status()" ] }, { "cell_type": "markdown", "id": "f5dd6d18-08e9-49eb-90b4-8b6037fd6d34", "metadata": {}, "source": [ "\n", "\n", "#### Schritt 4: Nachbearbeitung der Ergebnisse\n", "\n", "Wir werden zunächst die Ergebnisse erhalten.\n", "\n" ] }, { "cell_type": "code", "execution_count": 20, "id": "eb661ec3-b8fd-4e2b-a525-547685cc6864", "metadata": {}, "outputs": [], "source": [ "job = service.job(job_id)\n", "pub_result = job.result()" ] }, { "cell_type": "markdown", "id": "1840130b-3c40-4a10-ac83-1bc4350a1f58", "metadata": {}, "source": [ "Nun müssen wir aus diesen Ergebnissen die Erwartungswerte extrahieren.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "be186c8e-0408-4d2d-b843-5d27c82ba99c", "metadata": {}, "outputs": [], "source": [ "mag_hw_list = []\n", "for res in pub_result:\n", " evs = res.data.evs\n", " mag_hw_list.append(evs)" ] }, { "cell_type": "markdown", "id": "0a03e25f-d447-4c52-9595-c776c9b7a23c", "metadata": {}, "source": [ "Wir werden dies im Folgenden zum Vergleich heranziehen. Zunächst wollen wir sehen, ob wir unsere Schaltungen noch weiter optimieren können.\n", "\n", "\n", "\n", "## 3. Lösung unter Verwendung eines echten Quantencomputers II\n", "\n", "Kehren wir zu den Qiskit-Mustern aus Schritt 1 zurück, um zu sehen, ob wir die Tiefe unserer Schaltung verringern können.\n", "\n", "\n", "\n", "### 3.1 Schritt 1. Das Problem auf Quantenschaltungen und -operatoren abbilden\n", "\n", "\n", "\n", "#### Aktivität 7\n", "\n", "Konstruieren Sie eine Zeitentwicklungsschaltung. Nutzen Sie Ihr Wissen aus den vorangegangenen Lektionen, um zu versuchen, die Tiefe des Stromkreises zu verringern.\n", "\n", "**Lösung:**\n", "\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "52a28d34-0852-4099-bcb8-ea9487701d43", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: 7\n", "Gate count: 277\n", "Nonlocal gate count: 138\n", "Gate breakdown: CX: 138, U3: 70, U1: 69\n", "\n" ] }, { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define J\n", "J = 1.0\n", "# Define h\n", "h = -5.0\n", "# Create instruction for rotation around ZZ:\n", "# Initiate the circuit (use 2 qubits)\n", "Rzz_circ = QuantumCircuit(2)\n", "# Add Rzz gate (do not forget to multiply the angle by 2.0)\n", "Rzz_circ.rzz(-J * dt * 2.0, 0, 1)\n", "# Transform the QuantumCircuit to instruction (QuantumCircuit.to_instruction())\n", "Rzz_instr = Rzz_circ.to_instruction(label=\"RZZ\")\n", "\n", "# Create instruction for rotation around X:\n", "# Initiate the circuit (use 1 qubit)\n", "Rx_circ = QuantumCircuit(1)\n", "# Add Rx gate (do not forget to multiply the angle by 2.0)\n", "Rx_circ.rx(-h * dt * 2.0, 0)\n", "# Transform the QuantumCircuit to instruction (QuantumCircuit.to_instruction())\n", "Rx_instr = Rx_circ.to_instruction(label=\"RX\")\n", "\n", "# Define the interaction list\n", "interaction_list = [\n", " [[i, i + 1] for i in range(0, n_qubits2 - 1, 2)],\n", " [[i, i + 1] for i in range(1, n_qubits2 - 1, 2)],\n", "] # linear chain\n", "\n", "# Define the registers\n", "qr = QuantumRegister(n_qubits2)\n", "# Initiate the circuit\n", "single_step_evolution_sh = QuantumCircuit(qr)\n", "# Construct the Rzz gates\n", "for i, color in enumerate(interaction_list):\n", " for interaction in color:\n", " single_step_evolution_sh.append(Rzz_instr, interaction)\n", "\n", "# Construct the Rx gates\n", "for i in range(0, n_qubits2):\n", " single_step_evolution_sh.append(Rx_instr, [i])\n", "\n", "print(\n", " f\"\"\"\n", "Trotter step with Lie-Trotter\n", "-----------------------------\n", "Depth: {single_step_evolution_sh.decompose(reps=3).depth()}\n", "Gate count: {len(single_step_evolution_sh.decompose(reps=3))}\n", "Nonlocal gate count: {single_step_evolution_sh.decompose(reps=3).num_nonlocal_gates()}\n", "Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in single_step_evolution_sh.decompose(reps=3).count_ops().items()])}\n", "\"\"\"\n", ")\n", "\n", "single_step_evolution_sh.decompose(reps=2).draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "5cde0bf4-37e8-469a-a88f-bb9c37168cea", "metadata": {}, "source": [ "Dies war sehr erfolgreich. Wir können nun mit den restlichen Schritten der Qiskit-Muster fortfahren.\n", "\n", "\n", "\n", "### 3.2 Schritt 2. Für die Zielhardware optimieren\n", "\n", "Transpilieren Sie die Schaltkreise und sammeln Sie sie in einer Liste. Auch dies kann ein paar Minuten dauern.\n", "\n" ] }, { "cell_type": "code", "execution_count": 32, "id": "958e2251-2a1e-4caf-b501-946f32b4fe9e", "metadata": {}, "outputs": [], "source": [ "pm_hw2 = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "circuit_isa2 = []\n", "# Step 1. Map the problem\n", "evolved_state_hw2 = QuantumCircuit(initial_circuit2.num_qubits)\n", "evolved_state_hw2.append(initial_circuit2, evolved_state_hw2.qubits)\n", "# Step 2. Optimize\n", "circuit_isa2.append(pm_hw2.run(evolved_state_hw2))\n", "for n in range(num_timesteps):\n", " # Step 1. Map the problem\n", " evolved_state_hw2.append(single_step_evolution_sh, evolved_state_hw2.qubits)\n", " # Step 2. Optimize\n", " circuit_isa2.append(pm_hw2.run(evolved_state_hw2))" ] }, { "cell_type": "markdown", "id": "8c74b53d-abac-48ac-883c-029adcd4894c", "metadata": {}, "source": [ "Definieren Sie den Runtime Estimator und erstellen Sie die Liste der PUBs.\n", "\n" ] }, { "cell_type": "code", "execution_count": 33, "id": "754e4c6d-04cc-4cc1-af81-c6fc13c353e0", "metadata": {}, "outputs": [], "source": [ "estimator_hw2 = Estimator(mode=backend)\n", "pub_list2 = []\n", "for circuit in circuit_isa2:\n", " temp = (circuit, magnetization2.apply_layout(circuit.layout))\n", " pub_list2.append(temp)" ] }, { "cell_type": "markdown", "id": "e2fa2986-701d-4f68-ab38-d6bf24a599c6", "metadata": {}, "source": [ "\n", "\n", "### 3.3 Schritt 3. Auf Zielhardware ausführen\n", "\n", "Führen Sie den Job aus.\n", "\n" ] }, { "cell_type": "code", "execution_count": 34, "id": "5288e0f3-e12c-4e8c-80f8-6e2535ffb0d1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "d147qqeqf56g0081sye0\n" ] } ], "source": [ "job2 = estimator_hw2.run(pub_list2)\n", "job2_id = job2.job_id()\n", "print(job2_id)" ] }, { "cell_type": "code", "execution_count": 36, "id": "37dfc4b9-4757-4a87-a1a4-972a372b931a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'DONE'" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# check job status\n", "job2.status()" ] }, { "cell_type": "markdown", "id": "4d08139b-71af-4578-b3b5-45f9a3741c0b", "metadata": {}, "source": [ "Holen Sie sich die Ergebnisse.\n", "\n" ] }, { "cell_type": "code", "execution_count": 24, "id": "83d2d003-2f97-4294-a745-2e0a1c7ae80c", "metadata": {}, "outputs": [], "source": [ "job2 = service.job(job2_id)\n", "pub_result2 = job2.result()" ] }, { "cell_type": "markdown", "id": "7f32a06a-2974-4f22-9dbe-d2ec6143f3cf", "metadata": {}, "source": [ "\n", "\n", "### 3.4 Schritt 4. Nachbearbeitung\n", "\n", "Extrahieren Sie die Erwartungswerte aus den Ergebnissen.\n", "\n" ] }, { "cell_type": "code", "execution_count": 25, "id": "402c9208-9a1d-4424-8ef2-636407c398d7", "metadata": {}, "outputs": [], "source": [ "mag_hw_list2 = []\n", "for res in pub_result2:\n", " evs = res.data.evs\n", " mag_hw_list2.append(evs)" ] }, { "cell_type": "markdown", "id": "0c255702-0ef3-46ff-bb6e-4675af2676a3", "metadata": {}, "source": [ "Wandeln Sie die Liste in Numpy-Arrays für die grafische Darstellung um.\n", "\n" ] }, { "cell_type": "code", "execution_count": 26, "id": "0d28a88f-990c-4330-9506-4cf23ae57415", "metadata": {}, "outputs": [], "source": [ "mag_hw_array = np.array(mag_hw_list)\n", "mag_hw_array2 = np.array(mag_hw_list2)" ] }, { "cell_type": "markdown", "id": "128662bd-44dc-4730-bdaa-fd686d1dbf04", "metadata": {}, "source": [ "Nun wollen wir die Ergebnisse grafisch darstellen und die Ergebnisse der Hardware (Standard und flache Schaltung) mit denen des MPS-Simulators vergleichen. Wie wirkt sich der Fehler in der realen Hardware auf die Ergebnisse aus?\n", "\n" ] }, { "cell_type": "code", "execution_count": 27, "id": "3aa52fc2-1685-482c-8673-c25096ddb44f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0.98, 'Observable evolution')" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(3, sharex=True)\n", "times = np.linspace(0, evolution_time, num_timesteps + 1) # includes initial state\n", "axes[0].plot(\n", " times, mag_mps_array2, label=\"MPS\", marker=\"x\", c=\"darkmagenta\", ls=\"-\", lw=0.8\n", ")\n", "axes[1].plot(\n", " times, mag_hw_array, label=\"HW\", marker=\"x\", c=\"darkmagenta\", ls=\"-\", lw=0.8\n", ")\n", "axes[2].plot(\n", " times, mag_hw_array2, label=\"HW2\", marker=\"x\", c=\"darkmagenta\", ls=\"-\", lw=0.8\n", ")\n", "axes[0].set_ylabel(\"MPS\")\n", "axes[1].set_ylabel(\"HW\")\n", "axes[2].set_ylabel(\"HW2\")\n", "axes[2].set_xlabel(\"Time\")\n", "fig.suptitle(\"Observable evolution\")" ] }, { "cell_type": "markdown", "id": "ec7c30e2-eea0-4fb7-80c8-e0dfb826c95e", "metadata": {}, "source": [ "Glückwunsch! Sie sind einen Schritt weiter auf dem Weg zu einem Quantensystem im Nutzmaßstab. Es gibt nur noch eine Lektion!\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" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }