quantum_basics_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CB: Second notebook going over basics of eigenvectors and eigenvalues.\n",
    "# CB: This follows section 2.1.5 in N&C.\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eigenstuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "Eigenvector $v$ and eigenvalue $\\lambda$ of operator $\\mathbf{A}$:\n",
       "    \n",
       "$$\\mathbf{A}(v) = \\lambda v$$\n",
       "\n",
       "The vector's direction, under operator's action, is unchanged.  The scale/magnitude is the eigenvalue.\n",
       "\n",
       "Nielsen and Chuang Dirac/quantum computing notation where eigenvalue matches eigenvector:\n",
       "\n",
       "$$\\mathbf{A}|v\\rangle = v|v\\rangle$$\n",
       "\n",
       "Since, in computational basis, entries of 1 multiplied by the eigenvalue $\\lambda_i$ will just be the eigenvalue, $\\lambda_i$.\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "Eigenvector $v$ and eigenvalue $\\lambda$ of operator $\\mathbf{A}$:\n",
    "    \n",
    "$$\\mathbf{A}(v) = \\lambda v$$\n",
    "\n",
    "The vector's direction, under operator's action, is unchanged.  The scale/magnitude is the eigenvalue.\n",
    "\n",
    "Nielsen and Chuang Dirac/quantum computing notation where eigenvalue matches eigenvector:\n",
    "\n",
    "$$\\mathbf{A}|v\\rangle = v|v\\rangle$$\n",
    "\n",
    "Since, in computational basis, entries of 1 multiplied by the eigenvalue $\\lambda_i$ will just be the eigenvalue, $\\lambda_i$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "Characteristic function to find eigenvalues.\n",
       "\n",
       "$$c(\\lambda) \\equiv det|\\mathbf{A} - \\lambda\\mathbf{I}|$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "Characteristic function to find eigenvalues.\n",
    "\n",
    "$$c(\\lambda) \\equiv det|\\mathbf{A} - \\lambda\\mathbf{I}|$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "Example of 2 by 2 determinant:\n",
       "    \n",
       "$$det\\left(\n",
       "\\begin{bmatrix}\n",
       "a & b \\\\\n",
       "c & d \\\\\n",
       "\\end{bmatrix} \n",
       "\\right) =\n",
       "ad - cb\n",
       "\n",
       "$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "Example of 2 by 2 determinant:\n",
    "    \n",
    "$$det\\left(\n",
    "\\begin{bmatrix}\n",
    "a & b \\\\\n",
    "c & d \\\\\n",
    "\\end{bmatrix} \n",
    "\\right) =\n",
    "ad - cb\n",
    "\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "Calculate $\\mathbf{A} - \\lambda\\mathbf{I}$\n",
       "\n",
       "$$\\mathbf{A} - \\lambda\\mathbf{I} = \n",
       "\\begin{bmatrix}\n",
       "a & b \\\\\n",
       "c & d \\\\\n",
       "\\end{bmatrix}  - \n",
       "\\lambda \\begin{bmatrix}\n",
       "1 & 0 \\\\\n",
       "0 & 1 \\\\\n",
       "\\end{bmatrix} =\n",
       "\\begin{bmatrix}\n",
       "a - \\lambda & b \\\\\n",
       "c & d - \\lambda \\\\\n",
       "\\end{bmatrix} = \n",
       "\\mathbf{A_\\lambda}\n",
       "$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "Calculate $\\mathbf{A} - \\lambda\\mathbf{I}$\n",
    "\n",
    "$$\\mathbf{A} - \\lambda\\mathbf{I} = \n",
    "\\begin{bmatrix}\n",
    "a & b \\\\\n",
    "c & d \\\\\n",
    "\\end{bmatrix}  - \n",
    "\\lambda \\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & 1 \\\\\n",
    "\\end{bmatrix} =\n",
    "\\begin{bmatrix}\n",
    "a - \\lambda & b \\\\\n",
    "c & d - \\lambda \\\\\n",
    "\\end{bmatrix} = \n",
    "\\mathbf{A_\\lambda}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "Calculate $det(\\mathbf{A_\\lambda})$\n",
       "\n",
       "$$det(\\mathbf{A_\\lambda}) = ?$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "Calculate $det(\\mathbf{A_\\lambda})$\n",
    "\n",
    "$$det(\\mathbf{A_\\lambda}) = ?$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "\n",
       "\n",
       "$$c(\\lambda) = 0$$\n",
       "\n",
       "Will enable solving to find eigenvalues.  \n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "\n",
    "\n",
    "$$c(\\lambda) = 0$$\n",
    "\n",
    "Will enable solving to find eigenvalues.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "If eigenvectors of a matrix (operator, linear transformation) are unchanged, \n",
       "the eigenvectors are found by setting the matrix times unknown vector $v$ equal to zero vector.\n",
       "\n",
       "$$\\mathbf{A_\\lambda} v = \\mathbf{0}$$\n",
       "\n",
       "$$\\mathbf{A_\\lambda} v = \\mathbf{A_\\lambda} \\begin{bmatrix}\n",
       "x \\\\\n",
       "y \\\\\n",
       "\\end{bmatrix} = \\mathbf{0}$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "If eigenvectors of a matrix (operator, linear transformation) are unchanged, \n",
    "the eigenvectors are found by setting the matrix times unknown vector $v$ equal to zero vector.\n",
    "\n",
    "$$\\mathbf{A_\\lambda} v = \\mathbf{0}$$\n",
    "\n",
    "$$\\mathbf{A_\\lambda} v = \\mathbf{A_\\lambda} \\begin{bmatrix}\n",
    "x \\\\\n",
    "y \\\\\n",
    "\\end{bmatrix} = \\mathbf{0}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Examples: Pauli matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\n",
       "The Pauli matrices $I, X, Y, Z$ (see N&C 2.1.3) are the following (can also be denoted with $\\sigma$):\n",
       "    \n",
       "$$\\sigma_I = \n",
       "\\begin{bmatrix}\n",
       "1 & 0 \\\\\n",
       "0 & 1 \\\\\n",
       "\\end{bmatrix}$$\n",
       "\n",
       "$$\\sigma_x = \n",
       "\\begin{bmatrix}\n",
       "0 & 1 \\\\\n",
       "1 & 0 \\\\\n",
       "\\end{bmatrix}$$\n",
       "\n",
       "$$\\sigma_y = \n",
       "\\begin{bmatrix}\n",
       "0 & -i \\\\\n",
       "i & 0 \\\\\n",
       "\\end{bmatrix}$$\n",
       "\n",
       "$$\\sigma_z = \n",
       "\\begin{bmatrix}\n",
       "1 & 0 \\\\\n",
       "0 & -1 \\\\\n",
       "\\end{bmatrix}$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%latex\n",
    "\n",
    "The Pauli matrices $I, X, Y, Z$ (see N&C 2.1.3) are the following (can also be denoted with $\\sigma$):\n",
    "    \n",
    "$$\\sigma_I = \n",
    "\\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & 1 \\\\\n",
    "\\end{bmatrix}$$\n",
    "\n",
    "$$\\sigma_x = \n",
    "\\begin{bmatrix}\n",
    "0 & 1 \\\\\n",
    "1 & 0 \\\\\n",
    "\\end{bmatrix}$$\n",
    "\n",
    "$$\\sigma_y = \n",
    "\\begin{bmatrix}\n",
    "0 & -i \\\\\n",
    "i & 0 \\\\\n",
    "\\end{bmatrix}$$\n",
    "\n",
    "$$\\sigma_z = \n",
    "\\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & -1 \\\\\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.  Create numpy objects representing the Pauli matrices.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here is the identity matrix for you.\n",
    "sigma_I = np.array([[1,0],[0,1]])\n",
    "sigma_I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.  Use np.linalg.eig to calculate eigenvalues of Pauli matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 1.]),\n",
       " array([[1., 0.],\n",
       "        [0., 1.]]))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eig(sigma_I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Compute the eigenvalues and right eigenvectors of a square array.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "a : (..., M, M) array\n",
       "    Matrices for which the eigenvalues and right eigenvectors will\n",
       "    be computed\n",
       "\n",
       "Returns\n",
       "-------\n",
       "w : (..., M) array\n",
       "    The eigenvalues, each repeated according to its multiplicity.\n",
       "    The eigenvalues are not necessarily ordered. The resulting\n",
       "    array will be of complex type, unless the imaginary part is\n",
       "    zero in which case it will be cast to a real type. When `a`\n",
       "    is real the resulting eigenvalues will be real (0 imaginary\n",
       "    part) or occur in conjugate pairs\n",
       "\n",
       "v : (..., M, M) array\n",
       "    The normalized (unit \"length\") eigenvectors, such that the\n",
       "    column ``v[:,i]`` is the eigenvector corresponding to the\n",
       "    eigenvalue ``w[i]``.\n",
       "\n",
       "Raises\n",
       "------\n",
       "LinAlgError\n",
       "    If the eigenvalue computation does not converge.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "eigvals : eigenvalues of a non-symmetric array.\n",
       "eigh : eigenvalues and eigenvectors of a real symmetric or complex\n",
       "       Hermitian (conjugate symmetric) array.\n",
       "eigvalsh : eigenvalues of a real symmetric or complex Hermitian\n",
       "           (conjugate symmetric) array.\n",
       "scipy.linalg.eig : Similar function in SciPy that also solves the\n",
       "                   generalized eigenvalue problem.\n",
       "scipy.linalg.schur : Best choice for unitary and other non-Hermitian\n",
       "                     normal matrices.\n",
       "\n",
       "Notes\n",
       "-----\n",
       "\n",
       ".. versionadded:: 1.8.0\n",
       "\n",
       "Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
       "details.\n",
       "\n",
       "This is implemented using the ``_geev`` LAPACK routines which compute\n",
       "the eigenvalues and eigenvectors of general square arrays.\n",
       "\n",
       "The number `w` is an eigenvalue of `a` if there exists a vector\n",
       "`v` such that ``a @ v = w * v``. Thus, the arrays `a`, `w`, and\n",
       "`v` satisfy the equations ``a @ v[:,i] = w[i] * v[:,i]``\n",
       "for :math:`i \\in \\{0,...,M-1\\}`.\n",
       "\n",
       "The array `v` of eigenvectors may not be of maximum rank, that is, some\n",
       "of the columns may be linearly dependent, although round-off error may\n",
       "obscure that fact. If the eigenvalues are all different, then theoretically\n",
       "the eigenvectors are linearly independent and `a` can be diagonalized by\n",
       "a similarity transformation using `v`, i.e, ``inv(v) @ a @ v`` is diagonal.\n",
       "\n",
       "For non-Hermitian normal matrices the SciPy function `scipy.linalg.schur`\n",
       "is preferred because the matrix `v` is guaranteed to be unitary, which is\n",
       "not the case when using `eig`. The Schur factorization produces an\n",
       "upper triangular matrix rather than a diagonal matrix, but for normal\n",
       "matrices only the diagonal of the upper triangular matrix is needed, the\n",
       "rest is roundoff error.\n",
       "\n",
       "Finally, it is emphasized that `v` consists of the *right* (as in\n",
       "right-hand side) eigenvectors of `a`.  A vector `y` satisfying\n",
       "``y.T @ a = z * y.T`` for some number `z` is called a *left*\n",
       "eigenvector of `a`, and, in general, the left and right eigenvectors\n",
       "of a matrix are not necessarily the (perhaps conjugate) transposes\n",
       "of each other.\n",
       "\n",
       "References\n",
       "----------\n",
       "G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,\n",
       "Academic Press, Inc., 1980, Various pp.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> from numpy import linalg as LA\n",
       "\n",
       "(Almost) trivial example with real e-values and e-vectors.\n",
       "\n",
       ">>> w, v = LA.eig(np.diag((1, 2, 3)))\n",
       ">>> w; v\n",
       "array([1., 2., 3.])\n",
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])\n",
       "\n",
       "Real matrix possessing complex e-values and e-vectors; note that the\n",
       "e-values are complex conjugates of each other.\n",
       "\n",
       ">>> w, v = LA.eig(np.array([[1, -1], [1, 1]]))\n",
       ">>> w; v\n",
       "array([1.+1.j, 1.-1.j])\n",
       "array([[0.70710678+0.j        , 0.70710678-0.j        ],\n",
       "       [0.        -0.70710678j, 0.        +0.70710678j]])\n",
       "\n",
       "Complex-valued matrix with real e-values (but complex-valued e-vectors);\n",
       "note that ``a.conj().T == a``, i.e., `a` is Hermitian.\n",
       "\n",
       ">>> a = np.array([[1, 1j], [-1j, 1]])\n",
       ">>> w, v = LA.eig(a)\n",
       ">>> w; v\n",
       "array([2.+0.j, 0.+0.j])\n",
       "array([[ 0.        +0.70710678j,  0.70710678+0.j        ], # may vary\n",
       "       [ 0.70710678+0.j        , -0.        +0.70710678j]])\n",
       "\n",
       "Be careful about round-off error!\n",
       "\n",
       ">>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])\n",
       ">>> # Theor. e-values are 1 +/- 1e-9\n",
       ">>> w, v = LA.eig(a)\n",
       ">>> w; v\n",
       "array([1., 1.])\n",
       "array([[1., 0.],\n",
       "       [0., 1.]])\n",
       "\u001b[0;31mFile:\u001b[0m      /anaconda3/lib/python3.7/site-packages/numpy/linalg/linalg.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare the result with the documentation, make sure you understand what the function does.\n",
    "np.linalg.eig?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}