lecture_7_preparing_basis_states.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing Basis States in PennyLane"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing PennyLane and the wrapped version of NumPy\n",
    "\n",
    "PennyLane is an open source software for quantum machine learning and quantum computing algorithms. It integrates standard machine learning software and tools, such as TensorFlow and Pytorch, with quantum computing software like IBM's Qiskit, Microsoft's Q#, and Google's Cirq. It also has its own built in functions and models, and allows various hardware backends such as the quantum computers available from IBM via free cloud access. PennyLane has a wrapped version of NumPy that we import rather than the standard NumPy we have been using. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pennylane in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (0.8.1)\n",
      "Requirement already satisfied: networkx in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (2.3)\n",
      "Requirement already satisfied: scipy in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (1.4.1)\n",
      "Requirement already satisfied: numpy in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (1.18.0)\n",
      "Requirement already satisfied: semantic-version==2.6 in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (2.6.0)\n",
      "Requirement already satisfied: toml in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (0.10.0)\n",
      "Requirement already satisfied: autograd in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (1.3)\n",
      "Requirement already satisfied: appdirs in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from pennylane) (1.4.3)\n",
      "Requirement already satisfied: decorator>=4.3.0 in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from networkx->pennylane) (4.4.0)\n",
      "Requirement already satisfied: future>=0.15.2 in /Users/amelieschreiber/anaconda3/lib/python3.7/site-packages (from autograd->pennylane) (0.17.1)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install pennylane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis States\n",
    "\n",
    "In PennyLane, and other quantum computing software, we often want to prepare basis states. This is something we will return to again in the future when we study specific cases of quantum circuits, but having some basic introduction to state preparation now seems appropriate since the are simply tensor products of the basis states $|0\\rangle$ and $|1\\rangle$. In particular, we can prepare states like\n",
    "\n",
    "\\begin{align}\n",
    "|00 \\rangle &= |0\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes \\begin{pmatrix} 1\\\\0 \\end{pmatrix} = \\begin{pmatrix} 1\\\\0\\\\0\\\\0 \\end{pmatrix} \\\\\n",
    "|01 \\rangle &= |0\\rangle \\otimes |1\\rangle = \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes \\begin{pmatrix} 0\\\\1 \\end{pmatrix} = \\begin{pmatrix} 0\\\\1\\\\0\\\\0 \\end{pmatrix} \\\\\n",
    "|10 \\rangle &= |1\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 0\\\\1 \\end{pmatrix} \\otimes \\begin{pmatrix} 1\\\\0 \\end{pmatrix} = \\begin{pmatrix} 0\\\\0\\\\1\\\\0 \\end{pmatrix} \\\\\n",
    "|11 \\rangle &= |1\\rangle \\otimes |1\\rangle = \\begin{pmatrix} 0\\\\1 \\end{pmatrix} \\otimes \\begin{pmatrix} 0\\\\1 \\end{pmatrix} = \\begin{pmatrix} 0\\\\0\\\\0\\\\1 \\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define these in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define single qubit states spin-up and spin-down\n",
    "u = np.matrix([[1],\n",
    "               [0]])\n",
    "d = np.matrix([[0],\n",
    "               [1]])\n",
    "\n",
    "# Define the basis states:\n",
    "uu = np.kron(u, u)\n",
    "ud = np.kron(u, d)\n",
    "du = np.kron(d, u)\n",
    "dd = np.kron(d, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|00> =\n",
      "[[1]\n",
      " [0]\n",
      " [0]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "print('|00> =')\n",
    "print(uu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|01> =\n",
      "[[0]\n",
      " [1]\n",
      " [0]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "print('|01> =')\n",
    "print(ud)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|10> =\n",
      "[[0]\n",
      " [0]\n",
      " [1]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "print('|10> =')\n",
    "print(du)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|11> =\n",
      "[[0]\n",
      " [0]\n",
      " [0]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "print('|11> =')\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking this further, we can define states like:\n",
    "    \n",
    "\\begin{align}\n",
    "|000\\rangle = |0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 1\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0 \\end{pmatrix}\n",
    "\\end{align}\n",
    "\n",
    "\\begin{align}\n",
    "|010\\rangle = |0\\rangle \\otimes |1\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 0\\\\0\\\\1\\\\0\\\\0\\\\0\\\\0\\\\0 \\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In PennyLane the following code defines a device (quantum computer or simulator) on which to run code. We will use the default simulator for now since the code is very simple and running it on an actual quantum computer is unnecessary. The number of wires is equal to the number of qubits we are using. The number of shots is the number of times we want to run the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=2, shots=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can define an array that corresponds to the basis state $|00\\rangle$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "uu = np.array([0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a function `circuit()` that defines a quantum circuit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit():\n",
    "    qml.BasisState(uu, wires=[0, 1])\n",
    "    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we define a `qnode` class that runs on the device we have defined and samples the qubits and gives a $+1$ for spin-up and a $-1$ for spin down. This runs a quantum function (circuit) that we have just defined. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    qml.BasisState(uu, wires=[0, 1])\n",
    "    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))\n",
    "\n",
    "print(circuit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since qubits are by default in the spin-up state for any quantum circuit, and since we did not prepare any special initial state or perform any operations on the qubits, we get an expectation value of $+1$ for both when sampling the circuit. The vector above show a $+1$ in the first and second entry meaning it is measuring two spin-up states. Let's define a new state to prepare corresponding to $|01 \\rangle$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "ud = np.array([0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's define a new `qnode` to sample corresponding to this prepared state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1]\n",
      " [-1]]\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit():\n",
    "    qml.BasisState(ud, wires=[0, 1])\n",
    "    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))\n",
    "\n",
    "print(circuit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, we get a $+1$ in the first component, corresponding to the spin-up state, and we get a $-1$ in the second component corresponding to the spin-down state. We can also tell PennyLane to perform multiple \"shots\" or samples by defining a new device:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev2 = qml.device(\"default.qubit\", wires=2, shots=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  1  1  1  1  1  1  1  1  1]\n",
      " [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1]]\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev2)\n",
    "def circuit():\n",
    "    qml.BasisState(ud, wires=[0, 1])\n",
    "    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))\n",
    "\n",
    "print(circuit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives us 10 output samples instead of just one. If we define a new array corresponding to the state $|11\\rangle$,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dd = np.array([1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a new 'qnode' with the new device we just defined, and we should expect an output vector of \n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "-1\\\\-1\n",
    "\\end{pmatrix}\n",
    "\\end{align}\n",
    "\n",
    "ten times, corresponding to the ten samples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1 -1 -1 -1 -1 -1 -1 -1 -1 -1]\n",
      " [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1]]\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev2)\n",
    "def circuit():\n",
    "    qml.BasisState(dd, wires=[0, 1])\n",
    "    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1))\n",
    "\n",
    "print(circuit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will return to this when we discuss measurements and expectation values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "### Write code to compute the following basis states:\n",
    "\n",
    "1. $|000 \\rangle$\n",
    "2. $|001 \\rangle$\n",
    "3. $|010 \\rangle$\n",
    "4. $|011 \\rangle$\n",
    "5. $|100 \\rangle$\n",
    "6. $|101 \\rangle$\n",
    "7. $|110 \\rangle$\n",
    "8. $|111 \\rangle$\n",
    "\n",
    "Now, compute these by hand to verify your code is correct. For example, the first computation will be\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes\n",
    "\\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes\n",
    "\\begin{pmatrix} 0\\\\1 \\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Define a defaul device with \"3 wires\" and \"5 shots\".\n",
    "10. Define an array 'uud' for the basis state $|001\\rangle$.\n",
    "11. Now define a `qnode` that will print the samples: \n",
    "\n",
    "> `qml.sample(qml.PauliZ(0))`\n",
    "\n",
    "> `qml.sample(qml.PauliZ(1))` \n",
    "\n",
    "> `qml.sample(qml.PauliZ(2))`\n",
    "\n",
    "12. Run your 'qnode' and verify that you get the output vector\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "1 \\\\ 1 \\\\ -1\n",
    "\\end{pmatrix}\n",
    "\\end{align}\n",
    "\n",
    "five times.\n",
    "\n",
    "13. Try doing this with the other basis states given in Exercises 1-8."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}