Lab 1 - Vectors and Matrices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 1 - Vectors and Matrices\n",
    "This notebook demonstrates the use of vectors and matrices in IPython. Note that the basis is not explicit in any of these operations. You must keep track of the basis yourself (using variable names, or notes etc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array, dot, outer, sqrt, matrix\n",
    "from numpy.linalg import eig, eigvals\n",
    "from matplotlib.pyplot import hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rv = array([1,2])  # a row vector\n",
    "rv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv = array([[3],[4]])  # a column vector\n",
    "cv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two kinds of vector products we'll see: inner product (dot product) and outer product\n",
    "\n",
    "### 1) Use the function _dot(vector1, vector2)_ to find the dot product of rv and cv. Does the order of the arguments matter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(rv,cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (2,1) and (2,) not aligned: 1 (dim 1) != 2 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-c47554307e31>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (2,1) and (2,) not aligned: 1 (dim 1) != 2 (dim 0)"
     ]
    }
   ],
   "source": [
    "dot(cv,rv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Use the function _outer(vector1, vector2)_ to find the outer product of rv and cv. Does the order of the arguments matter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outer(rv,cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 6],\n",
       "       [4, 8]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outer(cv,rv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II. Complex vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1+2j)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Complex numbers in python have a j term:\n",
    "a = 1+2j\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.+2.j, 3.+2.j, 5.+1.j, 4.+0.j])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 = array([1+2j, 3+2j, 5+1j, 4+0j])\n",
    "v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complex conjugate changes the sign of the imaginary part:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.-2.j, 3.-2.j, 5.-1.j, 4.-0.j])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1.conjugate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Use _dot()_ and _.conjugate()_ to find the dot product of v1 and it's own conjugate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60+0j)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1.conjugate(),v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III. Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [-2,  3]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a two-dimensional array\n",
    "m1 = array([[0,1],[-2,3]])\n",
    "m1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, -2],\n",
       "       [ 1,  3]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can find transpose with the T method:\n",
    "m1.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2.]), array([[-0.70710678, -0.4472136 ],\n",
       "        [-0.70710678, -0.89442719]]))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find the eigenvalues and eigenvectors of a matrix:\n",
    "eig(m1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can also use the `matrix` type which is like array but restricts to 2D. Also, `matrix` adds `.H` and `.I` methods for hermitian and inverse, respectively. For more information, see Stack Overflow question [#4151128](http://stackoverflow.com/questions/4151128/what-are-the-differences-between-numpy-arrays-and-matrices-which-one-should-i-u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "m2 = matrix( [[2,1],[2,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[2, 2],\n",
       "        [1, 1]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2.H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "evals, evec = eig(m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3., 0.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.70710678, -0.4472136 ],\n",
       "        [ 0.70710678,  0.89442719]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use a question mark to get help on a command\n",
    "eig?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Examples:\n",
    "## Example 1.4\n",
    "Find the eigenvalues and eigenvectors of M = ([0,1],[-2,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "M14 = array([[0,1],[-2,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2.]), array([[-0.70710678, -0.4472136 ],\n",
       "        [-0.70710678, -0.89442719]]))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eig(M14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpret this result:\n",
    "the two eigenvalues are 1 and 2\n",
    "the eigenvectors are strange decimals, but we can check them against the stated solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7071067811865475"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/sqrt(2)  # this is the value for both entries in the first eigenvector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4472135954999579"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/sqrt(5)  # this is the first value in the second eigenvector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8944271909999159"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2/sqrt(5)  # this is the second value in the second eigenvector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2.]), array([[-0.70710678, -0.4472136 ],\n",
       "        [-0.70710678, -0.89442719]]))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eig(M14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Signs are opposite compared to the book, but it turns out that (-) doesn't matter in the interpretation of eigenvectors: only \"direction\" matters (the relative size of the entries)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Problem 1.16 using Python functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "M16 = array([[0,-1j],[1j,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "evals, evecs = eig(M16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.        -0.70710678j,  0.70710678+0.j        ],\n",
       "       [ 0.70710678+0.j        ,  0.        -0.70710678j]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.        -0.70710678j,  0.70710678+0.j        ])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.70710678+0.j        , 0.        -0.70710678j])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot(evecs[:,0].conjugate(),evecs[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Using QuTiP\n",
    "Keeping track of row and column vectors in Ipython is somewhat artificial and tedious. The QuTiP library is designed to take care of many of these headaches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qutip import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 2.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra\n",
       "Qobj data =\n",
       "[[1. 2.]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a row vector:\n",
    "qv = Qobj([[1,2]])\n",
    "qv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0\\\\2.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[1.]\n",
       " [2.]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the corresponding column vector\n",
    "qv.dag()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra\\begin{equation*}\\left(\\begin{array}{*{11}c}(1.0+2.0j) & (4.0-1.0j)\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra\n",
       "Qobj data =\n",
       "[[1.+2.j 4.-1.j]]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv2 = Qobj([[1+2j,4-1j]])\n",
    "qv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}(1.0-2.0j)\\\\(4.0+1.0j)\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[1.-2.j]\n",
       " [4.+1.j]]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv2.dag()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vector products in QuTiP\n",
    "Only need to know one operator: \"\\*\"\n",
    "The product will depend on the order, either inner or outer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[1], [1]], shape = (1, 1), type = bra\\begin{equation*}\\left(\\begin{array}{*{11}c}22.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[1], [1]], shape = (1, 1), type = bra\n",
       "Qobj data =\n",
       "[[22.]]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv2*qv2.dag()  # inner product (dot product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}5.0 & (2.0-9.0j)\\\\(2.0+9.0j) & 17.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
       "Qobj data =\n",
       "[[ 5.+0.j  2.-9.j]\n",
       " [ 2.+9.j 17.+0.j]]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv2.dag()*qv2  # outer product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix in QuTiP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\\begin{equation*}\\left(\\begin{array}{*{11}c}1.0 & 2.0\\\\2.0 & 1.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = True\n",
       "Qobj data =\n",
       "[[1. 2.]\n",
       " [2. 1.]]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qm = Qobj([[1,2],[2,1]])\n",
    "qm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  3.])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qm.eigenenergies()  # in quantum (as we will learn) eigenvalues often correspond to energy levels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "evals, evecs = qm.eigenstates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[-0.70710678]\n",
       " [ 0.70710678]],\n",
       "       Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[0.70710678]\n",
       " [0.70710678]]], dtype=object)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}-0.707\\\\0.707\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[-0.70710678]\n",
       " [ 0.70710678]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example from class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False\\begin{equation*}\\left(\\begin{array}{*{11}c}0.0 & 1.0\\\\-2.0 & 3.0\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False\n",
       "Qobj data =\n",
       "[[ 0.  1.]\n",
       " [-2.  3.]]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv = Qobj([[0,1],[-2,3]])\n",
    "qv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "evals, evecs = qv.eigenstates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.+0.j, 2.+0.j])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[0.70710678]\n",
       " [0.70710678]],\n",
       "       Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[0.4472136 ]\n",
       " [0.89442719]]], dtype=object)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evecs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}0.707\\\\0.707\\\\\\end{array}\\right)\\end{equation*}"
      ],
      "text/plain": [
       "Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket\n",
       "Qobj data =\n",
       "[[0.70710678]\n",
       " [0.70710678]]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv*evecs[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv*evecs[0] == evals[0]*evecs[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv*evecs[1] == evals[1]*evecs[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some additional examples we have already done by hand:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1.2 using the _hist()_ function.\n",
    "Create a histogram of the data and from it estimate the probability distribution. Use min and max values for the range of 5 and 14, and use 5 bins (5 and 6 go in the first bin)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "data = [10,13,14,14,6,8,7,9,12,14,13,11,10,7,7]\n",
    "# Fill in the hist() function:\n",
    "n, bins, patches = hist(data, bins=9, range=(5,14))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1.8\n",
    "Find the constant $c$ that normalizes the probability density:\n",
    "$$p(x) =\n",
    "\\begin{cases}\n",
    "ce^{-ax},  & x \\geq 0 \\\\[2ex]\n",
    "0 & x < 0\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "**Hint:** using sympy, we can calculate the relevant integral. The conds='none' asks the solver to ignore any strange conditions on the variables in the integral. This is fine for most of our integrals. Usually the variables are real and well-behaved numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{c}{a}$"
      ],
      "text/plain": [
       "c/a"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Partial Solution:\n",
    "from sympy import *\n",
    "c,a,x = symbols(\"c a x\")\n",
    "Q.positive((c,a))\n",
    "first = integrate( c*exp(-a*x) ,(x,0,oo),conds='none')\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check = integrate( a*exp(-a*x) ,(x,0,oo),conds='none')\n",
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "python3"
  },
  "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.4"
  },
  "nteract": {
   "version": "0.15.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}