iqm-benchmarks 2.55__tar.gz → 2.56__tar.gz

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56}/CHANGELOG.rst

@@ -2,6 +2,11 @@
 Changelog
 =========
 
+Version 2.56
+============
+* Fixed import bug with iRB.
+* Improved execution of star_optimal GHZ creation circuit.
+
 Version 2.55
 ============
 * Compatibility with new job metadata formats.

{iqm_benchmarks-2.55/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.55
+Version: 2.56
 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>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

iqm_benchmarks-2.56/docs/examples/example_ghz.ipynb

@@ -0,0 +1,242 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "feba4cfa-dc9d-4029-967c-83140c11d750",
+   "metadata": {},
+   "source": [
+    "# Greenberger–Horne–Zeilinger (GHZ) State Fidelity\n",
+    "\n",
+    "The aim of this benchmark is to show whether a GHZ state with high enough fidelity can be prepared such that the state is genuinely multipartite entangled. One can show that a fidelity larger than 0.5 is a sufficient condition (see Leibfried, D. et al., Creation of a six-atom ‘Schrödinger cat’ state. Nature 438, 639–642 (2005))\n",
+    "\n",
+    "The benchmark currently offers two methods to estimate the fidelity:\n",
+    "* Multiple quantum coherences (G. J. Mooney et al., Generation and verification of 27-qubit Greenberger-Horne-Zeilinger states in a superconducting quantum computer, J. Phys. Commun. 5, 095004 (2021))\n",
+    "* Randomized measurements (Elben, A. et al., Statistical correlations between locally randomized measurements: A toolbox for probing entanglement in many-body quantum states, Phys. Rev. A 99, 052323 (2019))\n",
+    "\n",
+    "Additionally, for a given set of $n$ qubits, different circuits can be applied which lead to the same GHZ state. Currently there are the following implementations:\n",
+    "* \"naive\": The textbook ciruit of depth $n$, which starts from a Hadamrd gate on one qubit and entangles each additional qubit with a CNOT operation from the first.\n",
+    "* \"log_depth\": A logarithmic depth circuit utilizing parallel CNOT applications. Either the method in Cruz et al. https://arxiv.org/abs/1807.05572 or the method in Mooney et al. https://arxiv.org/abs/2101.08946 is used, depending on which yields the lower depth or the lower number of 2-qubit gates. \n",
+    "* \"tree\": An in-house logarithmic depth circuit utilizing calibration data of the CZ-fidelities and a tree-graph algorithm to find a circuit with minimal depth and high fidelity 2-qubit gates. \n",
+    "\n",
+    "Note that the first two methods will always give the same circuit for the same qubit layout (and the same coupling map), while the \"tree\" method relies on the latest calibration fidelities and can give different circuits on different days. \n",
+    "Thus for consistent comparisons one of the first two methods should be chosen, while for the best results, i.e. the largest possible GME entangled GHZ state, the tree-method is preferable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c517b115acb6fbc1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from iqm.benchmarks.entanglement.ghz import *\n",
+    "import os\n",
+    "from iqm.qiskit_iqm import IQMProvider\n",
+    "\n",
+    "token = \"XXXXXXX\"\n",
+    "os.environ[\"IQM_TOKEN\"] = token\n",
+    "quantum_computer = \"qc_name\" # provide actual quantum computer name\n",
+    "iqm_server_url = \"iqm_server_url\" # provide actual IQM server URL\n",
+    "os.environ[\"IQM_SERVER_URL\"] = iqm_server_url\n",
+    "provider = IQMProvider(iqm_server_url, quantum_computer=quantum_computer)\n",
+    "backend = provider.get_backend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8b83411414e5a18",
+   "metadata": {},
+   "source": [
+    "## Dynamical decoupling strategy\n",
+    "\n",
+    "The success of dynamical decoupling (DD) depends on the coherence several factors, like\n",
+    "* Amount and lenght of idle segments in the circuit,\n",
+    "* Magnitude of idling errors,\n",
+    "* Single qubit gate fidelities (since DD adds additional single qubit gates).\n",
+    "\n",
+    "Therefore just using the default DD strategy is not guaranteed to improve the results. In this notebook we apply a minimal DD strategy which only add single qubit gates on qubits with a high single qubit gate fidelity, and only adds a minimal amount of extra gates per idle segment (just tow X-Gates). This strategy should improve outcomes in most cases."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cdcd5ae9663b21fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from iqm.iqm_client.models import DDStrategy\n",
+    "\n",
+    "strategy = DDStrategy(gate_sequences=[(2, 'XX', 'center')], target_qubits = None)\n",
+    "\n",
+    "print(f\"Minimal dynamical decoupling strategy:\")\n",
+    "for k, v in strategy.__dict__.items():\n",
+    "    print(f\"\\t{k}: {v}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d483c8396dc58041",
+   "metadata": {},
+   "source": [
+    "## Definition of the benchmark configuration\n",
+    "The important parameters are:\n",
+    "* ``custom_qubits_array``: A ``list[list[int]]`` which includes all qubit layouts on which the benchmark is run.\n",
+    "* ``shots``: The number of shots for the fidelity measurement\n",
+    "* ``fidelity_routine``: Either \"coherences\" or \"randomized_measurements\"\n",
+    "* ``rem``: Boolean value that controls whether readout error mitigation is used\n",
+    "* ``mit_shots``: Whenever rem=True, this parameter controls the total number of shots used to calibrate readout error mitgation\n",
+    "* ``num_RMs``: The number of randomized measurement settings (only necessary when choosing ``fidelity_routine=randomized_measurements``)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81059f0ce9442e7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MINIMAL_GHZ = GHZConfiguration(\n",
+    "    state_generation_routine=\"tree\",\n",
+    "            custom_qubits_array=[ # These are naive settings, replace with better qubit layouts!\n",
+    "                list(np.arange(10)),\n",
+    "                list(np.arange(20)),\n",
+    "            ],\n",
+    "    shots=1000,\n",
+    "    fidelity_routine=\"coherences\", \n",
+    "    rem=True,\n",
+    "    mit_shots=1000,\n",
+    "    use_dd = True,\n",
+    "    dd_strategy=strategy,\n",
+    "    quantum_computer=quantum_computer\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8cb9a0ddbd88c6fb",
+   "metadata": {},
+   "source": [
+    "### Improved qubit selection via layout fidelity graph\n",
+    "\n",
+    "For thinking about which qubit layouts to use, the following visualization of the connectivity and CZ fidelities is helpful.\n",
+    "\n",
+    "Requirements: \n",
+    "* Access to the backend, in this example IQM Garnet.\n",
+    "* An access token environment variable needs to be set via ``os.environ[\"IQM_TOKEN\"] = <your_token>``.\n",
+    "\n",
+    "Use of the plot:\n",
+    "* If the ``qubit_layouts`` argument is provided, the selected qubits are marked in orange.\n",
+    "* CZ errors are indicated with edge width (**thinner edge is better**), where the edge width is given by $w_{ij} = - \\mathrm{log}(\\mathcal{F}_{\\mathrm{CZ}}^{ij})$.\n",
+    "* Each edge is also labeled with the width value. \n",
+    "* Some graph layouts are predefined to match the layout as shown in IQM-Resonance. If the layout is not predefined, a graph in grid or star layout will be automatically generated, dependeing on the backend. Automatically generated graphs might need to be rerun a few times until a nice node layout is found.\n",
+    "* Single qubit errors are visualized as node size (**smaller radius is better**), with the node size being determined by $- \\mathrm{log}(\\mathcal{F})$, where $\\mathcal{F}$ is either the single qubit average gate fidelity, the single qubit readout fidelity, or the single qubit idle gate fidelity. Which of these is used can be controlled by the ``sq_metric`` argument, which can be set to \"fidelity\" \"readout\", or \"coherence\", where the latter option leads to the idle fidelities being shown.\n",
+    "* If the option `show_ghz_path` is set to True, the connections used for creating the GHZ state are highlighted red. Furthermore the \"Edge map\" is printed, which is the list of qubit pairs on which CZ gates act in the GHZ circuit. The list is ordered, so the first pair is scheduled first, and so on. CZ-Gates on subsequent pairs that don't share the same qubit are executed in parallel. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6cf7b3d715e6da6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from iqm.benchmarks.utils_plots import plot_layout_fidelity_graph\n",
+    "import os\n",
+    "\n",
+    "print(f\"Check if access token environment variable is set: {'IQM_TOKEN' in os.environ}\")\n",
+    "qubit_layouts = [list(range(20))]\n",
+    "fig = plot_layout_fidelity_graph(iqm_server_url, backend, quantum_computer = quantum_computer, qubit_layouts = qubit_layouts, sq_metric=\"coherence\", show_ghz_path = True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc253129-4f0d-4a9e-aff1-852c2e7d4e21",
+   "metadata": {},
+   "source": [
+    "## Running the benchmark"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ca4c757-9b58-4ee6-b9b6-365e22e3b378",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-07-21T15:14:11.771971Z",
+     "start_time": "2025-07-21T15:13:57.980121Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "benchmark_ghz = GHZBenchmark(backend, MINIMAL_GHZ)\n",
+    "run_ghz = benchmark_ghz.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c20f246c-9fd0-4399-96a9-3755ccbfd81e",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-07-21T15:14:49.112922Z",
+     "start_time": "2025-07-21T15:14:49.042215Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "result = benchmark_ghz.analyze()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11f39392-7350-4010-bec4-08ca4c6ed908",
+   "metadata": {},
+   "source": [
+    "## Accessing the results\n",
+    "To see individual fidelitiy and uncertainty values of a given qubit layout, one can filter the ``result.observations``-list by layout as shown below. \n",
+    "\n",
+    "The plot allows a comparison of all layout results with and without REM, where the data point description labels \"L0\", \"L1\", ... enumerate the layouts in the order defined in the configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93df7e17-4eda-4ab4-95de-8b0e7fbfed30",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-07-21T15:14:54.536169Z",
+     "start_time": "2025-07-21T15:14:54.405959Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "qubit_layout = list(range(20))\n",
+    "for observation in result.observations:\n",
+    "    if observation.identifier.string_identifier == str(qubit_layout):\n",
+    "        print(f\"{observation.name}: {observation.value} +/- {observation.uncertainty}\")\n",
+    "result.plot_all()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56}/docs/examples/example_qscore.ipynb

@@ -32,7 +32,7 @@
    "id": "61b1a1228ac49ff3",
    "metadata": {},
    "source": [
-    "## Choose (or define) a backend"
+    "## Choose (or define) a backend and the token"
    ]
   },
   {
@@ -47,35 +47,41 @@
    },
    "outputs": [],
    "source": [
-    "backend = \"fakeadonis\"\n",
-    "# backend = \"fakeapollo\"\n",
-    "#backend = \"garnet\"\n",
-    "#backend = \"deneb\"\n",
-    "#backend = \"pyrite\""
+    "import os\n",
+    "from iqm.qiskit_iqm import IQMProvider\n",
+    "\n",
+    "token = \"XXXXXXX\"\n",
+    "os.environ[\"IQM_TOKEN\"] = token\n",
+    "quantum_computer = \"qc_name\" # provide actual quantum computer name\n",
+    "iqm_server_url = \"iqm_server_url\" # provide actual IQM server URL\n",
+    "os.environ[\"IQM_SERVER_URL\"] = iqm_server_url\n",
+    "provider = IQMProvider(iqm_server_url, quantum_computer=quantum_computer)\n",
+    "backend = provider.get_backend()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "c5e8e58810f038b7",
+   "id": "619c1341",
    "metadata": {},
    "source": [
-    "## Set IQM Token if using Resonance."
+    "## Define DD startegy"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "d27a0f6a5b492fc8",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-01-08T19:52:55.789229Z",
-     "start_time": "2025-01-08T19:52:55.776713Z"
-    }
-   },
+   "id": "7a9f437e",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "os.environ[\"IQM_TOKEN\"] = \"XXXXXXXXXXXXXX\""
+    "from iqm.iqm_client.models import DDStrategy\n",
+    "\n",
+    "# Define DD strategy\n",
+    "strategy = DDStrategy(gate_sequences=[(2, 'XX', 'center')], target_qubits = None)\n",
+    "\n",
+    "print(f\"Minimal dynamical decoupling strategy:\")\n",
+    "for k, v in strategy.__dict__.items():\n",
+    "    print(f\"\\t{k}: {v}\")"
    ]
   },
   {
@@ -98,24 +104,23 @@
    },
    "outputs": [],
    "source": [
+    "min_num_nodes = 6 # minimum number of nodes in the graph\n",
+    "max_num_nodes = 10 # maximum number of nodes in the graph]\n",
     "EXAMPLE_QSCORE = QScoreConfiguration(\n",
-    "    num_instances = 100,\n",
-    "    num_qaoa_layers= 1,\n",
-    "    shots = 10000,\n",
-    "    calset_id=None, # calibration set ID, default is None\n",
-    "    min_num_nodes =  3,\n",
-    "    max_num_nodes= 5, # put it to run for all the node sizes\n",
-    "    use_virtual_node = True,\n",
-    "    use_classically_optimized_angles = True,\n",
-    "    choose_qubits_routine = \"custom\",\n",
-    "    custom_qubits_array=[\n",
-    "                    [2, 0, 1],\n",
-    "                    [2, 0, 1, 3],\n",
-    "                    [2, 0, 1, 3, 4]],\n",
-    "    seed = random.randint(1, 999999),\n",
-    "    REM = True,\n",
-    "    mit_shots=1000,\n",
-    "    num_trials=1, # number of trials per instance to improve transpilation robustness\n",
+    "    num_instances = 100, # number of graph instances to run\n",
+    "    num_qaoa_layers= 1, # number of QAOA layers (depth of the QAOA circuit). Usually is set to 1 for QScore benchmark.\n",
+    "    shots = 2048, # number of shots per instance\n",
+    "    min_num_nodes = min_num_nodes, # minimum number of nodes in the graph\n",
+    "    max_num_nodes= max_num_nodes, # maximum number of nodes in the graph\n",
+    "    use_virtual_node = True, # whether to use a virtual node in the graph (works only for depth 1 QAOA)\n",
+    "    use_classically_optimized_angles = True, # whether to use classically optimized angles or use\n",
+    "    choose_qubits_routine = \"naive\", # routine to choose qubits for the QAOA circuit, \"naive\" is the default selection, while \"custom\" allows for custom qubit selection\n",
+    "    custom_qubits_array=None, # custom qubits array, only used if choose_qubits_routine is set to \"custom\"\n",
+    "    seed = random.randint(1, 999999), # random seed for reproducibility\n",
+    "    REM = True, # whether to use the readout error mitigation protocol\n",
+    "    mit_shots=1000, # number of shots for the readout error mitigation protocol\n",
+    "    use_dd = False, # whether to use dynamical decoupling\n",
+    "    dd_strategy = strategy, # dynamical decoupling strategy\n",
     "    )"
    ]
   },
@@ -199,7 +204,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "env-iqm-benchmarks",
+   "display_name": ".conda",
    "language": "python",
    "name": "python3"
   },

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56}/docs/examples/example_quantum_volume.ipynb

@@ -24,39 +24,51 @@
    "id": "b2c63962f3ca4618",
    "metadata": {},
    "source": [
-    "## Choose (or define) a backend"
+    "## Choose (or define) a backend and initialise token"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "bd04e92bc8bc6d22",
    "metadata": {},
    "outputs": [],
    "source": [
-    "#backend = \"fakeadonis\"\n",
-    "backend = \"fakeapollo\"\n",
-    "#backend = \"garnet\"\n",
-    "#backend = \"deneb\""
+    "import os\n",
+    "from iqm.qiskit_iqm import IQMProvider\n",
+    "\n",
+    "token = \"XXXXXXX\"\n",
+    "os.environ[\"IQM_TOKEN\"] = token\n",
+    "quantum_computer = \"qc_name\" # provide actual quantum computer name\n",
+    "iqm_server_url = \"iqm_server_url\" # provide actual IQM server URL\n",
+    "os.environ[\"IQM_SERVER_URL\"] = iqm_server_url\n",
+    "provider = IQMProvider(iqm_server_url, quantum_computer=quantum_computer)\n",
+    "backend = provider.get_backend()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "24a83603a9b243f4",
+   "id": "850d5144",
    "metadata": {},
    "source": [
-    "## Set IQM Token if using Resonance."
+    "## Customising DD"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "249d8974af559964",
+   "execution_count": null,
+   "id": "ae95bb25",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# import os\n",
-    "# os.environ[\"IQM_TOKEN\"] = \"\""
+    "from iqm.iqm_client.models import DDStrategy\n",
+    "\n",
+    "# Define DD strategy\n",
+    "strategy = DDStrategy(gate_sequences=[(2, 'XX', 'center')], target_qubits = None)\n",
+    "\n",
+    "print(f\"Minimal dynamical decoupling strategy:\")\n",
+    "for k, v in strategy.__dict__.items():\n",
+    "    print(f\"\\t{k}: {v}\")"
    ]
   },
   {
@@ -79,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "1072ddc990ea37e1",
    "metadata": {},
    "outputs": [],
@@ -87,17 +99,14 @@
     "EXAMPLE_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=[[0,1,2,3], [0,1,3,4]],\n",
-    "    qiskit_optim_level=3,\n",
-    "    optimize_sqg=True,\n",
-    "    routing_method=\"sabre\",\n",
-    "    physical_layout=\"fixed\",\n",
-    "    max_gates_per_batch=60_000,\n",
+    "    max_gates_per_batch=10_000,\n",
     "    rem=True,\n",
     "    mit_shots=1_000,\n",
+    "    dd_strategy=strategy,\n",
+    "    use_dd=True,\n",
     ")"
    ]
   },
@@ -974,7 +983,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "env-iqm-benchmarks",
+   "display_name": ".conda",
    "language": "python",
    "name": "python3"
   },
@@ -988,7 +997,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.11.14"
   }
  },
  "nbformat": 4,

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56}/src/iqm/benchmarks/entanglement/ghz.py

@@ -792,10 +792,10 @@ class GHZBenchmark(Benchmark):
                 qc_phase = qc.copy()
                 qc_phase.barrier()
                 for _, qubit in enumerate(qubit_layout):
-                    qc_phase.p(phase, qubit + 1)
+                    qc_phase.p(phase, qubit)
                 qc_phase.barrier()
                 qc_phase.compose(qc_inv, inplace=True)
-                qc_phase.measure([q + 1 for q in qubit_layout], list(range(qubit_count)))
+                qc_phase.measure(qubit_layout, list(range(qubit_count)))
                 qc_list.append(qc_phase)
         else:
             qc_inv = qc.inverse()

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56}/src/iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -22,7 +22,6 @@ from typing import Any, Dict, List, Literal, Optional, Sequence, Type
 from matplotlib.figure import Figure
 import numpy as np
 import xarray as xr
-from pycparser.ply.ctokens import t_STRING
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import (

{iqm_benchmarks-2.55 → iqm_benchmarks-2.56/src/iqm_benchmarks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.55
+Version: 2.56
 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>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks