vGHC_2020_qiskit_workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How to Program a Quantum Computer\n",
    "## Neereja Sundaresan, Maika Takita, Soolu Thomas \n",
    "### September 29, 2020\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Before we begin...\n",
    "\n",
    "Make sure that you've joined the **`#vghc2020-qiskit-workshop`** slack channel in [Qiskit Workspace](http://ibm.co/joinqiskitslack)!  (See the [README.md](https://github.com/SooluThomas/GHC2020/blob/master/README.md) file for more info)\n",
    "\n",
    "Check [https://github.com/sooluthomas/ghc2020](https://github.com/sooluthomas/ghc2020) for the slack channel invite link.\n",
    "\n",
    "Follow the steps:\n",
    "1. Join the **Qiskit workspace** - https://ibm.co/joinqiskitslack\n",
    "2. Search and join the slack channel - **#vghc2020-qiskit-workshop**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's start programming!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running the IBM Quantum Experience\n",
    "This will run Qiskit seamlessly in your browser. All you need to do is sign up for an IBMid or log in with your existing account, such as Google, GitHub, LinkedIn, or Twitter. And then you’re ready to start writing your first quantum circuit.\n",
    "[ibm.co/iqx](https://ibm.co/iqx)\n",
    "\n",
    "### Installing Qiskit\n",
    "Not everyone needs to install Qiskit now that it fully runs in the cloud on the IBM Quantum Experience, but if you’d like to get into the code, use these resources:\n",
    "[ibm.co/installqiskit](https://ibm.co/installqiskit) (video) or [ibm.co/installqiskitdoc](https://ibm.co/installqiskitdoc) (documentation)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Computer: New model of computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.visualization import plot_bloch_vector\n",
    "%matplotlib inline\n",
    "\n",
    "plot_bloch_vector([0,0,1], title=\"Bloch Sphere\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The Pauli Gates\n",
    "### X, Y, and Z-gates\n",
    "#### Rotation by $\\pi$ around the x, y and z-axis of the Bloch sphere\n",
    "$$ X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} \\quad\\quad\\quad\\quad Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix} \\quad\\quad\\quad\\quad Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Quantum Circuits - `QuantumCircuit(qr, cr)`\n",
    "\n",
    "**Quantum Registers (qr)**: The register to store Quantum information\n",
    "\n",
    "**Classical Registers (cr)**: The register to store Classical information/results\n",
    "\n",
    "\n",
    "For more information, check out the [Getting started documentation](https://qiskit.org/documentation/getting_started.html)\n",
    "\n",
    "### The import statements that we are using are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import (QuantumCircuit, \n",
    "                    QuantumRegister, \n",
    "                    ClassicalRegister, \n",
    "                    execute, \n",
    "                    Aer,\n",
    "                    IBMQ)\n",
    "from qiskit.providers import ibmq\n",
    "from qiskit.visualization import plot_histogram, plot_bloch_multivector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#X-gate on |0>\n",
    "qc = QuantumCircuit(1)\n",
    "qc.x(0)\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('statevector_simulator')\n",
    "out = execute(qc,backend).result().get_statevector()\n",
    "plot_bloch_multivector(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Around the eqator\n",
    "plot_bloch_vector([1,0,0], title=\"Bloch Sphere\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Superposition\n",
    "In addition to  $|0\\rangle$ and  $|1\\rangle$, a single qubit can be a superposition of both.\n",
    "\n",
    "$$\\frac{|0\\rangle \\pm |1\\rangle}{\\sqrt{2}}$$\n",
    "\n",
    "We can create a superposition state using the Hadamard gate\n",
    "\n",
    "- **Hadamard gate**: The gate that is used to create superposition\n",
    "          ┌───┐\n",
    "         ─┤ H ├─\n",
    "          └───┘\n",
    "\n",
    "- **Measure gate**: To measure the output to a classical register\n",
    "\n",
    "             ┌─┐\n",
    "         q  ─┤M├─\n",
    "             └╥┘\n",
    "         c   ═╩═"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(1)\n",
    "qc.h(0)\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('statevector_simulator')\n",
    "out = execute(qc,backend).result().get_statevector()\n",
    "plot_bloch_multivector(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Add classical register \n",
    "qr = QuantumRegister(1)\n",
    "cr = ClassicalRegister(1)\n",
    "# Building a circuit to create superposition\n",
    "qc = QuantumCircuit(qr, cr)  # Optionally, we can simply use QuantumCircuit(1, 1)\n",
    "# Adding gates to the circuit\n",
    "qc.h(qr)\n",
    "qc.measure(qr, cr)\n",
    "# Draw the circuit\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "backend = Aer.get_backend('qasm_simulator')\n",
    "# Execute the circuit\n",
    "result = execute(qc, backend, shots=1000).result()\n",
    "# Display the result\n",
    "plot_histogram(result.get_counts(qc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Try it out:\n",
    "\n",
    "Which state do you get if you run `shots = 1`\n",
    "\n",
    "Put your result in a poll in slack channel **`#vghc2020-qiskit-workshop`** in [Qiskit Workspace](http://ibm.co/joinqiskitslack). (See the [README.md](https://github.com/SooluThomas/GHC2020/blob/master/README.md) file for more info)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "To know more about other types of visualizations, checkout the [Qiskit Visualizations tutorials](https://qiskit.org/documentation/tutorials/circuits/2_plotting_data_in_qiskit.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Entanglement \n",
    "\n",
    "We can also create states involving multiple qubits that have non-classical correlations.  Such a state could look like $ \\frac{|00\\rangle \\pm |11\\rangle}{\\sqrt{2}}$\n",
    "\n",
    "If we measure one qubit at a time the outcome looks random, but if we measure both qubits we only find 00 or 11\n",
    "\n",
    "We can create an entangled state using the CNOT gate\n",
    "\n",
    "- **CNOT gate**: The gate that is used to create entanglement\n",
    "      \n",
    "       q0 ───■───\n",
    "           ┌─┴─┐\n",
    "       q1 ─┤ X ├─\n",
    "           └───┘ \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "bell_circuit = QuantumCircuit(2, 2)\n",
    "\n",
    "bell_circuit.h(0)\n",
    "bell_circuit.cx(0, 1)\n",
    "\n",
    "bell_circuit.measure([0, 1], [0, 1])\n",
    "\n",
    "bell_circuit.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Execute the circuit\n",
    "simulator_counts = execute(bell_circuit, backend, shots=1000).result().get_counts()\n",
    "# Display the result\n",
    "plot_histogram(simulator_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For more information about other gates, check the [tutorials](https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html#Single-Qubit-Quantum-states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Time to run the `bell_circuit` on real Quantum computer!!\n",
    "\n",
    "For more information on how to use IBM Systems, go to this [documentation](https://qiskit.org/documentation/install.html#access-ibm-quantum-systems)\n",
    "\n",
    "### Quantum computers available at IBM\n",
    "#### https://quantum-computing.ibm.com/docs/manage/backends/\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "provider = IBMQ.load_account()\n",
    "for backend in provider.backends(simulator=False, operational=True):\n",
    "    print(backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.tools.jupyter import *\n",
    "# import qiskit.providers.ibmq.jupyter - for IQX\n",
    "\n",
    "backend = provider.get_backend('ibmq_santiago') \n",
    "backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How to pick a backend to run on?\n",
    "- Circuit requirements \n",
    "- Backend properties\n",
    "- Backend availability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.providers.ibmq import least_busy\n",
    "\n",
    "small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits == 5\n",
    "                                   and not x.configuration().simulator)\n",
    "\n",
    "least_busy(small_devices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## specify real backend to use from above list\n",
    "`backend = provider.get_backend('ibmq_valencia')`\n",
    "\n",
    "## or use least busy real backend\n",
    "`backend = least_busy(small_devices)`\n",
    "\n",
    "## or use fake backend for speedy result \n",
    "`from qiskit.test.mock import FakeVigo`<br/>\n",
    "`backend = FakeVigo()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put backend of your choice\n",
    "\n",
    "from qiskit.test.mock import FakeVigo\n",
    "backend = FakeVigo()\n",
    "backend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "print('Running circuit on ', backend)\n",
    "\n",
    "bell_job = execute(bell_circuit, backend)\n",
    "print(bell_job.job_id())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "bell_job.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# run this cell when bell_job.status() outputs: <JobStatus.DONE: 'job has successfully run'>\n",
    "\n",
    "device_counts = bell_job.result().get_counts()\n",
    "\n",
    "plot_histogram([device_counts, simulator_counts], legend = ['real device', 'simulation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.quantum_info.analysis import hellinger_fidelity\n",
    "\n",
    "target = {'00': 0.5, '11': 0.5}\n",
    "\n",
    "hellinger_fidelity(device_counts, target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Optimizing quantum circuits for running on quantum hardware\n",
    "## Circuit Transpilation: [Transpiler documentation](https://qiskit.org/documentation/apidoc/transpiler.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Translating to Basis Gates\n",
    "swap_circ = QuantumCircuit(2)\n",
    "swap_circ.swap(0, 1)\n",
    "swap_circ.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "swap_circ_decompose = swap_circ.decompose()\n",
    "print('Operations in circuit:', swap_circ.depth(), ', Basis gates: ', swap_circ_decompose.depth())\n",
    "swap_circ.decompose().draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##  Let's try another example! \n",
    "### 5 qubit entangled state \n",
    "\n",
    "$$\\frac{|00000\\rangle \\pm |11111\\rangle}{\\sqrt{2}}$$\n",
    "\n",
    "See https://quantum-computing.ibm.com/docs/iqx/guide/entanglement#ghz-states for more information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "num_bits = 5\n",
    "entangling_qubits = QuantumCircuit(num_bits, num_bits)\n",
    "\n",
    "entangling_qubits.h(0)\n",
    "entangling_qubits.cx(0,1)\n",
    "entangling_qubits.cx(0,2)\n",
    "entangling_qubits.cx(0,3)\n",
    "entangling_qubits.cx(0,4)\n",
    "\n",
    "entangling_qubits.barrier(range(num_bits))\n",
    "\n",
    "entangling_qubits.measure(range(num_bits), range(num_bits))\n",
    "\n",
    "entangling_qubits.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.visualization import plot_gate_map, plot_circuit_layout\n",
    "from qiskit.test.mock import FakeParis\n",
    "\n",
    "backend = FakeParis()\n",
    "plot_gate_map(backend, plot_directed=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import transpile\n",
    "\n",
    "entangling_qubits_poorly = transpile(entangling_qubits, backend=backend, initial_layout=[0,6,17,9,20]) \n",
    "plot_circuit_layout(entangling_qubits_poorly, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_poorly.draw(output='mpl',fold=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_poorly.depth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_poorly.count_ops()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_opt = transpile(entangling_qubits, backend=backend, optimization_level=3)\n",
    "\n",
    "plot_circuit_layout(entangling_qubits_opt, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_opt.draw(output='mpl',fold=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_opt.depth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_opt.count_ops()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put your choice of backend\n",
    "backend = FakeVigo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_backend = transpile(entangling_qubits, backend=backend, optimization_level=3)\n",
    "plot_circuit_layout(entangling_qubits_backend, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_job = execute(entangling_qubits_backend, backend)\n",
    "print(entangling_qubits_job.job_id())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "entangling_qubits_job.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# run this cell when entangling_qubits_job.status() outputs: <JobStatus.DONE: 'job has successfully run'>\n",
    "counts = entangling_qubits_job.result().get_counts()\n",
    "target = {'00000': 0.5, '11111': 0.5}\n",
    "print(hellinger_fidelity(counts, target))\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Choosing the best qubits for you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "backend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "edges = backend.configuration().coupling_map\n",
    "n_qubits = backend.configuration().n_qubits\n",
    "edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "jobs = []\n",
    "bell_pairs = []\n",
    "\n",
    "for q1,q2 in edges:\n",
    "    circ = QuantumCircuit(n_qubits,2)\n",
    "    circ.h(q1)\n",
    "    circ.cx(q1,q2)\n",
    "    circ.measure([q1,q2], [0, 1])\n",
    "    bell_pairs.append('Q%d_Q%d' %(q1,q2))\n",
    "    \n",
    "    job = execute(circ, backend,optimization_level=0, shots=8192)\n",
    "    jobs.append(job)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for job in jobs:\n",
    "        print('%s %s' % (job.job_id(),job.status()) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fidelities = []\n",
    "target = {'00': 0.5, '11': 0.5}\n",
    "\n",
    "for job in jobs:\n",
    "    fid = hellinger_fidelity(job.result().get_counts(), target)\n",
    "    fidelities.append(fid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.bar(bell_pairs,fidelities)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Next steps!\n",
    "### Learn Quantum Computing with Qiskit: \n",
    "https://qiskit.org/textbook/preface.html <br/>\n",
    "http://qiskit.org/learn \n",
    "### More tutorials and examples: \n",
    "https://qiskit.org/documentation/index.html <br/>\n",
    "https://qisk.it/sub  \n",
    "### Community Events\n",
    "https://qiskit.org/events\n",
    "### Slack channel\n",
    "https://ibm.co/joinqiskitslack\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## [CLICK HERE TO PLAY QUANTUM 8 BALL](https://studio.code.org/projects/applab/kZc6NzDM6seJ0a5OtGnLd0nQEbgC3iCBxc1Crg-ValA)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other SDKs/ libraries available for Quantum Computing\n",
    "- https://strawberryfields.readthedocs.io/en/stable/\n",
    "- https://pyquil-docs.rigetti.com/en/stable/\n",
    "- https://cirq.readthedocs.io/en/stable/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# THANK YOU!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hideCode": true,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.20.1</td></tr><tr><td>Terra</td><td>0.15.2</td></tr><tr><td>Aer</td><td>0.6.1</td></tr><tr><td>Ignis</td><td>0.4.0</td></tr><tr><td>Aqua</td><td>0.7.5</td></tr><tr><td>IBM Q Provider</td><td>0.8.0</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.8 | packaged by conda-forge | (default, Jul 31 2020, 02:25:08) \n",
       "[GCC 7.5.0]</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>31.40900421142578</td></tr><tr><td colspan='2'>Mon Sep 28 20:57:42 2020 UTC</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, 2020.</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\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_code_all_hidden": false,
  "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.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}