Lab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 3: Entangle More Qubits! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An additional power of quantum is that we can entangle two particles or pieces of information together such that having the knowledge of one piece will provide us with knowledge about the other. There are different ways in which we can generate entanglement using quantum gates, but the one requirement is that we utilize two-qubit gates. These gates are actually difficult to implement physically and therefore, remain a limitation of near-term quantum computing. Thus, it is important that we find ways to create short depth circuits that use less two-qubit gates. \n",
    "\n",
    "In this lab, you will see how this entanglement becomes harder to generate with an increased number of qubits! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Necessary Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the necessary packages and libraries\n",
    "from pyquil.quil import Program\n",
    "import pyquil.api as api\n",
    "from pyquil.gates import *\n",
    "import matplotlib.pyplot as plt\n",
    "from random import *\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "qvm = api.QVMConnection()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pyquil Notation Tricks "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 1 #Sets the number of qubits or coin flips \n",
    "\n",
    "theta = math.pi #Sets the 1-qubit gate rotation angle theta to pi\n",
    "\n",
    "main_program = Program() #Creates a quantum circuit program \n",
    "\n",
    "main_program += H(0) #Performs a Hadamard Gate on the 0th qubit \n",
    "\n",
    "main_program += X(0) #Performs a Not Gate on the 0th qubit \n",
    "\n",
    "main_program += CNOT(0,1) #Performs a Controlled-Not Gate with 0th qubit as the control and the 1st qubit as the target\n",
    "\n",
    "main_program += RZ(theta, 0) #Performs a Pauli Z Rotation by angle theta on the 0th qubit \n",
    "\n",
    "main_program += RX(theta, 0) #Performs a Pauli X Rotation by angle theta on the 0th qubit \n",
    "\n",
    "main_program += RY(theta, 0) #Performs a Pauli Y Rotation by angle theta on the 0th qubit \n",
    "\n",
    "wave_function =  qvm.wavefunction(main_program) #Get the output quantum circuit wavefunction\n",
    "\n",
    "probs_dist    =  wave_function.get_outcome_probs()  #Get the probability distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Circuit 1: The Challenge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to create the state of an equal probability for '0000' and '1111' (and zero probability for all the other states). Below is not a solution as this is very hard to generate without the help of a classical algorithm to find our optimal rotation angles to do this. This is actually a place where machine learning can help quantum! Have a go in playing around with the angles below and introduce new gates! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0000': 0.06249999999999996, '0001': 0.06249999999999996, '0010': 0.06249999999999996, '0011': 0.06249999999999996, '0100': 0.06249999999999996, '0101': 0.06249999999999996, '0110': 0.06249999999999996, '0111': 0.06249999999999996, '1000': 0.06249999999999996, '1001': 0.06249999999999996, '1010': 0.06249999999999996, '1011': 0.06249999999999996, '1100': 0.06249999999999996, '1101': 0.06249999999999996, '1110': 0.06249999999999996, '1111': 0.06249999999999996}\n"
     ]
    }
   ],
   "source": [
    "main_program = Program() #Creates a quantum circuit program \n",
    "\n",
    "# We've added some Hadamard gates to get the state that gives every bitstring an equal probability.\n",
    "# Add (or remove) gates i order to create the state that gives '0000' and '1111' a probability of 0.5 each, and all\n",
    "# the other states a probability of 0\n",
    "main_program += H(0)\n",
    "main_program += H(1)\n",
    "main_program += H(2)\n",
    "main_program += H(3)\n",
    "\n",
    "# Once you've built the state, use this to print out the wave function\n",
    "wave_function =  qvm.wavefunction(main_program) #Get the output quantum circuit wavefunction\n",
    "probs_dist    =  wave_function.get_outcome_probs()  #Get the probability distribution\n",
    "print(probs_dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}