iqm-benchmarks 2.17__tar.gz → 2.18__tar.gz

{iqm_benchmarks-2.17 → iqm_benchmarks-2.18}/CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+Version 2.18
+============
+* Added notebook to benchmark IQM Star QPUs and bug fixes done for Qscore.
+
 Version 2.17
 ============
 * Update installation command for development mode. `#41 <https://github.com/iqm-finland/iqm-benchmarks/pull/41>`_

{iqm_benchmarks-2.17/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iqm-benchmarks
-Version: 2.17
+Version: 2.18
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.17 → iqm_benchmarks-2.18}/docs/devices/devices.rst

@@ -6,3 +6,4 @@ This section provides examples and guidance on how to benchmark specific IQM dev
    :maxdepth: 1
 
    spark
+   star

{iqm_benchmarks-2.17 → iqm_benchmarks-2.18}/docs/devices/spark.ipynb

@@ -49,6 +49,7 @@
             "source": [
                 "import os\n",
                 "from iqm.qiskit_iqm import IQMProvider\n",
+                "import random\n",
                 "\n",
                 "os.environ[\"IQM_TOKENS_FILE\"]=\"YOUR TOKEN HERE\"\n",
                 "iqm_url =  'YOUR URL HERE'\n",
@@ -71,10 +72,17 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "from rustworkx.visualization import mpl_draw\n",
-                "from rustworkx import spring_layout\n",
+                "import networkx as nx\n",
+                "import matplotlib.pyplot as plt\n",
                 "\n",
-                "mpl_draw(backend.coupling_map.graph.to_undirected(multigraph=False), arrows=True, with_labels=True, node_color='#32a8a4', pos=spring_layout(backend.coupling_map.graph, num_iter=200))"
+                "coupling_map = backend.coupling_map\n",
+                "\n",
+                "G = nx.Graph()\n",
+                "G.add_edges_from(coupling_map) \n",
+                "pos = nx.spring_layout(G, seed=42) \n",
+                "nx.draw(G, pos, with_labels=True, node_color='lightblue', edge_color='gray', \n",
+                "        node_size=1000, font_size=10, linewidths=1.5, width=2)\n",
+                "plt.show()"
             ]
         },
         {
@@ -640,7 +648,7 @@
                 "QSCORE = QScoreConfiguration(\n",
                 "    num_instances = 100,\n",
                 "    num_qaoa_layers= 1,\n",
-                "    shots = 2**8,\n",
+                "    shots = 1000,\n",
                 "    calset_id=None, \n",
                 "    min_num_nodes = 2,\n",
                 "    max_num_nodes = 5,\n",
@@ -652,7 +660,10 @@
                 "                    [2, 0, 1],\n",
                 "                    [2, 0, 1, 3],\n",
                 "                    [2, 0, 1, 3, 4]],\n",
-                "    seed = 1\n",
+                "    seed = random.randint(1, 999999),\n",
+                "    REM = True,\n",
+                "    mit_shots = 1000,\n",
+                "    qpu_topology = \"crystal\",\n",
                 "    )"
             ]
         },
@@ -750,7 +761,7 @@
                 "\n",
                 "### QS \n",
                 "obs_qs = result_qscore.observations\n",
-                "qs = np.argmin([obs_qs[i].value-0.2 for i in range(len(obs_qs)) if obs_qs[i].name == 'approximation_ratio' and obs_qs[i].value-0.2>0])+2\n",
+                "qs = np.argmin([obs_qs[i].value-0.2 for i in range(len(obs_qs)) if obs_qs[i].name == 'mean_approximation_ratio' and obs_qs[i].value-0.2>0])+2\n",
                 "\n",
                 "\n",
                 "summary = {'5-qubit GHZ state fidelity': ['≥ 0.5', fidelity],\n",

iqm_benchmarks-2.18/docs/devices/star.ipynb

@@ -0,0 +1,543 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "8665b62277d47a17",
+            "metadata": {},
+            "source": [
+                "# Benchmarking IQM Star"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "afde8699",
+            "metadata": {},
+            "source": [
+                "This notebook allows you to run some useful benchmarks for the Star system."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "66ed5587739635b5",
+            "metadata": {},
+            "source": [
+                "## Connect to the backend"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "691a27964b11b9ed",
+            "metadata": {
+                "ExecuteTime": {
+                    "end_time": "2024-11-26T11:04:54.444032Z",
+                    "start_time": "2024-11-26T11:04:52.642210Z"
+                }
+            },
+            "outputs": [],
+            "source": [
+                "import os\n",
+                "from iqm.qiskit_iqm import IQMProvider\n",
+                "import random\n",
+                "\n",
+                "QPU = \"deneb\" # or any other star QPU\n",
+                "token = \"\"\n",
+                "os.environ[\"IQM_TOKEN\"] = token\n",
+                "\n",
+                "iqm_url = \"https://cocos.resonance.meetiqm.com/\" + QPU\n",
+                "provider = IQMProvider(iqm_url)\n",
+                "backend = provider.get_backend()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "06f43ca2",
+            "metadata": {},
+            "source": [
+                "We can access the Star backend and plot its connectivity graph to check that everything is working properly."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "e183e7c5",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import networkx as nx\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "coupling_map = backend.coupling_map\n",
+                "\n",
+                "G = nx.Graph()\n",
+                "G.add_edges_from(coupling_map) \n",
+                "pos = nx.spring_layout(G, seed=42) \n",
+                "nx.draw(G, pos, with_labels=True, node_color='lightblue', edge_color='gray', \n",
+                "        node_size=1000, font_size=10, linewidths=1.5, width=2)\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "34c084c2",
+            "metadata": {},
+            "source": [
+                "## As one can see, the label \"0\" is reserved for the resontor. So it is advised to define the qubit indices in the layout of interest starting from 1.\n",
+                "\n",
+                "We run the cell below to ignore those warnings that are not critical for the correct run of the benchmarks."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "28154b11",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import warnings\n",
+                "warnings.filterwarnings(action=\"ignore\")  "
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "3a5460c0",
+            "metadata": {},
+            "source": [
+                "## GHZ state fidelity"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "42d71982",
+            "metadata": {},
+            "source": [
+                "The GHZ (Greenberger-Horne-Zeilinger) state is a maximally entangled quantum state that involves three or more qubits, $n$. It is an equal superposition of all qubits being in state 0 and all qubits being in state 1, i.e., $| GHZ \\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle^{\\otimes n}+|1\\rangle^{\\otimes n})$.\n",
+                "\n",
+                "The GHZ state fidelity acts as a **witness** for genuine multi-qubit entanglement if found to be above $0.5$. This means that the measurement results cannot be explained without entanglement involving **all** qubits, so it is a great way to evaluate the \"quantumness\" of the computer. \n",
+                "\n",
+                "The state $\\rho_{\\text{ideal}}= |GHZ\\rangle\\langle GHZ|$ is a pure state, so in this case the fidelity can be computed as:\n",
+                "\n",
+                "$$\n",
+                "F(\\text{ideal}, \\text{measured})= \\langle GHZ | \\rho_{\\text{measured}} | GHZ \\rangle,$$\n",
+                "\n",
+                "where $\\rho_{\\text{measured}}$ is the density matrix given by the actual results of the quantum computer. The ideal GHZ state density matrix entries can be written as $\\rho_{i,j}=\\langle i| \\rho_{\\text{ideal}} | j \\rangle$ where $i,j$ are the $n$ basis states $\\{|00..0\\rangle, ..., |11..1\\rangle\\}$; only the corner entries $\\rho_{0,0},\\rho_{0,n},\\rho_{n,0}$ and $\\rho_{n,n} $ are non-zero. This simplifies the process since we only need to measure these four components. In the fidelity formula, all other entries are effectively nullified by the zero entries in the ideal state matrix. To measure the coherences (off-diagonal entries) we use the method of multiple quantum coherences [Mooney, 2021](https://iopscience.iop.org/article/10.1088/2399-6528/ac1df7/meta). "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "55bf7633",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.entanglement.ghz import GHZConfiguration, GHZBenchmark"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "29c9dda9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "num_qubits = backend.num_qubits\n",
+                "chosen_layout = [list(range(1,qubits+1)) for qubits in range(2,num_qubits)]\n",
+                "GHZ = GHZConfiguration(\n",
+                "    state_generation_routine=\"star\",\n",
+                "    custom_qubits_array=chosen_layout,\n",
+                "    shots=2000,\n",
+                "    fidelity_routine=\"coherences\", \n",
+                "    rem=True,\n",
+                "    mit_shots=1000,\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "f2d380a8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_ghz = GHZBenchmark(backend, GHZ)\n",
+                "run_ghz = benchmark_ghz.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "770f39cb",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_ghz = benchmark_ghz.analyze()\n",
+                "result_ghz.plot_all()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "beb8d573",
+            "metadata": {},
+            "source": [
+                "## Quantum Volume"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "a8451afb",
+            "metadata": {},
+            "source": [
+                "Quantum volume is a single-number metric that was introduced in [Cross, 2019](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.100.032328). It evaluates the quality of a quantum processor via the largest random *square* circuit, i.e., with the same number of layers of parallel random 2-qubit unitaries as number of qubits, that it can run successfully.\n",
+                "\n",
+                "The success of a run is based on the heavy output probability, which corresponds to the probability of observing *heavy outputs*, i.e. the measurement outputs that occcur with a probability greater than the median of the distribution. The heavy output generation problem asks if the generated distribution of the random circuit we run contains heavy outputs at least 2/3 of the time (on average) with a high confidence level, typically higher than 97.5%. It can be shown that the heavy output probability for an ideal device is at around 0.85 asymptotically. \n",
+                "The quantum volume is then defined as\n",
+                "\n",
+                "$$\\log_2 V_q = \\underset{n}{\\text{argmax}} \\min (n, d(n))$$\n",
+                "\n",
+                "where $n \\leq N$ is a number of qubits and $d(n)$ is the *achievable depth*, i.e. the largest depth such that we are confident the probability of observing a heavy output is greater than 2/3.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "2953c181",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.quantum_volume.quantum_volume import QuantumVolumeConfiguration, QuantumVolumeBenchmark"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa510035",
+            "metadata": {},
+            "source": [
+                "We define a combination of qubits to test quantum volume on. Due to the star topology, the combinations must not contain the index of the resontor \"0\"."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "0a828dca",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "chosen_layouts = [[1,2,5]] ## choose the optimal layouts to run\n",
+                "QV = QuantumVolumeConfiguration(\n",
+                "    num_circuits=500, \n",
+                "    shots=2**8,\n",
+                "    calset_id=None,\n",
+                "    num_sigmas=2,\n",
+                "    choose_qubits_routine=\"custom\",\n",
+                "    custom_qubits_array=chosen_layouts, \n",
+                "    qiskit_optim_level=3,\n",
+                "    optimize_sqg=True,\n",
+                "    max_gates_per_batch=10_000,\n",
+                "    rem=True,\n",
+                "    mit_shots=1_000,\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "f4961b2b",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.quantum_volume.quantum_volume.QuantumVolumeConfiguration.html#iqm.benchmarks.quantum_volume.quantum_volume.QuantumVolumeConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "121ddd03",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cell may take few minutes to run since it will compute the benchmark on all the qubit layouts specified above."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "4a5abb3d",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_qv = QuantumVolumeBenchmark(backend, QV)\n",
+                "run_qv = benchmark_qv.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "7d649b35",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qv = benchmark_qv.analyze()\n",
+                "for v in result_qv.plots.values():\n",
+                "    display(v)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "bbd2d8a9",
+            "metadata": {},
+            "source": [
+                "## Circuit Layer Operations Per Second (CLOPS)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "4e659f10",
+            "metadata": {},
+            "source": [
+                "CLOPS is a metric that estimates the speed at which a quantum computer can execute Quantum Volume (QV) layers of a quantum circuit. That is, the circuits to calculate this benchmark have the same structure as the ones used for QV. Here we follow the definition introduced in ([Wack, 2021](https://arxiv.org/abs/2110.14108)), but other versions of this benchmark exist. \n",
+                "\n",
+                "CLOPS is measured by means of a quantum variational-like protocol, where templates of parametrized QV circuits are assigned random parameters, executed, and outcomes are used as a seed to assign new parameters and repeat the process. The ratio of number of templates ($M$), parameter updates ($K$), measurement shots ($S$) and QV layers ($\\log_2\\mathrm{QV}$) with the time taken to run all, constitutes the CLOPS value: \n",
+                "\n",
+                "$$\n",
+                "\\mathrm{CLOPS}=M\\times{K}\\times{S}\\times\\log_2\\mathrm{QV}/\\mathrm{total\\_time}.\n",
+                "$$\n",
+                "\n",
+                "Notice that the total CLOPS time includes that of assignment of parameters, submission of circuits and retrieval of results."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "1e1687c8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.quantum_volume.clops import CLOPSConfiguration, CLOPSBenchmark, plot_times"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "e2c3a156",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "CLOPS = CLOPSConfiguration(\n",
+                "    qubits=[1,2,5], # run with the same layout as \n",
+                "    num_circuits=100,\n",
+                "    num_updates=10, \n",
+                "    num_shots=100, \n",
+                "    calset_id=None,\n",
+                "    qiskit_optim_level=3,\n",
+                "    optimize_sqg=True,\n",
+                "    routing_method=\"sabre\",\n",
+                "    physical_layout=\"fixed\",\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "e9f0a8d4",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.quantum_volume.clops.CLOPSConfiguration.html#iqm.benchmarks.quantum_volume.clops.CLOPSConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "dcd33d91",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_clops = CLOPSBenchmark(backend, CLOPS)\n",
+                "run_clops = benchmark_clops.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "28d75dac",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_clops = benchmark_clops.analyze()\n",
+                "fig_clops = plot_times(result_clops.dataset, result_clops.observations)\n",
+                "display(fig_clops[1])"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "4ee1e163",
+            "metadata": {},
+            "source": [
+                "## Q-Score"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "e62cba69",
+            "metadata": {},
+            "source": [
+                "*The Q-score measures the maximum number of qubits that can be used\n",
+                "effectively to solve the MaxCut combinatorial optimization problem with the Quantum Approximate\n",
+                "Optimization Algorithm* - [Martiel,2021](https://ieeexplore.ieee.org/document/9459509)\n",
+                "\n",
+                "The graphs chosen for the benchmark are random Erdős-Rényi graphs with 50% edge-probability between nodes.\n",
+                "The obtained cost of the solution, i.e. the average number of cut edges, must be above a certain threshold. Specifically, one has to find the cost of a graph to be above $\\beta\\geq 0.2$ on a scale where $\\beta = 0$ corresponds to a random solution and $\\beta = 1$ to an ideal solution. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "036d7839",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.optimization.qscore import QScoreConfiguration, QScoreBenchmark"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "22b8116c",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "num_qubits = backend.num_qubits\n",
+                "chosen_layout = [list(range(1,qubits+1)) for qubits in range(1,num_qubits)]\n",
+                "QSCORE = QScoreConfiguration(\n",
+                "    num_instances = 1,\n",
+                "    num_qaoa_layers= 1,\n",
+                "    shots = 10000,\n",
+                "    calset_id=None, \n",
+                "    min_num_nodes = 2,\n",
+                "    max_num_nodes = None,\n",
+                "    use_virtual_node = True,\n",
+                "    use_classically_optimized_angles = True,\n",
+                "    choose_qubits_routine = \"custom\",\n",
+                "    custom_qubits_array=chosen_layout,\n",
+                "    seed = random.randint(1, 999999),\n",
+                "    REM = True,\n",
+                "    mit_shots = 1000,\n",
+                "    qpu_topology = \"star\",\n",
+                "    )"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "58813ef0",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.optimization.qscore.QScoreConfiguration.html#iqm.benchmarks.optimization.qscore.QScoreConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "c5f14175",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cell may take **several** minutes to run."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "aed5ee90",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_qscore = QScoreBenchmark(backend, QSCORE)\n",
+                "run_qscore = benchmark_qscore.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "0bec0284",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qscore = benchmark_qscore.analyze()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "619342db",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qscore.plot_all()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "70bdb002",
+            "metadata": {},
+            "source": [
+                "## Summary"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d805a3d9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import numpy as np\n",
+                "\n",
+                "### GHZ\n",
+                "obs_ghz = result_ghz.observations\n",
+                "fidelity = round(min([obs_ghz[i].value for i in range(len(obs_ghz)) if obs_ghz[i].name=='fidelity']),2)\n",
+                "\n",
+                "### QV\n",
+                "obs_qv = result_qv.observations\n",
+                "qv = max([obs_qv[i].value for i in range(len(obs_qv)) if obs_qv[i].name=='QV_result'])\n",
+                "\n",
+                "### CLOPS\n",
+                "obs_clops = result_clops.observations\n",
+                "clops = max([obs_clops[item]['clops_v']['value'] for item in obs_clops])\n",
+                "\n",
+                "### QS \n",
+                "obs_qs = result_qscore.observations\n",
+                "qs = np.argmin([obs_qs[i].value-0.2 for i in range(len(obs_qs)) if obs_qs[i].name == 'mean_approximation_ratio' and obs_qs[i].value-0.2>0])+2\n",
+                "\n",
+                "\n",
+                "summary = {'GHZ state fidelity': ['≥ 0.5', fidelity],\n",
+                "    'Quantum Volume': qv, \n",
+                "    'CLOPS':  clops, \n",
+                "    'Q-Score':  qs \n",
+                "}\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "78cf1680",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "summary"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "iqm-benchmarks",
+            "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.11.11"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}