lecture_6_tensor_products.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor Products of Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing NumPy\n",
    "\n",
    "We will need to import NumPy for tensor products. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most common tensor products we will encounter throughout the following chapters of the book will be the tensor product of two qubits, which are represented by $2$-dimensional vector which have length (or \"norm\") $1$.\n",
    "\n",
    "The general rule for the tensor product of two $2$-dimensional vectors is as follows:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "a_1 \\\\ a_2\n",
    "\\end{pmatrix} \\otimes\n",
    "\\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1 \\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} \\\\ a_2 \\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix}\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1b_1 \\\\ a_1b_2 \\\\ a_2b_1 \\\\ a_2b_2\n",
    "\\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a numerical example:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "2 \\\\ 5\n",
    "\\end{pmatrix} \\otimes \n",
    "\\begin{pmatrix}\n",
    "3 \\\\ 1\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "2 \\begin{pmatrix}\n",
    "3 \\\\ 1\n",
    "\\end{pmatrix} \\\\ 5 \\begin{pmatrix}\n",
    "3 \\\\ 1\n",
    "\\end{pmatrix}\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "2 \\cdot 3 \\\\ 2 \\cdot 1 \\\\ 5 \\cdot 3 \\\\ 5 \\cdot 1\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "6 \\\\ 2 \\\\ 15 \\\\ 5\n",
    "\\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For an example using Python we will use the \"np.kron()\" function, which is the [Kronecker product](https://en.wikipedia.org/wiki/Kronecker_product), \n",
    "\n",
    "> \"In mathematics, the Kronecker product, sometimes denoted by ⊗, is an operation on two matrices of arbitrary size resulting in a block matrix. It is a generalization of the outer product (which is denoted by the same symbol) from vectors to matrices, and gives the matrix of the tensor product with respect to a standard choice of basis. The Kronecker product should not be confused with the usual matrix multiplication, which is an entirely different operation.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6],\n",
       "       [ 2],\n",
       "       [15],\n",
       "       [ 5]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define two ket-vectors\n",
    "\n",
    "A = np.array([[2], \n",
    "              [5]])\n",
    "\n",
    "B = np.array([[3],\n",
    "              [1]])\n",
    "\n",
    "# Take the Kronecker (tensor) product of the two column vectors\n",
    "np.kron(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define these two vectors as matrices which will allow us to compute Hermitian conjugates. The Kronecker product function 'np.kron()' will work all the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 6],\n",
       "        [ 2],\n",
       "        [15],\n",
       "        [ 5]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define the ket-vectors as 2x1 column matrices:\n",
    "ket_A = np.matrix([[2], \n",
    "                   [5]])\n",
    "\n",
    "ket_B = np.matrix([[3], \n",
    "                   [1]])\n",
    "\n",
    "# Compute their Kronecker product\n",
    "np.kron(ket_A, ket_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can also be done with complex vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[-6. +3.j],\n",
       "        [ 6. -8.j],\n",
       "        [-0. -9.j],\n",
       "        [ 6.+12.j]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define the ket-vectors as 2x1 column matrices:\n",
    "ket_psi = np.matrix([[2-1j], \n",
    "                     [3j]])\n",
    "\n",
    "ket_phi = np.matrix([[-3], \n",
    "                     [4-2j]])\n",
    "\n",
    "# Compute their Kronecker product\n",
    "np.kron(ket_psi, ket_phi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a more complicated example with two vectors of different dimensions:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "a_1 \\\\ a_2\n",
    "\\end{pmatrix} \\otimes \n",
    "\\begin{pmatrix}\n",
    "b_1 \\\\ b_2 \\\\ b_3\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1 \\begin{pmatrix}\n",
    "b_1 \\\\ b_2 \\\\ b_3\n",
    "\\end{pmatrix} \\\\\n",
    "a_2 \\begin{pmatrix}\n",
    "b_1 \\\\ b_2 \\\\ b_3\n",
    "\\end{pmatrix}\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1b_1 \\\\ a_1b_2 \\\\ a_1b_3 \\\\ a_2b_1 \\\\ a_2b_2 \\\\ a_2b_3\n",
    "\\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a corresponding numerical example:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "1 \\\\ 4\n",
    "\\end{pmatrix} \\otimes \n",
    "\\begin{pmatrix}\n",
    "5 \\\\ 2 \\\\ 4\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "1 \\begin{pmatrix}\n",
    "5 \\\\ 2 \\\\ 4\n",
    "\\end{pmatrix} \\\\\n",
    "4 \\begin{pmatrix}\n",
    "5 \\\\ 2 \\\\ 4\n",
    "\\end{pmatrix}\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "5 \\\\ 2 \\\\ 4 \\\\ 20 \\\\ 8 \\\\ 16\n",
    "\\end{pmatrix}\n",
    "\\end{align} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the code for computing this tensor product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 5],\n",
       "        [ 2],\n",
       "        [ 4],\n",
       "        [20],\n",
       "        [ 8],\n",
       "        [16]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ket_X = np.matrix([[1], \n",
    "                   [4]])\n",
    "\n",
    "ket_Y = np.matrix([[5], \n",
    "                   [2], \n",
    "                   [4]])\n",
    "\n",
    "np.kron(ket_X, ket_Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Using the following rule, \n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "a_1 \\\\ a_2 \\\\ a_3\n",
    "\\end{pmatrix} \\otimes\n",
    "\\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1 \\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} \\\\ a_2\\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} \\\\ a_3\\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix}\n",
    "\\end{pmatrix} = \n",
    "\\begin{pmatrix}\n",
    "a_1b_1 \\\\ a_1b_2 \\\\ a_2b_1 \\\\ a_2b_2 \\\\ a_3b_1 \\\\ a_3b_2\n",
    "\\end{pmatrix}\n",
    "\\end{align}\n",
    "\n",
    "compute the following tensor/Kroneckar product by hand:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "2 \\\\ 7 \\\\ 3\n",
    "\\end{pmatrix} \\otimes\n",
    "\\begin{pmatrix}\n",
    "5 \\\\ 9\n",
    "\\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write Python code to compute the above computation using the 'np.kron()' function. Remember to define two column (ket) vectors as matrices first.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Derive a general rule for the following tensor product by performing the tensor product inside the parenthesis first:\n",
    "\n",
    "\\begin{align}\n",
    "\\left( \\begin{pmatrix}\n",
    "a_1 \\\\ a_2\n",
    "\\end{pmatrix} \\otimes \n",
    "\\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix}\\right) \\otimes \n",
    "\\begin{pmatrix}\n",
    "c_1 \\\\ c_2\n",
    "\\end{pmatrix}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Now derive a general rule for the following tensor product by performing the tensor product in the parenthesis first:\n",
    "\n",
    "\\begin{align}\n",
    "\\begin{pmatrix}\n",
    "a_1 \\\\ a_2\n",
    "\\end{pmatrix} \\otimes \n",
    "\\left( \\begin{pmatrix}\n",
    "b_1 \\\\ b_2\n",
    "\\end{pmatrix} \\otimes \n",
    "\\begin{pmatrix}\n",
    "c_1 \\\\ c_2\n",
    "\\end{pmatrix}\\right)\n",
    "\\end{align}\n",
    "\n",
    "Convince yourself that your results from the previous two computations are in fact equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5. Write Python code to compute $|0\\rangle \\otimes |0 \\rangle $. \n",
    "6. Write Python code to compute $|0\\rangle \\otimes |1 \\rangle $. \n",
    "7. Write Python code to compute $|1\\rangle \\otimes |0 \\rangle $.\n",
    "8. Write Python code to compute $|1\\rangle \\otimes |1 \\rangle $."
   ]
  }
 ],
 "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
}