qiskit/ignis/interleaved_rb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\\\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interleaved Randomized Benchmarking\n",
    "---\n",
    "\n",
    "* **Last Updated:** June 12, 2019\n",
    "* **Requires:** qiskit-terra 0.8, qiskit-ignis 0.1.2, qiskit-aer 0.2\n",
    "\n",
    "\n",
    "## Introduction\n",
    "\n",
    "**Interleved Randomized Benhcmaking** is a variant of the Randomized Benchmarking (RB) method that is used for benchmarking individual Clifford gates via randomization. The protocol consists of interleaving random gates between the given Clifford gate of interest. The protocol estimates the gate error of the given Clifford. \n",
    "The method is based on the paper *\"Efficient measurement of quantum gate error by interleaved randomized benchmarking\"*(https://arxiv.org/abs/1203.4550).\n",
    "\n",
    "This notebook gives an example for how to use the ``ignis.verification.randomized_benchmarking`` module in order to perform interleaved RB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Import general libraries (needed for functions)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython import display\n",
    "\n",
    "#Import the RB Functions\n",
    "import qiskit.ignis.verification.randomized_benchmarking as rb\n",
    "\n",
    "#Import Qiskit classes classes\n",
    "import qiskit\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Select the Parameters of the Interleaved RB Run\n",
    "\n",
    "First, wee need to choose the regular RB parameters:\n",
    "\n",
    "- **nseeds:** The number of seeds. For each seed there you will get a separate list of output circuits in rb_circs.\n",
    "- **length_vector:** The length vector of Clifford lengths. Must be in ascending order. RB sequences of increasing length grow on top of the previous sequences.\n",
    "- **rb_pattern:** A list of the form [[i,j],[k],...] which will make simultaneous RB sequences where Qi,Qj are a 2-qubit RB sequence and Qk is a 1-qubit sequence, etc. The number of qubits is the sum of the entries. For 'regular' RB the qubit_pattern is just [[0]],[[0,1]].\n",
    "- **length_multiplier:** If this is an array it scales each rb_sequence by the multiplier.\n",
    "- **seed_offset:** What to start the seeds at (e.g. if we want to add more seeds later)\n",
    "- **align_cliffs:**  If true adds a barrier across all qubits in rb_pattern after each set of cliffords \n",
    "\n",
    "As well as another parameter for interleaved RB:\n",
    "- **interleaved_gates:** A list of gates of Clifford elements that will be interleaved. The length of the list would equal the length of the rb_pattern.\n",
    "\n",
    "In this example we have 3 qubits Q0,Q1,Q2. \n",
    "We are running 2Q RB (on qubits Q0,Q2) and 1Q RB (on qubit Q1) simultaneously, \n",
    "where there are twice as many 1Q Clifford gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Number of qubits\n",
    "nQ = 3\n",
    "#There are 3 qubits: Q0,Q1,Q2.\n",
    "#Number of seeds (random sequences)\n",
    "nseeds = 5\n",
    "#Number of Cliffords in the sequence (start, stop, steps)\n",
    "nCliffs = np.arange(1,200,20)\n",
    "#2Q RB on Q0,Q2 and 1Q RB on Q1\n",
    "rb_pattern = [[0,2],[1]]\n",
    "#Do three times as many 1Q Cliffords\n",
    "length_multiplier = [1,3]\n",
    "#Interleaved Clifford gates (2-qubits and 1-qubit)\n",
    "interleaved_gates = [['h 0', 'cx 0 1'],['x 0']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Interleaved RB sequences\n",
    "\n",
    "We generate RB sequences. We start with a small example (so it doesn't take too long to run).\n",
    "\n",
    "In order to generate the RB sequences **rb_circs**, which is a list of lists of quantum circuits, \n",
    "we run the function **rb.randomized_benchmarking_seq**.\n",
    "\n",
    "This function returns:\n",
    "\n",
    "- **rb_original_circs:** A list of lists of circuits for the original rb sequences (separate list for each seed).\n",
    "- **xdata:** The Clifford lengths (with multiplier if applicable).\n",
    "- **rb_opts_dict:** Option dictionary back out with default options appended.\n",
    "\n",
    "As well as:\n",
    "- **rb_interleaved_circs**: A list of lists of circuits for the interleaved rb sequences (separate list for each seed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rb_opts = {}\n",
    "rb_opts['length_vector'] = nCliffs\n",
    "rb_opts['nseeds'] = nseeds\n",
    "rb_opts['rb_pattern'] = rb_pattern\n",
    "rb_opts['length_multiplier'] = length_multiplier\n",
    "#rb_opts['align_cliffs'] = True\n",
    "rb_opts['interleaved_gates'] = interleaved_gates\n",
    "rb_original_circs, xdata, rb_interleaved_circs = rb.randomized_benchmarking_seq(**rb_opts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, we print the circuit corresponding to the first original and interleaved RB sequences:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          ┌───┐ ┌─────┐┌───┐        ┌───┐     ┌─────┐┌───┐┌───┐ ░     ┌───┐ »\n",
      "qr_0: |0>─┤ H ├─┤ Sdg ├┤ H ├──■─────┤ X ├─────┤ Sdg ├┤ H ├┤ Y ├─░─────┤ Y ├─»\n",
      "          ├───┤ └┬───┬┘├───┤  │   ░ └─┬─┘┌───┐└┬───┬┘├───┤├───┤ ░  ░ ┌┴───┴┐»\n",
      "qr_1: |0>─┤ H ├──┤ S ├─┤ Y ├──┼───░───┼──┤ H ├─┤ H ├─┤ S ├┤ Z ├────░─┤ Sdg ├»\n",
      "         ┌┴───┴┐ ├───┤ └───┘┌─┴─┐ ░   │  └───┘ ├───┤ ├───┤├───┤ ░  ░ └┬───┬┘»\n",
      "qr_2: |0>┤ Sdg ├─┤ H ├──────┤ X ├─────■────────┤ H ├─┤ S ├┤ X ├─░─────┤ X ├─»\n",
      "         └─────┘ └───┘      └───┘              └───┘ └───┘└───┘ ░     └───┘ »\n",
      " cr_0: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      " cr_1: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      " cr_2: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      "«       ┌───┐ ┌───┐┌───┐               ┌───┐┌───┐      ┌───┐┌─┐\n",
      "«qr_0: ─┤ H ├─┤ S ├┤ X ├───────■───────┤ H ├┤ S ├──────┤ H ├┤M├\n",
      "«       ├───┤ └─░─┘└─┬─┘┌───┐  │  ┌───┐├───┤├───┤   ┌─┐└───┘└╥┘\n",
      "«qr_1: ─┤ H ├───░────┼──┤ Y ├──┼──┤ H ├┤ S ├┤ H ├───┤M├──────╫─\n",
      "«      ┌┴───┴┐┌───┐  │  └───┘┌─┴─┐└───┘├───┤├───┤┌─┐└╥┘      ║ \n",
      "«qr_2: ┤ Sdg ├┤ H ├──■───────┤ X ├─────┤ H ├┤ S ├┤M├─╫───────╫─\n",
      "«      └─────┘└───┘          └───┘     └───┘└───┘└╥┘ ║       ║ \n",
      "«cr_0: ═══════════════════════════════════════════╬══╬═══════╩═\n",
      "«                                                 ║  ║         \n",
      "«cr_1: ═══════════════════════════════════════════╩══╬═════════\n",
      "«                                                    ║         \n",
      "«cr_2: ══════════════════════════════════════════════╩═════════\n",
      "«                                                              \n"
     ]
    }
   ],
   "source": [
    "#Original RB circuits\n",
    "print (rb_original_circs[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          ┌───┐ ┌─────┐┌───┐        ┌───┐     ┌─────┐┌───┐┌───┐ ░      ┌───┐»\n",
      "qr_0: |0>─┤ H ├─┤ Sdg ├┤ H ├──■─────┤ X ├─────┤ Sdg ├┤ H ├┤ Y ├─░──────┤ H ├»\n",
      "          ├───┤ └┬───┬┘├───┤  │   ░ └─┬─┘┌───┐└──░──┘├───┤├───┤ ░ ┌───┐├───┤»\n",
      "qr_1: |0>─┤ H ├──┤ S ├─┤ Y ├──┼───░───┼──┤ X ├───░───┤ H ├┤ H ├───┤ S ├┤ Z ├»\n",
      "         ┌┴───┴┐ ├───┤ └───┘┌─┴─┐ ░   │  └───┘ ┌───┐ ├───┤├───┤ ░ └───┘└───┘»\n",
      "qr_2: |0>┤ Sdg ├─┤ H ├──────┤ X ├─────■────────┤ H ├─┤ S ├┤ X ├─░───────────»\n",
      "         └─────┘ └───┘      └───┘              └───┘ └───┘└───┘ ░           »\n",
      " cr_0: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      " cr_1: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      " cr_2: 0 ═══════════════════════════════════════════════════════════════════»\n",
      "                                                                            »\n",
      "«               ░      ┌───┐       ┌───┐             ┌─────┐┌───┐┌───┐┌─┐     »\n",
      "«qr_0: ──■──────░──────┤ X ├───────┤ X ├───────■─────┤ Sdg ├┤ H ├┤ H ├┤M├─────»\n",
      "«        │   ░  ░ ┌───┐└─░─┘┌─────┐└─┬─┘┌───┐  │   ░ └┬───┬┘└─░─┘├───┤└╥┘┌───┐»\n",
      "«qr_1: ──┼───░────┤ X ├──░──┤ Sdg ├──┼──┤ H ├──┼───░──┤ X ├───░──┤ Y ├─╫─┤ H ├»\n",
      "«      ┌─┴─┐ ░  ░ └───┘┌───┐└┬───┬┘  │  └───┘┌─┴─┐ ░  ├───┤ ┌───┐└┬─┬┘ ║ └───┘»\n",
      "«qr_2: ┤ X ├────░──────┤ H ├─┤ S ├───■───────┤ X ├────┤ H ├─┤ S ├─┤M├──╫──────»\n",
      "«      └───┘    ░      └───┘ └───┘           └───┘    └───┘ └───┘ └╥┘  ║      »\n",
      "«cr_0: ════════════════════════════════════════════════════════════╬═══╩══════»\n",
      "«                                                                  ║          »\n",
      "«cr_1: ════════════════════════════════════════════════════════════╩══════════»\n",
      "«                                                                             »\n",
      "«cr_2: ═══════════════════════════════════════════════════════════════════════»\n",
      "«                                                                             »\n",
      "«                   \n",
      "«qr_0: ─────────────\n",
      "«      ┌───┐┌───┐┌─┐\n",
      "«qr_1: ┤ S ├┤ H ├┤M├\n",
      "«      └───┘└───┘└╥┘\n",
      "«qr_2: ───────────╫─\n",
      "«                 ║ \n",
      "«cr_0: ═══════════╬═\n",
      "«                 ║ \n",
      "«cr_1: ═══════════╬═\n",
      "«                 ║ \n",
      "«cr_2: ═══════════╩═\n",
      "«                   \n"
     ]
    }
   ],
   "source": [
    "#Interleaved RB circuits\n",
    "print (rb_interleaved_circs[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the noise model\n",
    "\n",
    "We define a noise model for the simulator. To simulate decay, we add depolarizing error probabilities to the CNOT and U gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_model = NoiseModel()\n",
    "p1Q = 0.002\n",
    "p2Q = 0.01\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(p1Q, 1), 'u2')\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(2*p1Q, 1), 'u3')\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(p2Q, 2), 'cx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can execute the original and interleaved RB sequences either using Qiskit Aer Simulator (with some noise model) or using IBMQ provider, and obtain a list of results result_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling seed 0\n",
      "Simulating seed 0\n",
      "Compiling seed 1\n",
      "Simulating seed 1\n",
      "Compiling seed 2\n",
      "Simulating seed 2\n",
      "Compiling seed 3\n",
      "Simulating seed 3\n",
      "Compiling seed 4\n",
      "Simulating seed 4\n",
      "Finished Simulating Original Circuits\n"
     ]
    }
   ],
   "source": [
    "#Original RB circuits\n",
    "backend = qiskit.Aer.get_backend('qasm_simulator')\n",
    "basis_gates = ['u1','u2','u3','cx'] # use U,CX for now\n",
    "shots = 200\n",
    "original_result_list = []\n",
    "original_qobj_list = []\n",
    "import time\n",
    "for rb_seed,rb_circ_seed in enumerate(rb_original_circs):\n",
    "    print('Compiling seed %d'%rb_seed)\n",
    "    new_rb_circ_seed = qiskit.compiler.transpile(rb_circ_seed, basis_gates=basis_gates)\n",
    "    qobj = qiskit.compiler.assemble(new_rb_circ_seed, shots=shots)\n",
    "    print('Simulating seed %d'%rb_seed)\n",
    "    job = backend.run(qobj, noise_model=noise_model, backend_options={'max_parallel_experiments': 0})\n",
    "    original_result_list.append(job.result())\n",
    "    original_qobj_list.append(qobj)    \n",
    "print(\"Finished Simulating Original Circuits\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling seed 0\n",
      "Simulating seed 0\n",
      "Compiling seed 1\n",
      "Simulating seed 1\n",
      "Compiling seed 2\n",
      "Simulating seed 2\n",
      "Compiling seed 3\n",
      "Simulating seed 3\n",
      "Compiling seed 4\n",
      "Simulating seed 4\n",
      "Finished Simulating Interleaved Circuits\n"
     ]
    }
   ],
   "source": [
    "#Interleaved RB circuits\n",
    "backend = qiskit.Aer.get_backend('qasm_simulator')\n",
    "basis_gates = ['u1','u2','u3','cx'] # use U,CX for now\n",
    "shots = 200\n",
    "interleaved_result_list = []\n",
    "interleaved_qobj_list = []\n",
    "import time\n",
    "for rb_seed,rb_circ_seed in enumerate(rb_interleaved_circs):\n",
    "    print('Compiling seed %d'%rb_seed)\n",
    "    new_rb_circ_seed = qiskit.compiler.transpile(rb_circ_seed, basis_gates=basis_gates)\n",
    "    qobj = qiskit.compiler.assemble(new_rb_circ_seed, shots=shots)\n",
    "    print('Simulating seed %d'%rb_seed)\n",
    "    job = backend.run(qobj, noise_model=noise_model, backend_options={'max_parallel_experiments': 0})\n",
    "    interleaved_result_list.append(job.result())\n",
    "    interleaved_qobj_list.append(qobj)    \n",
    "print(\"Finished Simulating Interleaved Circuits\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the results\n",
    "\n",
    "We fit the results of the original RB circuits and the interleaved RB circuits into an exponentially decaying function and obtain the Errors per Clifford $\\alpha$ and $\\alpha_C$ of the original and interleaved sequences respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Create the original and interleaved RB fitter\n",
    "original_rb_fit = rb.RBFitter(original_result_list, xdata, rb_opts['rb_pattern'])\n",
    "interleaved_rb_fit = rb.RBFitter(interleaved_result_list, xdata, rb_opts['rb_pattern'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the interleaved gate error fidelity\n",
    "\n",
    "From the values of $\\alpha$ and $\\alpha_C$ we obtain the gate error of the interleaved Clifford $c$, and $r_C=1-$(average gate fidelity of the interleaved Clifford $C$), is estimated by:\n",
    "$$ EPC^{est} = r_C^{est} = \\frac{(2^n-1)(1-\\alpha_C/\\alpha)}{2^n}$$\n",
    "and must lie in the range given by certain systematic error bounds: \n",
    "$$[r_C^{est}-E,r_C^{est}+E]$$ \n",
    "for each of the patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate the joint fitter\n",
    "joint_rb_fit = rb.InterleavedRBFitter(original_result_list, interleaved_result_list, xdata, rb_opts['rb_pattern'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pattern: 0 - 2 qubit interleaved RB: {'alpha': 0.9766373691786432, 'alpha_err': 0.0015825080898092354, 'alpha_c': 0.9640070368767524, 'alpha_c_err': 0.0005456186923444421, 'epc_est': 0.009699351596984984, 'epc_est_err': 0.0012706295631885306, 'systematic_err': 0.025344594635050233, 'systematic_err_L': -0.01564524303806525, 'systematic_err_R': 0.03504394623203522}\n",
      "pattern: 1 - 1 qubit interleaved RB: {'alpha': 0.9960251435019465, 'alpha_err': 0.0003669407547404784, 'alpha_c': 0.9913473590240941, 'alpha_c_err': 0.00039220779755112816, 'epc_est': 0.002348226100701456, 'epc_est_err': 0.0002690295801775469, 'systematic_err': 0.002348226100701456, 'systematic_err_L': 0.0, 'systematic_err_R': 0.004696452201402912}\n"
     ]
    }
   ],
   "source": [
    "#Print the joint fitter parameters\n",
    "for patt_ind, pattern in enumerate(rb_pattern):\n",
    "    print ('pattern:', patt_ind, '-', len(pattern), 'qubit interleaved RB:', joint_rb_fit.fit_int[patt_ind])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot the joint RB data\n",
    "plt.figure(figsize=(15, 6))\n",
    "\n",
    "for i in range(2):\n",
    "    ax = plt.subplot(1, 2, i+1)\n",
    "    pattern_ind = i\n",
    "\n",
    "    # Plot the essence by calling plot_rb_data\n",
    "    joint_rb_fit.plot_rb_data(pattern_ind, ax=ax, add_label=True, show_plt=False)\n",
    "\n",
    "    # Add title and label\n",
    "    ax.set_title('%d Qubit interleaved RB'%(len(rb_opts['rb_pattern'][i])), fontsize=18)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}