introduction_to_quantum_computing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# An introduction to Quantum Computing and programming on a quantum computer\n",
    "\n",
    "Welcome to this *Jupyter Notebook* that comes with my articles about Quantum Computing, [part 1](https://adrienvdb.com/2020/12/27/a-brief-introduction-to-quantum-computing-part-1/) and part 2. You will learn about the basics of quantum computing and programming on quantum computers. This *Jupyter Notebook* will guide you so that you can implement your first quantum programs.\n",
    "\n",
    "The goal is for you to get a bit more familiar with some concepts in quantum computing in order to be able to create programs that can run on quantum machines. The session focuses on two aspects: first an introduction to quantum computing, followed by a hands-on introduction to *Qiskit*, the *Python* package provided by *IBM* to create and run \"quantum\" programs . \n",
    "\n",
    "Now let's have a look at what you will do:\n",
    "\n",
    "## Content\n",
    "\n",
    "- **Part 1: What is quantum computing?**\n",
    "    - Qubits\n",
    "    - Superposition\n",
    "    - Measurement\n",
    "    - Entanglement\n",
    "\n",
    "- **Part 2: The circuit model of quantum computation**\n",
    "    - Gates\n",
    "    - Controlled Gates\n",
    "    - Measurements\n",
    "\n",
    "- **Part 3: Discovering Qiskit**\n",
    "    - Installation\n",
    "    - Qiskit structure\n",
    "    - Creating a circuit\n",
    "    - How to run them on a real quantum computer\n",
    "    \n",
    "- **Part 4: Simple programs**\n",
    "    - Create a superposition\n",
    "    - Create entanglement\n",
    "    - Quantum teleportation and further"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: What is quantum computing?\n",
    "\n",
    "### Qubits\n",
    "\n",
    "Let's start with the notion of a bit. A bit is the smallest unit of information, a `0` or a `1`. We can encode any type of information using a sequence of bits, that is a sequence of `0`s and `1`s.\n",
    "\n",
    "Now what does it happen when we let them follow the rules of quantum mechanics? Well you get qubits! We'll start to explore how qubits can allow us to do things in a different way. After reading the next few sections, you should already be able to start thinking about interesting things to try out with qubits.\n",
    "\n",
    "### Superposition\n",
    "\n",
    "In the quantum world, bits can not only be `0` or `1`, but a superposition of them. In this case, we use the quantum mechanics notation and we say that a qubit can be a superposition of $|0⟩$ or $|1⟩$. This can be mathematically represented as $\\alpha |0⟩ + \\beta |1⟩$, so a superposition is a linear combination of our classical bits. An interpretation of this is that with probabiliy $|\\alpha|^2$ it is $|0⟩$ and with probability $|\\beta|^2$ it is $|1⟩$.\n",
    "\n",
    "### Measurement\n",
    "\n",
    "Now the thing is, since a qubit can be in a complex state like a superposition, how can this be used and understood by us who are using classical computers? The problem is that we don't know if the qubit is a `0` or a `1`, so we need to do something with it to get a classical bit out of it. That's when measurements comes into play. What they do is to reveal something about the qubit, in our case whether it is a `0` or a `1`.\n",
    "\n",
    "\n",
    "### Entanglement\n",
    "\n",
    "A very curious phoenomenon that can arise when dealing with systems with multiple qubits is *entanglement*. What this means is that somehow, two (or more) qubits cannot be described independently of the state of the others, even when they are separated by a large distance. They are somehow correlated.\n",
    "\n",
    "Let's take a famous example. Imagine someone prepares a system with two qubits in the state $\\frac{|00⟩ + |11⟩}{\\sqrt{2}}$, so that if we measure, either we end up in `00` or in `11`.\n",
    "After preparation of the state, one qubit is given to Alice and the other one to Bob. We say that the pair is entangled because if now Alice measure her qubit and gets `0`, then she knows for sure, *whithout looking at Bob's qubit*, that he will also get `0` if he measure his qubit. This happens simply because as explained at the beginning, the two qubits are either `00` or `11`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: The circuit model of quantum computation\n",
    "\n",
    "### Quantum computation and circuits\n",
    "\n",
    "One of the most widely used model of computation is the circuit model. In the classical world, those are the boolean circuits, where a bit is represented by a wire carrying the information. We can then compute things by applying gates (AND, OR, ...) to the bits. A depiction of such a circuit could be for example:\n",
    "\n",
    "![alt text](https://sub.allaboutcircuits.com/images/04287.png \"Hadamard Gate\")\n",
    "\n",
    "In the quantum world, you can just do the same! So you represent qubits as wires carrying the information, and then you can apply gates to those qubits. The difference is that since we can have superposition of qubits, we have access to a lot more exotic types of gates.\n",
    "\n",
    "### Gates\n",
    "\n",
    "As mentioned above, there exists many quantum gates. Here we will focus on those that Qiskit provides to its users, and more specifically in this workshop we will discover three main gates,the $X$ gate (also referred to as NOT gate),  the $H$ gate (also referred to as the Hadamard gate), and the controlled-$X$ gate. They will allow us to build our first circuits, and show us the strange things that can happen in the quantum world.\n",
    "\n",
    "For example the $X$ gate acts as follows:\n",
    "\n",
    "$X|0⟩ = |1⟩$, $X|1⟩ = |0⟩$\n",
    "\n",
    "The $H$ gate is used to create a superposition of `0` and `1` as follows:\n",
    "\n",
    "$H|0⟩ = \\frac{|0⟩ + |1⟩}{\\sqrt{2}}$, $H|1⟩ = \\frac{|0⟩ - |1⟩}{\\sqrt{2}}$\n",
    "\n",
    "The way we represent the gates is usually in a circuit, and they are represented as boxes acting on wires, which represent the qubits. An example for the $H$ gate is below, acting on qubits $|0⟩$ and $|1⟩$:\n",
    "\n",
    "![alt text](https://www.researchgate.net/profile/Daniel_Ciocirlan/publication/263046229/figure/fig3/AS:296567878766594@1447718700257/the-Hadamard-gate.png \"Hadamard Gate\")\n",
    "\n",
    "### Controlled Gates\n",
    "\n",
    "There also exist more complex gates, that don't just take as input one qubit, but multiple of them. A good example is what we call the *controlled gates*. \n",
    "\n",
    "Controlled gates act on two or more qubits, where one or more qubits act as a control for some operation. For example, the controlled-$X$ gate acts on 2 qubits, and performs the $X$ operation on the second qubit only when the first qubit is $|1⟩$ , and otherwise leaves it unchanged.\n",
    "\n",
    "It is represented this way in a circuit:\n",
    "\n",
    "![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/6/6d/Qcircuit_CX.svg/225px-Qcircuit_CX.svg.png \"Controlled X gate\")\n",
    "\n",
    "So only if the first qubit is $|1⟩$ will the $X$ gate be applied on the second qubit.\n",
    "\n",
    "Another way of representing the same gate, which is how it is displayed in Qiskit, is as follows:\n",
    "\n",
    "![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4e/CNOT_gate.svg/225px-CNOT_gate.svg.png \"Controlled X gate\")\n",
    "\n",
    "### Measurements\n",
    "\n",
    "Finally, we have the measurements, which can be thought of as a special kind of gate, which get the information of a qubit to a classical bit.\n",
    "\n",
    "It is generally represented like this:\n",
    "\n",
    "![alt text](https://upload.wikimedia.org/wikipedia/commons/thumb/2/2b/Qcircuit_measure-arrow.svg/225px-Qcircuit_measure-arrow.svg.png \"Measurement\")\n",
    "\n",
    "The two lines on the right hand side represents a classical bit, the single line on the left hand side represents a qubit.\n",
    "\n",
    "\n",
    "### Recap\n",
    "\n",
    "A good summary of what we have seen about the circuits is displayed below.\n",
    "\n",
    "![alt text](https://miro.medium.com/max/2400/1*t2quxKpPFUxOF2OgE8a2ew.jpeg \"Circuit\")\n",
    "\n",
    "Now, you know all the basics of quantum computing to start playing with Qiskit! We will first start to see how Qiskit implements all the concepts we've just seen, and then we will go through some simple example programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3: Discovering Qiskit\n",
    "\n",
    "![alt text](https://repository-images.githubusercontent.com/161550823/42869700-c4cc-11e9-9e6c-497e53a7d861 \"Qiskit\")\n",
    "\n",
    "\"Qiskit is an open-source quantum computing software development framework for leveraging today's quantum processors in research, education, and business\" (see https://qiskit.org/)\n",
    "\n",
    "### Qiskit structure\n",
    "\n",
    "Qiskit is a package that actually is made of four smaller packages, each one taking care of some part of th whole software stack. The packages are:\n",
    "<br/>\n",
    "<br/>\n",
    "- **Qiskit Terra**\n",
    "\n",
    "    Contains a set of tools for composing quantum programs at the level of circuits and pulses, optimizing them for the constraints of a particular physical quantum processor, and managing the batched execution of experiments on remote-access backends. \n",
    "    \n",
    "    \n",
    "- **Qiskit Aer**\n",
    "\n",
    "    Provides a high performance simulator framework which let you execute circuits compiled in Qiskit Terra, and use tools for constructing highly configurable noise models for performing realistic noisy simulations of the errors that occur during execution on real devices.\n",
    "    \n",
    "\n",
    "- **Qiskit Aqua**\n",
    "\n",
    "    Contains a library of cross-domain quantum algorithms upon which applications for near-term quantum computing can be built.\n",
    "    \n",
    "\n",
    "- **Qiskit Ignis**\n",
    "\n",
    "    It is a framework for understanding and mitigating noise in quantum circuits and systems.\n",
    "    \n",
    "Today, we will focus *Qiskit Terra* in order to build circuits, and we will use *Qiskit Aer* to simulate them.\n",
    "\n",
    "\n",
    "Before we start, let's first import everything we will need from the package. In Python, you need to do: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bits and qubits\n",
    "\n",
    "To create bits and qubits in Qiskit, you will need to use registers. This is basically what is used to store them. Depending on if you want to use classical or quantum bits, you will need to specify it, like: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classical register, containing 2 bits\n",
    "classical_reg = ClassicalRegister(2)\n",
    "\n",
    "# Quantum register, containing 2 qubits\n",
    "quantum_reg = QuantumRegister(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a circuit\n",
    "\n",
    "As explained before, in order to compute things, we will need to create circuits. In Qiskit, this is done by creating an object called a `QuantumCircuit`, and specifying the registers (both classical and quantum) used in the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a circuit using the registers we defined before\n",
    "circuit = QuantumCircuit(quantum_reg, classical_reg)\n",
    "\n",
    "# Alternative way of creating a circuit without creating registers explicitly as before\n",
    "# circuit = QuantumCircuit(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can draw a circuit simply by using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIwAAACoCAYAAAAy/QYeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAJuUlEQVR4nO3de0iUex7H8Y9lM07WpCmWdNEuluUtaleKti0ozaKwxG5iUYHTFYr+6GwRLRFUht2WoHUj1hbassspha5zTmR6oshjVFKmdLP25GHtppZbOn33D8vNrNN83Rlnmvm8QIhnnufxN/Tm9zyj+Px8RERAZKcOrh4AfVsYDKkwGFJhMKTCYEiFwZAKgyEVBkMqDIZUGAypMBhSYTCkwmBIhcGQCoMhFQZDKgyGVBgMqTAYUmEwpMJgSIXBkAqDIRUGQyoMhlQYDKkwGFJhMKTCYEiFwZAKgyEVBkMqDIZUGAypMBhSYTAfefnyJRYvXoyQkBB07twZo0ePRlFRkauH5VYYzHsiguTkZBw/fhxZWVnIz89HcHAwEhIScO3aNVcPz30IiYhIfn6+AJBTp041b3vz5o0MHDhQJk2a5MKRuRevmGHevXuHrKwsREREwM/PD3FxcSgoKMDgwYNhsVgAAHl5eQgKCkJSUlLzcQaDAbNnz4bVasWrV69cNXy34hXBLFy4EBs3bsSiRYtw+vRpzJw5E3PmzMG9e/cwYsQIAEBpaSmioqLg4+PT4tjo6Gg0NjairKzMFUN3P66e4pztwIEDAkAuXLjQYntKSooAkKtXr4qISEREhCQnJ7c6/ty5cwJAzp07JyIiVVVVkpCQICaTSWJjY6WkpMT5b8KNePwMs3nzZiQlJWHs2LEttg8cOBCdOnVCTEwMgKab3k9nFwCtti1ZsgSRkZF4+vQpli1bhtTUVNhsNue9gfdjcPaXvTw6mMePH6O0tBQzZsxo9VplZSWioqJgNBoBAEFBQXj27Fmr/T5s6969O2pra3Hy5EmsX78eJpMJFosFNpsNly9fdu4bcSMeHwwA9OzZs8X2+vp6FBQUNN+/AEBUVBRu3boF+WTphdLSUvj6+iIyMhIVFRUICgpCcHBw8+sxMTG4deuWE99F0+zn7C97eXQwH/5jy8vLW2zfunUrnjx5guHDhzdvS05ORnV1Nc6ePdu8raGhAYcOHcKECRPg7++PV69ewWw2tziX2WxGXV2dE9+Fe/F19QCcqX///oiNjcWmTZvQvXt39OrVC0ePHsWpU6cAoMUMM3XqVIwZMwYLFizA1q1bERoait27d6OyshIHDx4EAPj7+6O2trbF96ipqUGXLl3a7025WjvdXLvMnTt3ZNy4cdK5c2fp06ePrFu3TjIzM8XX11dev37dYt/nz5+LxWKR4OBg8fPzk1GjRklBQUHz6zU1NWIwGKS6urp5W3h4uBQVFbXb+3E1jw/mc9LT0yUmJqZNx06fPl1WrFgh9fX1snfvXunXr580NjY6eITuy6MvSV9SXFyMkSNHtunYPXv2ID09HYGBgYiIiMCxY8fQsWNHB4/QfXldMHV1dSgvL8fSpUvbdHyPHj1gtVodPKpvh48Il/Aj+3n0x2pyPAZDKgyGVBgMqTAYUmEwpMJgSIXBkAqDIRUGQyoMhlQYDKkwGFJhMKTCYEiFwZAKgyEVBkMqDIZUGAypMBhSYTCkwmBIhcGQCoMhFQZDKgyGVBgMqTAYUmEwpMJgPsEVTX4bg/mIcEWTr3PxI9PcClc0+TqvmWG4ooljeE0wXNHEQVw9xbUHR69osn79ehkyZIj4+PjIkSNHnD5+AE7/spdXzDCOXtEkIiICu3btQnx8vPMG7aY8PhhHr2gCAOnp6UhISICfn58TR/4/wsUp2o+jVzTxdh4fjKNXNPF2Hv8kcEevaOL1/t87+G+BI1c0+djYsWPb5VOSO/HaR8fPnTsX169fx40bN9THNjQ0wGazITExEUuWLMH06dNhNBpVayd+qzz+HuZLiouLW1yONDIyMmAymVBYWIi0tDSYTCY8fPjQwSN0T14ZzIcVTT6+4dXIyclp9bE0PDzcsYN0U157SaK28coZhtqOwZAKgyEVBkMqDIZUGAypMBhSYTCkwmBIhcGQCoMhFQZDKgyGVBgMqTAYUmEwpMJgSIXBkAqDIRUGQyoMhlQYDKkwGC/x6NEjjB8/HkOGDEF0dDTWrFnTpvMwGC/h6+uLzMxM3L59GyUlJbh06RLy8vL053HC2MgNhYaGIjQ0FEDTgx5jY2NRWVmpPg9nGC/09OlTnDhxAgkJCepjGYyXefPmDVJTU7Fy5co2PVGLf1vtRWw2G2bNmoW+ffti+/btbToHZ5j3rl69ismTJyMgIAD+/v4YOXIkDh8+7OphOZTFYkHXrl2xbdu2tp/EVU8ycifnz5+XTp06SdeuXSUjI0NWrVolYWFhAkCysrJcPTyHKCoqEgASHR0tcXFxEhcXJ7t27RIRkXfv3tl9Hq+/JDU2NiIyMhKPHz/G5cuXMWzYMABNq5rEx8fjwYMHKC8vR1hYmItH6jwH839EUIAZiX/8/Vf39YpLUl5eHqZMmYKQkBAYjUaEhYUhLS0NN2/exPnz53H37l2kpaU1xwIA3bp1w9q1a/H27Vvs37/fhaN3rl9+rcb123fRoYN9KXj0z2EaGxuRnp6O3Nxc9O7dGykpKTCbzSgvL8exY8cwb948XLx4EQCQmJjY6viJEycCAAoKCtp13O3px0sl8DMaMPp30Xbt79HBLF++HLm5ucjIyMCOHTtaPGf30aNHCAgIwL59+wA0PQ7+Uz179kSXLl1QUVHh1HH+KfNvTj2/PUx+Rrv289hgCgsLkZ2djaSkJGRnZ7d6wmWfPn0ANN2rAE2XoM8xm83N+5AHB7Nz504AwJYtW9z+cahbvrO0+/f85ddq/CXne0wYPQIT/mD/00Q9Nhir1Yrw8HDExcX95n4fZpYvzSI1NTUIDAx0+Pg+5spL0g8//YwffvrZ7mg98lPSixcvUFtba9ejUD/cu3zuPqWqqgp1dXWfvb/xWs75MZFrPXv2TADI0KFDv7rvmTNnBIAsWLCg1Ws5OTkCQDZs2OCMYbrMP74/K3/e8Xd5Xf8f9bEeGYyIyIABA8THx0esVmur18rKypr/3dDQIP379xej0SjXrl1r3v7ixQsZNGiQGAwGuX//fnsMuV38q+rf8t2WbLEWFrfpeI8NJjc3VwBIx44dJSUlRVavXi3z58+XQYMGybRp01rs6w2/GvjgZtk9yfzrP9s0u4h4cDAiTZeb8ePHi9lsFoPBIL1795aUlBS5ePFiq32vXLkiSUlJYjabxWQySXx8vBw6dMgFo3Y+m83W5mO9/ndJpOORn5LIeRgMqTAYUmEwpMJgSIXBkAqDIRUGQyoMhlQYDKkwGFJhMKTCYEiFwZAKgyEVBkMqDIZUGAypMBhSYTCkwmBIhcGQCoMhFQZDKgyGVBgMqTAYUvkvBU+2d2hhkesAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 167.356x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, since there are no gates, it might seem like it doesn't bring much. However, as the circuit becomes more and more complex, it is a very useful way to check that your circuit corresponds to what you intend to build."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying transformations (gates) to our qubits\n",
    "\n",
    "In order for our circuit to become a little more interesting, we will need to add gates to it in order to perform transformation on our qubits.\n",
    "\n",
    "The syntax to use when you want to apply gate `x` to qubit `y` in the circuit `circuit` is as follows:\n",
    "\n",
    "`circuit.x(y)`\n",
    "\n",
    "If the gate takes multiple qubits as input, just specify all the qubits to be inputted to the gate. The syntax to use when you want to apply gate `x` to qubits `y`, `z`, ... in the circuit `circuit` is as follows:\n",
    "\n",
    "`circuit.x(y, z, ...)` \n",
    "\n",
    "So if we want to apply a $X$ (NOT-gate) on the first qubit of our circuit, we just need to write: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 227.556x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apply a X gate to the first qubit (qubit at index 0 in our quantum register)\n",
    "circuit.x(quantum_reg[0])\n",
    "\n",
    "# Alternative way to apply a X gate to the first qubit (index 0)\n",
    "# circuit.x(0)\n",
    "\n",
    "# Draw the circuit\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, with all the gates, we are now able to build more complex circuits! But remember, we don't have a direct access to the content of a quantum state. Indeed, for that, we need to \"transform\" the information from a qubit to a classical bit. For that, we need to measure our qubits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measurements\n",
    "\n",
    "To tell Qiskit that you want to measure qubits, you need to specify a qubit and a classical bit (that will contain the result of the measurement). A syntax similar to applying gates is used. So if you want to measure qubit `x` to the classical bit `y` will do: `circuit.measure(x, y)`\n",
    "\n",
    "Let's see it in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 287.756x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Measure first qubit (qubit with index 0 in the quantum register)\n",
    "# to first classical bit (bit with index 0 in classical register)\n",
    "circuit.measure(quantum_reg[0], classical_reg[0])\n",
    "\n",
    "# Measure second qubit (qubit with index 1 in the quantum register)\n",
    "# to second classical bit (bit with index 1 in classical register)\n",
    "circuit.measure(quantum_reg[1], classical_reg[1])\n",
    "\n",
    "# Draw the circuit\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to measure all qubits in a quantum register, you can simply specify the register, and also the classical register that will hold the result of the measurement. In our case, this would translate to: \n",
    "\n",
    "`circuit.measure(quantum_reg, classical_reg)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute your program!\n",
    "\n",
    "To test and get the output of your circuit, you have two possibilities:\n",
    "- Simulate it using Qiskit\n",
    "- Run it on one of IBM's quantum computer\n",
    "\n",
    "What's the big difference? \n",
    "\n",
    "If you simulate a circuit, you will get the output of an *ideal* quantum computer. With Qiskit, you can specify how you want the simulation to behave (how much noise you want to introduce, ...).\n",
    "\n",
    "When you run on a real quantum computer, what will be output is the result of real quantum experiments. Noise may come from the way it is built, but you have no control over that. However, it is great when you want to see how a circuit would behave in real life.\n",
    "\n",
    "#### How to simulate with Qiskit simulator\n",
    "\n",
    "If you want to simulate your program, you just need to execute you just need to execute your circuit and specify a simulator to use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use what is called the QASM simulator\n",
    "simulator = qiskit.BasicAer.get_backend('qasm_simulator')\n",
    "\n",
    "# Execute the circuit using the simulator\n",
    "job = execute(circuit, backend=simulator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After that, we want to get results. Now results will be given together with probabilities of the result happening. Why? \n",
    "\n",
    "As explained at the beginning, when a qubit is in a superposition, it has some probability to be `0` and some probability to be `1`. But after measurement, it has to collapse to some classical bit. So since we have this uncertainty, what the simulator does is to run the circuit many times, and then it will display all the answers he got, and how frequently they appeared.\n",
    "\n",
    "The code you should use to get those results is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the result of the execution\n",
    "result = job.result()\n",
    "\n",
    "# Get the counts, the frequency of each answer\n",
    "counts = result.get_counts(circuit)\n",
    "\n",
    "# Display the results\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the case above, we see that 100% of the executions, that is, all executions,  returned answer `01`.\n",
    "\n",
    "This happened because in our circuit there was no superposition. At the beginning, both qubits where in state $|0⟩$. Then the $X$ gate was applied on the first qubit so it changed to a $|1⟩$. After that we simply measured, so the first qubit ended up in a classical state `1`, while the second one ended up in classical state `0`.\n",
    "\n",
    "Note that on the plot, it says `01` because in Qiskit we have to read the result from right to left. The rightmost bit corresponds to the first qubit, a `1`, and the second one to a `0`.\n",
    "\n",
    "#### Running your circuit on IBM's quantum computers\n",
    "\n",
    "The same syntax is almost the same, instead that here, instead of using a simulator, we will indicate on which quantum computer we want to run our program. It works as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQSimulator('ibmq_qasm_simulator') from IBMQ(hub='ibm-q', group='open', project='main')>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ(hub='ibm-q', group='open', project='main')>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ(hub='ibm-q', group='open', project='main')>,\n",
       " <IBMQBackend('ibmq_vigo') from IBMQ(hub='ibm-q', group='open', project='main')>,\n",
       " <IBMQBackend('ibmq_ourense') from IBMQ(hub='ibm-q', group='open', project='main')>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load your account\n",
    "qiskit.IBMQ.load_account()\n",
    "\n",
    "# After loading credentials we ask IBMQ what are the quantum\n",
    "# computers (backends) that we can use to run our circuits\n",
    "account_provider = qiskit.IBMQ.get_provider()\n",
    "account_provider.backends()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We choose a quantum computer, here te one called ibmqx2\n",
    "quantum_computer = account_provider.get_backend('ibmqx2')\n",
    "\n",
    "# We execute the job just as before, but this time to be run on the ibmqx2\n",
    "job = execute(circuit, backend=quantum_computer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, almost there! Now the thing when using real quantum computers, is that we are not the only one asking to run a program. So you will be put into a queue, and when your turn will come, the circuit will be run and you will get the results.\n",
    "\n",
    "In order to know what is going on with your program while waiting, you can ask Qiskit to display information, such as where you are in the queue, or whether the program has been successfully run. For that, we use something called `job_monitor`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "# Monitor the status of our job\n",
    "job_monitor(job)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we can get the results in the exact same way as we did before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the result of the execution\n",
    "result = job.result()\n",
    "\n",
    "# Get the counts, the frequency of each answer\n",
    "counts = result.get_counts(circuit)\n",
    "\n",
    "# Display the results\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly here, even though we didn't have superposition in our circuit, we end up with multiple answers when running on a quantum computer. Why is that so?\n",
    "\n",
    "As you can imagine, the quantum computer, even though it works, is not perfect like our simulator. In reality, there is noise that will affect our computations. In this case, we see that more than 90% of the time, the right answer `01` was found, but sometimes there were some imperfections and noise and other results were given as output.\n",
    "\n",
    "So from now on, you have the choice: either you can use the simulator to run your experiments, or you can decide to use one of IBM's quantum computers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 4: Simple example programs\n",
    "\n",
    "Now that you know the basics of Qiskit, you can start playing with it. We suggest you some simple circuits below to discover some quantum effects we talked about at the beginning, but you are free to experiment by yourself!\n",
    "\n",
    "### Create  a superposition\n",
    "\n",
    "Now let's say that for the second qubit, we want to create a superposition of `0` and `1`. You can simply apply a $H$ (Hadamard) gate to perform this operation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 233.576x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a circuit with one qubit and one bit\n",
    "circuit = QuantumCircuit(1, 1)\n",
    "\n",
    "# Apply a H gate to the qubit (qubit at index  in the quantum register)\n",
    "circuit.h(0)\n",
    "\n",
    "# Measure the qubit to the classical bit\n",
    "circuit.measure(0, 0)\n",
    "\n",
    "# Draw the circuit\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the qubit should be in the state $\\frac{|0⟩ + |1⟩}{\\sqrt{2}}$, so there is 50% chance to be in state  `0` and 50% chance to be in state `1`. Let's see the results (using the simulator): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute the circuit using the simulator\n",
    "job = execute(circuit, backend=simulator)\n",
    "\n",
    "# Get the result of the execution\n",
    "result = job.result()\n",
    "\n",
    "# Get the counts, the frequency of each answer\n",
    "counts = result.get_counts(circuit)\n",
    "\n",
    "# Display the results\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And just as expected, about 50% of the time it ends up in state `0`, and 50% of the time in state `1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create entanglement\n",
    "\n",
    "After applying the $H$ gate, the first bit is in state $\\frac{|0⟩ + |1⟩}{\\sqrt{2}}$ while the second one in state $|0⟩$, so we can write the state of both as $\\frac{|00⟩ + |10⟩}{\\sqrt{2}}$. How can we end up to state $\\frac{|00⟩ + |11⟩}{\\sqrt{2}}$?\n",
    "\n",
    "One way of doing this is to see that we would want $|00⟩$ to stay $|00⟩$, and $|10⟩$ to become $|11⟩$. This says that altogether, we want that if the first qubit is `1`, \"invert\" the state of the second qubit. But this is exactly what a controlled-$X$ gate does! So we just need to add that gate after the $H$ gate, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 397.32x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a circuit with 2 qubits and 2 bits\n",
    "circuit = QuantumCircuit(2, 2)\n",
    "\n",
    "# Apply an H gate to the first qubit\n",
    "circuit.h(0)\n",
    "\n",
    "# Apply a controlled-X gate to the second qubit, with first one as control\n",
    "circuit.cx(0, 1)\n",
    "\n",
    "# Measure the qubits\n",
    "circuit.measure(0, 0)\n",
    "circuit.measure(1, 1)\n",
    "\n",
    "# Draw the circuit\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that here, we should imagine that we only measure one qubit to see if there is entanglement indeed. That is, if we measure the first qubit and get `0` then we should get `0` for the second qubit too. Just as if we measure `1`, we should get `1` for the second qubit. But since we want to see the state of the second qubit too, we need to measure it to check whether the entanglement happened.\n",
    "\n",
    "Now let's run everything and see if indeed we get the answer as claimed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute the circuit using the simulator\n",
    "job = execute(circuit, backend=simulator)\n",
    "\n",
    "# Get the result of the execution\n",
    "result = job.result()\n",
    "\n",
    "# Get the counts, the frequency of each answer\n",
    "counts = result.get_counts(circuit)\n",
    "\n",
    "# Display the results\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can see that as we expected, either both qubits collapse to a classical state `00` or `11`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum teleportation and further\n",
    "\n",
    "Now that you know a bit more and played with Qiskit, you can go deeper and check out https://www.youtube.com/watch?v=mMwovHK2NrE, a tutorial on how to do Quantum Teleporation in Qiskit, explained by the Qiskit team. There is also much more on their channel, so it's a great way to continue to learn to program with Qiskit.\n",
    "\n",
    "Thank you for following this workshop, and we wish you a lot of fun learning about quantum computing and all its possibilities!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}