Povm notebook

terra/qis_adv/performing_POVMs.ipynb

@@ -0,0 +1,478 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Performing a general POVM on a quantum computer\n",
+    "\n",
+    "\n",
+    "### Contributors\n",
+    "Yordan S. Yordanov, Crispin H. W. Barnes\n",
+    "\n",
+    "### Introduction\n",
+    "\n",
+    "#### What is a POVM \n",
+    "\n",
+    "In quantum mechanics positive operator-valued measures (POVMs) describe the most general form of a quantum measurement. They can be used to distinguish probabilistically between non-orthogonal quantum states and are used in applications like state discrimination, quantum tomography, and qunatum encryption. \n",
+    "A POVM is defined as a set of $n$ positive operators $\\{\\hat{E}_i\\}$ that satisfy the completeness relation $ \\sum_{i=1}^{n} \\hat{E}_i = \\hat{I}$, where $\\hat{E}_i = \\hat{M}_i^\\dagger \\hat{M}_i$ and the $\\{\\hat{M}_i\\}$ are measurement operators. Performing a POVM on a system in initial state $|\\psi_0\\rangle$ results in wave function reduction to one of $n$ possible measurement outcomes $|\\psi_0\\rangle \\rightarrow |\\psi_i\\rangle =\\frac{\\hat{M}_i|\\psi_0\\rangle}{\\sqrt{\\langle\\psi_0|\\hat{M}_i^{\\dagger}  \\hat{M}_i|\\psi_0\\rangle}}$, with probability $p_i = \\langle\\psi_0|\\hat{M}_i^{\\dagger}  \\hat{M}_i|\\psi_0\\rangle$. \n",
+    "\n",
+    "#### How can POVMs be implemented\n",
+    "\n",
+    "In practice POVMs are either implemented by a physical hardware, specifically tailored for the task, or simulated by quantum gate operations, in some cases involving classical post-processing. \n",
+    "A well known way to perform a POVM in a deterministic way, without classical post-processing is using Neumark's theorem. From it follows that a POVM of $n$-elements, on a target system A, can be performed by introducing an ancilla system B, with Hilbert space spanned by $n$ orthonormal basis states $|i^{(B)}\\rangle$ that are in one-to-one correspondence with the POVM measurement outcomes. A unitary operation $\\hat{U}_{AB}$ is then applied to the joint state of the two systems, such that\n",
+    "\\begin{equation}\\label{eq.Uab}\n",
+    "\\hat{U}_{AB}|\\psi_0^{(A)}\\rangle|0^{(B)}\\rangle = \\sum_{i=1}^n\\big[\\hat{M}_{i}|\\psi_0^{(A)}\\rangle\\big]|i^{(B)}\\rangle.\n",
+    "\\end{equation}\n",
+    "By performing a projective measurement on system B, system A collapses to one of the $n$ states $\\hat{M}_i|\\psi^{(A)}_0\\rangle$ that correspond to the outcomes of the POVM.\n",
+    "\n",
+    " [For more details on POVMs and their implementation see Nielsen and Chuang](http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf)\n",
+    "\n",
+    "#### Implementing a POVM on  a gate based quantum computer\n",
+    "\n",
+    "Based on the method, above, we show how to perform a general $n$-element POVM on a target system consisting of a single qubit, using an ancilla system of $~ \\log_2n$ qubits. To implement $\\hat{U}_{AB}$, we divide it into a sequence of $(n-1)$ quantum gate circuits, which we refer to as modules. Each of these modules, except the first, will perform a general single-qubit $2$-element POVM on one of the POVM outcomes of the preceding module, and entangle the additionally produced outcome to a new state of the ancilla system. At the end each POVM outcome will be entangled to a different state of the set of ancilla qubits. Therefore a measurement of the ancilla qubits will collapse the state of the target qubit to one of the POVM outcomes. Since we don't measure the target qubit itself it can be further used, so that this method for performing a POVM can be incorporated as a subroutine of a larger program.\n",
+    "\n",
+    "In this notebook we will illustrate this technique by implementing an example of a $3$-element single-qubit POVM, consisting of just two modules, defined by measurement operators that project on three states separated by $\\frac{2 \\pi}{3} rad$ in the $x-z$ plane of the Bloch sphere of the target qubit:\n",
+    "\\begin{equation}\\label{eq:M31}\n",
+    "\\hat{M}_1=\\sqrt{\\frac{2}{3}}|0\\rangle\\langle 0|,\n",
+    "\\end{equation}\n",
+    "\\begin{equation}\\label{eq:M32}\n",
+    "\\hat{M}_2=\\frac{1}{\\sqrt{6}}\\frac{|0\\rangle + \\sqrt{3}|1\\rangle}{2}\\frac{\\langle0| + \\sqrt{3}\\langle1|}{2},\n",
+    "\\end{equation}\n",
+    "\\begin{equation}\\label{eq:M33}\n",
+    "\\hat{M}_3=\\frac{1}{\\sqrt{6}}\\frac{|0\\rangle - \\sqrt{3}|1\\rangle}{2}\\frac{\\langle0| - \\sqrt{3}\\langle1|}{2}.\n",
+    "\\end{equation}\n",
+    "This POVM is a classic example considered in literature that can be used to distinguish between non-orthogonal states (for example $ |1\\rangle$ and $\\frac{\\sqrt{3}|0\\rangle+|1\\rangle}{2} $). \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import required libraries\n",
+    "\n",
+    "from numpy import pi\n",
+    "import numpy as np\n",
+    "\n",
+    "from qiskit import Aer\n",
+    "from qiskit import IBMQ\n",
+    "\n",
+    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\n",
+    "from qiskit.tools.visualization import circuit_drawer, plot_histogram"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constructing a multi-qubit controlled rotation gate\n",
+    "\n",
+    "Before we construct the two modules for our $3$-element POVM, we need a way to peform multi-qubit-controlled rotations, which will be extensively used.\n",
+    "To carry out a rotation around a single axis of the Bloch sphere of a qubit $q_0$, controlled by qubits $q_1..q_m$, the rotation is decomposed to two rotations with $m-1$ control qubits as\n",
+    "\\begin{equation}\n",
+    "CR_i(\\theta, q_1..q_m, q_0) =  CNOT(q_1, q_0)CR_i(-\\frac{\\theta}{2}, q_2..q_m, q_0)CNOT(q_1, q_0)CR_i(\\frac{\\theta}{2}, q_2..q_m, q_0)\n",
+    "\\end{equation}\n",
+    "where $i\\in \\{x,y,z\\}$ and $CR$ stands for controlled-rotation. By decomposing each controlled rotation further, the overall operation can be brought down to $(2^m-2)$ CNOTs and $2m$ one-qubit rotations.\n",
+    "\n",
+    "(Note that this method is exponential in number of gates and circuit depth. In general there are more efficient ways to perform controlled operations, that require constant depth circuits and linear number of gates, but at the cost of additional ancilla qubits. However, in for the example of the 3-element POVM, the method described here is optimal in both circuit depth and qubits used.)\n",
+    "\n",
+    "Below we present a recursive function to construct a circut for a multi-qubit controlled rotation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nCU1(axis, angle, q_circ, ctrls, target):\n",
+    "    \"\"\"\n",
+    "        Construct a circuit for n-qubit controlled rotation\n",
+    "        * axis: axis of rotation (accepts values 'y' and 'z')\n",
+    "        * angle: angle of rotation\n",
+    "        * q_circ: the quantum circuit to, which the nCU1 operation is added\n",
+    "        * ctrls: a List or a quantum register of control qubits.\n",
+    "        * target: the target qubit\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    n_ctrls = len(ctrls)\n",
+    "    list_ctrls = list(ctrls)    \n",
+    "\n",
+    "    if n_ctrls == 1:\n",
+    "        \n",
+    "        if axis == 'y':\n",
+    "            q_circ.u3(angle, 0, 0, target)\n",
+    "            q_circ.cx(list_ctrls[0], target)\n",
+    "            q_circ.u3(-angle, 0, 0, target)\n",
+    "            q_circ.cx(list_ctrls[0], target)\n",
+    "            \n",
+    "        elif axis == 'z':\n",
+    "            q_circ.u3(0,0,angle, target)\n",
+    "            q_circ.cx(list_ctrls[0], target)\n",
+    "            q_circ.u3(0,0,-angle, target)\n",
+    "            q_circ.cx(list_ctrls[0], target)\n",
+    "            \n",
+    "        else:\n",
+    "            raise ValueError('Invalid value for axis!')\n",
+    "        \n",
+    "    elif n_ctrls >= 2:\n",
+    "        \n",
+    "        new_ctrls = list_ctrls[:-1]\n",
+    "        \n",
+    "        nCU1(axis, angle/2, q_circ, new_ctrls, target)\n",
+    "        q_circ.cx(list_ctrls[-1], target)\n",
+    "        nCU1(axis, -angle/2, q_circ, new_ctrls, target)\n",
+    "        q_circ.cx(list_ctrls[-1], target)\n",
+    "        \n",
+    "    else:\n",
+    "\n",
+    "        if axis == 'y':\n",
+    "            q_circ.u3(angle*2, 0, 0, target)\n",
+    "        elif axis == 'z':\n",
+    "            q_circ.u3(0, 0, angle*2, target)\n",
+    "        else:\n",
+    "            raise ValueError('Invalid value for axis!')\n",
+    "\n",
+    "    return 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constructing the first 2-element POVM module\n",
+    "\n",
+    "![Image](https://i.imgur.com/dY92Djq.png)\n",
+    "\n",
+    "Now we proceed to construct the first of the two POVM modules. For this we need to consider one target and one ancilla qubit. For a target qubit in an arbitrary initial state $|\\psi_0 \\rangle = a|0\\rangle + b|1\\rangle$ and an ancilla qubit in $|0\\rangle$, the initial state of the joint system is $|\\Psi_0 \\rangle = |\\psi_0 \\rangle|0\\rangle $.\n",
+    "The module should perform a general $2$-element POVM on the state of the target qubit. This is accomplished with the circuit above, which transforms the system state as\n",
+    "\n",
+    "\\begin{equation}\\label{eq:2POVM_res}\n",
+    "|\\Psi_0 \\rangle \\rightarrow |\\Psi_f\\rangle= \\Big(\\hat{V}_1\\hat{D}_1\\hat{U}|\\psi_0\\rangle\\Big)|0\\rangle + \\Big(\\hat{V}_2\\hat{D}_2\\hat{U} |\\psi_0\\rangle\\Big)|1\\rangle,\n",
+    "\\end{equation}\n",
+    "where $\\hat{D}_1 = \\cos \\theta_1 |0 \\rangle \\langle 0 | + \\cos \\theta_2 |1 \\rangle \\langle 1 |$ and\n",
+    "$\\hat{D}_2 = \\sin \\theta_1 |0 \\rangle \\langle 0 | + \\sin \\theta_2 |1 \\rangle \\langle 1 |$. Upon measurement of the ancilla qubit, the state of the target qubit will collapse to one of the two states $\\hat{M}_1|0\\rangle$ and $\\hat{M}_2|1\\rangle$, described by the operators $ \\hat{M}_1 =\\hat{V}_1 \\hat{D}_1 \\hat{U}$ and $\\hat{M}_2 = \\hat{V}_1 \\hat{D}_2 \\hat{U}$. These operators satisfy the completeness relation and are also given by singular value decomposition expressions, therefore they represent the measurement operators of a general $2$-element POVM.\n",
+    "\n",
+    "Below we construct the circuit for the first POVM module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def module_1(q_circ, q, u_y=0, u_z=0, theta1=0, theta2=0, v1_y=0, v1_z=0, v2_y=0, v2_z=0):  \n",
+    "    \"\"\" Constructs the circuit for the first POVM module\n",
+    "        q_circ: a quantun circuit object\n",
+    "        q: a register of at least 2 qubits.\n",
+    "            q[0] the target qubit \n",
+    "            q[1] the ancilla qubit\n",
+    "        u_y, u_z, v1_y, v1_z, v2_y, v2_z: y and z rotation angles speciying single-qubit unitaries\n",
+    "                                          U, V1 and V2 (a general single-qubit unitary can be expsresed\n",
+    "                                          by a combination of an x- and y- rotation)\n",
+    "        theta1, theta2: angles specifying y-rotations (see diagram above)\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # perform U\n",
+    "    q_circ.u3(u_y, 0, u_z, q[0])\n",
+    "    \n",
+    "    # Ry(theta1) (controlled by value 0, hence the two X gates)\n",
+    "    q_circ.x(q[0])\n",
+    "    nCU1('y', theta1, q_circ,[q[0]],q[1]) \n",
+    "    q_circ.x(q[0])\n",
+    "    \n",
+    "    # Ty(theta2)\n",
+    "    nCU1('y', theta2, q_circ,[q[0]],q[1])\n",
+    "    \n",
+    "    #perform V1\n",
+    "    q_circ.x(q[1])\n",
+    "    nCU1('y', v1_y, q_circ,[q[1]],q[0]) \n",
+    "    nCU1('z', v1_z, q_circ,[q[1]],q[0]) \n",
+    "    q_circ.x(q[1])\n",
+    "    \n",
+    "    #perform V2\n",
+    "    nCU1('y', v2_y, q_circ,[q[1]],q[0]) \n",
+    "    nCU1('z', v2_z, q_circ,[q[1]],q[0]) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constructing the second 2-element POVM module\n",
+    "An implementation of an $n$-element POVM can be performed sequentially by $(n-1)$ POVM modules, that share an ancilla register of $\\log_2 n$ qubits. The $i^{th}$ module in the sequence will be characterized by rotation angles $\\theta^{(i)}_1$ and $\\theta^{(i)}_2$, and unitary operations $\\hat{V}_1^{(i)}$ and $\\hat{V}^{(i)}_2$.\n",
+    "Only the first module is additionally characterized by the unitary $\\hat{U}$ acting on the target qubit, as shown above. Each of the modules, except the first one, performs a $2$-element POVM on the second outcome of the preceding module, so that the term in the target qubit state, corresponding to this outcome, is evolved in a similar way as in the case of the first module (see above).\n",
+    "\n",
+    "Therefore to construct the second module for our $3$-element POVM we need to specify two rotation angles  $\\theta^{(2)}_1$ and $\\theta^{(2)}_2$, and two single-qubit unitaries $\\hat{V}_1^{(2)}$ and $\\hat{V}^{(2)}_2$. The quantum circuit for the second module will be similar to that for the first, except that the $U$ will be missing, and that there will be an additional ancilla qubit, two in total, used for control.\n",
+    "\n",
+    "![Image](https://i.imgur.com/vpPzW2N.png)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def module_2(q_circ, q, theta1=0, theta2=0, v1_y=0, v1_z=0, v2_y=0, v2_z=0):  \n",
+    "    \"\"\" Constructs the circuit for the second POVM module\n",
+    "        q_circ: a quantun circuit object\n",
+    "        q: a register of at least 2 qubits.\n",
+    "            q[0] the target qubit \n",
+    "            q[1] the ancilla qubit\n",
+    "        v1_y, v1_z, v2_y, v2_z: y and z rotation angles speciying the single-qubit \n",
+    "                                unitaries V1 and V2\n",
+    "        theta1, theta2: angles specifying y-rotations (see diagram above)\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Ry(theta1)\n",
+    "    qc.x(q[0])\n",
+    "    nCU1('y', theta1, qc,[q[1], q[0]],q[2])\n",
+    "    qc.x(q[0])\n",
+    "    \n",
+    "    # Ry(theta2)\n",
+    "    nCU1('y', theta2,qc ,[q[1], q[0]],q[2])\n",
+    "  \n",
+    "    #perform V1\n",
+    "    q_circ.x(q[2])\n",
+    "    nCU1('y', v1_y, q_circ,[q[1], q[2]], q[0]) \n",
+    "    nCU1('z', v1_z, q_circ,[q[1], q[2]], q[0]) \n",
+    "    q_circ.x(q[2])\n",
+    "    \n",
+    "    #perform V2\n",
+    "    nCU1('y', v2_y, q_circ,[q[1], q[2]], q[0]) \n",
+    "    nCU1('z', v2_z, q_circ,[q[1], q[2]], q[0]) \n",
+    "    \n",
+    "    # the CNOT below changes the labelling of the ancilla states, so that the \n",
+    "    # POVM outcomes are entangled to ancilla states in binary order. \n",
+    "    qc.cx(q[2], q[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constructing the 3-element POVM\n",
+    "\n",
+    "To construct the POVM defined by the three measurement operators given in the beginning of the notebook, we combine the two POVM modules specified by $\\hat{U}=\\hat{I}$,  $\\theta_1^{(1)} = \\cos^{-1}\\Big(\\sqrt{\\frac{2}{3}}\\Big)$,  $\\theta^{(1)}_2 =\\frac{\\pi}{2}$,  $\n",
+    "\\hat{V}_2^{(1)}= \\frac{1}{\\sqrt{2}}\\bigl( \\begin{smallmatrix}1 & 1\\\\ -1 & 1\\end{smallmatrix}\\bigr)$,  $\n",
+    "\\hat{V}_1^{(1)} = \\hat{I}$,  $ \\theta_1^{(2)}=0, \\theta_2^{(2)} =\\frac{\\pi}{2}$, $\\hat{V}_1^{(2)}= \\frac{1}{2}\\bigl( \\begin{smallmatrix} 1 & -\\sqrt{3}\\\\ \\sqrt{3} & 1\\end{smallmatrix}\\bigr)$ and $\\hat{V}_2^{(2)} =- \\frac{1}{2}\\bigl( \\begin{smallmatrix}\\sqrt{3} & -1\\\\ 1 & \\sqrt{3}\\end{smallmatrix}\\bigr)$. Unitaries $V^{(1)}_2$, $V^{(2)}_1$ and $V^{(2)}_2$ can be implemented by $y$-rotations given by angles $\\frac{\\pi}{4}$, $-\\frac{\\pi}{3}$ and $\\frac{5\\pi}{6}$ respectively.\n",
+    "For the target qubit we leave the initial state to be $|0\\rangle$.\n",
+    "The expected output state of the $3$ qubits, the target plus the two ancillas, is\n",
+    "$$ \\Psi = \\big[ M_1 |0\\rangle \\big] |00\\rangle + \\big[ M_2 |0\\rangle \\big] |10\\rangle + \\big[ M_3 |0\\rangle \\big] |01\\rangle = \\sqrt{\\frac{3}{2}}|0\\rangle|00\\rangle + \\frac{|0\\rangle +  \\sqrt{3}|1\\rangle}{2\\sqrt{6}}|10\\rangle + \\frac{|0\\rangle - \\sqrt{3}|1\\rangle}{2\\sqrt{6}}|01\\rangle,$$\n",
+    "where the leftmost qubit corresponds to the target.\n",
+    "\n",
+    "To complete the POVM, at the end we have to measure the ancilla qubits. In practice we may want to leave the target qubit unmeasured, so that we can further use it (for example, send it to another party in a quantum communication protocol). However here we will measure all qubits, including the target, in order to illustrate the results, especially the ones from the real device."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the non-zero parameters for the two modules\n",
+    "\n",
+    "theta11 = np.arccos(np.sqrt(2/3))\n",
+    "theta12 = pi/2\n",
+    "theta22 = pi/2\n",
+    "\n",
+    "# rotation angles specifying the unitaries V12, V21 and V22\n",
+    "v21_y=-pi/3\n",
+    "v22_y= 5*pi/6\n",
+    "v12_y = pi/4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Assemble the whole qauntum circuit, consisting of the two POVM modules, followed by measurements\n",
+    "\n",
+    "# Create a quantum register with 3 qubits.\n",
+    "q = QuantumRegister(3, 'q')\n",
+    "\n",
+    "# Create a quantum circuit acting on the register\n",
+    "qc = QuantumCircuit(q)\n",
+    "\n",
+    "# Perform the 1st POVM module\n",
+    "module_1(qc,q,theta1=theta11,theta2=theta12, v2_y=v12_y)\n",
+    "\n",
+    "# Perform the 2nd POVM mdoule\n",
+    "module_2(qc,q, theta2=theta22 ,v1_y= v21_y, v2_y=v22_y)\n",
+    "\n",
+    "\n",
+    "# Add Measurements\n",
+    "c = ClassicalRegister(3, 'c')\n",
+    "meas = QuantumCircuit(q, c)\n",
+    "meas.measure(q,c)\n",
+    "qc = qc+meas\n",
+    "\n",
+    "# draw the circuit\n",
+    "# circuit_drawer(qc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x360 with 1 Axes>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run  on the quantum simulator\n",
+    "backend = Aer.get_backend('qasm_simulator')\n",
+    "shots = 8192\n",
+    "job = execute(qc, backend, shots = shots)\n",
+    "\n",
+    "# execute\n",
+    "result_sim = job.result()\n",
+    "\n",
+    "# obtain results\n",
+    "counts_sim = result_sim.get_counts(qc)\n",
+    "plot_histogram(counts_sim)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Prepare an experiment on a real device\n",
+    "\n",
+    "# IBMQ.save_account(token)\n",
+    "IBMQ.load_account()\n",
+    "\n",
+    "\n",
+    "shots = 8192           # Number of shots to run the program (experiment); maximum is 8192 shots.\n",
+    "max_credits = 10       # Maximum number of credits to spend on executions. \n",
+    "n_qubits = 3\n",
+    "\n",
+    "# ibmqx2 was found to produce the best results\n",
+    "backend = IBMQ.backends(name = 'ibmqx2')[0]  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# <<<<<<<<<<< EXECUTE on a real device >>>>>>>>>>>>>>\n",
+    "run = 0  # keep 0 untill you want to run the experiment\n",
+    "if run:\n",
+    "    job_exp = execute(qc, backend=backend, shots=shots, max_credits=max_credits)\n",
+    "    result = job_exp.result()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x360 with 1 Axes>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Uncomment to plot the new results\n",
+    "\n",
+    "#counts = result.get_counts(qc)\n",
+    "#plot_histogram(counts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.12.0</td></tr><tr><td>Terra</td><td>0.9.0</td></tr><tr><td>Aer</td><td>0.3.0</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.6.0</td></tr><tr><td>IBM Q Provider</td><td>0.3.2</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.6.7 (default, Oct 22 2018, 11:32:17) \n",
+       "[GCC 8.2.0]</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>7.706508636474609</td></tr><tr><td colspan='2'>Mon Dec 02 10:44:11 2019 GMT</td></tr></table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2019.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import qiskit.tools.jupyter\n",
+    "%qiskit_version_table\n",
+    "%qiskit_copyright"
+   ]
+  },
+  {
+   "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.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}