qiskit-documentation/docs/tutorials/long-range-entanglement-with-limited-qubit-connectivity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ba4719fa",
   "metadata": {
    "heading_collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "{/* cspell:ignore XIXI, IZIZ, XZXZ, YZYI, ZZZI, YIYZ, ZIZZ, IXXX, XYIY, IYXY, ZYYX, YYZX, ZXYY, YXZY, quasidistillation */}\n",
    "\n",
    "# Long-range entanglement with limited qubit connectivity\n",
    "*Usage estimate: 90 minutes on IBM Sherbrooke (NOTE: This is an estimate only. Your runtime may vary.)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82f9be30",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "# This cell is hidden from users;\n",
    "# it disables a linting rule that we should fix.\n",
    "# ruff: noqa: E722"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "619fd9f9",
   "metadata": {},
   "source": [
    "## Background\n",
    "Long-range entanglement between distant qubits on a quantum processor can be a challenging task for devices with limited qubit connectivity. This tutorial shows three different ways that can be used to generate long-range entanglement between qubits on a line, at varying distances between each other:\n",
    "- a unitary-based implementation, which uses SWAP operations to reduce the distance between distant qubits and entangle them directly,\n",
    "- a measurement-based implementation with post-processing, which  discards some amount of information to generate the desired entangled state, and\n",
    "- a measurement-based implementation with dynamic circuits, which uses measurement and feedforward of information during the quantum computation to entangle the qubits.\n",
    "In particular, the results show the effectiveness of dynamic circuits in generating long-range entanglement between two unconnected qubits at utility scales.\n",
    "The notebook uses the ideas and results from [1] by Elisa Bäumer et al."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f0b8be3",
   "metadata": {},
   "source": [
    "## Requirements\n",
    "\n",
    "Before starting this tutorial, ensure that you have the following installed:\n",
    "\n",
    "- Qiskit SDK 1.0 or later, with visualization support ( `pip install 'qiskit[visualization]'` )\n",
    "- Qiskit Runtime ( `pip install qiskit-ibm-runtime` ) 0.22 or later"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f0c85a6-8b59-4543-8e9f-788eaeef886a",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d02f8a1-3069-4507-91ed-73b7f6610f39",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from typing import List, Dict, Union, Optional, Callable\n",
    "\n",
    "import random\n",
    "from IPython.display import clear_output\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# Importing standard Qiskit libraries\n",
    "from qiskit import (\n",
    "    QuantumCircuit,\n",
    "    QuantumRegister,\n",
    "    ClassicalRegister,\n",
    ")\n",
    "from qiskit.primitives import BitArray\n",
    "\n",
    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
    "\n",
    "from qiskit.circuit import Gate\n",
    "from qiskit.circuit.library import XGate\n",
    "\n",
    "from qiskit.providers.backend import BackendV2 as Backend\n",
    "from qiskit.transpiler import CouplingMap, InstructionDurations\n",
    "from qiskit.transpiler.passmanager import PassManager\n",
    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
    "from qiskit_ibm_provider.transpiler.passes.scheduling import (\n",
    "    DynamicCircuitInstructionDurations,\n",
    ")\n",
    "from qiskit_ibm_provider.transpiler.passes.scheduling import (\n",
    "    ALAPScheduleAnalysis,\n",
    ")\n",
    "from qiskit_ibm_provider.transpiler.passes.scheduling import (\n",
    "    PadDynamicalDecoupling,\n",
    ")\n",
    "from qiskit_ibm_runtime import Batch, SamplerV2 as Sampler\n",
    "\n",
    "from qiskit.circuit.classical import expr\n",
    "\n",
    "from qiskit.quantum_info import Pauli, PauliList\n",
    "from qiskit.result import marginal_counts\n",
    "\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c75dbecb-c273-4955-991e-557f9b5a41df",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Step 1: Map classical inputs to a quantum problem\n",
    "\n",
    "In this tutorial you will run a gate teleportation circuit in three different setups, where you always assume a line of n qubits (for varying n with n-2 empty ancillas in the middle and a CNOT to apply between the two ends):\n",
    "\n",
    "- Unitary-based implementation swapping the qubits to the middle\n",
    "- Measurement-based implementation with post-processing\n",
    "- Measurement-based implementation with dynamic circuits\n",
    "\n",
    "For each implementation you measure the average gate fidelity to compare among the different implementations. For details on how the average gate fidelity is calculated, see the [Appendix](#appendix-calculating-the-average-fidelity)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "28f3fa83-e6da-4a76-ab86-09142557bc1b",
   "metadata": {},
   "source": [
    "### Experimental setup\n",
    "\n",
    "The experiments in this notebook use a predefined 1-D line of qubits with a coupling map that ensures that no shortcuts can be taken."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e0025777",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Define 1-D line\n",
    "\n",
    "First, set up a line of qubits through the machine that you intend to use such that you avoid broken qubits or areas with high readout errors. To do this, examine the calibration data (which can be found online or via the command `plot_error_map(backend)`). For example, suppose that you use `ibm_sherbrooke` and that you need to avoid, for example, qubits 20 and 71 as well as qubits 56 and 73. One such qubit line would be:\n",
    "\n",
    "![A coupling map of ibm_sherbrooke showing a subset of qubits connected by a single continuous line](/images/tutorials/long-range-entanglement-with-limited-qubit-connectivity/sherbrooke-1d-line.avif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00af850-c30b-44c8-b40c-e0c6642ceb24",
   "metadata": {},
   "source": [
    "You describe the line as a simple list of integer indices and add that line to the `qubit_lines` dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13b544fb-5b38-427c-8b37-63f07cb577db",
   "metadata": {},
   "source": [
    "You can visualize the coupling map and qubit indices as follows (this example is for `ibm_sherbrooke`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb35aa4f-3199-4bff-ba63-5781b08cf818",
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Current Qubit 1D lines with key the name of the machine. e.g. ibm_sherbrooke\n",
    "qubit_lines = {\n",
    "    \"ibm_sherbrooke\": [\n",
    "        19,\n",
    "        18,\n",
    "        14,\n",
    "        0,\n",
    "        1,\n",
    "        2,\n",
    "        3,\n",
    "        4,\n",
    "        5,\n",
    "        6,\n",
    "        7,\n",
    "        8,\n",
    "        9,\n",
    "        10,\n",
    "        11,\n",
    "        12,\n",
    "        17,\n",
    "        30,\n",
    "        29,\n",
    "        28,\n",
    "        27,\n",
    "        26,\n",
    "        25,\n",
    "        24,\n",
    "        34,\n",
    "        43,\n",
    "        44,\n",
    "        45,\n",
    "        46,\n",
    "        47,\n",
    "        48,\n",
    "        49,\n",
    "        55,\n",
    "        68,\n",
    "        69,\n",
    "        70,\n",
    "        74,\n",
    "        89,\n",
    "        88,\n",
    "        87,\n",
    "        86,\n",
    "        85,\n",
    "        84,\n",
    "        83,\n",
    "        82,\n",
    "        80,\n",
    "        79,\n",
    "        78,\n",
    "        77,\n",
    "        76,\n",
    "        75,\n",
    "        90,\n",
    "        94,\n",
    "        95,\n",
    "        96,\n",
    "        97,\n",
    "        98,\n",
    "        99,\n",
    "        100,\n",
    "        101,\n",
    "        102,\n",
    "        103,\n",
    "        104,\n",
    "        105,\n",
    "        106,\n",
    "        107,\n",
    "        108,\n",
    "        112,\n",
    "        126,\n",
    "        125,\n",
    "        124,\n",
    "        123,\n",
    "        122,\n",
    "        121,\n",
    "        120,\n",
    "        119,\n",
    "        118,\n",
    "        117,\n",
    "        116,\n",
    "        115,\n",
    "        114,\n",
    "        113,\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11e35681-d7d0-4d5d-8764-5517181d91d0",
   "metadata": {},
   "source": [
    "#### Set primary parameters\n",
    "\n",
    "In this section are definitions for some common parameters that you will use later. You'll need to specify these parameters for a particular backend. In order to do so, you will need an account on [IBM Quantum™ Platform](https://quantum-computing.ibm.com/). More details on how to initialize your account can be found in the [documentation](https://docs.quantum.ibm.com/start/setup-channel#set-up-to-use-ibm-quantum-platform)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fc13eba-bc50-4607-88f9-8ada04b69794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine is set to: ibm_sherbrooke\n",
      "Maximum number of qubits between CNOT for ibm_sherbrooke is 80 with the given qubit line.\n"
     ]
    }
   ],
   "source": [
    "def coupling_map_from_qubit_line(\n",
    "    coupling_map: List[List[int]], qubit_line: List[List[int]]\n",
    ") -> List[List[int]]:\n",
    "    \"\"\"\n",
    "    Modify the full coupling map to force linearity in the qubit layout\n",
    "    \"\"\"\n",
    "    new_coupling_map = []\n",
    "    line_edge_list = []\n",
    "    for i in range(len(qubit_line) - 1):\n",
    "        line_edge_list.append([qubit_line[i], qubit_line[i + 1]])\n",
    "\n",
    "    for edge in coupling_map:\n",
    "        u, v = edge\n",
    "        edge_rev = [v, u]\n",
    "        if (edge in line_edge_list) or (edge_rev in line_edge_list):\n",
    "            new_coupling_map.append(edge)\n",
    "    return new_coupling_map\n",
    "\n",
    "\n",
    "# Set up access to IBM Quantum devices\n",
    "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n",
    "backend = service.least_busy(\n",
    "    operational=True, simulator=False, min_num_qubits=127\n",
    ")\n",
    "\n",
    "# Set which quantum computer to use\n",
    "MACHINE_NAME = backend.name\n",
    "\n",
    "# Set qubit line and coupling map\n",
    "QUBIT_LINE = qubit_lines[MACHINE_NAME]\n",
    "COUPLING_MAP_FULL = [\n",
    "    list(edge)\n",
    "    for edge in list(\n",
    "        QiskitRuntimeService().backend(MACHINE_NAME).coupling_map\n",
    "    )\n",
    "]\n",
    "COUPLING_MAP_1D = coupling_map_from_qubit_line(COUPLING_MAP_FULL, QUBIT_LINE)\n",
    "MAX_POSSIBLE_QUBITS_BTW_CNOT = len(QUBIT_LINE) - 2\n",
    "\n",
    "# Use this duration class to get appropriate durations for dynamic\n",
    "# circuit backend scheduling\n",
    "DURATIONS = DynamicCircuitInstructionDurations.from_backend(backend)\n",
    "\n",
    "print(f\"Machine is set to: {MACHINE_NAME}\")\n",
    "print(\n",
    "    f\"Maximum number of qubits between CNOT for {MACHINE_NAME} is {MAX_POSSIBLE_QUBITS_BTW_CNOT} with the given qubit line.\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56d793dc-19d4-4197-9f34-118683d95486",
   "metadata": {},
   "source": [
    "Next, set the global scope of the experiment. These variables can be used in each circuit type or can be set individually in each experiment that will override these globals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c7718980-3efe-4810-afb0-29f8d252a2ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set which Pauli's to sample (default is all 16 combinations that have a non-zero expectation)\n",
    "SAMPLES = list(range(16))\n",
    "\n",
    "# Level of optimizations the transpiler uses: There are 4 optimization levels ranging from 0 to 3,\n",
    "# where higher optimization levels take more time and computational effort but may yield a more\n",
    "# optimal circuit. level 0 does no explicit optimization, it will just try to make a circuit\n",
    "# runnable by transforming it to match a topology and basis gate set, if necessary.\n",
    "# Level 1, 2 and 3 do light, medium and heavy optimization, using a combination of passes, and by\n",
    "# configuring the passes to search for better solutions.\n",
    "OPTIMIZATION_LEVEL = 1\n",
    "\n",
    "# Set to True to use dynamical decoupling\n",
    "USE_DYNAMIC_DECOUPLING = True\n",
    "\n",
    "# Default dynamic decoupling sequence if dynamic decoupling is used\n",
    "DD_SEQUENCE = [XGate(), XGate()]\n",
    "\n",
    "# Set the number of repetitions of each circuit, for sampling.\n",
    "# The number of qubits between the control and target are grouped into blocks\n",
    "# of length 4. The provided min and max number of qubits will be modified to\n",
    "# align with these block sizes.\n",
    "SHOTS = 1000\n",
    "\n",
    "# The min number of qubits between the control and target qubits on line\n",
    "MIN_NUMBER_QUBITS = 0\n",
    "\n",
    "# The max number of qubits between the control and target qubits on line\n",
    "# The max for MIN_NUMBER_QUBITS is len(QUBIT_LINE) - 2\n",
    "# max_number_qubits must satisfy MAX_NUMBER_QUBITS - MIN_NUMBER_QUBITS = 3 (mod 4)\n",
    "# at this point. This is just to make things easier to break jobs up. Not a real limitation.\n",
    "MAX_NUMBER_QUBITS = 63\n",
    "assert (\n",
    "    (MAX_NUMBER_QUBITS - MIN_NUMBER_QUBITS) % 4 == 3\n",
    "), \"MAX_NUMBER_QUBITS must satisfy MAX_NUMBER_QUBITS - MIN_NUMBER_QUBITS = 3 (mod 4)\"\n",
    "assert (MAX_NUMBER_QUBITS + 2) <= len(\n",
    "    QUBIT_LINE\n",
    "), \"MAX_NUMBER_QUBITS must satisfy MAX_NUMBER_QUBITS + 2 <= len(QUBIT_LINE)\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "222c5d97-8da0-4abe-b7ba-457701ad1fc7",
   "metadata": {
    "code_folding": [],
    "hidden": true
   },
   "source": [
    "#### Monte Carlo state certification\n",
    "Next, you utilize the methods `prep_P_ij_conj` and `meas_P_kl` to prepare the circuits for Monte Carlo state certification. The method can be used to calculate the average state fidelity of the state prepared by a circuit without having to estimate the full quantum state (for example with state tomography or similar technqiques). For more details see the [Appendix](#appendix-calculating-the-average-fidelity). Monte Carlo state certification requires us to prepare the complex conjugate of random product of eigenstates of local Pauli operators, corresponding to the Paulis $P_i^*$ and $P_j^*$ - and then to measure the the final state in different Pauli bases, corresponding to the Pauli operators $P_k$ and $P_l$. You can do this with the following two methods: the `prep_P_ij_conj` method prepares a list of circuits so that the control and target qubits are in the eigenstates of $P_i^*$ and $P_j^*$, respectively; and the `meas_P_kl` method prepares a list of circuits so that the control and target qubits are measured in the $P_k$ and $P_l$ bases, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b524396c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prep_P_ij_conj(\n",
    "    circuits: List[QuantumCircuit], P_prep: PauliList\n",
    ") -> List[QuantumCircuit]:\n",
    "    \"\"\"Prepare circuits with the possible complex conjugates of the eigenstates of given Pauli operators\n",
    "\n",
    "    The first and last qubits are prepared in one of the four possible eigenstates of P_i^* and P_j^*\n",
    "    respectively. The resulting collection of circuits covers all four possibilities.\n",
    "\n",
    "    Assumes that circuits have qubits 0, ... ,n+1 where the long range NOT is between qubit 0 (control) to n+1 (target)\n",
    "\n",
    "    Arg:\n",
    "        circuits (List[QuantumCircuit]: List of 4 Quantum Circuits with at least two data qubits\n",
    "        P_prep (PauliList): A pair of single qubit Paulis with the first Pauli referred to as P_i and the second as P_j\n",
    "\n",
    "    Returns:\n",
    "        List[QuantumCircuits]\n",
    "    \"\"\"\n",
    "\n",
    "    pauliX = Pauli(\"X\")\n",
    "    pauliY = Pauli(\"Y\")\n",
    "    for p in range(2):\n",
    "        for q in range(2):\n",
    "            qc = circuits[2 * p + q]\n",
    "            if p == 1:\n",
    "                qc.x(0)\n",
    "            if q == 1:\n",
    "                qc.x(-1)\n",
    "            for i in range(2):\n",
    "                if P_prep[i] == pauliX:\n",
    "                    qc.h(-i)\n",
    "                if P_prep[i] == pauliY:\n",
    "                    qc.h(-i)  # Change basis to initialise in Y^* basis\n",
    "                    qc.s(-i)  # i.e. Apply SH = (HS^\\dagger)^*\n",
    "            circuits[2 * p + q] = qc\n",
    "    return circuits\n",
    "\n",
    "\n",
    "def meas_P_kl(\n",
    "    circuits: List[QuantumCircuit], P_meas: PauliList\n",
    ") -> List[QuantumCircuit]:\n",
    "    \"\"\"Prepare circuits so that the final state can be measured in different Pauli bases with a Z measurement\n",
    "\n",
    "    The first and last qubits are the qubits that the given operator P_meas will operate\n",
    "\n",
    "    Arg:\n",
    "        circuits (List[QuantumCircuit]: List of 4 Quantum Circuits with at least two data qubits\n",
    "        P_meas (PauliList): A pair of single qubit Paulis with the first Pauli referred to as P_k and the second as P_l\n",
    "    \"\"\"\n",
    "    pauliX = Pauli(\"X\")\n",
    "    pauliY = Pauli(\"Y\")\n",
    "    for p in range(2):\n",
    "        for q in range(2):\n",
    "            qc = circuits[2 * p + q]\n",
    "            for i in range(2):\n",
    "                if P_meas[i] == pauliX:\n",
    "                    qc.h(\n",
    "                        -i\n",
    "                    )  # Change of basis to measure X by measuring in Z basis: i.e., apply H\n",
    "                if P_meas[i] == pauliY:\n",
    "                    qc.sdg(\n",
    "                        -i\n",
    "                    )  # Change of basis to measure Y by measuring in Z basis\n",
    "                    qc.h(-i)  # i.e. apply HS^dagger\n",
    "            qc.measure(0, 0)\n",
    "            qc.measure(-1, 1)\n",
    "            circuits[2 * p + q] = qc\n",
    "    return circuits"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d892de47-78f4-46b7-b425-da5ce4b9c6b8",
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "source": [
    "#### Unitary-based implementation swapping the qubits to the middle\n",
    "\n",
    "First, examine the case where a long-range CNOT gate is implemented using nearest-neighbor connections and unitary gates. In the following figure, on the left is a circuit for a long-range CNOT gate spanning a 1D chain of n-qubits subject to nearest-neighbor connections only. On the right is an equivalent unitary decomposition implementable with local CNOT gates, circuit depth O(n).\n",
    "\n",
    "![Two circuit diagrams, one showing a CNOT acting on non-neighbor qubits, and the other showing a sequence of neighbor-only CNOTs that achieve the same behaviour.](/images/tutorials/long-range-entanglement-with-limited-qubit-connectivity/swap-map-illustration.avif)\n",
    "\n",
    "The circuit on the right can be implemented as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d54f7f67-ae85-45a6-86aa-9d0151d572bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CNOT_unitary(\n",
    "    qc: QuantumCircuit, control_qubit: int, target_qubit: int\n",
    ") -> QuantumCircuit:\n",
    "    \"\"\"Generate a CNOT gate between data qubit control_qubit and data qubit target_qubit using local CNOTs\n",
    "\n",
    "    Assumes that the long-range CNOT gate will be spanning a 1D chain of n-qubits subject to nearest-neighbor\n",
    "    connections only with the chain starting at the control qubit and finishing at the target qubit.\n",
    "\n",
    "    Assumes that control_qubit < target_qubit (as integers) and that the provided circuit qc has |0> set\n",
    "    qubits control_qubit+1, ..., target_qubit-1\n",
    "\n",
    "    Args:\n",
    "        qc (QuantumCicruit) : A Quantum Circuit to add the long range localized unitary CNOT\n",
    "        control_qubit (int) : The qubit used as the control.\n",
    "        target_qubi (int) : The qubit targeted by the gate.\n",
    "\n",
    "    Example:\n",
    "\n",
    "        qc = QuantumCircuit(8,2)\n",
    "        qc = CNOT_unitary(qc, 0, 7)\n",
    "\n",
    "    Returns:\n",
    "        QuantumCircuit\n",
    "\n",
    "    \"\"\"\n",
    "    assert target_qubit > control_qubit\n",
    "    n = target_qubit - control_qubit - 1\n",
    "    k = int(n / 2)\n",
    "    qc.barrier()\n",
    "    for i in range(control_qubit, control_qubit + k):\n",
    "        qc.cx(i, i + 1)\n",
    "        qc.cx(i + 1, i)\n",
    "        qc.cx(-i - 1, -i - 2)\n",
    "        qc.cx(-i - 2, -i - 1)\n",
    "    if n % 2 == 1:\n",
    "        qc.cx(k + 2, k + 1)\n",
    "        qc.cx(k + 1, k + 2)\n",
    "    qc.barrier()\n",
    "    qc.cx(k, k + 1)\n",
    "    for i in range(control_qubit, control_qubit + k):\n",
    "        qc.cx(k - i, k - 1 - i)\n",
    "        qc.cx(k - 1 - i, k - i)\n",
    "        qc.cx(k + i + 1, k + i + 2)\n",
    "        qc.cx(k + i + 2, k + i + 1)\n",
    "    if n % 2 == 1:\n",
    "        qc.cx(-2, -1)\n",
    "        qc.cx(-1, -2)\n",
    "    qc.barrier()\n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c6b8e59-c90b-4276-873e-a94ac2d375d3",
   "metadata": {
    "code_folding": [],
    "hidden": true
   },
   "source": [
    "The `build_circuits_uni` method therefore builds a list of circuits to run with different Paulis $P_i, P_j, P_k$ and $P_l$ in order to estimate the state fidelity with the Monte Carlo state certification method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8df7c4a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_circuits_uni(n: int, samples: List[int]) -> List[QuantumCircuit]:\n",
    "    \"\"\"Builds the unitary circuits needed to estimate the average gate fidelity\n",
    "\n",
    "    Args:\n",
    "        samples (List[int]): Which of the 16 Paulis with non-zero expectation value to prepare and measure\n",
    "        n (int): Number of qubits between the control and target of the CNOT\n",
    "    \"\"\"\n",
    "    circuits_all = []\n",
    "    # 16 Paulis with non-zero expectation value to prepare and measure\n",
    "    P_lkji = PauliList(\n",
    "        [\n",
    "            \"IIII\",\n",
    "            \"XIXI\",\n",
    "            \"IZIZ\",\n",
    "            \"XZXZ\",\n",
    "            \"YZYI\",\n",
    "            \"ZZZI\",\n",
    "            \"YIYZ\",\n",
    "            \"ZIZZ\",\n",
    "            \"XXIX\",\n",
    "            \"IXXX\",\n",
    "            \"XYIY\",\n",
    "            \"IYXY\",\n",
    "            \"ZYYX\",\n",
    "            \"YYZX\",\n",
    "            \"ZXYY\",\n",
    "            \"YXZY\",\n",
    "        ]\n",
    "    )\n",
    "    for sample in samples:\n",
    "        P_prep = P_lkji[sample][0:2]\n",
    "        P_meas = P_lkji[sample][2:4]\n",
    "        circuits = [QuantumCircuit(n + 2, 2) for i in range(4)]\n",
    "        circuits = prep_P_ij_conj(\n",
    "            circuits, P_prep\n",
    "        )  # Prepare circuits in eigenstates P_i^* and P_j^*\n",
    "        circuits = [\n",
    "            CNOT_unitary(circuit, 0, n + 1) for circuit in circuits\n",
    "        ]  # Add long range CNOT\n",
    "        circuits = meas_P_kl(\n",
    "            circuits, P_meas\n",
    "        )  # Prepare circuits to measure the final state in P_k and P_l bases\n",
    "        circuits_all += circuits\n",
    "    return circuits_all"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c15fa5c8",
   "metadata": {},
   "source": [
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e048983d-0441-40a1-944f-6f6725f01096",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1959.72x785.944 with 1 Axes>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sample circuit\n",
    "n = 6\n",
    "sample = [11]\n",
    "test_circuits = build_circuits_uni(n, sample)\n",
    "test_circuits[3].draw(\"mpl\", fold=-1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e3e88181",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Measurement-based implementation with post-processing\n",
    "\n",
    "Next, examine the case where a long-range CNOT gate is implemented using nearest-neighbor connections of a measurement-based CNOT with post-processing. In the following figure, below on the left is a circuit for a long-range CNOT gate spanning a 1D chain of n-qubits subject to nearest-neighbor connections only. On the right is an equivalent implementable with local CNOT gates with measurements, and which requires post-processing.\n",
    "\n",
    "![Two circuit diagrams showing a single CNOT operation before and after post processing. Both circuits are equivalent.](/images/tutorials/long-range-entanglement-with-limited-qubit-connectivity/post-processing-illustration.avif)\n",
    "\n",
    "The circuit on the right can be implemented as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8fb3b80e-240d-4795-9142-7b87bd24b5c3",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def CNOT_postproc(\n",
    "    qc: QuantumCircuit,\n",
    "    control_qubit: int,\n",
    "    target_qubit: int,\n",
    "    c1: Optional[ClassicalRegister] = None,\n",
    "    c2: Optional[ClassicalRegister] = None,\n",
    "    add_barriers: Optional[bool] = True,\n",
    ") -> QuantumCircuit:\n",
    "    \"\"\"Generate a CNOT gate between data qubit control_qubit and data qubit target_qubit using Bell Pairs.\n",
    "\n",
    "    Post processing is used to enable the CNOT gate via the provided classical registers c1 and c2\n",
    "\n",
    "    Assumes that the long-range CNOT gate will be spanning a 1D chain of n-qubits subject to nearest-neighbor\n",
    "    connections only with the chain starting at the control qubit and finishing at the target qubit.\n",
    "\n",
    "    Assumes that control_qubit < target_qubit (as integers) and that the provided circuit qc has |0> set\n",
    "    qubits control_qubit+1, ..., target_qubit-1\n",
    "\n",
    "    n = target_qubit - control_qubit - 1 : Number of qubits between the target and control qubits\n",
    "    k = int(n/2) : Number of Bell pairs created\n",
    "\n",
    "    Args:\n",
    "        qc (QuantumCicruit) : A Quantum Circuit to add the long range localized unitary CNOT\n",
    "        control_qubit (int) : The qubit used as the control.\n",
    "        target_qubi (int) : The qubit targeted by the gate.\n",
    "\n",
    "    Optional Args:\n",
    "        c1 (ClassicalRegister) : Default = None. Required if n > 1. Register requires k bits\n",
    "        c2 (ClassicalRegister) : Default = None. Required if n > 0. Register requires n - k bits\n",
    "        add_barriers (bool) : Default = True. Include barriers before and after long range CNOT\n",
    "\n",
    "    Returns:\n",
    "        QuantumCircuit\n",
    "    \"\"\"\n",
    "    assert target_qubit > control_qubit\n",
    "    n = target_qubit - control_qubit - 1\n",
    "    k = int(n / 2)\n",
    "\n",
    "    # Determine where to start the bell pairs and\n",
    "    # add an extra CNOT when n is odd\n",
    "    if n % 2 == 0:\n",
    "        x0 = 1\n",
    "    else:\n",
    "        x0 = 2\n",
    "        qc.cx(0, 1)\n",
    "\n",
    "    # Create k Bell pairs\n",
    "    for i in range(k):\n",
    "        qc.h(x0 + 2 * i)\n",
    "        qc.cx(x0 + 2 * i, x0 + 2 * i + 1)\n",
    "\n",
    "    # Entangle Bell pairs and data qubits and measure\n",
    "    for i in range(k + 1):\n",
    "        qc.cx(x0 - 1 + 2 * i, x0 + 2 * i)\n",
    "\n",
    "    for i in range(1, k + x0):\n",
    "        qc.h(2 * i + 1 - x0)\n",
    "        qc.measure(2 * i + 1 - x0, c2[i - 1])\n",
    "\n",
    "    for i in range(k):\n",
    "        qc.measure(2 * i + x0, c1[i])\n",
    "\n",
    "    if add_barriers is True:\n",
    "        qc.barrier()\n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75c0cde5-1300-40ec-9fea-e3018b762ee2",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Again, utilize the methods `prep_P_ij_conj` and `meas_P_kl` to prepare the circuits for Monte Carlo state certification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "df8920d5-68ea-4c6c-8c7c-787d23e4ed2c",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def build_circuits_postproc(\n",
    "    n: int, samples: List[int]\n",
    ") -> List[QuantumCircuit]:\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        n (int): Number of qubits between the control and target qubits\n",
    "    \"\"\"\n",
    "    assert n >= 0, \"Error: n needs to be a non-negative integer\"\n",
    "    circuits_all = []\n",
    "\n",
    "    qr = QuantumRegister(\n",
    "        n + 2, name=\"q\"\n",
    "    )  # Circuit with n qubits between control and target\n",
    "    cr = ClassicalRegister(\n",
    "        2, name=\"cr\"\n",
    "    )  # Classical register for measuring long range CNOT\n",
    "\n",
    "    k = int(n / 2)  # Number of Bell States to be used\n",
    "    c1 = ClassicalRegister(\n",
    "        k, name=\"c1\"\n",
    "    )  # Classical register needed for post processing\n",
    "    c2 = ClassicalRegister(\n",
    "        n - k, name=\"c2\"\n",
    "    )  # Classical register needed for post processing\n",
    "\n",
    "    # 16 Paulis with non-zero expectation value to prepare and measure\n",
    "    P_lkji = PauliList(\n",
    "        [\n",
    "            \"IIII\",\n",
    "            \"XIXI\",\n",
    "            \"IZIZ\",\n",
    "            \"XZXZ\",\n",
    "            \"YZYI\",\n",
    "            \"ZZZI\",\n",
    "            \"YIYZ\",\n",
    "            \"ZIZZ\",\n",
    "            \"XXIX\",\n",
    "            \"IXXX\",\n",
    "            \"XYIY\",\n",
    "            \"IYXY\",\n",
    "            \"ZYYX\",\n",
    "            \"YYZX\",\n",
    "            \"ZXYY\",\n",
    "            \"YXZY\",\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    for sample in samples:\n",
    "        P_prep = P_lkji[sample][0:2]\n",
    "        P_meas = P_lkji[sample][2:4]\n",
    "        if n > 1:\n",
    "            circuits = [\n",
    "                QuantumCircuit(qr, cr, c1, c2, name=\"CNOT\") for i in range(4)\n",
    "            ]\n",
    "        elif n == 1:\n",
    "            circuits = [\n",
    "                QuantumCircuit(qr, cr, c2, name=\"CNOT\") for i in range(4)\n",
    "            ]\n",
    "        elif n == 0:\n",
    "            circuits = [QuantumCircuit(qr, cr, name=\"CNOT\") for i in range(4)]\n",
    "        circuits = prep_P_ij_conj(\n",
    "            circuits, P_prep\n",
    "        )  # Prepare control and target qubits\n",
    "        # in eigenstates of P_i^* and P_j^* respectively\n",
    "        circuits = [\n",
    "            CNOT_postproc(\n",
    "                qc=circuit, control_qubit=0, target_qubit=n + 1, c1=c1, c2=c2\n",
    "            )\n",
    "            for circuit in circuits\n",
    "        ]  # Add long range CNOT\n",
    "        circuits = meas_P_kl(\n",
    "            circuits, P_meas\n",
    "        )  # Prepare circuits to measure the control and target\n",
    "        # qubits in P_k and P_l bases respectively\n",
    "        circuits_all += circuits\n",
    "    return circuits_all"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cab24fd",
   "metadata": {},
   "source": [
    "This is an example of a circuit (including the state certification step):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "db53b428-14e0-485a-9e9e-b17d59936c02",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1374.44x953.167 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example Circuit\n",
    "n = 6\n",
    "sample = [15]\n",
    "test_post_proc_circuits = build_circuits_postproc(n, sample)\n",
    "test_post_proc_circuits[1].draw(\"mpl\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1439e5e6-af49-4b7a-95ba-ac7cc75a31e7",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Long-range measurement-based CNOT with feedforward\n",
    "\n",
    "Finally, examine the case where a long-range CNOT gate is implemented using measurement-based CNOT with feedforward (dynamic circuits). In the following figure, on the left is a circuit for a long-range CNOT gate spanning a 1D chain of n-qubits subject to nearest-neighbor connections only. On the right is an equivalent implementable with local CNOT gates, measurement-based CNOT with feedforward (dynamic circuits).\n",
    "\n",
    "![Two equivalent circuits, one using feedforward](/images/tutorials/long-range-entanglement-with-limited-qubit-connectivity/feedforward-illustration.avif)\n",
    "\n",
    "The circuit on the right can be implemented as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5c864fcf-0b77-44df-9750-0cd510640305",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def CNOT_dyn(\n",
    "    qc: QuantumCircuit,\n",
    "    control_qubit: int,\n",
    "    target_qubit: int,\n",
    "    c1: Optional[ClassicalRegister] = None,\n",
    "    c2: Optional[ClassicalRegister] = None,\n",
    "    add_barriers: Optional[bool] = True,\n",
    ") -> QuantumCircuit:\n",
    "    \"\"\"Generate a CNOT gate between data qubit control_qubit and data qubit target_qubit using Bell Pairs.\n",
    "\n",
    "    Post processing is used to enable the CNOT gate via the provided classical registers c1 and c2\n",
    "\n",
    "    Assumes that the long-range CNOT gate will be spanning a 1D chain of n-qubits subject to nearest-neighbor\n",
    "    connections only with the chain starting at the control qubit and finishing at the target qubit.\n",
    "\n",
    "    Assumes that control_qubit < target_qubit (as integers) and that the provided circuit qc has |0> set\n",
    "    qubits control_qubit+1, ..., target_qubit-1\n",
    "\n",
    "    n = target_qubit - control_qubit - 1 : Number of qubits between the target and control qubits\n",
    "    k = int(n/2) : Number of Bell pairs created\n",
    "\n",
    "    Args:\n",
    "        qc (QuantumCicruit) : A Quantum Circuit to add the long range localized unitary CNOT\n",
    "        control_qubit (int) : The qubit used as the control.\n",
    "        target_qubi (int) : The qubit targeted by the gate.\n",
    "\n",
    "    Optional Args:\n",
    "        c1 (ClassicalRegister) : Default = None. Required if n > 1. Register requires k bits\n",
    "        c2 (ClassicalRegister) : Default = None. Required if n > 0. Register requires n - k bits\n",
    "        add_barriers (bool) : Default = True. Include barriers before and after long range CNOT\n",
    "\n",
    "    Note: This approached uses two if_test statements. A better (more performant) approach is\n",
    "    to have the parity values combined into a single classical register and then use a switch\n",
    "    statement. This was done in the associated paper my modifying the qasm file directly. The ability\n",
    "    to use a switch statement via Qiskit in this way is a future release capability.\n",
    "\n",
    "    Returns:\n",
    "        QuantumCircuit\n",
    "    \"\"\"\n",
    "    assert target_qubit > control_qubit\n",
    "    n = target_qubit - control_qubit - 1\n",
    "    t = int(n / 2)\n",
    "\n",
    "    if add_barriers is True:\n",
    "        qc.barrier()\n",
    "\n",
    "    # Determine where to start the bell pairs and\n",
    "    # add an extra CNOT when n is odd\n",
    "    if n % 2 == 0:\n",
    "        x0 = 1\n",
    "    else:\n",
    "        x0 = 2\n",
    "        qc.cx(0, 1)\n",
    "\n",
    "    # Create t Bell pairs\n",
    "    for i in range(t):\n",
    "        qc.h(x0 + 2 * i)\n",
    "        qc.cx(x0 + 2 * i, x0 + 2 * i + 1)\n",
    "\n",
    "    # Entangle Bell pairs and data qubits and measure\n",
    "    for i in range(t + 1):\n",
    "        qc.cx(x0 - 1 + 2 * i, x0 + 2 * i)\n",
    "\n",
    "    for i in range(1, t + x0):\n",
    "        if i == 1:\n",
    "            qc.h(2 * i + 1 - x0)\n",
    "            qc.measure(2 * i + 1 - x0, c2[i - 1])\n",
    "            parity_control = expr.lift(c2[i - 1])\n",
    "        else:\n",
    "            qc.h(2 * i + 1 - x0)\n",
    "            qc.measure(2 * i + 1 - x0, c2[i - 1])\n",
    "            parity_control = expr.bit_xor(c2[i - 1], parity_control)\n",
    "\n",
    "    for i in range(t):\n",
    "        if i == 0:\n",
    "            qc.measure(2 * i + x0, c1[i])\n",
    "            parity_target = expr.lift(c1[i])\n",
    "        else:\n",
    "            qc.measure(2 * i + x0, c1[i])\n",
    "            parity_target = expr.bit_xor(c1[i], parity_target)\n",
    "\n",
    "    if n > 0:\n",
    "        with qc.if_test(parity_control):\n",
    "            qc.z(0)\n",
    "\n",
    "    if n > 1:\n",
    "        with qc.if_test(parity_target):\n",
    "            qc.x(-1)\n",
    "\n",
    "    if add_barriers is True:\n",
    "        qc.barrier()\n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d278d6c6-b46b-4be7-8419-942f92f9a63d",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Put it together with the Monte Carlo state certification methods `prep_P_ij_conj` and `meas_P_kl`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4486c01c-c3ca-47e2-a11f-58134d86806b",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def build_circuits_dyn(n: int, samples: List[int]) -> List[QuantumCircuit]:\n",
    "    \"\"\" \"\"\"\n",
    "    assert n >= 0, \"Error: n needs to be a non-negative integer\"\n",
    "    circuits_all = []\n",
    "\n",
    "    qr = QuantumRegister(\n",
    "        n + 2, name=\"q\"\n",
    "    )  # Circuit with n qubits between control and target\n",
    "    cr = ClassicalRegister(\n",
    "        2, name=\"cr\"\n",
    "    )  # Classical register for measuring long range CNOT\n",
    "\n",
    "    k = int(n / 2)  # Number of Bell States to be used\n",
    "    c1 = ClassicalRegister(\n",
    "        k, name=\"c1\"\n",
    "    )  # Classical register needed for post processing\n",
    "    c2 = ClassicalRegister(\n",
    "        n - k, name=\"c2\"\n",
    "    )  # Classical register needed for post processing\n",
    "\n",
    "    # 16 Paulis with non-zero expectation value to prepare and measure\n",
    "    P_lkji = PauliList(\n",
    "        [\n",
    "            \"IIII\",\n",
    "            \"XIXI\",\n",
    "            \"IZIZ\",\n",
    "            \"XZXZ\",\n",
    "            \"YZYI\",\n",
    "            \"ZZZI\",\n",
    "            \"YIYZ\",\n",
    "            \"ZIZZ\",\n",
    "            \"XXIX\",\n",
    "            \"IXXX\",\n",
    "            \"XYIY\",\n",
    "            \"IYXY\",\n",
    "            \"ZYYX\",\n",
    "            \"YYZX\",\n",
    "            \"ZXYY\",\n",
    "            \"YXZY\",\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    for sample in samples:\n",
    "        P_prep = P_lkji[sample][0:2]\n",
    "        P_meas = P_lkji[sample][2:4]\n",
    "        if n > 1:\n",
    "            circuits = [\n",
    "                QuantumCircuit(qr, cr, c1, c2, name=\"CNOT\") for i in range(4)\n",
    "            ]\n",
    "        elif n == 1:\n",
    "            circuits = [\n",
    "                QuantumCircuit(qr, cr, c2, name=\"CNOT\") for i in range(4)\n",
    "            ]\n",
    "        elif n == 0:\n",
    "            circuits = [QuantumCircuit(qr, cr, name=\"CNOT\") for i in range(4)]\n",
    "        circuits = prep_P_ij_conj(\n",
    "            circuits, P_prep\n",
    "        )  # Prepare control and target qubits\n",
    "        # in eigenstates of P_i^* and P_j^* respectively\n",
    "        circuits = [\n",
    "            CNOT_dyn(\n",
    "                qc=circuit, control_qubit=0, target_qubit=n + 1, c1=c1, c2=c2\n",
    "            )\n",
    "            for circuit in circuits\n",
    "        ]  # Add long range CNOT\n",
    "        circuits = meas_P_kl(\n",
    "            circuits, P_meas\n",
    "        )  # Prepare circuits to measure the control and target\n",
    "        # qubits in P_k and P_l bases respectively\n",
    "        circuits_all += circuits\n",
    "    return circuits_all"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae97fd46",
   "metadata": {},
   "source": [
    "This results in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f9277469-cc4e-464c-b803-e11f6ad3603a",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1959.72x785.944 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# View an example circuit with Monte Carlo Prep\n",
    "\n",
    "n_qubits = 4\n",
    "sample = range(16)\n",
    "example_post_proc_circuits = build_circuits_dyn(n_qubits, sample)\n",
    "example_post_proc_circuits[16].draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66325a1a-5b3b-41fd-b4d0-e1e1702d89a0",
   "metadata": {},
   "source": [
    "## Step 2: Optimize problem for quantum hardware execution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa55c1a8-3f16-4483-a90c-1eae1a40e90e",
   "metadata": {},
   "source": [
    "Because you have already specified the physical qubit layout and built the circuits with a line topology in mind, there is no need to further optimize the circuits."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "210a251f-a4b0-43f1-b081-67da215719bb",
   "metadata": {},
   "source": [
    "## Step 3: Execute using Qiskit primitives\n",
    "In this step you execute the experiment on the specified backend. A lightweight transpilation is done before submission to ensure that the circuits have all the physical parameters needed for execution on the device. This is done in the `submit_circuits` function, which also splits the circuits into smaller batches to be submitted to the device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9b960de5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def submit_circuits(\n",
    "    min_qubits: int,\n",
    "    max_qubits: int,\n",
    "    num_circuits_per_job: int,\n",
    "    qubit_line: List[int],\n",
    "    coupling_map: Union[CouplingMap, List],\n",
    "    samples: List[int],\n",
    "    optimization_level: int,\n",
    "    backend: Backend,\n",
    "    shots: int,\n",
    "    build_circuits: Callable,\n",
    "    transpile_dynamic: Optional[bool] = True,\n",
    "    use_dynamic_decoupling: Optional[bool] = True,\n",
    "    dd_sequence: Optional[List[Gate]] = [XGate(), XGate()],\n",
    "    durations: Optional[InstructionDurations] = None,\n",
    ") -> List[str]:\n",
    "    \"\"\"\n",
    "    Submit circuits in appropriate batches\n",
    "    \"\"\"\n",
    "\n",
    "    # Calculated constants and storage variables\n",
    "    line_length = len(qubit_line)\n",
    "    num_samples = len(samples)\n",
    "    num_circuits = (max_qubits - min_qubits + 1) * 4 * num_samples\n",
    "    nr_jobs = int(num_circuits / num_circuits_per_job)\n",
    "\n",
    "    # Run some parameter checks\n",
    "    # Min number of qubits between control and target must be a non-negative integer\n",
    "    assert min_qubits >= 0, \"Error: min_qubits must be >= 0\"\n",
    "\n",
    "    # Max number of qubits between control and target musts be <= line_length - 2\n",
    "    assert (\n",
    "        max_qubits + 2\n",
    "    ) <= line_length, \"Error: max_qubits must be <= len(qubit_line) - 2\"\n",
    "\n",
    "    # (max_qubits - min_qubits) must equal to 3(mod 4)\n",
    "    rem = (max_qubits - min_qubits) % 4\n",
    "    assert rem == 3, \"Fail: (max_qubits - min_qubits) must equal to 3(mod 4)\"\n",
    "\n",
    "    # First transpile all the circuits\n",
    "    print(\"Transpiling circuits...\")\n",
    "\n",
    "    all_transpiled_circs = []\n",
    "\n",
    "    for n in range(min_qubits, max_qubits + 1):\n",
    "        layout = qubit_line[: n + 2]\n",
    "        circuits = build_circuits(n, samples)\n",
    "\n",
    "        clear_output(wait=True)\n",
    "        percentage_completed = (n - min_qubits + 1) / (\n",
    "            max_qubits - min_qubits + 1\n",
    "        )\n",
    "\n",
    "        print(\n",
    "            f\"[{percentage_completed:.0%} completed] Transpiling circuits \"\n",
    "            + f\"with {n} qubits between CNOT\"\n",
    "        )\n",
    "\n",
    "        # Generate the main Qiskit transpile passes.\n",
    "        pm = generate_preset_pass_manager(\n",
    "            coupling_map=coupling_map,\n",
    "            initial_layout=layout,\n",
    "            optimization_level=optimization_level,\n",
    "            backend=backend,\n",
    "        )\n",
    "\n",
    "        if use_dynamic_decoupling is True:\n",
    "            # Configure the as-late-as-possible scheduling pass and DD insertion pass\n",
    "            pm.scheduling = PassManager(\n",
    "                [\n",
    "                    ALAPScheduleAnalysis(durations),\n",
    "                    PadDynamicalDecoupling(durations, dd_sequence),\n",
    "                ]\n",
    "            )\n",
    "\n",
    "        transpiled_circuits = pm.run(circuits)\n",
    "        all_transpiled_circs.extend(transpiled_circuits)\n",
    "\n",
    "    clear_output(wait=True)\n",
    "    print(\"Sumbitting jobs ...\")\n",
    "\n",
    "    job_ids = []\n",
    "\n",
    "    with Batch(backend=backend) as batch:\n",
    "        sampler = Sampler(session=batch)\n",
    "        for job_num in range(nr_jobs):\n",
    "            transpiled_circs = all_transpiled_circs[\n",
    "                num_circuits_per_job * job_num : num_circuits_per_job\n",
    "                * (job_num + 1)\n",
    "            ]\n",
    "\n",
    "            # Submit circuits\n",
    "            print(\"Submitting circuits:\")\n",
    "\n",
    "            percentage_completed = job_num / nr_jobs\n",
    "            print(f\"[{percentage_completed:.0%} completed]\")\n",
    "\n",
    "            job = sampler.run(transpiled_circs, shots=shots)\n",
    "            job_ids.append(job.job_id())\n",
    "            print(\n",
    "                \"Job id for circuits \"\n",
    "                + f\"[{num_circuits_per_job*nr_jobs}, {num_circuits_per_job*(nr_jobs + 1) -1 }] : {job.job_id()}\"\n",
    "            )\n",
    "\n",
    "            clear_output(wait=True)\n",
    "\n",
    "        clear_output(wait=True)\n",
    "    print(\"All jobs submitted.\\n\")\n",
    "\n",
    "    # Display qubit ranges and job ids\n",
    "    for job_num in range(nr_jobs):\n",
    "        print(\n",
    "            f\"[{num_circuits_per_job*job_num}, {num_circuits_per_job*(job_num + 1)}]: \"\n",
    "            f\"Id = {job_ids[job_num]}\"\n",
    "        )\n",
    "\n",
    "    return job_ids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efdbec84",
   "metadata": {},
   "source": [
    "First, set the parameters for the unitary approach and submit circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f561ce90-32bb-47cc-b0bd-2e910c9e62e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All jobs submitted.\n",
      "\n",
      "[0, 256]: Id = cskwzwfvnxy0008d6m8g\n",
      "[256, 512]: Id = cskwzx73fxq0008c9t60\n",
      "[512, 768]: Id = cskwzxzvnxy0008d6m9g\n",
      "[768, 1024]: Id = cskwzyzvnxy0008d6mb0\n",
      "[1024, 1280]: Id = cskwzzqvnxy0008d6mbg\n",
      "[1280, 1536]: Id = cskx00rp1vzg008a4neg\n",
      "[1536, 1792]: Id = cskx0203fxq0008c9t8g\n",
      "[1792, 2048]: Id = cskx038p1vzg008a4ng0\n",
      "[2048, 2304]: Id = cskx04gvwqp0008avw10\n",
      "[2304, 2560]: Id = cskx060vwqp0008avw20\n",
      "[2560, 2816]: Id = cskx07g1k2e0008nz7pg\n",
      "[2816, 3072]: Id = cskx091p1vzg008a4nh0\n",
      "[3072, 3328]: Id = cskx0b11k2e0008nz7q0\n",
      "[3328, 3584]: Id = cskx0csvwqp0008avw4g\n",
      "[3584, 3840]: Id = cskx0esvwqp0008avw50\n",
      "[3840, 4096]: Id = cskx0gtvnxy0008d6mf0\n"
     ]
    }
   ],
   "source": [
    "# Set local parameters\n",
    "SAMPLES_UNI = SAMPLES\n",
    "OPTIMIZATION_LEVEL_UNI = OPTIMIZATION_LEVEL\n",
    "SHOTS_UNI = SHOTS\n",
    "MIN_NUMBER_QUBITS_UNI = MIN_NUMBER_QUBITS\n",
    "MAX_NUMBER_QUBITS_UNI = MAX_NUMBER_QUBITS\n",
    "NUM_CIRCUITS_PER_JOB_UNI = 256\n",
    "USE_DYNAMIC_DECOUPLING_UNI = False\n",
    "\n",
    "# Submit jobs for using unitary circuit approach\n",
    "job_ids_uni = submit_circuits(\n",
    "    MIN_NUMBER_QUBITS_UNI,\n",
    "    MAX_NUMBER_QUBITS_UNI,\n",
    "    NUM_CIRCUITS_PER_JOB_UNI,\n",
    "    QUBIT_LINE,\n",
    "    COUPLING_MAP_1D,\n",
    "    SAMPLES_UNI,\n",
    "    OPTIMIZATION_LEVEL_UNI,\n",
    "    backend,\n",
    "    SHOTS_UNI,\n",
    "    build_circuits_uni,\n",
    "    use_dynamic_decoupling=USE_DYNAMIC_DECOUPLING_UNI,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ca51a9d",
   "metadata": {},
   "source": [
    "Then, do the same for the measurement-based post-selection approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5c644035-2457-4a11-8790-662d790893eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All jobs submitted.\n",
      "\n",
      "[0, 128]: Id = cskxtx3p1vzg008a4qx0\n",
      "[128, 256]: Id = cskxtxkvwqp0008aw0b0\n",
      "[256, 384]: Id = cskxtybea560008f8sj0\n",
      "[384, 512]: Id = cskxtykea560008f8sk0\n",
      "[512, 640]: Id = cskxtzb1k2e0008nzbh0\n",
      "[640, 768]: Id = cskxtzv3fxq0008c9xdg\n",
      "[768, 896]: Id = cskxv0c1k2e0008nzbhg\n",
      "[896, 1024]: Id = cskxv0w3fxq0008c9xe0\n",
      "[1024, 1152]: Id = cskxv1cea560008f8skg\n",
      "[1152, 1280]: Id = cskxv1w3fxq0008c9xf0\n",
      "[1280, 1408]: Id = cskxv2c1k2e0008nzbjg\n",
      "[1408, 1536]: Id = cskxv34vnxy0008d6r7g\n",
      "[1536, 1664]: Id = cskxv3mea560008f8sm0\n",
      "[1664, 1792]: Id = cskxv4c1k2e0008nzbkg\n",
      "[1792, 1920]: Id = cskxv543fxq0008c9xg0\n",
      "[1920, 2048]: Id = cskxv5m1k2e0008nzbm0\n",
      "[2048, 2176]: Id = cskxv6c1k2e0008nzbn0\n",
      "[2176, 2304]: Id = cskxv6w1k2e0008nzbng\n",
      "[2304, 2432]: Id = cskxv7mvnxy0008d6r9g\n",
      "[2432, 2560]: Id = cskxv8d3fxq0008c9xgg\n",
      "[2560, 2688]: Id = cskxv95p1vzg008a4qz0\n",
      "[2688, 2816]: Id = cskxv9x3fxq0008c9xhg\n",
      "[2816, 2944]: Id = cskxvanvwqp0008aw0e0\n",
      "[2944, 3072]: Id = cskxvbdea560008f8sp0\n",
      "[3072, 3200]: Id = cskxvc51k2e0008nzbq0\n",
      "[3200, 3328]: Id = cskxvcx3fxq0008c9xk0\n",
      "[3328, 3456]: Id = cskxvdnvwqp0008aw0f0\n",
      "[3456, 3584]: Id = cskxvenvnxy0008d6rag\n",
      "[3584, 3712]: Id = cskxvfd3fxq0008c9xkg\n",
      "[3712, 3840]: Id = cskxvgevnxy0008d6rcg\n",
      "[3840, 3968]: Id = cskxvh63fxq0008c9xm0\n",
      "[3968, 4096]: Id = cskxvj6vwqp0008aw0g0\n"
     ]
    }
   ],
   "source": [
    "# Set local parameters\n",
    "SAMPLES_POSTPROC = SAMPLES\n",
    "OPTIMIZATION_LEVEL_POSTPROC = OPTIMIZATION_LEVEL\n",
    "SHOTS_POSTPROC = SHOTS\n",
    "MIN_NUMBER_QUBITS_POSTPROC = MIN_NUMBER_QUBITS\n",
    "MAX_NUMBER_QUBITS_POSTPROC = MAX_NUMBER_QUBITS\n",
    "NUM_CIRCUITS_PER_JOB_POSTPROC = 128\n",
    "USE_DYNAMIC_DECOUPLING_POSTPROC = USE_DYNAMIC_DECOUPLING\n",
    "DURATIONS_POSTPROC = DURATIONS\n",
    "\n",
    "# Submit jobs for the measurement based post selection approach\n",
    "job_ids_postproc = submit_circuits(\n",
    "    MIN_NUMBER_QUBITS_POSTPROC,\n",
    "    MAX_NUMBER_QUBITS_POSTPROC,\n",
    "    NUM_CIRCUITS_PER_JOB_POSTPROC,\n",
    "    QUBIT_LINE,\n",
    "    COUPLING_MAP_1D,\n",
    "    SAMPLES_POSTPROC,\n",
    "    OPTIMIZATION_LEVEL_POSTPROC,\n",
    "    backend,\n",
    "    SHOTS_POSTPROC,\n",
    "    build_circuits_postproc,\n",
    "    use_dynamic_decoupling=USE_DYNAMIC_DECOUPLING_POSTPROC,\n",
    "    durations=DURATIONS_POSTPROC,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d539cc4c",
   "metadata": {},
   "source": [
    "Finally, for the measurement-based dynamic circuit approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5b85cae8-a2e3-40cd-a1ea-65a59e7e810e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All jobs submitted.\n",
      "\n",
      "[0, 16]: Id = cskyn0cvwqp0008aw420\n",
      "[16, 32]: Id = cskyn0m3fxq0008ca280\n",
      "[32, 48]: Id = cskyn0wea560008f8y90\n",
      "[48, 64]: Id = cskyn14vnxy0008d6vqg\n",
      "[64, 80]: Id = cskyn1cea560008f8y9g\n",
      "[80, 96]: Id = cskyn1wea560008f8ya0\n",
      "[96, 112]: Id = cskyn241k2e0008nzg40\n",
      "[112, 128]: Id = cskyn2c3fxq0008ca290\n",
      "[128, 144]: Id = cskyn2mvnxy0008d6vr0\n",
      "[144, 160]: Id = cskyn34ea560008f8yag\n",
      "[160, 176]: Id = cskyn3mp1vzg008a4v8g\n",
      "[176, 192]: Id = cskyn3wp1vzg008a4v90\n",
      "[192, 208]: Id = cskyn441k2e0008nzg4g\n",
      "[208, 224]: Id = cskyn4cvnxy0008d6vrg\n",
      "[224, 240]: Id = cskyn4m3fxq0008ca2b0\n",
      "[240, 256]: Id = cskyn4w3fxq0008ca2bg\n",
      "[256, 272]: Id = cskyn54vwqp0008aw440\n",
      "[272, 288]: Id = cskyn5mea560008f8ybg\n",
      "[288, 304]: Id = cskyn5wvwqp0008aw44g\n",
      "[304, 320]: Id = cskyn64ea560008f8ycg\n",
      "[320, 336]: Id = cskyn6c3fxq0008ca2c0\n",
      "[336, 352]: Id = cskyn6mp1vzg008a4v9g\n",
      "[352, 368]: Id = cskyn74ea560008f8yd0\n",
      "[368, 384]: Id = cskyn7cea560008f8ydg\n",
      "[384, 400]: Id = cskyn7mea560008f8ye0\n",
      "[400, 416]: Id = cskyn7w1k2e0008nzg60\n",
      "[416, 432]: Id = cskyn853fxq0008ca2d0\n",
      "[432, 448]: Id = cskyn8dea560008f8yf0\n",
      "[448, 464]: Id = cskyn8nvnxy0008d6vsg\n",
      "[464, 480]: Id = cskyn95p1vzg008a4vag\n",
      "[480, 496]: Id = cskyn9d1k2e0008nzg6g\n",
      "[496, 512]: Id = cskyn9nvnxy0008d6vtg\n",
      "[512, 528]: Id = cskyn9xvwqp0008aw450\n",
      "[528, 544]: Id = cskyna5vwqp0008aw45g\n",
      "[544, 560]: Id = cskynanvnxy0008d6vv0\n",
      "[560, 576]: Id = cskynaxvwqp0008aw460\n",
      "[576, 592]: Id = cskynb5vwqp0008aw46g\n",
      "[592, 608]: Id = cskynbdvwqp0008aw470\n",
      "[608, 624]: Id = cskynbn1k2e0008nzg70\n",
      "[624, 640]: Id = cskynbxvnxy0008d6vw0\n",
      "[640, 656]: Id = cskync53fxq0008ca2fg\n",
      "[656, 672]: Id = cskyncdvnxy0008d6vwg\n",
      "[672, 688]: Id = cskyncxvnxy0008d6vx0\n",
      "[688, 704]: Id = cskynd5vnxy0008d6vxg\n",
      "[704, 720]: Id = cskynddvnxy0008d6vy0\n",
      "[720, 736]: Id = cskyndnvnxy0008d6vyg\n",
      "[736, 752]: Id = cskyndxp1vzg008a4vc0\n",
      "[752, 768]: Id = cskyne53fxq0008ca2g0\n",
      "[768, 784]: Id = cskynedp1vzg008a4vcg\n",
      "[784, 800]: Id = cskynenvwqp0008aw48g\n",
      "[800, 816]: Id = cskynf5p1vzg008a4vd0\n",
      "[816, 832]: Id = cskynfdp1vzg008a4ve0\n",
      "[832, 848]: Id = cskynfnvnxy0008d6vz0\n",
      "[848, 864]: Id = cskynfxp1vzg008a4veg\n",
      "[864, 880]: Id = cskyng6vnxy0008d6w00\n",
      "[880, 896]: Id = cskyngp3fxq0008ca2h0\n",
      "[896, 912]: Id = cskyngyvnxy0008d6w0g\n",
      "[912, 928]: Id = cskynh6vnxy0008d6w10\n",
      "[928, 944]: Id = cskynhe1k2e0008nzg8g\n",
      "[944, 960]: Id = cskynhpp1vzg008a4vfg\n",
      "[960, 976]: Id = cskynj6vwqp0008aw490\n",
      "[976, 992]: Id = cskynjep1vzg008a4vgg\n",
      "[992, 1008]: Id = cskynjyvnxy0008d6w20\n",
      "[1008, 1024]: Id = cskynk6p1vzg008a4vh0\n",
      "[1024, 1040]: Id = cskynkevnxy0008d6w2g\n",
      "[1040, 1056]: Id = cskynkyvwqp0008aw49g\n",
      "[1056, 1072]: Id = cskynm6p1vzg008a4vhg\n",
      "[1072, 1088]: Id = cskynmeea560008f8yhg\n",
      "[1088, 1104]: Id = cskynmpea560008f8yj0\n",
      "[1104, 1120]: Id = cskynmyvwqp0008aw4a0\n",
      "[1120, 1136]: Id = cskynn6vwqp0008aw4ag\n",
      "[1136, 1152]: Id = cskynnevnxy0008d6w4g\n",
      "[1152, 1168]: Id = cskynny1k2e0008nzga0\n",
      "[1168, 1184]: Id = cskynp6vwqp0008aw4bg\n",
      "[1184, 1200]: Id = cskynpevnxy0008d6w50\n",
      "[1200, 1216]: Id = cskynppea560008f8ykg\n",
      "[1216, 1232]: Id = cskynpyp1vzg008a4vk0\n",
      "[1232, 1248]: Id = cskynq6vnxy0008d6w5g\n",
      "[1248, 1264]: Id = cskynqep1vzg008a4vm0\n",
      "[1264, 1280]: Id = cskynqpea560008f8ym0\n",
      "[1280, 1296]: Id = cskynr7p1vzg008a4vn0\n",
      "[1296, 1312]: Id = cskynrfp1vzg008a4vng\n",
      "[1312, 1328]: Id = cskynrqp1vzg008a4vp0\n",
      "[1328, 1344]: Id = cskynrzp1vzg008a4vpg\n",
      "[1344, 1360]: Id = cskyns7vnxy0008d6w60\n",
      "[1360, 1376]: Id = cskynsfp1vzg008a4vqg\n",
      "[1376, 1392]: Id = cskynsz1k2e0008nzgag\n",
      "[1392, 1408]: Id = cskynt7vnxy0008d6w6g\n",
      "[1408, 1424]: Id = cskyntf3fxq0008ca2mg\n",
      "[1424, 1440]: Id = cskyntqvnxy0008d6w70\n",
      "[1440, 1456]: Id = cskynv7ea560008f8yng\n",
      "[1456, 1472]: Id = cskynvf1k2e0008nzgbg\n",
      "[1472, 1488]: Id = cskynvqvnxy0008d6w7g\n",
      "[1488, 1504]: Id = cskynvz3fxq0008ca2ng\n",
      "[1504, 1520]: Id = cskynwf1k2e0008nzgcg\n",
      "[1520, 1536]: Id = cskynwq1k2e0008nzgd0\n",
      "[1536, 1552]: Id = cskynwzvnxy0008d6w80\n",
      "[1552, 1568]: Id = cskynxf1k2e0008nzge0\n",
      "[1568, 1584]: Id = cskynxqea560008f8ypg\n",
      "[1584, 1600]: Id = cskynxz3fxq0008ca2pg\n",
      "[1600, 1616]: Id = cskyny7vwqp0008aw4d0\n",
      "[1616, 1632]: Id = cskynyq3fxq0008ca2q0\n",
      "[1632, 1648]: Id = cskynyz1k2e0008nzgeg\n",
      "[1648, 1664]: Id = cskynz71k2e0008nzgf0\n",
      "[1664, 1680]: Id = cskynzf3fxq0008ca2qg\n",
      "[1680, 1696]: Id = cskynzzvwqp0008aw4dg\n",
      "[1696, 1712]: Id = cskyp00ea560008f8yq0\n",
      "[1712, 1728]: Id = cskyp08vnxy0008d6w90\n",
      "[1728, 1744]: Id = cskyp0r3fxq0008ca2r0\n",
      "[1744, 1760]: Id = cskyp101k2e0008nzgfg\n",
      "[1760, 1776]: Id = cskyp18p1vzg008a4vrg\n",
      "[1776, 1792]: Id = cskyp1rvnxy0008d6w9g\n",
      "[1792, 1808]: Id = cskyp203fxq0008ca2rg\n",
      "[1808, 1824]: Id = cskyp283fxq0008ca2s0\n",
      "[1824, 1840]: Id = cskyp2g1k2e0008nzggg\n",
      "[1840, 1856]: Id = cskyp301k2e0008nzgh0\n",
      "[1856, 1872]: Id = cskyp38vnxy0008d6wa0\n",
      "[1872, 1888]: Id = cskyp3gvwqp0008aw4e0\n",
      "[1888, 1904]: Id = cskyp40vnxy0008d6wag\n",
      "[1904, 1920]: Id = cskyp48ea560008f8yrg\n",
      "[1920, 1936]: Id = cskyp4g1k2e0008nzghg\n",
      "[1936, 1952]: Id = cskyp50vwqp0008aw4eg\n",
      "[1952, 1968]: Id = cskyp581k2e0008nzgj0\n",
      "[1968, 1984]: Id = cskyp5gea560008f8ysg\n",
      "[1984, 2000]: Id = cskyp5r1k2e0008nzgjg\n",
      "[2000, 2016]: Id = cskyp68vwqp0008aw4fg\n",
      "[2016, 2032]: Id = cskyp6g1k2e0008nzgk0\n",
      "[2032, 2048]: Id = cskyp6r3fxq0008ca2tg\n",
      "[2048, 2064]: Id = cskyp701k2e0008nzgkg\n",
      "[2064, 2080]: Id = cskyp7gea560008f8yv0\n",
      "[2080, 2096]: Id = cskyp7rvnxy0008d6wbg\n",
      "[2096, 2112]: Id = cskyp81vnxy0008d6wc0\n",
      "[2112, 2128]: Id = cskyp8h3fxq0008ca2vg\n",
      "[2128, 2144]: Id = cskyp8svnxy0008d6wcg\n",
      "[2144, 2160]: Id = cskyp911k2e0008nzgm0\n",
      "[2160, 2176]: Id = cskyp9hvwqp0008aw4hg\n",
      "[2176, 2192]: Id = cskyp9svwqp0008aw4jg\n",
      "[2192, 2208]: Id = cskypa1vwqp0008aw4k0\n",
      "[2208, 2224]: Id = cskypa9vnxy0008d6wd0\n",
      "[2224, 2240]: Id = cskypasp1vzg008a4vv0\n",
      "[2240, 2256]: Id = cskypb93fxq0008ca2w0\n",
      "[2256, 2272]: Id = cskypbh3fxq0008ca2wg\n",
      "[2272, 2288]: Id = cskypc1ea560008f8yx0\n",
      "[2288, 2304]: Id = cskypc9vwqp0008aw4mg\n",
      "[2304, 2320]: Id = cskypchvwqp0008aw4n0\n",
      "[2320, 2336]: Id = cskypcsvwqp0008aw4ng\n",
      "[2336, 2352]: Id = cskypd9p1vzg008a4vvg\n",
      "[2352, 2368]: Id = cskypdh1k2e0008nzgmg\n",
      "[2368, 2384]: Id = cskype1vwqp0008aw4p0\n",
      "[2384, 2400]: Id = cskype91k2e0008nzgn0\n",
      "[2400, 2416]: Id = cskypehvwqp0008aw4q0\n",
      "[2416, 2432]: Id = cskypf1vwqp0008aw4qg\n",
      "[2432, 2448]: Id = cskypf9p1vzg008a4vw0\n",
      "[2448, 2464]: Id = cskypfs1k2e0008nzgng\n",
      "[2464, 2480]: Id = cskypg2vwqp0008aw4r0\n",
      "[2480, 2496]: Id = cskypga1k2e0008nzgp0\n",
      "[2496, 2512]: Id = cskypgt1k2e0008nzgpg\n",
      "[2512, 2528]: Id = cskyph21k2e0008nzgq0\n",
      "[2528, 2544]: Id = cskyphjea560008f8yz0\n",
      "[2544, 2560]: Id = cskypht3fxq0008ca2xg\n",
      "[2560, 2576]: Id = cskypj21k2e0008nzgr0\n",
      "[2576, 2592]: Id = cskypjjvwqp0008aw4s0\n",
      "[2592, 2608]: Id = cskypk2vwqp0008aw4sg\n",
      "[2608, 2624]: Id = cskypkaea560008f8yzg\n",
      "[2624, 2640]: Id = cskypkjea560008f8z00\n",
      "[2640, 2656]: Id = cskypm2vwqp0008aw4t0\n",
      "[2656, 2672]: Id = cskypmap1vzg008a4vx0\n",
      "[2672, 2688]: Id = cskypmtp1vzg008a4vxg\n",
      "[2688, 2704]: Id = cskypn21k2e0008nzgsg\n",
      "[2704, 2720]: Id = cskypnjea560008f8z1g\n",
      "[2720, 2736]: Id = cskypntp1vzg008a4vy0\n",
      "[2736, 2752]: Id = cskyppj1k2e0008nzgt0\n",
      "[2752, 2768]: Id = cskypptea560008f8z20\n",
      "[2768, 2784]: Id = cskypqaea560008f8z2g\n",
      "[2784, 2800]: Id = cskypqjvwqp0008aw4vg\n",
      "[2800, 2816]: Id = cskypr3p1vzg008a4vyg\n",
      "[2816, 2832]: Id = cskyprkvnxy0008d6weg\n",
      "[2832, 2848]: Id = cskyprvea560008f8z30\n",
      "[2848, 2864]: Id = cskypsbvwqp0008aw4wg\n",
      "[2864, 2880]: Id = cskypskp1vzg008a4vzg\n",
      "[2880, 2896]: Id = cskypt3vnxy0008d6wf0\n",
      "[2896, 2912]: Id = cskyptbvwqp0008aw4y0\n",
      "[2912, 2928]: Id = cskyptv1k2e0008nzgtg\n",
      "[2928, 2944]: Id = cskypvbvwqp0008aw4yg\n",
      "[2944, 2960]: Id = cskypvkea560008f8z4g\n",
      "[2960, 2976]: Id = cskypw3p1vzg008a4w00\n",
      "[2976, 2992]: Id = cskypwk1k2e0008nzgv0\n",
      "[2992, 3008]: Id = cskypwvea560008f8z60\n",
      "[3008, 3024]: Id = cskypx3vwqp0008aw4zg\n",
      "[3024, 3040]: Id = cskypxkvnxy0008d6wg0\n",
      "[3040, 3056]: Id = cskypy31k2e0008nzgwg\n",
      "[3056, 3072]: Id = cskypybea560008f8z6g\n",
      "[3072, 3088]: Id = cskypyvea560008f8z70\n",
      "[3088, 3104]: Id = cskypzbvnxy0008d6wh0\n",
      "[3104, 3120]: Id = cskypzkvnxy0008d6whg\n",
      "[3120, 3136]: Id = cskyq041k2e0008nzgz0\n",
      "[3136, 3152]: Id = cskyq0cvwqp0008aw510\n",
      "[3152, 3168]: Id = cskyq0wvwqp0008aw51g\n",
      "[3168, 3184]: Id = cskyq1cea560008f8z7g\n",
      "[3184, 3200]: Id = cskyq1m1k2e0008nzgzg\n",
      "[3200, 3216]: Id = cskyq241k2e0008nzh00\n",
      "[3216, 3232]: Id = cskyq2m3fxq0008ca30g\n",
      "[3232, 3248]: Id = cskyq34vwqp0008aw520\n",
      "[3248, 3264]: Id = cskyq3cp1vzg008a4w10\n",
      "[3264, 3280]: Id = cskyq3wvwqp0008aw530\n",
      "[3280, 3296]: Id = cskyq4cvnxy0008d6wmg\n",
      "[3296, 3312]: Id = cskyq4mp1vzg008a4w1g\n",
      "[3312, 3328]: Id = cskyq541k2e0008nzh10\n",
      "[3328, 3344]: Id = cskyq5cvnxy0008d6wn0\n",
      "[3344, 3360]: Id = cskyq5w1k2e0008nzh1g\n",
      "[3360, 3376]: Id = cskyq64vnxy0008d6wng\n",
      "[3376, 3392]: Id = cskyq6cea560008f8z80\n",
      "[3392, 3408]: Id = cskyq6wvwqp0008aw540\n",
      "[3408, 3424]: Id = cskyq741k2e0008nzh2g\n",
      "[3424, 3440]: Id = cskyq7m1k2e0008nzh30\n",
      "[3440, 3456]: Id = cskyq7wvnxy0008d6wp0\n",
      "[3456, 3472]: Id = cskyq8dea560008f8z8g\n",
      "[3472, 3488]: Id = cskyq8n1k2e0008nzh3g\n",
      "[3488, 3504]: Id = cskyq95vwqp0008aw560\n",
      "[3504, 3520]: Id = cskyq9dvnxy0008d6wpg\n",
      "[3520, 3536]: Id = cskyq9xvnxy0008d6wq0\n",
      "[3536, 3552]: Id = cskyqa5vwqp0008aw56g\n",
      "[3552, 3568]: Id = cskyqadvnxy0008d6wqg\n",
      "[3568, 3584]: Id = cskyqax1k2e0008nzh4g\n",
      "[3584, 3600]: Id = cskyqb51k2e0008nzh50\n",
      "[3600, 3616]: Id = cskyqbnvwqp0008aw570\n",
      "[3616, 3632]: Id = cskyqbxvnxy0008d6wrg\n",
      "[3632, 3648]: Id = cskyqc5vwqp0008aw57g\n",
      "[3648, 3664]: Id = cskyqcnvnxy0008d6wsg\n",
      "[3664, 3680]: Id = cskyqcx1k2e0008nzh5g\n",
      "[3680, 3696]: Id = cskyqddvnxy0008d6wt0\n",
      "[3696, 3712]: Id = cskyqdn1k2e0008nzh60\n",
      "[3712, 3728]: Id = cskyqe53fxq0008ca32g\n",
      "[3728, 3744]: Id = cskyqedvnxy0008d6wtg\n",
      "[3744, 3760]: Id = cskyqen1k2e0008nzh6g\n",
      "[3760, 3776]: Id = cskyqf5vwqp0008aw580\n",
      "[3776, 3792]: Id = cskyqfn1k2e0008nzh70\n",
      "[3792, 3808]: Id = cskyqfxvnxy0008d6wv0\n",
      "[3808, 3824]: Id = cskyqgevnxy0008d6wvg\n",
      "[3824, 3840]: Id = cskyqgp1k2e0008nzh7g\n",
      "[3840, 3856]: Id = cskyqh6p1vzg008a4w4g\n",
      "[3856, 3872]: Id = cskyqhevnxy0008d6ww0\n",
      "[3872, 3888]: Id = cskyqhy1k2e0008nzh8g\n",
      "[3888, 3904]: Id = cskyqj6p1vzg008a4w5g\n",
      "[3904, 3920]: Id = cskyqjevnxy0008d6wx0\n",
      "[3920, 3936]: Id = cskyqjy1k2e0008nzh9g\n",
      "[3936, 3952]: Id = cskyqk63fxq0008ca340\n",
      "[3952, 3968]: Id = cskyqkp3fxq0008ca350\n",
      "[3968, 3984]: Id = cskyqkyvwqp0008aw590\n",
      "[3984, 4000]: Id = cskyqme3fxq0008ca35g\n",
      "[4000, 4016]: Id = cskyqmpvnxy0008d6wyg\n",
      "[4016, 4032]: Id = cskyqn61k2e0008nzha0\n",
      "[4032, 4048]: Id = cskyqne1k2e0008nzhag\n",
      "[4048, 4064]: Id = cskyqnpvnxy0008d6wz0\n",
      "[4064, 4080]: Id = cskyqp63fxq0008ca36g\n",
      "[4080, 4096]: Id = cskyqpevnxy0008d6x00\n"
     ]
    }
   ],
   "source": [
    "# Set local parameters\n",
    "SAMPLES_DYN = SAMPLES\n",
    "OPTIMIZATION_LEVEL_DYN = OPTIMIZATION_LEVEL\n",
    "SHOTS_DYN = SHOTS\n",
    "MIN_NUMBER_QUBITS_DYN = MIN_NUMBER_QUBITS\n",
    "MAX_NUMBER_QUBITS_DYN = MAX_NUMBER_QUBITS\n",
    "DURATIONS_DYN = DURATIONS\n",
    "DD_SEQUENCE_DYN = DD_SEQUENCE\n",
    "NUM_CIRCUITS_PER_JOB_DYN = 16\n",
    "USE_DYNAMIC_DECOUPLING_DYN = USE_DYNAMIC_DECOUPLING\n",
    "\n",
    "# Submit jobs for the measurement based dynamic circuit approach\n",
    "job_ids_dyn = submit_circuits(\n",
    "    MIN_NUMBER_QUBITS_DYN,\n",
    "    MAX_NUMBER_QUBITS_DYN,\n",
    "    NUM_CIRCUITS_PER_JOB_DYN,\n",
    "    QUBIT_LINE,\n",
    "    COUPLING_MAP_1D,\n",
    "    SAMPLES_DYN,\n",
    "    OPTIMIZATION_LEVEL_DYN,\n",
    "    backend,\n",
    "    SHOTS_DYN,\n",
    "    build_circuits_dyn,\n",
    "    durations=DURATIONS_DYN,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db31a1df",
   "metadata": {},
   "source": [
    "## Step 4: Post-process and return result in desired classical format\n",
    "\n",
    "After the experiments have successfully executed, proceed to post-process the resulting counts to gain insight on the final results. You can take advantage of resampling techniques (also known as [bootstrapping](https://en.wikipedia.org/wiki/Bootstrapping_(statistics))) to calculate average fidelities and deviations from the experimental counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0670acf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def resample_single_dictionary(d):\n",
    "    \"\"\"Resample a single dictionary based on its weights.\"\"\"\n",
    "    keys = list(d.keys())\n",
    "    weights = list(d.values())\n",
    "    total = sum(weights)\n",
    "\n",
    "    resampled_keys = random.choices(keys, weights=weights, k=total)\n",
    "\n",
    "    # Count the occurrences of each key in the resampled keys\n",
    "    resampled_counts = {}\n",
    "    for key in resampled_keys:\n",
    "        resampled_counts[key] = resampled_counts.get(key, 0) + 1\n",
    "\n",
    "    return resampled_counts\n",
    "\n",
    "\n",
    "def resample_dict_list(dict_list, n_samples):\n",
    "    \"\"\"Resample the entire list of dictionaries n_samples times.\"\"\"\n",
    "    resampled_lists = []\n",
    "\n",
    "    for _ in range(n_samples):\n",
    "        new_version = [resample_single_dictionary(d) for d in dict_list]\n",
    "        resampled_lists.append(new_version)\n",
    "\n",
    "    return resampled_lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d939f70",
   "metadata": {},
   "source": [
    "In addition, to post-process the results, you need to extract the information from the Monte Carlo state certification protocol - thus, depending on the preparation/measurement basis, you will group the results differently. The utility functions below are meant to carry out this procedure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e10d498d-443f-4875-99bf-bb0b3f6a8e3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parity(string: str) -> int:\n",
    "    return string.count(\"1\") % 2\n",
    "\n",
    "\n",
    "def parities(string: str) -> str:\n",
    "    strings = string.split()\n",
    "    parities = [parity(val) for val in strings]\n",
    "    return parities\n",
    "\n",
    "\n",
    "def postproc_counts(counts, i, samples):\n",
    "    P_lkji = PauliList(\n",
    "        [\n",
    "            \"IIII\",\n",
    "            \"XIXI\",\n",
    "            \"IZIZ\",\n",
    "            \"XZXZ\",\n",
    "            \"YZYI\",\n",
    "            \"ZZZI\",\n",
    "            \"YIYZ\",\n",
    "            \"ZIZZ\",\n",
    "            \"XXIX\",\n",
    "            \"IXXX\",\n",
    "            \"XYIY\",\n",
    "            \"IYXY\",\n",
    "            \"ZYYX\",\n",
    "            \"YYZX\",\n",
    "            \"ZXYY\",\n",
    "            \"YXZY\",\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    PauliI = Pauli(\"I\")\n",
    "    PauliX = Pauli(\"X\")\n",
    "    PauliZ = Pauli(\"Z\")\n",
    "\n",
    "    P_k = P_lkji[samples[i]][2]\n",
    "    P_l = P_lkji[samples[i]][3]\n",
    "\n",
    "    # determine parities\n",
    "    counts_post = {\"00\": 0, \"01\": 0, \"10\": 0, \"11\": 0}\n",
    "\n",
    "    for key in counts:\n",
    "        parities_list = parities(key)\n",
    "        w = len(parities_list)\n",
    "        if w == 3:\n",
    "            parity_of_c2, parity_of_c1, _ = parities_list\n",
    "        elif w == 2:\n",
    "            parity_of_c1 = 0\n",
    "            parity_of_c2, _ = parities_list\n",
    "        else:\n",
    "            parity_of_c1 = 0\n",
    "            parity_of_c2 = 0\n",
    "\n",
    "        # add parity_of_c2 to q0 (key[-1]) only if P_k is 'X' or 'Y'\n",
    "        if P_k == PauliI or P_k == PauliZ:\n",
    "            parity_of_c2 = 0\n",
    "\n",
    "        # add parity_c1 to q1 (key[-2]) only if P_l is 'I' or 'Z' or 'Y'\n",
    "        if P_l == PauliX:\n",
    "            parity_of_c1 = 0\n",
    "\n",
    "        control_qubit_value = int(key[-1])  # Control qubit q0\n",
    "        target_qubit_value = int(key[-2])  # Target qubit q1\n",
    "\n",
    "        new_control_qubit_value = (control_qubit_value + parity_of_c2) % 2\n",
    "        new_target_qubit_value = (target_qubit_value + parity_of_c1) % 2\n",
    "\n",
    "        new_key = str(new_target_qubit_value) + str(new_control_qubit_value)\n",
    "\n",
    "        counts_post[new_key] += counts[key]\n",
    "\n",
    "    return counts_post\n",
    "\n",
    "\n",
    "def post_process_postproc(count, i, p, q, samples):\n",
    "    return postproc_counts(count, i, samples)\n",
    "\n",
    "\n",
    "def post_process_dyn(count, i, p, q, samples):\n",
    "    return marginal_counts(count, indices=range(2))\n",
    "\n",
    "\n",
    "def process_fidelities(\n",
    "    counts: Union[dict[str, int], List[dict[str, int]]],\n",
    "    samples: List[int],\n",
    "    shots: int,\n",
    "    post_process: Optional[Callable] = None,\n",
    ") -> List[float]:\n",
    "    \"\"\"Calculate the estimated process fidelities from experiment counts data\n",
    "\n",
    "    Args:\n",
    "        counts (dict[str:int] or List[dict[str:int]]): counts data from an experiment\n",
    "        samples (List[int]): which of the 16 Paulis with non-zero expectation value to prepare and measure\n",
    "        shots (int): Number of shots used in experiment\n",
    "        post_process (Callable): Post process the counts with post_proc if given. Default = None\n",
    "    \"\"\"\n",
    "    exp_all = []\n",
    "    # 16 Paulis with non-zero expectation value to prepare and measure\n",
    "    P_lkji = PauliList(\n",
    "        [\n",
    "            \"IIII\",\n",
    "            \"XIXI\",\n",
    "            \"IZIZ\",\n",
    "            \"XZXZ\",\n",
    "            \"YZYI\",\n",
    "            \"ZZZI\",\n",
    "            \"YIYZ\",\n",
    "            \"ZIZZ\",\n",
    "            \"XXIX\",\n",
    "            \"IXXX\",\n",
    "            \"XYIY\",\n",
    "            \"IYXY\",\n",
    "            \"ZYYX\",\n",
    "            \"YYZX\",\n",
    "            \"ZXYY\",\n",
    "            \"YXZY\",\n",
    "        ]\n",
    "    )\n",
    "    sign_rho_lkji = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1]\n",
    "\n",
    "    PauliI = Pauli(\"I\")\n",
    "\n",
    "    for i in range(len(samples)):\n",
    "        P_i = P_lkji[samples[i]][0]\n",
    "        P_j = P_lkji[samples[i]][1]\n",
    "        P_k = P_lkji[samples[i]][2]\n",
    "        P_l = P_lkji[samples[i]][3]\n",
    "\n",
    "        exp = 0\n",
    "        # initial state p with eig value p_eig prepared\n",
    "        for p in range(2):\n",
    "            if P_i == PauliI:\n",
    "                p_eig = 1\n",
    "            else:\n",
    "                p_eig = (-1) ** p\n",
    "\n",
    "            # initial state q with eig value q_eig prepared\n",
    "            for q in range(2):\n",
    "                if P_j == PauliI:\n",
    "                    q_eig = 1\n",
    "                else:\n",
    "                    q_eig = (-1) ** q\n",
    "\n",
    "                # post process count if provided\n",
    "                if post_process is not None:\n",
    "                    if len(counts) > 0:\n",
    "                        counts_post = post_process(\n",
    "                            counts[i * 4 + 2 * p + q], i, p, q, samples\n",
    "                        )\n",
    "                else:\n",
    "                    if len(counts) > 0:\n",
    "                        counts_post = counts[i * 4 + 2 * p + q]\n",
    "\n",
    "                # measurement projecting to states r with eig value r_eig\n",
    "                for r in range(2):\n",
    "                    if P_k == PauliI:\n",
    "                        r_eig = 1\n",
    "                    else:\n",
    "                        r_eig = (-1) ** r\n",
    "                    for s in range(2):\n",
    "                        if P_l == PauliI:\n",
    "                            s_eig = 1\n",
    "                        else:\n",
    "                            s_eig = (-1) ** s\n",
    "\n",
    "                        str_r = str(r)\n",
    "                        str_s = str(s)\n",
    "                        try:\n",
    "                            exp += (\n",
    "                                p_eig\n",
    "                                * q_eig\n",
    "                                * s_eig\n",
    "                                * r_eig\n",
    "                                * counts_post[str_s + str_r]\n",
    "                                / shots\n",
    "                                / 4\n",
    "                                / sign_rho_lkji[samples[i]]\n",
    "                            )\n",
    "                        except:\n",
    "                            pass\n",
    "\n",
    "        exp_all.append(exp)\n",
    "    return exp_all\n",
    "\n",
    "\n",
    "def get_counts_from_bitarray(instance):\n",
    "    \"\"\"\n",
    "    Extract counts from result data\n",
    "    \"\"\"\n",
    "    for field, value in instance.__dict__.items():\n",
    "        if isinstance(value, BitArray):\n",
    "            return value.get_counts()\n",
    "    return None\n",
    "\n",
    "\n",
    "def cal_average_fidelities(\n",
    "    job_ids: List[str],\n",
    "    min_qubits: int,\n",
    "    max_qubits: int,\n",
    "    samples: List[int],\n",
    "    shots: int,\n",
    "    num_circuits_per_job: int,\n",
    "    post_process: Optional[Callable] = None,\n",
    "    all_counts: Optional[List[Dict]] = None,\n",
    "    display: Optional[bool] = True,\n",
    "    debug: Optional[bool] = False,\n",
    "    n_bootstrap_sample: Optional[int] = 4,\n",
    ") -> (List[float], List[float]):\n",
    "    \"\"\"\n",
    "    Calculate the average gate fidelities\n",
    "    \"\"\"\n",
    "\n",
    "    proc_fidelities = []\n",
    "    proc_std = []\n",
    "    nr_jobs = len(job_ids)\n",
    "    num_samples = len(samples)\n",
    "    empty_counts = {\"00\": 0, \"01\": 0, \"10\": 0, \"11\": 0}\n",
    "    if all_counts is None:\n",
    "        counts_flag = False\n",
    "        all_counts = []\n",
    "    else:\n",
    "        counts_flag = True\n",
    "\n",
    "    if debug is True:\n",
    "        print(f\"{nr_jobs} to process\")\n",
    "    if len(all_counts) == 0:\n",
    "        for j in range(nr_jobs):\n",
    "            job = service.job(job_ids[j])\n",
    "\n",
    "            if str(job.status()) == \"JobStatus.DONE\":\n",
    "                if display is True:\n",
    "                    print(\n",
    "                        f\"Retrieving job data: {job_ids[j]}: {j} of {nr_jobs-1}\"\n",
    "                    )\n",
    "                result = job.result()\n",
    "                for i in range(len(result)):\n",
    "                    counts = get_counts_from_bitarray(result[i].data)\n",
    "                    # if post_process=='post_process_postproc' or post_process == 'post_process_dyn':\n",
    "                    #     counts = result[i].data.cr.get_counts()\n",
    "                    # else:\n",
    "                    #     counts = result[i].data.cr.get_counts()\n",
    "                    all_counts.append(counts)\n",
    "\n",
    "            else:\n",
    "                print(\n",
    "                    f\"Warning: Job id : {job_ids[j]} returned status of {job.status()} : Adding empty dictionaries\"\n",
    "                )\n",
    "                all_counts += [empty_counts] * num_circuits_per_job\n",
    "            if debug is False:\n",
    "                clear_output(wait=True)\n",
    "    else:\n",
    "        print(\"Using provided all_counts data instead of loading from server\")\n",
    "        print(all_counts)\n",
    "\n",
    "    for n in range(min_qubits, max_qubits + 1):\n",
    "        if display is True:\n",
    "            print(\n",
    "                f\"Resampling counts for n = {n}: {max_qubits + 1 - n} remaining\"\n",
    "            )\n",
    "        counts = all_counts[\n",
    "            (n - min_qubits) * 4 * num_samples : (n - min_qubits + 1)\n",
    "            * 4\n",
    "            * num_samples\n",
    "        ]\n",
    "        proc_fid_temp = []\n",
    "\n",
    "        for _ in range(n_bootstrap_sample):\n",
    "            resample_counts = resample_dict_list(counts, 1)[0]\n",
    "            sample_fidelities = process_fidelities(\n",
    "                resample_counts, samples, shots, post_process\n",
    "            )\n",
    "            proc_fid_temp.append(np.mean(sample_fidelities))\n",
    "\n",
    "        mean, std = (\n",
    "            np.mean(np.array(proc_fid_temp)),\n",
    "            np.std(np.array(proc_fid_temp)),\n",
    "        )\n",
    "        proc_fidelities.append(mean)\n",
    "        proc_std.append(std)\n",
    "        if debug is False:\n",
    "            clear_output(wait=True)\n",
    "\n",
    "    if display is True:\n",
    "        print(\"Process fidelities:\")\n",
    "        print([\"{0:0.3f}\".format(i) for i in proc_fidelities])\n",
    "        print(\"Process fidelities std:\")\n",
    "        print([\"{0:0.3f}\".format(i) for i in proc_std])\n",
    "\n",
    "    # Calculate average gate fidelity from the process fidelity\n",
    "\n",
    "    avg_gate_fidelities = []\n",
    "\n",
    "    for i in range(len(proc_fidelities)):\n",
    "        # Use result of Horodecki et al. to calculate the average gate fidelity\n",
    "        avg_gate_fidelity = (proc_fidelities[i] * 4 + 1) / 5\n",
    "        avg_gate_fidelities.append(avg_gate_fidelity)\n",
    "\n",
    "    if display is True:\n",
    "        print(\"Average Gate Fidelites\")\n",
    "        print([\"{0:0.3f}\".format(i) for i in avg_gate_fidelities])\n",
    "\n",
    "    # Calculate average gate fidelity std from the process fidelity std\n",
    "\n",
    "    avg_gate_stds = []\n",
    "\n",
    "    for i in range(len(proc_std)):\n",
    "        # We scale the std as in the average gate fidelity\n",
    "        avg_gate_std = (proc_std[i] * 4) / 5\n",
    "        avg_gate_stds.append(avg_gate_std)\n",
    "\n",
    "    if display is True:\n",
    "        print(\"Average Gate Std\")\n",
    "        print([\"{0:0.3f}\".format(i) for i in avg_gate_stds])\n",
    "\n",
    "    if counts_flag is True:\n",
    "        return (avg_gate_fidelities, avg_gate_stds, all_counts)\n",
    "    else:\n",
    "        return (avg_gate_fidelities, avg_gate_stds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "12c9ef74-1c91-4e69-a22d-326d8db1a192",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process fidelities:\n",
      "['0.873', '0.516', '0.372', '0.413', '0.431', '0.487', '0.332', '0.448', '0.341', '0.157', '0.300', '0.336', '0.296', '0.335', '0.269', '0.256', '0.252', '0.273', '0.189', '0.284', '0.229', '0.273', '0.236', '0.144', '0.214', '0.257', '0.199', '0.266', '0.215', '0.257', '0.211', '0.235', '0.202', '0.215', '0.234', '0.235', '0.198', '0.169', '0.182', '0.208', '0.202', '0.210', '0.177', '0.191', '0.129', '0.135', '0.193', '0.207', '0.196', '0.175', '0.194', '0.201', '0.177', '0.195', '0.166', '0.160', '0.156', '0.150', '0.156', '0.184', '0.191', '0.178', '0.174', '0.131']\n",
      "Process fidelities std:\n",
      "['0.002', '0.002', '0.001', '0.004', '0.004', '0.004', '0.005', '0.003', '0.004', '0.002', '0.005', '0.005', '0.004', '0.003', '0.003', '0.004', '0.005', '0.001', '0.003', '0.004', '0.005', '0.003', '0.003', '0.001', '0.003', '0.002', '0.002', '0.004', '0.004', '0.003', '0.002', '0.003', '0.000', '0.003', '0.003', '0.001', '0.001', '0.003', '0.005', '0.003', '0.003', '0.002', '0.004', '0.002', '0.001', '0.003', '0.005', '0.002', '0.001', '0.001', '0.001', '0.002', '0.001', '0.003', '0.002', '0.003', '0.003', '0.002', '0.004', '0.004', '0.003', '0.001', '0.004', '0.001']\n",
      "Average Gate Fidelites\n",
      "['0.898', '0.613', '0.497', '0.531', '0.545', '0.590', '0.465', '0.559', '0.473', '0.326', '0.440', '0.469', '0.437', '0.468', '0.415', '0.405', '0.402', '0.419', '0.351', '0.427', '0.383', '0.418', '0.389', '0.316', '0.371', '0.406', '0.359', '0.413', '0.372', '0.406', '0.369', '0.388', '0.362', '0.372', '0.387', '0.388', '0.359', '0.335', '0.345', '0.366', '0.362', '0.368', '0.342', '0.353', '0.303', '0.308', '0.354', '0.366', '0.357', '0.340', '0.355', '0.361', '0.342', '0.356', '0.333', '0.328', '0.325', '0.320', '0.324', '0.347', '0.353', '0.343', '0.339', '0.305']\n",
      "Average Gate Std\n",
      "['0.001', '0.002', '0.001', '0.003', '0.004', '0.004', '0.004', '0.002', '0.003', '0.002', '0.004', '0.004', '0.003', '0.002', '0.002', '0.003', '0.004', '0.001', '0.003', '0.003', '0.004', '0.003', '0.002', '0.001', '0.003', '0.001', '0.002', '0.003', '0.003', '0.002', '0.002', '0.003', '0.000', '0.002', '0.002', '0.001', '0.001', '0.002', '0.004', '0.003', '0.002', '0.001', '0.003', '0.001', '0.001', '0.003', '0.004', '0.002', '0.001', '0.001', '0.001', '0.001', '0.001', '0.002', '0.001', '0.002', '0.002', '0.002', '0.003', '0.003', '0.002', '0.001', '0.004', '0.001']\n"
     ]
    }
   ],
   "source": [
    "# No post processing of the counts is required in the Unitary circuits. The average gate fidelities can now be calculated:\n",
    "avg_gate_fidelities_uni, avg_gate_stds_uni = cal_average_fidelities(\n",
    "    job_ids_uni,\n",
    "    MIN_NUMBER_QUBITS_UNI,\n",
    "    MAX_NUMBER_QUBITS_UNI,\n",
    "    SAMPLES_UNI,\n",
    "    SHOTS_UNI,\n",
    "    NUM_CIRCUITS_PER_JOB_UNI,\n",
    ")\n",
    "\n",
    "\n",
    "avg_gate_fidelities_postproc, avg_gate_stds_postproc = cal_average_fidelities(\n",
    "    job_ids_postproc,\n",
    "    MIN_NUMBER_QUBITS_POSTPROC,\n",
    "    MAX_NUMBER_QUBITS_POSTPROC,\n",
    "    SAMPLES_POSTPROC,\n",
    "    SHOTS_POSTPROC,\n",
    "    NUM_CIRCUITS_PER_JOB_POSTPROC,\n",
    "    post_process=post_process_postproc,\n",
    ")\n",
    "\n",
    "\n",
    "avg_gate_fidelities_dyn, avg_gate_stds_dyn = cal_average_fidelities(\n",
    "    job_ids_dyn,\n",
    "    MIN_NUMBER_QUBITS_DYN,\n",
    "    MAX_NUMBER_QUBITS_DYN,\n",
    "    SAMPLES_DYN,\n",
    "    SHOTS_DYN,\n",
    "    NUM_CIRCUITS_PER_JOB_DYN,\n",
    "    post_process=post_process_dyn,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "982f8e1b-5cd8-440f-af89-8b81eed1a15d",
   "metadata": {},
   "source": [
    "### Plot the results\n",
    "To appreciate the results visually, the cell below plots the estimated gate fidelities measured at varying distance between entangled qubits for the three different methods. In general, the fidelity will decrease with increasing distance. The results show that although the unitary method (using SWAPs to implement a long-range entangling interaction) performs better at short distances, there is a cross-over to a regime where dynamic circuits become a better option. This is true for both the measurement-and-feedforward technique as well as the post-processing one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0400e350",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.errorbar(\n",
    "    range(MIN_NUMBER_QUBITS_UNI, MAX_NUMBER_QUBITS_UNI + 1),\n",
    "    avg_gate_fidelities_uni,\n",
    "    avg_gate_stds_uni,\n",
    "    fmt=\"o-.\",\n",
    "    color=\"c\",\n",
    "    label=\"Unitary\",\n",
    ")\n",
    "ax.errorbar(\n",
    "    range(MIN_NUMBER_QUBITS_UNI, MAX_NUMBER_QUBITS_UNI + 1),\n",
    "    avg_gate_fidelities_postproc,\n",
    "    avg_gate_stds_postproc,\n",
    "    fmt=\"o-.\",\n",
    "    color=\"y\",\n",
    "    label=\"Post-processing\",\n",
    ")\n",
    "ax.errorbar(\n",
    "    range(MIN_NUMBER_QUBITS_UNI, MAX_NUMBER_QUBITS_UNI + 1),\n",
    "    avg_gate_fidelities_dyn,\n",
    "    avg_gate_stds_dyn,\n",
    "    fmt=\"o-.\",\n",
    "    color=\"m\",\n",
    "    label=\"Dynamic\",\n",
    ")\n",
    "ax.axhline(y=1 / 4, color=\"g\", linestyle=\"--\", label=\"Random gate\")\n",
    "legend = ax.legend(frameon=True)\n",
    "for text in legend.get_texts():\n",
    "    text.set_color(\"black\")  # Set the legend text color to black\n",
    "legend.get_frame().set_facecolor(\n",
    "    \"white\"\n",
    ")  # Set the legend background color to white\n",
    "legend.get_frame().set_edgecolor(\n",
    "    \"black\"\n",
    ")  # Optional: set the legend border color to black\n",
    "ax.set_xlabel(\"Number of qubits between control and target\", color=\"black\")\n",
    "ax.set_ylabel(\"Teleported gate fidelity\", color=\"black\")\n",
    "ax.grid(linestyle=\":\", linewidth=0.6, alpha=0.4, color=\"gray\")\n",
    "ax.set_ylim((0.2, 1))\n",
    "ax.set_facecolor(\"white\")  # Set the background color of the axes\n",
    "fig.patch.set_facecolor(\"white\")  # Set the background color of the figure\n",
    "\n",
    "# Ensure the axis lines and ticks are visible\n",
    "for spine in ax.spines.values():\n",
    "    spine.set_visible(True)\n",
    "    spine.set_color(\"black\")  # Set the color of the axis lines to black\n",
    "ax.tick_params(axis=\"x\", colors=\"black\")\n",
    "ax.tick_params(axis=\"y\", colors=\"black\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1ffc24",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### Data from the paper\n",
    "\n",
    "The results from this tutorial are likely to vary from the results of the paper due to different calibrations and machines used. The code presented above also uses a slightly different method to calculate parities than was used in the paper, as well as some other differences to make the notebook cleaner and more accessible to a wider audience."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8a3adfa1-7fa1-4632-be7f-a316c26c844d",
   "metadata": {
    "hidden": true
   },
   "source": [
    "#### Plot from Paper\n",
    "\n",
    "![Plot of teleported gate fidelity against the number of qubits.](/images/tutorials/long-range-entanglement-with-limited-qubit-connectivity/paper-plot.avif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "804dcf16-7a26-477d-b9eb-34e383fc983d",
   "metadata": {},
   "source": [
    "## Appendix: Calculating the average fidelity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e8a1f4-64f7-431a-a188-789590ab2357",
   "metadata": {},
   "source": [
    "The *fidelity* [2] of two states $\\rho$ and $\\sigma$ is defined by\n",
    "\n",
    "$$\\mathcal{F}(\\rho,\\sigma) = \\mathrm{Tr}\\left(\\sqrt{\\sqrt{\\rho}\\sigma\\sqrt{\\rho}} \\right)^2$$\n",
    "\n",
    "If one of $\\rho$ or $\\sigma$ is a pure state then this reduces to $\\mathcal{F}(\\rho,\\sigma)=\\mathrm{Tr}(\\rho\\sigma)$.\n",
    "*Gate fidelity* is a tool for comparing how well the implemented quantum channel $\\xi$ approximates the desired unitary channel $\\mathcal{U}(\\rho) = U\\rho{U^\\dagger}$. Gate fidelity is a function defined on pure states as follows:\n",
    "\n",
    "$$\n",
    "\\mathcal{F}_{\\xi,\\mathcal{U}}(|\\phi\\rangle) := \\mathcal{F}\\bigl(\\xi(|\\phi\\rangle\\langle\\phi|), \\mathcal{U}(|\\phi\\rangle\\langle\\phi|)\\bigl)\n",
    "= \\langle\\phi|(\\mathcal{U}^\\dagger\\circ\\xi)(|\\phi\\rangle\\langle\\phi|)|\\phi\\rangle\n",
    ":= \\mathcal{F}_{\\mathcal{U}^\\dagger\\circ\\xi}(|\\phi\\rangle).\n",
    "$$\n",
    "\n",
    "Here $\\mathcal{F}_{\\mathcal{U}^\\dagger\\circ\\xi}$ can be thought of as measuring how noisy the channel $\\mathcal{U}^\\dagger\\circ\\xi$ is. The average gate fidelity of a channel $\\mathcal{U}^\\dagger\\circ\\xi$ is defined by averaging the gate fidelity via the induced haar measure (the Fubini-Stufy meaure):\n",
    "\n",
    "$$\\mathcal{F}_{avg}(\\mathcal{U},\\xi):=\\mathcal{F}_{avg}(\\mathcal{U}^\\dagger\\circ\\xi) := \\int\\langle\\phi|(\\mathcal{U}^\\dagger\\circ\\xi)(|\\phi\\rangle\\langle\\phi|)|\\phi\\rangle d\\phi$$\n",
    "\n",
    "To calculate the average gate fidelity of the channel $\\mathcal{U}^\\dagger\\circ\\xi$ we use a result of Horodecki et al. [3] which relates the average gate fidelity to the entanglement fedilty of a channel. The entanglement fidelity of the channel $\\mathcal{U}^\\dagger\\circ\\xi$ is defined as\n",
    "\n",
    "$$\n",
    "\\mathcal{F}_{ent}(\\mathcal{U}^\\dagger\\circ\\xi) := \\mathcal{F}_{ent}(\\rho_{\\mathcal{U}^\\dagger\\circ\\xi}) :=\\langle\\psi_+|\\rho_{\\mathcal{U}^\\dagger\\circ\\xi}|\\psi_+\\rangle = \\mathrm{Tr}(\\mathcal{U}^\\dagger\\circ\\xi)/d^2.\n",
    "$$\n",
    "\n",
    "where $\\rho_{\\mathcal{U}^\\dagger\\circ\\xi}$ is the density operator obtained from the channel $\\mathcal{U}^\\dagger\\circ\\xi$ via the Choi-Jamoiłkawski isomorphism\n",
    "\n",
    "$$\n",
    "\\rho_{\\mathcal{U}^\\dagger\\circ\\xi} = \\bigl(I\\otimes(\\mathcal{U}^\\dagger\\circ\\xi)\\bigr)(|\\psi_+\\rangle\\langle\\psi_+|)\n",
    "$$\n",
    "\n",
    "and where $|\\psi_+\\rangle$ is the maximally entangle state\n",
    "\n",
    "$$\n",
    "|\\psi_+\\rangle = \\frac{1}{\\sqrt{d}}\\sum_{i=0}^{d-1}|i\\rangle \\otimes |i\\rangle.\n",
    "$$\n",
    "In our specific situation, where $\\mathcal{U}$ is a unitary channel, the entanglement fidelity of $\\mathcal{U}^\\dagger\\circ\\xi$ can be written in terms of the *process fidelity* of the two Choi states $\\rho_\\mathcal{U}$ and $\\rho_{\\xi}$ as follows:\n",
    "$$\n",
    "\\mathcal{F}_{ent}(\\mathcal{U}^\\dagger\\circ\\xi) = \\mathcal{F}_{proc}(\\rho_\\mathcal{U}, \\rho_{\\xi}) := \\mathcal{F}(\\rho_\\mathcal{U}, \\rho_{\\xi})\n",
    "$$\n",
    "and so we see via Proposition 1 of Horodecki et al. [3]  that\n",
    "$$\n",
    "\\mathcal{F}_{avg}(\\mathcal{U},\\xi) = \\mathcal{F}_{avg}(\\mathcal{U}^\\dagger\\circ\\xi) = \\frac{d\\mathcal{F}_{ent}(\\mathcal{U}^\\dagger\\circ\\xi) + 1}{d+1} = \\frac{d\\mathcal{F}(\\rho_\\mathcal{U}, \\rho_{\\xi}) +1}{d+1}\n",
    "$$\n",
    "Calculating the process fidelity between two states can now be achieved via Monte Carlo state certification.\n",
    "\n",
    "As per [4] a direct implementation of the quantum Monte Carlo state certification would\n",
    "prepare a maximally entangled state $|\\psi_+\\rangle$, apply $\\xi$ to half of\n",
    "the system, and then measure random Pauli operators on all\n",
    "qubits. A more practical approach consists of preparing the\n",
    "complex conjugate of random product of eigenstates of local\n",
    "Pauli operators (corresponding to the resulting state after half\n",
    "of the entangled state is measured destructively), applying the\n",
    "transformation $\\xi$ to the system, and finally measuring a random Pauli operator on each qubit. This can be seen from the following equality:\n",
    "\n",
    "$$\n",
    "\\mathrm{Tr}\\bigl[(P_i\\otimes P_j\\otimes P_k\\otimes P_l)(I\\otimes\\xi)(|\\psi_+\\rangle\\langle\\psi_+|)\\bigr]\n",
    "= \\frac{1}{d}\\mathrm{Tr}\\bigl[(P_k\\otimes P_l)\\cdot \\xi(P_i^*\\otimes P_j^*)\\bigl]\n",
    "$$\n",
    "\n",
    "The following three experiments use the modified and simplified version of Monte Carlo state certification combined with the relations derived above to calculate the average gate fidelity of the channel $\\xi$. For more details see [1] and associated references."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3809ec3-742c-4388-b0c1-7fec552c248b",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] Efficient Long-Range Entanglement using Dynamic Circuits, by\n",
    "*Elisa Bäumer, Vinay Tripathi, Derek S. Wang, Patrick Rall, Edward H. Chen, Swarnadeep Majumder, Alireza Seif, Zlatko K. Minev*. IBM Quantum, (2023).\n",
    "https://arxiv.org/abs/2308.13065\n",
    "\n",
    "[2] Quantum Computation and Quantum Information, by *Nielsen and Chuang*, Section 9.2.2, (2010)\n",
    "\n",
    "[3] General teleportation channel, singlet fraction, and quasidistillation, by *M. Horodecki, P. Horodecki, and R. Horodecki*, Phys. Rev. A 60, 1888 (1999).\n",
    "\n",
    "[4] Practical characterization of quantum devices without tomography, by *M. P. da Silva, O. Landon-Cardinal, and D. Poulin*, Phys. Rev. Lett. 107, 210404 (2011)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf40bed3",
   "metadata": {},
   "source": [
    "## Tutorial survey\n",
    "\n",
    "Please take one minute to provide feedback on this tutorial. Your insights will help us improve our content offerings and user experience.\n",
    "\n",
    "[Link to survey](https://your.feedback.ibm.com/jfe/form/SV_5nJZASV7wzDVLF4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae395952",
   "metadata": {},
   "source": [
    "© IBM Corp. 2024"
   ]
  }
 ],
 "metadata": {
  "description": "This tutorial shows three different ways that can be used to generate long-range entanglement between qubits on a line, at varying distances between each other.",
  "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"
  },
  "platform": "cloud",
  "title": "Long-range entanglement with limited qubit connectivity"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}