Pre-requisites/Chapter 2 - Math Tools II (Linear Operators).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 2 - Math Tools II (Linear Operators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the end of the last chapter, we showed that the state of a quantum system can be represented with a complex unit vector. Seeing as how a quantum computer is a machine that manipulates the quantum states of its qubits, we need to characterize how the state vector can evolve. Under the framework of quantum mechanics, _Linear Operators_ are used to describe the time evolution and measurement of quantum systems.\n",
    "\n",
    "In this chapter, we will describe what linear operators are and show how they relate to matrices. <a href=\"https://www.numpy.org\">Numpy</a> will also be used for Python implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Linear Operators\n",
    "Operators are functions that map vectors to vectors. \n",
    "$$ A : V \\rightarrow W,\\quad\\text{ where V and W are vector spaces.}$$\n",
    "If the operator $A$ maps the vector $|v\\rangle$ to $|w\\rangle$, then we write it as\n",
    "$$ A|v\\rangle = |w\\rangle.$$\n",
    "\n",
    "A linear operator is an operator that satisfies the conditions of lineararity, i.e.\n",
    "1. $$A \\left(|v\\rangle + |w\\rangle\\right) = \\left(A|v\\rangle\\right) + \\left(A|w\\rangle\\right)$$\n",
    "2. $$A \\left(c|v\\rangle\\right) = c \\left(A|v\\rangle\\right)$$\n",
    "\n",
    "Since every vector $|v\\rangle\\in V$ can be written as a linear combination of a set of basis vectors,\n",
    "$$ |v\\rangle = \\sum_{j} \\alpha_j |v_j\\rangle,$$\n",
    "knowing which vectors each basis vector is mapped to under the action of a linear operator allows us to calculate which vector any input vector is mapped to:\n",
    "$$ A|v\\rangle = A \\left(\\sum_{j} \\alpha_j |v_j\\rangle\\right) = \\sum_j \\alpha_j A|v_j\\rangle. $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing necessary modules: numpy can be used to describe matrices in two ways: np.array and np.matrix\n",
    "#Both were used in Chapter 1, but from now on, we will carry on with np.array\n",
    "#We'll also import a sympy function so that we can visualize matrices in a clearer way. This does not affect any calculation\n",
    "\n",
    "import numpy as np\n",
    "from sympy import Matrix, init_printing\n",
    "\n",
    "#This function uses SymPy to convert a numpy array into a clear matrix image\n",
    "\n",
    "def view(mat):\n",
    "    display(Matrix(mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "AB: \n",
      "[[ 42  36  30]\n",
      " [ 96  81  66]\n",
      " [150 126 102]]\n",
      "BA:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}18 & 24 & 30\\\\54 & 69 & 84\\\\90 & 114 & 138\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[18,  24,  30],\n",
       "[54,  69,  84],\n",
       "[90, 114, 138]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Importing necessary modules: numpy can be used to describe matrices in two ways: np.array and np.matrix\n",
    "#Both were used in Chapter 1, but from now on, we will carry on with np.array\n",
    "#We'll also import a sympy function so that we can visualize matrices in a clearer way. This does not affect any calculation\n",
    "\n",
    "import numpy as np\n",
    "from sympy import Matrix, init_printing\n",
    "\n",
    "#This function uses SymPy to convert a numpy array into a clear matrix image\n",
    "\n",
    "def view(mat):\n",
    "    display(Matrix(mat))#Defining a matrix in numpy, as an array\n",
    "\n",
    "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "\n",
    "print('Matrix A:')\n",
    "print(A)\n",
    "\n",
    "#Multiplying two matrices:\n",
    "\n",
    "B = np.array([[3,2,1],[6,5,4],[9,8,7]])\n",
    "\n",
    "print('AB: ')\n",
    "\n",
    "#Printing it\n",
    "\n",
    "print(A@B)\n",
    "\n",
    "print('BA:')\n",
    "\n",
    "#Viewing it... Looks better\n",
    "\n",
    "view(B@A)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([17,  8,  5])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's say we have a vector |u> ε R^3, where |u> = (5,2,1). Let's say we have a vector |v> = 3|u> + (2,2,2)\n",
    "#In other words, every component of |u>, u_i, is now mapped to 3u_i + 2\n",
    "import numpy as np\n",
    "\n",
    "u = np.array([5,2,1])\n",
    "v = 3*u+2\n",
    "\n",
    "v\n",
    "\n",
    "#How do we generally represent this operation, though? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Representing Linear Operators with Matrices\n",
    "\n",
    "A matrix is a two-dimensional array of numbers, and in chapter 1 we saw how to represent vectors as either column or row matrices — matrices with exactly one column or row respectively. A matrix can also be used to numerically represent a linear operator.\n",
    "\n",
    "Let $V$ be an $n$-dimensional vector space with a basis set $\\left\\{|v_k\\rangle : 1\\leq k \\leq n \\right\\}$, $W$ be an $m$-dimensional vector space with a basis set $\\left\\{|w_j\\rangle : 1\\leq j \\leq m \\right\\}$ and $A : V \\rightarrow W$ be a linear operator such that\n",
    "$$ A|v_k\\rangle = \\sum_{j=1}^m a_{jk} |w_j\\rangle. $$\n",
    "\n",
    "Then an $m\\times n$ matrix (a matrix with $m$ rows and $n$ columns) can be used to represent $A$:\n",
    "$$ A \\equiv \\begin{pmatrix}\n",
    "a_{11} & a_{12} & \\cdots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\cdots & a_{mn}\n",
    "\\end{pmatrix} $$\n",
    "\n",
    "The columns of this matrix are the column vectors $A|v_k\\rangle$.\n",
    "\n",
    "From here onwards, we will assume that our matrix representations use orthonormal basis sets, and for any operator $A: V\\rightarrow V$, we use the same basis set for input and output bases.\n",
    "\n",
    "### 2.2.1 Matrix-Vector Multiplication\n",
    "A matrix is a numerical representation of an operator, and matrix-vector multiplication is a numerical\n",
    "method to calculate the action of an operator on a vector.\n",
    "\n",
    "First, use the same basis of $V$ to represent $|v\\rangle$ as a column matrix: \n",
    "$$|v\\rangle = \\sum_{k=1}^n \\alpha_k |v_k\\rangle \\equiv \\begin{pmatrix} \\alpha_1 \\\\ \\alpha_2 \\\\ \\vdots \\\\ \\alpha_n \\end{pmatrix}.$$ \n",
    "\n",
    "Now since $A|v\\rangle = \\sum_{k=1}^n \\alpha_k |v_k\\rangle$, we can calculate the outcome of applying the operator:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "a_{11} & a_{12} & \\cdots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\cdots & a_{mn}\n",
    "\\end{pmatrix}\n",
    "\\begin{pmatrix} \\alpha_1 \\\\ \\alpha_2 \\\\ \\vdots \\\\ \\alpha_n \\end{pmatrix}\n",
    "&=\n",
    "\\alpha_1 \\begin{pmatrix} a_{11} \\\\ a_{21} \\\\ \\vdots \\\\ a_{m1} \\end{pmatrix} + \n",
    "\\alpha_2 \\begin{pmatrix} a_{12} \\\\ a_{22} \\\\ \\vdots \\\\ a_{m2} \\end{pmatrix} + \n",
    "\\cdots + \n",
    "\\alpha_n \\begin{pmatrix} a_{1n} \\\\ a_{2n} \\\\ \\vdots \\\\ a_{mn} \\end{pmatrix} \\\\\n",
    "&= \n",
    "\\begin{pmatrix} \n",
    "\\sum_{k=1}^n \\alpha_k a_{1k} \\\\ \n",
    "\\sum_{k=1}^n \\alpha_k a_{2k} \\\\ \n",
    "\\vdots \\\\ \n",
    "\\sum_{k=1}^n \\alpha_k a_{mk} \n",
    "\\end{pmatrix}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "### 2.2.2 Composition of Operators and Matrix-Matrix Multiplication\n",
    "Let $A: V\\rightarrow W$ and $B: W \\rightarrow X$ be linear operators acting on the vector spaces $V, W$ and $X$. The linear operator $BA : V \\rightarrow X$ is defined as the composition of $A$ and $B$:\n",
    "$$ BA|v\\rangle = B(A |v\\rangle)$$\n",
    "\n",
    "Since this composition is also a linear operator, it can also be numerically represented with a matrix. Given basis sets $\\{|v_i\\rangle\\}, \\{|w_j\\rangle\\}$ and $\\{|x_k\\rangle\\}$ for $V,W$ and $X$ respectively, and the matrices $A$ and $B$ written according to those basis sets:\n",
    "\n",
    "$$\n",
    "A = \n",
    "\\begin{pmatrix}\n",
    "| & | &  & | \\\\\n",
    "A|v_1\\rangle & A|v_2\\rangle & \\cdots & A|v_n\\rangle \\\\\n",
    "| & | &  & | \\end{pmatrix}\n",
    "=\n",
    "\\begin{pmatrix}\n",
    "a_{11} & a_{12} & \\cdots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\cdots & a_{mn} \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "B = \n",
    "\\begin{pmatrix}\n",
    "| & | &  & | \\\\\n",
    "B|w_1\\rangle & B|w_2\\rangle & \\cdots & B|w_m\\rangle \\\\\n",
    "| & | &  & | \\end{pmatrix}\n",
    "=\n",
    "\\begin{pmatrix}\n",
    "b_{11} & b_{12} & \\cdots & b_{1m} \\\\\n",
    "b_{21} & b_{22} & \\cdots & b_{2m} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "b_{o1} & b_{o2} & \\cdots & b_{om} \\end{pmatrix}\n",
    "$$\n",
    "$$\n",
    "\\begin{align}\n",
    "BA &=\n",
    "\\begin{pmatrix}\n",
    "| & | &  & | \\\\\n",
    "BA|v_1\\rangle & BA|v_2\\rangle & \\cdots & BA|v_n\\rangle \\\\\n",
    "| & | &  & | \\end{pmatrix} \\\\\n",
    "&= \n",
    "\\begin{pmatrix}\n",
    "b_{11} & b_{12} & \\cdots & b_{1m} \\\\\n",
    "b_{21} & b_{22} & \\cdots & b_{2m} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "b_{o1} & b_{o2} & \\cdots & b_{om} \\end{pmatrix}\n",
    "\\begin{pmatrix}\n",
    "a_{11} & a_{12} & \\cdots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\cdots & a_{mn} \\end{pmatrix} \\\\\n",
    "&=\n",
    "\\begin{pmatrix}\n",
    "c_{11} & c_{12} & \\cdots & c_{1n} \\\\\n",
    "c_{21} & c_{22} & \\cdots & c_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "c_{o1} & c_{o2} & \\cdots & c_{on}\n",
    "\\end{pmatrix}, \\quad\\text{where } c_{ij} = \\sum_{k=1}^m b_{ik} a_{kj}\n",
    "\\end{align} \n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "AB: \n",
      "[[ 42  36  30]\n",
      " [ 96  81  66]\n",
      " [150 126 102]]\n",
      "BA:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}18 & 24 & 30\\\\54 & 69 & 84\\\\90 & 114 & 138\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[18,  24,  30],\n",
       "[54,  69,  84],\n",
       "[90, 114, 138]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Defining a matrix in numpy, as an array\n",
    "\n",
    "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "\n",
    "print('Matrix A:')\n",
    "print(A)\n",
    "\n",
    "#Multiplying two matrices:\n",
    "\n",
    "B = np.array([[3,2,1],[6,5,4],[9,8,7]])\n",
    "\n",
    "print('AB: ')\n",
    "\n",
    "#Printing it\n",
    "\n",
    "print(A@B)\n",
    "\n",
    "print('BA:')\n",
    "\n",
    "#Viewing it... Looks better. Doesn't affect any calculation\n",
    "\n",
    "view(B@A)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1\\\\1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 1],\n",
       "[1, 0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Is X|0> = |1>:\n",
      "True\n",
      "\n",
      "X is a very important operator in quantum computing because it essentially acts as a quantum NOT gate. The implication of this tranformation is taking a qubit which is always 0 and making it always 1 and vice versa (X|1>=|0>).\n"
     ]
    }
   ],
   "source": [
    "#Representing a Linear Operator as Matrices\n",
    "\n",
    "#Application to Quantum Computing\n",
    "\n",
    "#X|0> = |1>, where, according to section 1.10, |0> = (1,0) and |1> = (0,1)\n",
    "\n",
    "zero = np.array([1,0])\n",
    "one = np.array([0,1])\n",
    "\n",
    "X = np.array([[0,1],[1,0]])\n",
    "print('X = ')\n",
    "view(X)\n",
    "\n",
    "print('')\n",
    "\n",
    "#Checking to see if X|0>\n",
    "XZero = X@zero\n",
    "print('Is X|0> = |1>:')\n",
    "#Prints true if all elements in both matrices are equal\n",
    "print(XZero.all() == one.all())\n",
    "\n",
    "print('')\n",
    "\n",
    "print('X is a very important operator in quantum computing because it essentially acts as a quantum NOT gate. The implication of this tranformation is taking a qubit which is always 0 and making it always 1 and vice versa (X|1>=|0>).')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Adjoint / Hermitian Conjugate\n",
    "Let $A : V\\rightarrow V$ be a linear operator, then there exists a linear operator $A^\\dagger : V \\rightarrow V$ defined such that for any vectors $|v\\rangle, |w\\rangle \\in V$ the inner product\n",
    "$$ (|v\\rangle, A|w\\rangle) = (A^\\dagger|v\\rangle, |w\\rangle)$$\n",
    "\n",
    "$A^\\dagger$ is called the _adjoint_ or _Hermitian conjugate_ of $A$.\n",
    "\n",
    "Although it may not seem obvious, given a matrix representation of $A$, we can compute the matrix representation of $A^\\dagger$ in the same basis by taking the transpose of $A$ and replacing every element with its complex conjugate:\n",
    "\n",
    "$$\n",
    "A \\equiv \\begin{pmatrix}\n",
    "a_{11} & a_{12} & \\cdots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{n1} & a_{n2} & \\cdots & a_{nn}\n",
    "\\end{pmatrix}\n",
    "\\implies\n",
    "A^\\dagger \\equiv \\begin{pmatrix}\n",
    "a_{11}^* & a_{21}^* & \\cdots & a_{n1}^* \\\\\n",
    "a_{12}^* & a_{22}^* & \\cdots & a_{n2}^* \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{1n}^* & a_{2n}^* & \\cdots & a_{nn}^*\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1.0 i & 1.0 + 2.0 i\\\\3.0 & - 1.0 i\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1.0*I, 1.0 + 2.0*I],\n",
       "[  3.0,      -1.0*I]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjoint of A = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}- 1.0 i & 3.0\\\\1.0 - 2.0 i & 1.0 i\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[     -1.0*I,   3.0],\n",
       "[1.0 - 2.0*I, 1.0*I]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculating the adjoint of a matrix\n",
    "A = np.array([ [0+1j, 1+2j], [3+0j, 0-1j] ])\n",
    "print('A = ')\n",
    "view(A)\n",
    "\n",
    "def adjoint(A):\n",
    "    return A.conj().transpose()\n",
    "\n",
    "A_dagger = adjoint(A)\n",
    "print('Adjoint of A = ')\n",
    "view(A_dagger)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Eigenvectors and Eigenvalues\n",
    "For linear operators that map to the same vector space, $A: V\\rightarrow V$, a vector $|v\\rangle\\neq \\mathbf{0}$ that is \n",
    "mapped to a scaled version of itself\n",
    "$$ A|v\\rangle = \\lambda|v\\rangle$$\n",
    "is called an _eigenvector_ of $A$, and the scale factor $\\lambda$ is called the _eigenvalue_ of $|v\\rangle$.\n",
    "\n",
    "For example, the matrix \n",
    "$$ X = \\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}$$\n",
    "has eigenvectors $|+\\rangle = \\frac{1}{\\sqrt2} \\binom{1}{1}$ and $|-\\rangle = \\frac{1}{\\sqrt2}\\binom{1}{-1}$ with eigenvalues +1 and -1 respectively.\n",
    "\n",
    "The set of all eigenvectors of an operator, sharing the same eigenvalue $\\lambda$, forms a vector space which is a subspace of $V$, we call this the $\\lambda$-eigenspace of the operator.\n",
    "\n",
    "### 2.4.1 Normal Operators\n",
    "If a set of eigenvectors forms a basis of $V$, we call it an eigenbasis. In the context of quantum computing, we will only consider operators that have at least one orthonormal eigenbasis that spans $V$. We call these operators _Normal operators_. A normal operator $N$ can be written in the form\n",
    "$$ N = \\sum_{k} \\lambda_k |v_k\\rangle \\langle v_k| $$\n",
    "where $\\{|v_k\\rangle\\}$ forms an orthonormal eigenbasis of $V$, and $\\lambda_k$ is the eigenvalue of $|v_k\\rangle$. This is called the _spectral decomposition_ of $N$.\n",
    "\n",
    "The spectral decomposition of $X$ is\n",
    "$$ X = (+1)|+\\rangle \\langle +| + (-1)|-\\rangle \\langle -| $$\n",
    "\n",
    "### 2.4.2 Trace\n",
    "The trace of an operator is the sum of all of its eigenvalues. It can be calculated by adding all of the diagonal elements of any matrix representation of the operator.\n",
    "\n",
    "### 2.4.3 Determinant\n",
    "The determinant of an operator is the product of all of its eigenvalues. [Click here](https://en.wikipedia.org/wiki/Determinant) to see how to numerically calculate the determinant of a matrix representation of an operator.\n",
    "\n",
    "Given this definition, you may now understand why solving for $\\lambda$ in the equation\n",
    "$$ \\det(A - \\lambda I) = 0$$\n",
    "allows us to calculate the eigenvalues of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1\\\\1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 1],\n",
       "[1, 0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X has 2 eigenvalues: [ 1. -1.]\n",
      "|+><+| = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.5 & 0.5\\\\0.5 & 0.5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0.5, 0.5],\n",
       "[0.5, 0.5]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|-><-| = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.5 & -0.5\\\\-0.5 & 0.5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 0.5, -0.5],\n",
       "[-0.5,  0.5]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|+><+| - |-><-| = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.0 & 1.0\\\\1.0 & 0.0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0.0, 1.0],\n",
       "[1.0, 0.0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Verifying the eigenvalues of X\n",
    "X = np.array([ [0, 1], [1, 0] ])\n",
    "print('X = ')\n",
    "view(X)\n",
    "\n",
    "eigenvalues = np.linalg.eigvals(X)\n",
    "print(f'X has {len(eigenvalues)} eigenvalues:', eigenvalues)\n",
    "\n",
    "# Verifying the spectral decomposition of X\n",
    "\n",
    "# The eigenvectors\n",
    "plus  = np.array([ [np.sqrt(0.5)], [np.sqrt(0.5)] ])\n",
    "minus = np.array([ [np.sqrt(0.5)], [-np.sqrt(0.5)] ])\n",
    "\n",
    "# |+><+|\n",
    "plus_plus = plus @ adjoint(plus)\n",
    "print('|+><+| = ')\n",
    "view(plus_plus)\n",
    "# |-><-|\n",
    "minus_minus = minus @ adjoint(minus)\n",
    "print('|-><-| = ')\n",
    "view(minus_minus)\n",
    "\n",
    "# the spectral decomposition\n",
    "sd = plus_plus - minus_minus\n",
    "print('|+><+| - |-><-| = ')\n",
    "view(sd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Types of Linear Operators\n",
    "The following classifications of linear operators will be used all the time in quantum computing:\n",
    "### 2.5.1 Identity Operator\n",
    "The identity operator maps all vectors onto themselves.\n",
    "$$ I |v\\rangle = |v\\rangle, \\forall |v\\rangle \\in V $$\n",
    "The matrix representation of the identity operator is a square matrix with 1s in all of the diagonal elements and 0s everywhere else in any choice of basis. So in a 2-dimensional space,\n",
    "$$ I_2 = \\begin{pmatrix} 1 & 0 \\\\ 0 & 1 \\end{pmatrix}. $$\n",
    "\n",
    "Every vector in $V$ is an eigenvector of the identity, with eigenvalue 1.\n",
    "### Unitary Operators\n",
    "A unitary operator $U$ is one whose adjoint is its own inverse:\n",
    "$$ U U^\\dagger = I = U^\\dagger U. $$\n",
    "\n",
    "The eigenvalues of a unitary operator all have length 1 (hence the name unitary).\n",
    "\n",
    "The columns of a unitary matrix are all mutually orthogonal to eachother, i.e. a unitary operator maps orthogonal bases to orthogonal bases.\n",
    "\n",
    "Unitary operators preserve inner products, i.e\n",
    "$$ (|v\\rangle, |w\\rangle) = (U|v\\rangle, U|w\\rangle) $$\n",
    "This can be easily shown using bra-ket notation:\n",
    "$$ \\begin{align}\n",
    "(U|v\\rangle, U|w\\rangle) &= (U|v\\rangle)^\\dagger U|w\\rangle \\\\\n",
    "&= \\langle v | U^\\dagger U |w\\rangle \\\\\n",
    "&= \\langle v | I |w\\rangle \\\\\n",
    "&= \\langle v|w \\rangle \\\\\n",
    "&= (|v\\rangle, |w\\rangle)\n",
    "\\end{align} $$\n",
    "\n",
    "Unitary operators are used to describe the time evolution of quantum systems.\n",
    "### Hermitian Operators\n",
    "A Hermitian operator $H$ is one that is equal to its adjoint:\n",
    "$$ H = H^\\dagger. $$\n",
    "\n",
    "The eigenvalues of a Hermitian operator are all real numbers, moreover the matrix representation of a Hermitian operator must have real numbers on the diagonal.\n",
    "\n",
    "Eigenvectors of a Hermitian operator with different eigenvalues are orthogonal.\n",
    "\n",
    "Hermitian operators are used to describe measurements of quantum systems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.707106781186548 & 0.707106781186548\\\\0.707106781186548 i & - 0.707106781186548 i\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[  0.707106781186548,    0.707106781186548],\n",
       "[0.707106781186548*I, -0.707106781186548*I]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U† = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.707106781186548 & - 0.707106781186548 i\\\\0.707106781186548 & 0.707106781186548 i\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0.707106781186548, -0.707106781186548*I],\n",
       "[0.707106781186548,  0.707106781186548*I]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UU† = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1.0 & - 4.26642158858964 \\cdot 10^{-17} i\\\\4.26642158858964 \\cdot 10^{-17} i & 1.0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                   1.0, -4.26642158858964e-17*I],\n",
       "[4.26642158858964e-17*I,                     1.0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This +/- 4.2*10^(-17)i is 0, so UU† = I\n",
      "\n",
      "Is <v|w> = <v| U† U |w>?\n",
      "Yes\n",
      "\n",
      "Do the eigenvalues have unit length?\n",
      "Yes\n",
      "Yes\n"
     ]
    }
   ],
   "source": [
    "# Unitary operators\n",
    "#Defining U and U†\n",
    "\n",
    "#U = 0.5*np.array([[1+1j, 1-1j],[1-1j, 1+1j]])\n",
    "U = np.sqrt(0.5)*np.array([ [1, 1], [0+1j, 0-1j] ])\n",
    "UDagger = adjoint(U)\n",
    "\n",
    "print('U = ')\n",
    "view(U)\n",
    "print('U† = ')\n",
    "view(UDagger)\n",
    "\n",
    "\n",
    "#|v> and |psi> = U|v>\n",
    "v = np.array([1,2])\n",
    "w = np.array([3,4])\n",
    "\n",
    "# <v|w>\n",
    "v_w = adjoint(v)@w\n",
    "# <v| UDagger U |w>\n",
    "v_U_w = adjoint(v)@UDagger@U@w\n",
    "\n",
    "#UU† (Supposed to be I_2)\n",
    "\n",
    "print('UU† = ')\n",
    "view(U@UDagger)\n",
    "\n",
    "print('This +/- 4.2*10^(-17)i is 0, so UU† = I')\n",
    "\n",
    "\n",
    "print('')\n",
    "\n",
    "print('Is <v|w> = <v| U† U |w>?')\n",
    "print('Yes' if np.abs(v_w - v_U_w) < 1e-5 else 'No')\n",
    "\n",
    "print('\\nDo the eigenvalues have unit length?')\n",
    "eigvals = np.linalg.eigvals(U)\n",
    "for x in eigvals:\n",
    "    print('Yes' if np.abs(np.abs(x) - 1.0 < 1e-5) else 'No')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1.0 i\\\\- 1.0 i & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[     0, 1.0*I],\n",
       "[-1.0*I,     0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y† = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1.0 i\\\\- 1.0 i & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[     0, 1.0*I],\n",
       "[-1.0*I,     0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are the eigenvalues real?\n",
      "Yes\n",
      "Yes\n"
     ]
    }
   ],
   "source": [
    "# Hermitian Operator\n",
    "Y = np.array([ [0, 0+1j], [0-1j, 0] ])\n",
    "print('Y = ')\n",
    "view(Y)\n",
    "print('Y† = ')\n",
    "view(adjoint(Y))\n",
    "\n",
    "print('Are the eigenvalues real?')\n",
    "for x in np.linalg.eigvals(Y):\n",
    "    print('Yes' if np.abs(x.imag) < 1e-5 else 'No')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 Tensor Product\n",
    "\n",
    "A _tensor product_ is a way to \"combine\" two vector spaces into a larger vector space.\n",
    "$$\\otimes : V \\times W \\rightarrow V\\otimes W$$\n",
    "\n",
    "### 2.6.1 Kronecker Product\n",
    "Within the context of quantum computing, the _Kronecker product_ is be used to numerically evaluate the tensor product of vectors and/or matrices.\n",
    "\n",
    "For a matrix\n",
    "$$ A = \\begin{pmatrix} \n",
    "a_{11} & a_{12} & \\cdots a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\cdots a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\cdots a_{mn} \\\\\n",
    "\\end{pmatrix} $$\n",
    "and any matrix $B$, the Kronecker product can be evaluated as \n",
    "$$\n",
    "A\\otimes B = \\begin{pmatrix} \n",
    "a_{11} B & a_{12} B & \\cdots a_{1n} B \\\\\n",
    "a_{21} B & a_{22} B & \\cdots a_{2n} B \\\\\n",
    "\\vdots & \\vdots & \\ddots \\vdots \\\\\n",
    "a_{m1} B & a_{m2} B & \\cdots a_{mn} B \\\\\n",
    "\\end{pmatrix} $$\n",
    "Where each $a_{jk} B$ is a submatrix that is just $B$ scaled by $a_{jk}$.\n",
    "\n",
    "The outer product $|v\\rangle \\langle w|$ is implicitly the tensor product $|v\\rangle\\otimes\\langle w|$,\n",
    "\n",
    "We often drop the $\\otimes$ symbol between two kets or two bras,\n",
    "$$ |v\\rangle\\otimes|w\\rangle \\equiv |v\\rangle|w\\rangle \\equiv |vw\\rangle $$\n",
    "\n",
    "### 2.6.2 Properties of the Tensor Product\n",
    "* $$ (\\alpha |v\\rangle) \\otimes |w\\rangle = \\alpha (|v\\rangle|w\\rangle) = |v\\rangle \\otimes (\\alpha |w\\rangle) $$\n",
    "* $$(|v_1\\rangle + |v_2\\rangle)\\otimes |w\\rangle = \\alpha|v_1\\rangle|w\\rangle + |v_2\\rangle|w\\rangle $$\n",
    "* $$|v\\rangle \\otimes( |w_1\\rangle + |w_2\\rangle) = |v\\rangle|w_1\\rangle + |v\\rangle|w_2\\rangle $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1],\n",
       "[2],\n",
       "[3]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}4\\\\5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[4],\n",
       "[5]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor product |v>⊗|w> = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}4\\\\5\\\\8\\\\10\\\\12\\\\15\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 4],\n",
       "[ 5],\n",
       "[ 8],\n",
       "[10],\n",
       "[12],\n",
       "[15]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer product |v><w| = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}4 & 5\\\\8 & 10\\\\12 & 15\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 4,  5],\n",
       "[ 8, 10],\n",
       "[12, 15]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X =\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1\\\\1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 1],\n",
       "[1, 0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & -1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1,  0],\n",
       "[0, -1]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X⊗Z = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & 1 & 0\\\\0 & 0 & 0 & -1\\\\1 & 0 & 0 & 0\\\\0 & -1 & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0,  0, 1,  0],\n",
       "[0,  0, 0, -1],\n",
       "[1,  0, 0,  0],\n",
       "[0, -1, 0,  0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z⊗X = \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 1 & 0 & 0\\\\1 & 0 & 0 & 0\\\\0 & 0 & 0 & -1\\\\0 & 0 & -1 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0, 1,  0,  0],\n",
       "[1, 0,  0,  0],\n",
       "[0, 0,  0, -1],\n",
       "[0, 0, -1,  0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v = np.array([1,2,3]).transpose()\n",
    "w = np.array([4,5]).transpose()\n",
    "\n",
    "print('v = ')\n",
    "view(v)\n",
    "print('w = ')\n",
    "view(w)\n",
    "\n",
    "print('Tensor product |v>⊗|w> = ')\n",
    "view(np.kron(v,w))\n",
    "\n",
    "print('Outer product |v><w| = ')\n",
    "view(np.outer(v,w))\n",
    "\n",
    "X = np.array([[0,1],[1,0]])\n",
    "Z = np.array([[1,0],[0,-1]])\n",
    "\n",
    "print('X =')\n",
    "view(X)\n",
    "print('Z = ')\n",
    "view(Z)\n",
    "\n",
    "print('X⊗Z = ')\n",
    "view(np.kron(X,Z))\n",
    "\n",
    "print('Z⊗X = ')\n",
    "view(np.kron(Z,X))\n",
    "\n",
    "#Excercise. Create the equivelent to np.kron() for ket vectors (i.e two column matrices)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}