Move ignis files to tutorials (#551)

Author: dcmckayibm

community/ignis/RB_overview.ipynb

@@ -0,0 +1,348 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Randomized Benchmarking Overview\n",
+    "\n",
+    "### Contributors\n",
+    "\n",
+    "Shelly Garion$^{1}$, Yael Ben-Haim$^{2}$ and David McKay$^{2}$\n",
+    "\n",
+    "1. IBM Research Haifa, Haifa University Campus, Mount Carmel Haifa, Israel\n",
+    "2. IBM T.J. Watson Research Center, Yorktown Heights, NY, USA\n",
+    "\n",
+    "### References\n",
+    "\n",
+    "1. Easwar Magesan, J. M. Gambetta, and Joseph Emerson, Robust randomized benchmarking of quantum processes,\n",
+    "https://arxiv.org/pdf/1009.3639\n",
+    "\n",
+    "2. Easwar Magesan,, Jay M. Gambetta, and Joseph Emerson, Characterizing Quantum Gates via Randomized Benchmarking,\n",
+    "https://arxiv.org/pdf/1109.6887\n",
+    "\n",
+    "3. A. D. C'orcoles, Jay M. Gambetta, Jerry M. Chow, John A. Smolin, Matthew Ware, J. D. Strand, B. L. T. Plourde, and M. Steffen, Supplementary material for ''Process verification of two-qubit quantum gates by randomized benchmarking'', https://arxiv.org/pdf/1210.7011\n",
+    "\n",
+    "4. Jay M. Gambetta, A. D. C´orcoles, S. T. Merkel, B. R. Johnson, John A. Smolin, Jerry M. Chow,\n",
+    "Colm A. Ryan, Chad Rigetti, S. Poletto, Thomas A. Ohki, Mark B. Ketchen, and M. Steffen,\n",
+    "Characterization of addressability by simultaneous randomized benchmarking, https://arxiv.org/pdf/1204.6308\n",
+    "\n",
+    "5. David C. McKay, Sarah Sheldon, John A. Smolin, Jerry M. Chow, and Jay M. Gambetta, Three Qubit Randomized Benchmarking,\n",
+    "https://arxiv.org/pdf/1712.06550"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Intorduction\n",
+    "\n",
+    "One of the main challenges in building a quantum information processor is the non-scalability of completely\n",
+    "characterizing the noise affecting a quantum system via process tomography. In addition, process tomography is sensitive to noise in the pre- and post rotation gates plus the measurements (SPAM errors). Gateset tomography can take these errors into account, but the scaling is even worse.  A complete characterization\n",
+    "of the noise is useful because it allows for  the determination of good error-correction schemes, and thus\n",
+    "the possibility of reliable transmission of quantum information.\n",
+    "\n",
+    "Since complete process tomography is infeasible for large systems, there is growing interest in scalable\n",
+    "methods for partially characterizing the noise affecting a quantum system. A scalable (in the number $n$ of qubits comprising the system) and robust algorithm for benchmarking the full set of Clifford gates by a single parameter using randomization techniques was presented in [1]. The concept of using randomization methods for benchmarking quantum gates is commonly called **Randomized Benchmarking\n",
+    "(RB)**."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Randomized Benchmarking Protocol\n",
+    "\n",
+    "A RB protocol consists of the following steps:\n",
+    "\n",
+    "(We should first import the relevant qiskit classes for the demonstration)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "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 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\n",
+    "\n",
+    "#Import the RB Functions\n",
+    "import qiskit.ignis.verification.randomized_benchmarking as rb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step 1: Generate RB sequences\n",
+    "\n",
+    "The RB sequences consist of random Clifford elements chosen uniformly from the Clifford group on $n$-qubits, \n",
+    "including a computed reversal element,\n",
+    "that should return the qubits to the initial state.\n",
+    "\n",
+    "More precisely, for each length $m$, we choose $K_m$ RB sequences. \n",
+    "Each such sequence contains $m$ random elements $C_{i_j}$ chosen uniformly from the Clifford group on $n$-qubits, and the $m+1$ element is defined as follows: $C_{i_{m+1}} = (C_{i_1}\\cdot ... \\cdot C_{i_m})^{-1}$.\n",
+    "\n",
+    "For example, we generate below several sequences of 2-qubit Clifford circuits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Generate RB circuits (2Q RB)\n",
+    "\n",
+    "#number of qubits\n",
+    "nQ=2 \n",
+    "rb_opts = {}\n",
+    "#Number of Cliffords in the sequence\n",
+    "rb_opts['length_vector'] = [1, 10, 20, 50, 75, 100, 125]\n",
+    "#Number of seeds (random sequences)\n",
+    "rb_opts['nseeds'] = 5 \n",
+    "#Default pattern\n",
+    "rb_opts['rb_pattern'] = [[0,1]]\n",
+    "\n",
+    "rb_circs, xdata = rb.randomized_benchmarking_seq(**rb_opts)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As an example, we print the circuit corresponding to the first RB sequence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         ┌───┐┌─────┐┌───┐                      ┌───┐┌───┐┌───┐ ░ ┌───┐┌─────┐»\n",
+      "qr_0: |0>┤ H ├┤ Sdg ├┤ H ├──■───────────────────┤ H ├┤ S ├┤ X ├─░─┤ X ├┤ Sdg ├»\n",
+      "         └───┘└─────┘└───┘┌─┴─┐┌─────┐┌───┐┌───┐└───┘└───┘└───┘ ░ └───┘└─────┘»\n",
+      "qr_1: |0>─────────────────┤ X ├┤ Sdg ├┤ H ├┤ X ├────────────────░─────────────»\n",
+      "                          └───┘└─────┘└───┘└───┘                ░             »\n",
+      " cr_0: 0 ═════════════════════════════════════════════════════════════════════»\n",
+      "                                                                              »\n",
+      " cr_1: 0 ═════════════════════════════════════════════════════════════════════»\n",
+      "                                                                              »\n",
+      "«      ┌───┐                       ┌───┐┌───┐┌───┐┌─┐\n",
+      "«qr_0: ┤ H ├─────────────────■─────┤ H ├┤ S ├┤ H ├┤M├\n",
+      "«      └───┘┌───┐┌───┐┌───┐┌─┴─┐┌─┐└───┘└───┘└───┘└╥┘\n",
+      "«qr_1: ─────┤ X ├┤ H ├┤ S ├┤ X ├┤M├────────────────╫─\n",
+      "«           └───┘└───┘└───┘└───┘└╥┘                ║ \n",
+      "«cr_0: ══════════════════════════╬═════════════════╩═\n",
+      "«                                ║                   \n",
+      "«cr_1: ══════════════════════════╩═══════════════════\n",
+      "«                                                    \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(rb_circs[0][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One can verify that the Unitary representing each RB circuit should be the identity (with a global phase). \n",
+    "We simulate this using Aer unitary simulator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Create a new circuit without the measurement\n",
+    "qc = qiskit.QuantumCircuit(*rb_circs[0][-1].qregs,*rb_circs[0][-1].cregs)\n",
+    "for i in rb_circs[0][-1][0:-nQ]:\n",
+    "    qc._attach(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Create a new circuit without the measurement\n",
+    "qc = qiskit.QuantumCircuit(*rb_circs[0][-1].qregs,*rb_circs[0][-1].cregs)\n",
+    "for i in rb_circs[0][-1][0:-nQ]:\n",
+    "    qc._attach(i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-0.707-0.707j  0.   +0.j     0.   +0.j     0.   +0.j   ]\n",
+      " [ 0.   -0.j    -0.707-0.707j -0.   +0.j     0.   +0.j   ]\n",
+      " [ 0.   +0.j     0.   +0.j    -0.707-0.707j  0.   +0.j   ]\n",
+      " [ 0.   -0.j     0.   +0.j     0.   +0.j    -0.707-0.707j]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#The Unitary is an identity (with a global phase)\n",
+    "backend = qiskit.Aer.get_backend('unitary_simulator')\n",
+    "basis_gates = ['u1','u2','u3','cx'] # use U,CX for now\n",
+    "basis_gates_str = ','.join(basis_gates)\n",
+    "job = qiskit.execute(qc, backend=backend, basis_gates=basis_gates_str)\n",
+    "print(np.around(job.result().get_unitary(),3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step 2: Execute the RB sequences (with some noise)\n",
+    "\n",
+    "We can execute the RB sequences either using Qiskit Aer Simulator (with some noise model) or using IBMQ provider, and obtain a list of results.\n",
+    "\n",
+    "By assumption each operation $C_{i_j}$ is allowed to have some error, represnted by $\\Lambda_{i_j,j}$, and each sequence can be modeled by the operation:\n",
+    "$$\\textit{S}_{\\textbf{i}_\\textbf{m}} = \\bigcirc_{j=1}^{m+1} (\\Lambda_{i_j,j} \\circ C_{i_j})$$\n",
+    "where ${\\textbf{i}_\\textbf{m}} = (i_1,...,i_m)$ and $i_{m+1}$ is uniquely determined by ${\\textbf{i}_\\textbf{m}}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run on a noisy simulator\n",
+    "noise_model = NoiseModel()\n",
+    "noise_model.add_all_qubit_quantum_error(depolarizing_error(0.002, 1), ['u1', 'u2', 'u3'])\n",
+    "noise_model.add_all_qubit_quantum_error(depolarizing_error(0.002, 2), 'cx')\n",
+    "\n",
+    "backend = qiskit.Aer.get_backend('qasm_simulator')\n",
+    "basis_gates = 'u1,u2,u3,cx'\n",
+    "result_list = []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step 3: Get statistics about the survival probabilities\n",
+    "\n",
+    "For each of the $K_m$ sequences the survival probability $Tr[E_\\psi \\textit{S}_{\\textbf{i}_\\textbf{m}}(\\rho_\\psi)]$\n",
+    "is measured. \n",
+    "Here $\\rho_\\psi$ is the initial state taking into account preparation errors and $E_\\psi$ is the\n",
+    "POVM element that takes into account measurement errors.\n",
+    "In the ideal (noise-free) case $\\rho_\\psi = E_\\psi = |\\psi \\rangle \\langle \\psi|$. \n",
+    "\n",
+    "In practice one can measure the probability to go back to the exact initial state, i.e. all the qubits in the ground state ($|00...0\\rangle$) or just the probability for one of the qubits to return back to the ground state. Measuring the qubits independently can be more convenient if a correlated measurement scheme is not possible. Both measurements will fit to the same decay parameter according to the properties of the twirl. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step 4: Find the averaged sequence fidelity\n",
+    "\n",
+    "Average over the $K_m$ random realizations to find the averaged sequence **fidelity**,\n",
+    "$$F_{seq}(m,\\psi) = Tr[E_\\psi \\textit{S}_{K_m}(\\rho_\\psi)]$$\n",
+    "where \n",
+    "$$\\textit{S}_{K_m} = \\frac{1}{K_m} \\sum_{\\textbf{i}_\\textbf{m}} \\textit{S}_{\\textbf{i}_\\textbf{m}}$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step 5: Fit the results\n",
+    "\n",
+    "Repeat Steps 1 through 4 for different values of $m$ and fit the\n",
+    "Fit the results for the averaged sequence delity to the model:\n",
+    "$$ \\textit{F}_g(m,|\\psi \\rangle ) = A_0 p^m +B_0$$\n",
+    "where $A_0$ and $B_0$ absorb state preparation and measurement errors as well as an edge effect from the\n",
+    "error on the final gate.\n",
+    "\n",
+    "$p$ determines the average error-rate $r$, which is also called **Error per Clifford (EPC)** \n",
+    "according to the relation $$ r = 1-p-\\frac{1-p}{2^n} = \\frac{2^n-1}{2^n}(1-p)$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After seed 0, EPC 0.011154\n",
+      "After seed 1, EPC 0.011494\n",
+      "After seed 2, EPC 0.010545\n",
+      "After seed 3, EPC 0.011478\n",
+      "After seed 4, EPC 0.011082\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Create the RB fitter\n",
+    "rb_fit = rb.RBFitter(None, xdata, rb_opts['rb_pattern'])\n",
+    "for rb_seed,rb_circ_seed in enumerate(rb_circs):\n",
+    "    qobj = qiskit.compile(rb_circ_seed,\n",
+    "    backend=backend,\n",
+    "    basis_gates=basis_gates)\n",
+    "    job = backend.run(qobj, noise_model=noise_model)\n",
+    "\n",
+    "    #add data to the fitter\n",
+    "    rb_fit.add_data(job.result())\n",
+    "    print('After seed %d, EPC %f'%(rb_seed,rb_fit.fit[0]['epc']))"
+   ]
+  },
+  {
+   "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
+}