QISKIT Workshop.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/peepeepoopooooo/2022-update-shecodes/blob/main/QISKIT%20Workshop.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XYW3NJ5YWF3d"
      },
      "source": [
        "<img src=\"https://github.com/mtreinish/qiskit-workshop/blob/master/qiskit-heading.png?raw=1\" alt=\"Drawing\" style=\"width: 300px;\"/>\n",
        "\n",
        "\n",
        "# Get Started with Quantum Computing and Qiskit\n",
        "\n",
        "This workshop is hosted at: https://github.com/mtreinish/qiskit-workshop"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_JhTbSiUWF3g"
      },
      "source": [
        "To get started we'll need to install Qiskit. If you have Python >= 3.5 and Jupyter installed you can run this locally. Or alternatively you can run this in Google Colab (if you have a Google account):\n",
        "https://colab.research.google.com/github/mtreinish/qiskit-workshop/blob/master/Workshop.ipynb\n",
        "\n",
        "Once you have the workshop running if you have not installed Qiskit before (or you are running in colab) you can uncomment and run the following cell to install it:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hrLOYp-DWF3g"
      },
      "outputs": [],
      "source": [
        "#!pip install qiskit"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VmxGkO_3WF3h"
      },
      "source": [
        "Once we have Qiskit is installed we want to test that it's working properly."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DFTYX_G6WF3h"
      },
      "outputs": [],
      "source": [
        "import qiskit\n",
        "qiskit.__version__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wEhpQsZVWF3i"
      },
      "source": [
        "## Signup for the Quantum Experience\n",
        "\n",
        "While for the most part we'll use local simulation for this workshop, if you want to run anything on a real quantum device you'll need an account on the Quantum Experience. We'll do this before moving on:\n",
        "\n",
        "1. Visit: https://quantumexperience.ng.bluemix.net/qx/ and signup for an account. You can use a SSO from an IBMid, LinkedIn, Github, Google, or Twitter in addition to creating a new account.\n",
        "\n",
        "![Login Box](https://github.com/mtreinish/qiskit-workshop/blob/master/QX_login.png?raw=1)\n",
        "\n",
        "\n",
        "\n",
        "2. After you're logged into your new account visit: https://quantumexperience.ng.bluemix.net/qx/account/advanced where you'll need to generate an **API Token**. Once you've generated a token you'll want to copy it so we can use Qiskit to store it locally so it can be used for accessing the quantum devices.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bJI-vavWWF3i"
      },
      "outputs": [],
      "source": [
        "# Enable your account on Qiskit, replace 'My_API_Token' with your newly generated token\n",
        "#qiskit.IBMQ.save_account('My_API_Token')\n",
        "qiskit.IBMQ.load_accounts()\n",
        "# After loading credentials we query the backends\n",
        "qiskit.IBMQ.backends()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PCRrY8OxWF3i"
      },
      "outputs": [],
      "source": [
        "from qiskit.tools.jupyter import *"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": false,
        "id": "KCEzvm_5WF3j"
      },
      "outputs": [],
      "source": [
        "# Show Quantum Device Overiew\n",
        "%qiskit_backend_overview"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": false,
        "id": "b4zCdQ32WF3j"
      },
      "outputs": [],
      "source": [
        "# Show individual backend details\n",
        "backend = qiskit.IBMQ.get_backend('ibmqx2')\n",
        "%qiskit_backend_monitor backend"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nUDFhag6WF3j"
      },
      "source": [
        "## Running on a Quantum Device\n",
        "In any of the examples below you can simply replace the use of the `backend_sim` variable with `backend` in any calls to `qiskit.execute()` below and it'll run the circuit on a real quantum device instead of in the local simulator. However be aware that because the real devices are shared time you'll likely have to wait some time in the queue before your job executes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0vIJqW8qWF3j"
      },
      "source": [
        "# The Qubit"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "osn4Xcs4WF3j"
      },
      "outputs": [],
      "source": [
        "# Use BasicAer's qasm_simulator\n",
        "backend_sim = qiskit.BasicAer.get_backend('qasm_simulator')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BYyN0qqjWF3j"
      },
      "outputs": [],
      "source": [
        "# Define the Quantum and Classical Registers\n",
        "q = qiskit.QuantumRegister(1)\n",
        "c = qiskit.ClassicalRegister(1)\n",
        "\n",
        "# Build the circuit\n",
        "single_q_measurement = qiskit.QuantumCircuit(q, c)\n",
        "single_q_measurement.measure(q, c);"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ozJ4HUH3WF3k"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_bloch_vector([0, 0, 1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M7vQCUfpWF3k"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit\n",
        "job = qiskit.execute(single_q_measurement, backend_sim)\n",
        "result = job.result()\n",
        "# Print the result\n",
        "counts = result.get_counts(single_q_measurement)\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AK1g-bj8WF3k"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T2MHYOzPWF3k"
      },
      "source": [
        "# The Quantum Not Gate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_l2zWexBWF3k"
      },
      "outputs": [],
      "source": [
        "# Create a Quantum Register with 1 qubit (wire).\n",
        "qr = qiskit.QuantumRegister(1)\n",
        "\n",
        "# Create a Classical Register with 1 bit (double wire).\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "\n",
        "# Create a Quantum Circuit from the quantum and classical registers\n",
        "circ = qiskit.QuantumCircuit(qr, cr)\n",
        "\n",
        "# Place an X gate on the qubit wire. The registers are zero-indexed.\n",
        "circ.x(qr[0])\n",
        "\n",
        "# Measure the qubit into the classical register\n",
        "circ.measure(qr, cr)\n",
        "\n",
        "# Draw the circuit\n",
        "circ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "O_RyY1DFWF3k"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_bloch_vector([0, 0, -1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y2Yiu1ydWF3k"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the qasm simulator, running it 100 times.\n",
        "job_sim = qiskit.execute(circ, backend_sim, shots=100)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# Print the counts, which are contained in a Python dictionary\n",
        "counts = result_sim.get_counts(circ)\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cj1rEnBDWF3k"
      },
      "outputs": [],
      "source": [
        "# Plot the results on a bar chart\n",
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hnoy6OApWF3k"
      },
      "source": [
        "# Superposition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6ExzL-LfWF3k"
      },
      "outputs": [],
      "source": [
        "# Create a Quantum Register with 1 qubit (wire).\n",
        "qr = qiskit.QuantumRegister(1)\n",
        "\n",
        "# Create a Classical Register with 1 bit (double wire).\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "\n",
        "# Create a Quantum Circuit from the quantum and classical registers\n",
        "circ = qiskit.QuantumCircuit(qr, cr)\n",
        "\n",
        "# Place an Hadamard gate on the qubit wire\n",
        "circ.h(qr[0])\n",
        "\n",
        "# Measure the qubit into the classical register\n",
        "circ.measure(qr, cr)\n",
        "\n",
        "# Draw the circuit\n",
        "circ.draw(output='mpl', scale=1.5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kg3yvZofWF3k"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the qasm simulator, running it 100 times.\n",
        "job_sim = qiskit.execute(circ, backend_sim, shots=100)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# Print the counts, which are contained in a Python dictionary\n",
        "counts = result_sim.get_counts(circ)\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QuRSALX9WF3k"
      },
      "outputs": [],
      "source": [
        "# Plot the results on a bar chart\n",
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtiUHr2BWF3l"
      },
      "source": [
        "This demonstrates the first principle fundamental princple of quantum mechanics that provide a good starting point for understanding quantum computation. The priciple of superposition, that a physical system in a definite state can still behave randomly."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "64rVU7vmWF3l"
      },
      "source": [
        "## Applying Hadarmards Twice\n",
        "\n",
        "Now that we've applied a Hadamard gate and put a qubit in superposition, what happens if you apply a hadamard to a qubit already in a the $|0+1\\rangle$ state."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iAUKyw0-WF3l"
      },
      "outputs": [],
      "source": [
        "# Build a circuit with 1 qubit and 1 classical bit\n",
        "qr = qiskit.QuantumRegister(1)\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "qc = qiskit.QuantumCircuit(qr, cr)\n",
        "# Apply 2 Hadamard gates on the circuit and then measure\n",
        "qc.h(qr[0])\n",
        "qc.h(qr[0])\n",
        "qc.measure(qr, cr)\n",
        "# Draw the circuit\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jdKbIjVwWF3l"
      },
      "outputs": [],
      "source": [
        "# Run the circuit and print the output counts\n",
        "result = qiskit.execute(qc, backend_sim, shots=100).result()\n",
        "counts = result.get_counts()\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8OICzGFmWF3l"
      },
      "outputs": [],
      "source": [
        "# Print the histogram\n",
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7c6QMW4WF3l"
      },
      "source": [
        "### Apply Hadamard twice from |$1\\rangle$ basis state"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zNsRh8KeWF3l"
      },
      "outputs": [],
      "source": [
        "# Build a circuit with 1 qubit and 1 classical bit\n",
        "qr = qiskit.QuantumRegister(1)\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "qc = qiskit.QuantumCircuit(qr, cr)\n",
        "# Apply 2 Hadamard gates on the circuit and then measure\n",
        "qc.x(qr[0])\n",
        "qc.h(qr[0])\n",
        "qc.h(qr[0])\n",
        "qc.measure(qr, cr)\n",
        "# Draw the circuit\n",
        "qc.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PKszVPpiWF3l"
      },
      "outputs": [],
      "source": [
        "# Run the circuit and print the output counts\n",
        "result = qiskit.execute(qc, backend_sim, shots=100).result()\n",
        "counts = result.get_counts()\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bbIvess_WF3l"
      },
      "outputs": [],
      "source": [
        "# Print the histogram\n",
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u7sVtBcrWF3l"
      },
      "source": [
        "# Other Quantum Gates\n",
        "\n",
        "The list of standard available logic gates are documented here:\n",
        "\n",
        "https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb\n",
        "\n",
        "However, that guide typically only explains the operation performed by using it's unitary matrix. If you want to visualize the output state from using a quantum gate on the bloch sphere you can use the statevector simulator to do this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oXwwMSbxWF3m"
      },
      "outputs": [],
      "source": [
        "# Get the statevector simulator to inspect the quantum state\n",
        "backend_sv_sim = qiskit.BasicAer.get_backend('statevector_simulator')\n",
        "qr = qiskit.QuantumRegister(1)\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "circ = qiskit.QuantumCircuit(qr, cr)\n",
        "circ.y(qr)\n",
        "result = qiskit.execute(circ, backend_sv_sim).result()\n",
        "qiskit.tools.visualization.plot_bloch_multivector(result.get_statevector())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yVaV7oMXWF3m"
      },
      "source": [
        "The above shows the end state after applying the Pauli Y gate (which like the Pauli X/Quantum Not gate) can be thought of a 180 degree rotation around the Y axis. So when starting from the |$0\\rangle$ basis state the result is the |$1\\rangle$ basis state.\n",
        "\n",
        "However, many gates rotate the phase. To visualize any change in phase you'll want to put the qubit in superposition with a hadamard gate first. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JR6k6KoIWF3m"
      },
      "outputs": [],
      "source": [
        "qr = qiskit.QuantumRegister(1)\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "circ = qiskit.QuantumCircuit(qr, cr)\n",
        "circ.h(qr)\n",
        "circ.sdg(qr)\n",
        "result = qiskit.execute(circ, backend_sv_sim).result()\n",
        "\n",
        "qiskit.tools.visualization.plot_bloch_multivector(result.get_statevector())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B3VuFrTkWF3p"
      },
      "source": [
        "This example shows the output of the $S^{\\dagger}$ (or, conjugate of $\\sqrt{Z}$ phase) gate on the bloch sphere for a qubit in superposition from a Hadamard gate. Since it is a phase gate it has no noticeable effect on a qubit in the |$0\\rangle$ basis state:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3QFG5mD1WF3p"
      },
      "outputs": [],
      "source": [
        "qr = qiskit.QuantumRegister(1)\n",
        "cr = qiskit.ClassicalRegister(1)\n",
        "circ = qiskit.QuantumCircuit(qr, cr)\n",
        "circ.sdg(qr)\n",
        "result = qiskit.execute(circ, backend_sv_sim).result()\n",
        "\n",
        "qiskit.tools.visualization.plot_bloch_multivector(result.get_statevector())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d1XQHZySWF3p"
      },
      "source": [
        "# Multi Qubit Circuits and Gates"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YfDMkS_iWF3p"
      },
      "outputs": [],
      "source": [
        "# Create a Quantum Register with 3 qubits\n",
        "qr = qiskit.QuantumRegister(3)\n",
        "\n",
        "# Create a Quantum Circuit from the quantum register. Because we're going to use\n",
        "# the statevector_simulator, we won't measure the circuit or need classical registers.\n",
        "circ = qiskit.QuantumCircuit(qr)\n",
        "\n",
        "# Place an X gate on the 2nd and 3rd wires. The topmost wire is index 0.\n",
        "circ.x(qr[1])\n",
        "circ.x(qr[2])\n",
        "\n",
        "# Draw the circuit\n",
        "circ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SOgdyzjwWF3q"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the state vector simulator\n",
        "job_sim = qiskit.execute(circ, backend_sv_sim)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# Obtain the state vector for the quantum circuit\n",
        "quantum_state = result_sim.get_statevector(circ, decimals=3)\n",
        "\n",
        "# Output the quantum state vector\n",
        "print(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hkfq1qcaWF3q"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_state_city(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "etKfSdliWF3q"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_bloch_multivector(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vIcOM9cJWF3q"
      },
      "outputs": [],
      "source": [
        "# Create a Quantum Register with 3 qubits\n",
        "qr = qiskit.QuantumRegister(2)\n",
        "cr = qiskit.ClassicalRegister(2)\n",
        "circ = qiskit.QuantumCircuit(qr)\n",
        "# Apply a CNOT gate with qr[0] as the control and qr[1] as the target\n",
        "circ.cx(qr[0], qr[1])\n",
        "\n",
        "meas = qiskit.QuantumCircuit(qr, cr)\n",
        "meas.measure(qr, cr)\n",
        "\n",
        "# Draw the circuit\n",
        "circ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h13iD-MmWF3q"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the state vector simulator\n",
        "job_sim = qiskit.execute(circ, backend_sv_sim)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# Obtain the state vector for the quantum circuit\n",
        "quantum_state = result_sim.get_statevector(circ, decimals=3)\n",
        "\n",
        "# Output the quantum state vector\n",
        "print(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KgB5bABKWF3q"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_state_city(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x7pl60O3WF3q"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the state vector simulator\n",
        "job_sim = qiskit.execute(circ + meas, backend_sim)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result = job_sim.result()\n",
        "\n",
        "counts = result.get_counts()\n",
        "# Output the quantum state vector\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dn9UNXF8WF3q"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "flYaFo3_WF3q"
      },
      "outputs": [],
      "source": [
        "circ = qiskit.QuantumCircuit(qr)\n",
        "# Apply an X gate on qr[0] before the CNOT\n",
        "circ.x(qr[0])\n",
        "\n",
        "# Apply a CNOT gate with qr[0] as the control and qr[1] as the target\n",
        "circ.cx(qr[0], qr[1])\n",
        "\n",
        "# Draw the circuit\n",
        "circ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x8883oqiWF3q"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the state vector simulator\n",
        "job_sim = qiskit.execute(circ, backend_sv_sim)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result_sim = job_sim.result()\n",
        "\n",
        "# Obtain the state vector for the quantum circuit\n",
        "quantum_state = result_sim.get_statevector(circ, decimals=3)\n",
        "\n",
        "# Output the quantum state vector\n",
        "print(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AX1dltt3WF3q"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_state_city(quantum_state)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gjLMZxqmWF3r"
      },
      "outputs": [],
      "source": [
        "# Execute the circuit on the state vector simulator\n",
        "job_sim = qiskit.execute(circ + meas, backend_sim)\n",
        "\n",
        "# Grab the results from the job.\n",
        "result = job_sim.result()\n",
        "\n",
        "counts = result.get_counts()\n",
        "# Output the quantum state vector\n",
        "print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EIL-EdpGWF3r"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AyVH2RWzWF3r"
      },
      "source": [
        "These are all still classical operations and states, just with multiple qubits. Lets look at what happens when we start using CNOT outside of a basis state."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W2PFrjHfWF3r"
      },
      "source": [
        "# Entanglement"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4v27rXtuWF3r"
      },
      "outputs": [],
      "source": [
        "# Creating registers\n",
        "q2 = qiskit.QuantumRegister(2)\n",
        "c1 = qiskit.ClassicalRegister(1)\n",
        "c2 = qiskit.ClassicalRegister(2)\n",
        "\n",
        "# quantum circuit to make an entangled bell state\n",
        "bell = qiskit.QuantumCircuit(q2)\n",
        "bell.h(q2[0])\n",
        "bell.cx(q2[0], q2[1])\n",
        "\n",
        "# quantum circuit to measure q0 in the standard basis\n",
        "measureIZ = qiskit.QuantumCircuit(q2, c1)\n",
        "measureIZ.measure(q2[0], c1[0])\n",
        "bellIZ = bell + measureIZ\n",
        "\n",
        "# quantum circuit to measure q0 in the superposition basis\n",
        "measureIX = qiskit.QuantumCircuit(q2, c1)\n",
        "measureIX.h(q2[0])\n",
        "measureIX.measure(q2[0], c1[0])\n",
        "bellIX = bell + measureIX\n",
        "\n",
        "# quantum circuit to measure q1 in the standard basis\n",
        "measureZI = qiskit.QuantumCircuit(q2, c1)\n",
        "measureZI.measure(q2[1], c1[0])\n",
        "bellZI = bell + measureZI\n",
        "\n",
        "# quantum circuit to measure q1 in the superposition basis\n",
        "measureXI = qiskit.QuantumCircuit(q2, c1)\n",
        "measureXI.h(q2[1])\n",
        "measureXI.measure(q2[1], c1[0])\n",
        "bellXI = bell + measureXI\n",
        "\n",
        "# quantum circuit to measure q in the standard basis\n",
        "measureZZ = qiskit.QuantumCircuit(q2, c2)\n",
        "measureZZ.measure(q2[0], c2[0])\n",
        "measureZZ.measure(q2[1], c2[1])\n",
        "bellZZ = bell + measureZZ\n",
        "\n",
        "# quantum circuit to measure q in the superposition basis\n",
        "measureXX = qiskit.QuantumCircuit(q2, c2)\n",
        "measureXX.h(q2[0])\n",
        "measureXX.h(q2[1])\n",
        "measureXX.measure(q2[0], c2[0])\n",
        "measureXX.measure(q2[1], c2[1])\n",
        "bellXX = bell + measureXX"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iIaXHbt4WF3r"
      },
      "outputs": [],
      "source": [
        "bellIZ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C__cgtL3WF3r"
      },
      "outputs": [],
      "source": [
        "bellIX.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ToF2FyHZWF3r"
      },
      "outputs": [],
      "source": [
        "bellZI.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hP0mjeQ0WF3r"
      },
      "outputs": [],
      "source": [
        "bellXI.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-3va1XSsWF3r"
      },
      "outputs": [],
      "source": [
        "bellZZ.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9UqCOYo6WF3r"
      },
      "outputs": [],
      "source": [
        "bellXX.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WOGtDtTjWF3s"
      },
      "outputs": [],
      "source": [
        "circuits = [bellIZ,bellIX,bellZI,bellXI,bellZZ,bellXX]\n",
        "job = qiskit.execute(circuits, backend_sim)\n",
        "result = job.result()\n",
        "\n",
        "result_sv = qiskit.execute(bell, backend_sv_sim).result()\n",
        "\n",
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellIZ))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vzo2on8RWF3s"
      },
      "outputs": [],
      "source": [
        "result.get_counts(bellIZ)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "obogP5P-WF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellIX))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PAk06KniWF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellZI))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8C4Q1LTBWF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellXI))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cGiT76KDWF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellZZ))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "91clkj03WF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_histogram(result.get_counts(bellXX))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jrnWhwWwWF3s"
      },
      "outputs": [],
      "source": [
        "qiskit.tools.visualization.plot_state_city(result_sv.get_statevector())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "669BkRPtWF3s"
      },
      "source": [
        "## Mixed State vs Entanglement"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RtjTIFYVWF3t"
      },
      "outputs": [],
      "source": [
        "# quantum circuit to make a mixed state\n",
        "mixed1 = qiskit.QuantumCircuit(q2, c2)\n",
        "mixed2 = qiskit.QuantumCircuit(q2, c2)\n",
        "mixed2.x(q2)\n",
        "mixed1.measure(q2[0], c2[0])\n",
        "mixed1.measure(q2[1], c2[1])\n",
        "mixed2.measure(q2[0], c2[0])\n",
        "mixed2.measure(q2[1], c2[1])\n",
        "\n",
        "mixed1.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jU98YUieWF3t"
      },
      "outputs": [],
      "source": [
        "mixed2.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2fg_JirMWF3t"
      },
      "outputs": [],
      "source": [
        "mixed_state = [mixed1,mixed2]\n",
        "job = qiskit.execute(mixed_state, backend_sim)\n",
        "result = job.result()\n",
        "\n",
        "counts1 = result.get_counts(mixed_state[0])\n",
        "counts2 = result.get_counts(mixed_state[1])\n",
        "\n",
        "import collections\n",
        "ground = collections.Counter(counts1)\n",
        "excited = collections.Counter(counts2)\n",
        "qiskit.tools.visualization.plot_histogram(ground + excited)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQ8A4tDlWF3t"
      },
      "source": [
        "We do see the same kind of correlation indeed as we observed in the \"bell_measureZZ\" circuit. But we know this is not an entangled state! All we have done is leave the qubits in their ground state for some of the shots and flip both qubits for some of the shots. This is called a mixed state and it is a classical state. Now, would we observe a similar outcome if we measured this mixed state in the superposition basis?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HG7rBSQ9WF3t"
      },
      "outputs": [],
      "source": [
        "# quantum circuit to make a mixed state\n",
        "mixed3 = qiskit.QuantumCircuit(q2, c2)\n",
        "mixed3.h(q2)\n",
        "mixed3.measure(q2[0], c2[0])\n",
        "mixed3.measure(q2[1], c2[1])\n",
        "mixed4 = qiskit.QuantumCircuit(q2, c2)\n",
        "mixed4.x(q2)\n",
        "mixed4.h(q2)\n",
        "mixed4.measure(q2[0], c2[0])\n",
        "mixed4.measure(q2[1], c2[1])\n",
        "mixed3.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CIRMzqGBWF3t"
      },
      "outputs": [],
      "source": [
        "mixed4.draw(output='mpl')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X0f9oqmuWF3t"
      },
      "outputs": [],
      "source": [
        "mixed_state = [mixed3, mixed4]\n",
        "job = qiskit.execute(mixed_state, backend_sim)\n",
        "result = job.result()\n",
        "\n",
        "counts1 = result.get_counts(mixed_state[0])\n",
        "counts2 = result.get_counts(mixed_state[1])\n",
        "\n",
        "import collections\n",
        "ground = collections.Counter(counts1)\n",
        "excited = collections.Counter(counts2)\n",
        "qiskit.tools.visualization.plot_histogram(ground + excited)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scXu3XZvWF3t"
      },
      "source": [
        "You can see here that when we measure the mixed state in the superposition basis that the results are not correlated, which is different from our previous entangled example \"bell_measureXX\". This shows that a mixed state is not actually entangled."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xiwAv1NwWF3u"
      },
      "source": [
        "# More Information\n",
        "\n",
        "This is just a starting point for learning about quantum computation. There are a several additional resources where to go for more information on this topic. This workshop was heavily based off of the community notebooks in the [qiskit-tutorials repository](https://github.com/Qiskit/qiskit-tutorials) these continue on and explore these topics in more detail:\n",
        "\n",
        "1. **Amplitude and Phase**: https://github.com/Qiskit/qiskit-tutorials/blob/master/community/terra/qis_intro/amplitude_and_phase.ipynb\n",
        "2. **Testing Entanglement**: https://github.com/Qiskit/qiskit-tutorials/blob/master/community/terra/qis_intro/entanglement_testing.ipynb\n",
        "3. **Quantum Teleportation and Superdense Coding**: https://github.com/Qiskit/qiskit-tutorials/blob/master/community/terra/qis_intro/teleportation_superdensecoding.ipynb\n",
        "\n",
        "The qiskit-tutorials repository also contains many other Jupyter notebooks covering a variety of topics. One thing that can be fun is applying these principles to make games: https://github.com/Qiskit/qiskit-tutorials/tree/master/community/games contains several games on Quantum computers.\n",
        "\n",
        "If you're interested in seeing applications and algorithms that are using quantum computation take a look at the [Qiskit Aqua](https://qiskit.org/aqua) which provides a Python library for quantum alogrithms.\n",
        "\n",
        "A paper outlining everything talked about here in more detail along with basic alogrithms building off of these concepts: https://arxiv.org/abs/1903.04359"
      ]
    }
  ],
  "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.2"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}