lecture_2_complex_numbers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complex Numbers in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complex numbers are fundamental to quantum computing so understanding them will be a good first step in understanding how quantum computers work. Quantum computers process information differently from classical computers like your laptop, smartphone, or a supercomputer used to train modern neural networks. They do this in part by using interference patterns of *amplitudes* which are complex numbers that describe the states of the qubits in a quantum computer. \n",
    "\n",
    "Complex numbers are always of the form\n",
    "\n",
    "\\begin{align}\n",
    "\\alpha = a + bi\n",
    "\\end{align}\n",
    "\n",
    "where $a$ and $b$ are real numbers and $i = \\sqrt{-1}$. Complex numbers can be used in Python by importing [NumPy](https://numpy.org/): \n",
    "\n",
    "> \"the fundamental package for scientific computing with Python. It contains among other things:\n",
    "> - a powerful N-dimensional array object\n",
    "> - sophisticated (broadcasting) functions\n",
    "> - tools for integrating C/C++ and Fortran code\n",
    "> - useful linear algebra, Fourier transform, and random number capabilities\n",
    "> Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing NumPy\n",
    "\n",
    "We will primarily use NumPy for arithmetic with complex numbers as well as for linear algebra. To import NumPy we type the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic of Complex Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will be working with complex numbers in this tutorial. If complex numbers are completely new and strange to you, consider watching the short video by [Khan Academy](https://www.youtube.com/watch?v=SP-YJe7Vldo&list=PLucNEDEq4z_AdqV1ii0vmH0clNhYPI4lK&index=2). In Python the imaginary unit $i$ is instead represented as $j$, and must always be written with a coefficient. So in Python, we must write $1j$ instead of $j$, and $-1j$ instead of just $-j$. Let's check that $j^2 = -1$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-1j)*(-1j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the output is:\n",
    "\n",
    "\\begin{align}\n",
    "-1 + 0j = -1. \n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's define two complex numbers \n",
    "\n",
    "\\begin{align}\n",
    "z &= 3+2j \\\\\n",
    "w &= -2-5j\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 3 + 2j\n",
    "w = -2 - 5j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to print $z$ and $w$, we could simply type them into a Jupyter cell as follows (followed by `shift+enter`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3+2j)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-2-5j)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also type the `print()` command (followed by `shift+enter`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+2j)\n"
     ]
    }
   ],
   "source": [
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-2-5j)\n"
     ]
    }
   ],
   "source": [
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to label what we are printing we can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z= (3+2j)\n"
     ]
    }
   ],
   "source": [
    "print(\"z=\", z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the complex number w is: (-2-5j)\n"
     ]
    }
   ],
   "source": [
    "print(\"the complex number w is:\", w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can print the real and imaginary parts of complex numbers as follows for $z = 3+4i:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z= (3+2j)\n",
      "Real(z)= 3.0\n",
      "Imag(Z)= 2.0\n"
     ]
    }
   ],
   "source": [
    "print('z=', z)\n",
    "print('Real(z)=', np.real(z))\n",
    "print('Imag(Z)=', np.imag(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w= (-2-5j)\n",
      "Real(w)= -2.0\n",
      "Imag(w)= -5.0\n"
     ]
    }
   ],
   "source": [
    "print('w=', w)\n",
    "print('Real(w)=', np.real(w))\n",
    "print('Imag(w)=', np.imag(w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complex Conjugates\n",
    "\n",
    "We can compute the **complex conjugates** $z^*$ and $w^*$, which just negates the imaginary part of the complex numbers as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3-2j)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.conj(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-2+5j)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.conj(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, complex conjugation negates the imaginary part of the complex number. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Norms/Absolute Values\n",
    "\n",
    "We can compute the **absolute value** of the complex numbers \n",
    "\n",
    "\\begin{align} ||z|| &= \\sqrt{zz^*} = \\sqrt{|z|^2},\\\\ ||w|| &= \\sqrt{ww^*} = \\sqrt{|w|^2}, \\end{align} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "||z||= 3.605551275463989\n"
     ]
    }
   ],
   "source": [
    "print('||z||=', np.abs(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "||w||= 5.385164807134504\n"
     ]
    }
   ],
   "source": [
    "print('||w||=', np.abs(w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, there are many different arithmetic operations we can perform on complex numbers. Addition, subtraction, multiplication, and division are all defined for complex numbers and can be computer using NumPy. As an example, let's compute the following three values, \n",
    "\n",
    "- $z+w$\n",
    "- $z-w$\n",
    "- $w-z$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1-3j)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z+w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5+7j)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z-w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-5-7j)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w-z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Addition and subtraction of complex numbers is done *componentwise*, meaning the real parts and the complex parts are added or subtracted individually and do not effect each other. So, for example, \n",
    "\n",
    "\\begin{align}\n",
    "z+w = (3+2j) + (-2-5j) = (3-2) + (2-5)j = 1-3j. \n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also multiply complex numbers and divide them as well. This is also handled by NumPy. Let's compute the following three values, \n",
    "\n",
    "- $z \\cdot w$\n",
    "- $\\frac{z}{w}$\n",
    "- $\\frac{w}{z}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4-19j)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z*w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5517241379310345+0.37931034482758624j)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z/w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1.2307692307692308-0.8461538461538463j)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w/z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Define two complex numbers $u = 1-3j$ and $v = 5+2j$ in Python.\n",
    "2. Compute $u+v$. \n",
    "3. Compute $u-v$. \n",
    "4. Compute $v-u$. \n",
    "5. Compute $u \\cdot v$. \n",
    "6. Compute $\\frac{u}{v}$. \n",
    "7. Compute $\\frac{v}{u}$. \n",
    "8. Compute the complex conjugate of the following complex numbers:\n",
    "\\begin{align}\n",
    "u = 2-i, \\quad z = 3+4i, \\quad w = -9i\n",
    "\\end{align}\n",
    "9. Compute the absolute value (or norm) of $u, z,$ and $w$.\n",
    "10. Compute the absolute values using Python to check that they match your answers. Don't forget to use \"$j$\" instead of \"$i$\" in Python. "
   ]
  }
 ],
 "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
}