lectures/Eigenvalue-Polynomials.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"interact-js-shim\">\n",
       "    <script charset=\"utf-8\">\n",
       "(function (IPython, $, _, MathJax) {\n",
       "    $.event.special.destroyed = {\n",
       "\tremove: function(o) {\n",
       "\t    if (o.handler) {\n",
       "\t\to.handler.apply(this, arguments)\n",
       "\t    }\n",
       "\t}\n",
       "    }\n",
       "\n",
       "    var OutputArea = IPython.version >= \"4.0.0\" ? require(\"notebook/js/outputarea\").OutputArea : IPython.OutputArea;\n",
       "\n",
       "    var redrawValue = function (container, type, val) {\n",
       "\tvar selector = $(\"<div/>\");\n",
       "\tvar oa = new OutputArea(_.extend(selector, {\n",
       "\t    selector: selector,\n",
       "\t    prompt_area: true,\n",
       "\t    events: IPython.events,\n",
       "\t    keyboard_manager: IPython.keyboard_manager\n",
       "\t})); // Hack to work with IPython 2.1.0\n",
       "\n",
       "\tswitch (type) {\n",
       "\tcase \"image/png\":\n",
       "            var _src = 'data:' + type + ';base64,' + val;\n",
       "\t    $(container).find(\"img\").attr('src', _src);\n",
       "\t    break;\n",
       "\tcase \"text/latex\":\n",
       "\t\tif (MathJax){\n",
       "\t\t\tvar math = MathJax.Hub.getAllJax(container)[0];\n",
       "\t\t\tMathJax.Hub.Queue([\"Text\", math, val.replace(/^\\${1,2}|\\${1,2}$/g, '')]);\n",
       "\t\t\tbreak;\n",
       "\t\t}\n",
       "\tdefault:\n",
       "\t    var toinsert = OutputArea.append_map[type].apply(\n",
       "\t\toa, [val, {}, selector]\n",
       "\t    );\n",
       "\t    $(container).empty().append(toinsert.contents());\n",
       "\t    selector.remove();\n",
       "\t}\n",
       "    }\n",
       "\n",
       "\n",
       "    $(document).ready(function() {\n",
       "\tfunction initComm(evt, data) {\n",
       "\t    var comm_manager = data.kernel.comm_manager;\n",
       "        //_.extend(comm_manager.targets, require(\"widgets/js/widget\"))\n",
       "\t    comm_manager.register_target(\"Signal\", function (comm) {\n",
       "            comm.on_msg(function (msg) {\n",
       "                var val = msg.content.data.value;\n",
       "                $(\".signal-\" + comm.comm_id).each(function() {\n",
       "                var type = $(this).data(\"type\");\n",
       "                if (typeof(val[type]) !== \"undefined\" && val[type] !== null) {\n",
       "                    redrawValue(this, type, val[type], type);\n",
       "                }\n",
       "                });\n",
       "                delete val;\n",
       "                delete msg.content.data.value;\n",
       "            });\n",
       "\t    });\n",
       "\n",
       "\t    // coordingate with Comm and redraw Signals\n",
       "\t    // XXX: Test using Reactive here to improve performance\n",
       "\t    $([IPython.events]).on(\n",
       "\t\t'output_appended.OutputArea', function (event, type, value, md, toinsert) {\n",
       "\t\t    if (md && md.reactive) {\n",
       "                // console.log(md.comm_id);\n",
       "                toinsert.addClass(\"signal-\" + md.comm_id);\n",
       "                toinsert.data(\"type\", type);\n",
       "                // Signal back indicating the mimetype required\n",
       "                var comm_manager = IPython.notebook.kernel.comm_manager;\n",
       "                var comm = comm_manager.comms[md.comm_id];\n",
       "                comm.then(function (c) {\n",
       "                    c.send({action: \"subscribe_mime\",\n",
       "                       mime: type});\n",
       "                    toinsert.bind(\"destroyed\", function() {\n",
       "                        c.send({action: \"unsubscribe_mime\",\n",
       "                               mime: type});\n",
       "                    });\n",
       "                })\n",
       "\t\t    }\n",
       "\t    });\n",
       "\t}\n",
       "\n",
       "\ttry {\n",
       "\t    // try to initialize right away. otherwise, wait on the status_started event.\n",
       "\t    initComm(undefined, IPython.notebook);\n",
       "\t} catch (e) {\n",
       "\t    $([IPython.events]).on('kernel_created.Kernel kernel_created.Session', initComm);\n",
       "\t}\n",
       "    });\n",
       "})(IPython, jQuery, _, MathJax);\n",
       "</script>\n",
       "    <script>\n",
       "        window.interactLoadedFlag = true\n",
       "       $(\"#interact-js-shim\").bind(\"destroyed\", function () {\n",
       "           if (window.interactLoadedFlag) {\n",
       "               console.warn(\"JavaScript required by Interact will be removed if you remove this cell or run using Interact more than once.\")\n",
       "           }\n",
       "       })\n",
       "       $([IPython.events]).on(\"kernel_starting.Kernel kernel_restarting.Kernel\", function () { window.interactLoadedFlag = false })\n",
       "   </script>\n",
       "</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using Polynomials, PyPlot, Interact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Eigenvalues: The Key Idea\n",
    "\n",
    "If we can find a solution $x \\ne 0$ to\n",
    "\n",
    "$$\n",
    "Ax = \\lambda x\n",
    "$$\n",
    "\n",
    "then, for this vector, the matrix $A$ **acts like a scalar**.  $x$ is called an **eigenvector** of $A$, and $\\lambda$ is called an **eigenvalue**.\n",
    "\n",
    "In fact, for an $m \\times m$ matrix $A$, we typically find $m$ linearly independendent eigenvectors $x_1,x_2,\\ldots,x_m$ and $m$ corresponding eigenvalues $\\lambda_1, \\lambda_2, \\ldots, \\lambda_m$.   Such a matrix is called **diagonalizable**.  Most matrices are diagonalizable; we will deal with the rare \"defective\" (non-diagonalizable) case later.\n",
    "\n",
    "Given such a **basis of eigenvectors**, the key idea for using them is:\n",
    "\n",
    "1. Take any vector $x$ and expand it in this basis: $x = c_1 x_1 + \\cdots c_m x_n$, or $x = Xc$ or $c = X^{-1}x$ where $X$ is the matrix whose *columns are the eigenvectors*.\n",
    "\n",
    "2. For each eigenvector $x_k$, the matrix $A$ acts like a scalar $\\lambda_k$.  Multiplication or division corresponds to multiplying/dividing $x_k$ by $\\lambda_k$.  **Solve your problem for each eigenvector by treating A as the scalar λ**.\n",
    "\n",
    "3. Add up the solution to your problem (sum the basis of the eigenvectors).  That is, multiply the new coefficients by $X$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The characteristic polynomial\n",
    "\n",
    "To *find* the eigenvalues, one approach is to realize that $Ax = \\lambda x$ means:\n",
    "\n",
    "$$\n",
    "(A - \\lambda I) x = 0 \\, ,\n",
    "$$\n",
    "\n",
    "so the matrix $A - \\lambda I$ is **singular for any eigenvalue λ**.  This corresponds to the determinant being zero:\n",
    "\n",
    "$$\n",
    "p(\\lambda) = \\det(A - \\lambda I) = 0\n",
    "$$\n",
    "\n",
    "where $p(\\lambda)$ is the **characteristic polynomial of A: a polynomial of degree m** if $A$ is $m \\times m$.  The **roots of this polynomial are the eigenvalues λ**.\n",
    "\n",
    "A polynomial of degree $m$ has at most $m$ roots (possibly complex), and typically has $m$ distinct roots.  **This is why most matrices have $m$ distinct eigenvalues/eigenvectors**, and are therefore **diagonalizable**.\n",
    "\n",
    "For example, let's plot the $\\det(A - \\lambda I)$ for a 4×4 matrix $A$.  The result is a *quartic* curve whose roots are the four eigenvalues (computed by the built-in `eigvals` function):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " 0.1\n",
       " 0.2\n",
       " 0.4\n",
       " 0.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# some \"random\" matrix:\n",
    "A = [ 0.325  -0.075   0.075  -0.075\n",
    "      0.025   0.225  -0.025  -0.275\n",
    "       0.15   -0.05    0.25   -0.05 \n",
    "       -0.1    -0.1     0.1     0.4  ]\n",
    "\n",
    "λ = eigvals(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(I admit it: $A$ was not chosen at random to have such special eigenvalues.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x1224f4110>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject Text(0.5,1,u'characteristic polynomial')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ξ = linspace(0,0.6,100)\n",
    "plot(ξ, [det(A - λ*I) for λ in ξ], \"r-\")\n",
    "plot(ξ, zeros(ξ), \"k--\")\n",
    "plot(λ, zeros(λ), \"bo\")\n",
    "xlabel(L\"\\lambda\")\n",
    "ylabel(L\"\\det(A - \\lambda I)\")\n",
    "title(\"characteristic polynomial\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eigenvalue example:\n",
    "\n",
    "For example, consider the matrix\n",
    "\n",
    "$$\n",
    "A = \\begin{pmatrix} 1 & 1 \\\\ -2 & 4 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "whose eigenvalues are $\\lambda = \\{2,3\\}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Int64,2}:\n",
       "  1  1\n",
       " -2  4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [ 1 1\n",
    "     -2 4 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigvals(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The characteristic polynomial is\n",
    "\n",
    "$$\n",
    "\\det(A - \\lambda I) = \\det \\begin{pmatrix} 1 - \\lambda & 1 \\\\ -2 & 4 - \\lambda \\end{pmatrix} = (1 - \\lambda)(4 - \\lambda) - (1)(-2) = \\lambda^2 - 5\\lambda + 6 = (\\lambda - 2) (\\lambda - 3)\n",
    "$$\n",
    "\n",
    "where we have used high-school algebra to factor the polynomial.   Hence its roots are $\\lambda = \\{2, 3\\}$, as computed above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eigenvectors\n",
    "\n",
    "Once we have the eigenvalues, finding the eigenvectors is (in principle) easy: **the eigenvectors are just (a basis for) the nullspace**\n",
    "\n",
    "$$\n",
    "N(A - \\lambda I)\n",
    "$$\n",
    "\n",
    "when $\\lambda$ is an eigenvalue.\n",
    "\n",
    "For example, with the matrix above, let's take the eigenvalue $\\lambda_1 = 2$:\n",
    "\n",
    "$$\n",
    "A - 2I = \\begin{pmatrix} -1 & 1 \\\\ -2 & 2 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "We could go through Gaussian elimination to find the nullspace, but we can see by inspection that the second column is minus the first, hence $x_1 = (1, 1)$ is a basis for the nullspace:\n",
    "\n",
    "$$\n",
    "(A - 2I) x_1 = \\begin{pmatrix} -1 & 1 \\\\ -2 & 2 \\end{pmatrix} \\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "or\n",
    "\n",
    "$$\n",
    "A x_1 = 2 x_1\n",
    "$$\n",
    "\n",
    "as desired.  $x_1 = (1, 1)$ is an eigenvector!  Let's check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Int64,1}:\n",
       " 2\n",
       " 2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * [1, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the other eigenvalue, $\\lambda = 3$, we get:\n",
    "\n",
    "$$\n",
    "A - 3I = \\begin{pmatrix} -2 & 1 \\\\ -2 & 1 \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "from which it is obvious that a basis for the nullspace is $x_2 = (1, 2)$.  Let's check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Int64,1}:\n",
       " 3\n",
       " 6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * [1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, $A x_2 = 3 x_2$!\n",
    "\n",
    "For more complicated cases, of course, we might have to go through elimination to find the nullspace.  In practice, though, we alway just let the computer do it.  The `eig` function in Julia will return the eigenvalues and eigenvectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([2.0, 3.0], [-0.707107 -0.447214; -0.707107 -0.894427])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "λ, X = eig(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "λ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Float64,2}:\n",
       " -0.707107  -0.447214\n",
       " -0.707107  -0.894427"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The columns of `X` are indeed the eigenvectors from above, but they are scaled differently (they are normalized to unit length).  If we divide each one by its first element, though, we should recover our scaling from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 1.0\n",
       " 1.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,1] / X[1,1]  # first column, with first entry scaled to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 1.0\n",
       " 2.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,2] / X[1,2] # second column, with second entry scaled to 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, computing eigenvalues by hand, especially by this method, is even more pointless than doing Gaussian elimination by hand, for reasons explained below, so I will **focus more on the properties of eigenvalues and how to use them than how to compute them.**  The computer will give us their values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpose: Same eigenvalues!\n",
    "\n",
    "One of the properties of determinant is that $\\det A^T = \\det A$.   It follows that\n",
    "$$\\det(A-\\lambda I) = \\det\\left[ (A -\\lambda I)^T \\right] = \\det (A^T - \\lambda I)$$\n",
    "and therefore $A$ and $A^T$ have the **same eigenvalues!**  (They have the **same characteristic polynomial**.)\n",
    "\n",
    "Let's check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigvals(A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, same eigenvalues (2 and 3) as for $A$.\n",
    "\n",
    "However, $A$ and $A^T$ in general have **different eigenvectors**, because the **left and right nullspaces are not usually the same**.  $N(A - \\lambda I) \\ne N(A^T - \\lambda I)$ in general.  Here, the eigenvectors are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Float64,2}:\n",
       "  1.0   1.0\n",
       " -0.5  -1.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y = eigvecs(A')\n",
    "Y ./ Y[1,:]' # normalize so that the first components are 1, for easier comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that these are different from the (1,1) and (1,2) that we got above.\n",
    "\n",
    "As you might guess, the eigenvectors of $A^T$ are sometimes called its **left eigenvectors**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complex eigenvalues\n",
    "\n",
    "If we change the matrix to:\n",
    "$$\n",
    "\\begin{pmatrix} 1 & 3 \\\\ -2 & 4 \\end{pmatrix}\n",
    "$$\n",
    "we get a characteristic polynomial:\n",
    "$$\n",
    "\\det \\begin{pmatrix} 1 - \\lambda & 3 \\\\ -2 & 4 - \\lambda \\end{pmatrix} = (1 - \\lambda)(4 - \\lambda) - (3)(-2) = \\lambda^2 - 5\\lambda + 10\n",
    "$$\n",
    "whose roots, from the quadratic formula, are:\n",
    "$$\n",
    "\\lambda = \\frac{5 \\pm \\sqrt{5^2 - 40}}{2} = \\frac{5 \\pm \\sqrt{-15}}{2}\n",
    "$$\n",
    "which are complex!  Let's check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Complex{Float64},1}:\n",
       " 2.5+1.93649im\n",
       " 2.5-1.93649im"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigvals([1 3\n",
    "        -2 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.5 + 1.9364916731037085im"
      ],
      "text/plain": [
       "2.5 + 1.9364916731037085im"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5 + sqrt(15)*im) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, it matches our formula.\n",
    "\n",
    "**Eigenvalues may be complex numbers, even for real matrices**.  We can't avoid complex numbers for any longer in 18.06!\n",
    "\n",
    "(But, for real matrices, they are the [roots of a real polynomial](https://en.wikipedia.org/wiki/Complex_conjugate_root_theorem) and hence come in [complex conjugate pairs](https://en.wikipedia.org/wiki/Complex_conjugate).)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The perils of polynomial roots\n",
    "\n",
    "You might think that finding roots of polynomials is we must inevitably find eigenvalues.  In fact, although we use the characteristic polynomial to *think* about eigenvalues, in practice they are not used to *compute* them except for tiny matrices.\n",
    "\n",
    "In fact, working with the characteristic polynomial is a computational disaster in general, because **roots of polynomials are exponentially sensitive to their coefficients**.  Any tiny roundoff error leads to disaster.\n",
    "\n",
    "For example, consider the polynomial\n",
    "\n",
    "$$\n",
    "w(x) = (x - 1) (x - 2) (x - 3) \\cdots (x - 10)\n",
    "$$\n",
    "whose roots are, obviously, ${1,2,\\ldots,10}$.  What happens if we actually multiply this polynomial together and compute the roots from the coefficients?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3.6288e6 &#45; 1.062864e7&#8729;x &#43; 1.2753576e7&#8729;x^2 &#45; 8.4095e6&#8729;x^3 &#43; 3.41693e6&#8729;x^4 &#45; 902055.0&#8729;x^5 &#43; 157773.0&#8729;x^6 &#45; 18150.0&#8729;x^7 &#43; 1320.0&#8729;x^8 &#45; 55.0&#8729;x^9 &#43; 1.0&#8729;x^10"
      ],
      "text/plain": [
       "Poly(3.6288e6 - 1.062864e7*x + 1.2753576e7*x^2 - 8.4095e6*x^3 + 3.41693e6*x^4 - 902055.0*x^5 + 157773.0*x^6 - 18150.0*x^7 + 1320.0*x^8 - 55.0*x^9 + 1.0*x^10)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = prod([Poly([-n, 1.0]) for n = 1:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Already, this seems hard: how do we find roots of a high-degree polynomial?  More on this below.\n",
    "\n",
    "For the moment, we will just use a \"black box\" function `roots` provided by the Polynomials package to \"magically\" get the roots of $w$ from its coefficients:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Float64,1}:\n",
       " 10.0\n",
       "  9.0\n",
       "  8.0\n",
       "  7.0\n",
       "  6.0\n",
       "  5.0\n",
       "  4.0\n",
       "  3.0\n",
       "  2.0\n",
       "  1.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good!  The roots are what they should be.\n",
    "\n",
    "Howevever, suppose we make a *tiny error* in computing the coefficients.  Let's multiply each coefficient by $1 + \\epsilon$, where $\\epsilon$ is a *random small number* of root-mean-square value $R$.\n",
    "\n",
    "The following code plots the roots in the [complex plane](https://en.wikipedia.org/wiki/Complex_plane) for 100 random perturbations, and lets us vary the magnitude $R$ of the pertubation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "Interact.Options{:SelectionSlider,Any}(1: \"input\" = -6.5 Any , \"logR\", -6.5, \"-6.5\", 56, Interact.OptionDict(DataStructures.OrderedDict{Any,Any}(\"-12.0\"=>-12.0,\"-11.9\"=>-11.9,\"-11.8\"=>-11.8,\"-11.7\"=>-11.7,\"-11.6\"=>-11.6,\"-11.5\"=>-11.5,\"-11.4\"=>-11.4,\"-11.3\"=>-11.3,\"-11.2\"=>-11.2,\"-11.1\"=>-11.1…), Dict{Any,Any}(Pair{Any,Any}(-6.3, \"-6.3\"),Pair{Any,Any}(-2.3, \"-2.3\"),Pair{Any,Any}(-7.0, \"-7.0\"),Pair{Any,Any}(-1.3, \"-1.3\"),Pair{Any,Any}(-8.3, \"-8.3\"),Pair{Any,Any}(-9.1, \"-9.1\"),Pair{Any,Any}(-3.4, \"-3.4\"),Pair{Any,Any}(-10.1, \"-10.1\"),Pair{Any,Any}(-8.2, \"-8.2\"),Pair{Any,Any}(-3.0, \"-3.0\")…)), Any[], Any[], true, \"horizontal\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x1288f4d50>)"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "comm_id": "663b94a0-9a98-4f60-bad9-9f0ef6b1e40e",
      "reactive": true
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 10\n",
    "w = prod([Poly([-n, 1.0]) for n = 1:N])\n",
    "fig = figure()\n",
    "@manipulate for logR in -12:0.1:-1\n",
    "    withfig(fig) do\n",
    "        plot(1:N, zeros(10), \"r*\")\n",
    "        R = exp10(logR)\n",
    "        for i = 1:100\n",
    "            r = roots(Poly(coeffs(w) .* (1 .+ R .* randn(N+1))))\n",
    "            plot(real(r), imag(r), \"b.\")\n",
    "        end\n",
    "        xlabel(\"real part of roots\")\n",
    "        ylabel(\"imaginary part of roots\")\n",
    "        title(\"roots of \\$(x-1)\\\\cdots(x-10)\\$ with coeffs perturbed by R=$R\")\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even a **tiny error** causes the roots to be **complete garbage**.  This gets exponentially worse as the degree of the polynomials increases.\n",
    "\n",
    "Because computers inevitably use a finite precision (usually about 15 significant digits), the tiny roundoff errors mean that characteristic polynomials are a computational disaster if they are actually computed explicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Companion matrices\n",
    "\n",
    "Finding **roots of polynomials is *equivalent* to finding eigenvalues**.  Not only can you find eigenvalues by solving for the roots of the characteristic polynomial, but you can conversely find roots of *any* polynomial by turning into a matrix and finding the eigenvalues.\n",
    "\n",
    "Given the degree-$n$ polynomial:\n",
    "\n",
    "$$\n",
    "p(z)=c_0 + c_1 z + \\cdots + c_{n-1}z^{n-1} + z^n \\;,\n",
    "$$\n",
    "\n",
    "(notice that the $z^n$ coefficient is 1), we define the $n \\times n$  **companion matrix**\n",
    "\n",
    "$$\n",
    "C=\\begin{pmatrix}\n",
    "0 & 1 & 0 & \\dots & 0 \\\\\n",
    "0 & 0 & 1 & \\dots & 0 \\\\\n",
    "0 & \\ddots & \\ddots & \\ddots & \\vdots \\\\\n",
    "\\vdots & \\vdots & \\ddots & 0 & 1 \\\\\n",
    "-c_0 & -c_1 & \\dots & -c_{n-2} & -c_{n-1}\n",
    "\\end{pmatrix}.\n",
    "$$\n",
    "\n",
    "The amazing fact is that the *characteristic polynomial* $\\det (C - \\lambda I) = p(\\lambda)$, and so the **eigenvalues of C are the roots of p**.\n",
    "\n",
    "## Proof\n",
    "\n",
    "Suppose $z$ is an root of $p(z) = 0$.  We can now show that this is an eigenvalue of $C$, with eigenvector $= (1,z,z^2,\\ldots,z^{n-1})$:\n",
    "\n",
    "$$\n",
    "C \\begin{pmatrix} 1 \\\\ z \\\\ z^2 \\\\ \\vdots \\\\ z^{n-1} \\end{pmatrix}\n",
    "= \\begin{pmatrix} z \\\\ z^2 \\\\ \\vdots \\\\ z^{n-1} \\\\ -c_0 - c_1 z - \\cdots - c_{n-1} z^{m-1} \\end{pmatrix}\n",
    "= \\begin{pmatrix} z \\\\ z^2 \\\\ \\vdots \\\\ z^{n-1} \\\\ z^n \\end{pmatrix}\n",
    "= z \\begin{pmatrix} 1 \\\\ z \\\\ z^2 \\\\ \\vdots \\\\ z^{n-1} \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "where in the last row we used the fact that $p(z) = 0$ so $z^n = -c_0 - c_1 z - \\cdots - c_{n-1} z^{m-1}$.\n",
    "\n",
    "Hence $z$ is an eigenvalue.  The **eigenvalues of C are the roots of p** and vice versa.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "If you have a polynomial whose leading coefficient is *not* 1, you can just divide the polynomial by that coefficient to get it in this form, without changing its roots.   Hence the **roots of any polynomial can be found by computing the eigenvalues of a companion matrix.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "companion (generic function with 1 method)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function companion(p::Poly)\n",
    "    c = coeffs(p)\n",
    "    n = degree(p)\n",
    "    c = c[1:n] / c[end]\n",
    "    C = [ [ zeros(n-1)'; eye(n-1,n-1) ] -c ]'\n",
    "    return C\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "6 &#45; 5&#8729;x &#43; x^2"
      ],
      "text/plain": [
       "Poly(6 - 5*x + x^2)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Poly([-2, 1]) * Poly([-3, 1]) # (x - 2) * (x - 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Float64,2}:\n",
       "  0.0  1.0\n",
       " -6.0  5.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = companion(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigvals(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "&#45;24 &#43; 2&#8729;x &#43; 17&#8729;x^2 &#45; 8&#8729;x^3 &#43; x^4"
      ],
      "text/plain": [
       "Poly(-24 + 2*x + 17*x^2 - 8*x^3 + x^4)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # (x - 2) * (x - 3) * (x - 4) * (x + 1)\n",
    "p = Poly([-2, 1]) * Poly([-3, 1]) * Poly([-4, 1]) * Poly([1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Float64,2}:\n",
       "  0.0   1.0    0.0  0.0\n",
       "  0.0   0.0    1.0  0.0\n",
       "  0.0   0.0    0.0  1.0\n",
       " 24.0  -2.0  -17.0  8.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = companion(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " -1.0\n",
       "  4.0\n",
       "  3.0\n",
       "  2.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigvals(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, **this is the most common method to find roots of polynomials of degree ≥ 5**: you find the companion matrix, and compute its eigenvalues.  This is precisely how the Polynomials package does it (albeit with some extra cleverness to check for leading and trailing zero coefficients):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "roots<i>{T}</i>(p::<b>Polynomials.Poly{T}</b>) at <a href=\"https://github.com/JuliaMath/Polynomials.jl/tree/6e60f2d99e4b3813b86f0d38e97461acb340eef8//src/Polynomials.jl#L625\" target=\"_blank\">/Users/stevenj/.julia/v0.6/Polynomials/src/Polynomials.jl:625</a>"
      ],
      "text/plain": [
       "roots(p::Polynomials.Poly{T}) where T in Polynomials at /Users/stevenj/.julia/v0.6/Polynomials/src/Polynomials.jl:625"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which roots(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This would seem rather circular if eigenvalues were computed, in turn, by finding roots of polynomials.  But they aren't: **practical computer eigenvalue solvers never compute the characteristic polynomial, and don't resemble generic root-finding algorithms (like Newton's method)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computing eigenvalues = polynomial roots = hard\n",
    "\n",
    "* Everyone learns the [quadratic formula](https://en.wikipedia.org/wiki/Quadratic_formula) to find roots of a quadratic (degree-2) polynomial.\n",
    "\n",
    "* There is a (horrible) [cubic formula](https://en.wikipedia.org/wiki/Cubic_function) to find the roots of any cubic (degree-3) polynomial.\n",
    "\n",
    "* There is a (terrifying) [quartic formula](https://en.wikipedia.org/wiki/Quartic_function) to find the roots of any quartic (degree-4) polynomial.\n",
    "\n",
    "* There is **no formula** (in terms of a *finite number* of ±,×,÷,ⁿ√) for the roots of an **arbitrary quintic** polynomial or **any degree ≥ 5**.  This is the [Abel–Ruffini theorem](https://en.wikipedia.org/wiki/Abel%E2%80%93Ruffini_theorem), proved in the 19th century.\n",
    "\n",
    "This does **not mean** that you can't compute roots (or eigenvalues) in practice!  But it means that **root-finding/eigenvalue algorithms are necessarily *iterative***: they **converge toward the solution** but **never reach it exactly**.  You can get the solution to *any desired accuracy*.\n",
    "\n",
    "For example we've already seen one such algorithm!  [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method) is an algorithm that could be used to find the roots of an arbitrary polynomial (given enough starting guesses), and converges *very* quickly without ever exactly *reaching* the root.\n",
    "\n",
    "The most common algorithm to find eigenvalues (and hence polynomial roots, via companion matrices) is the [QR algorithm](https://en.wikipedia.org/wiki/QR_algorithm).  As you might guess, it is *related* to the $A=QR$ factorization.  Explaining *how* and *why* this algorithm works, however, is outside the scope of 18.06.  (It takes me a week+ in 18.335: graduate numerical methods.)\n",
    "\n",
    "This means that the textbook characteristic-polynomial method we use to find eigenvalues of $2\\times 2$ matrices is something of a fraud: unlike Gaussian elimination, it bears no resemblance whatsoever to how eigenvalues are really computed.  In 18.06, therefore, we will mostly assume that the computer hands us the eigenvalues and eigenvectors, and **we will focus on what eigensolutions *mean*, how they are *used*, and what their *properties* are.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "One thing that it is useful to know, however, is that the computer algorithm to compute eigenvalues/eigenvectors of an $m \\times m$ matrix requires $\\sim m^3$ operations, just like Gaussian elimination.  However, the \"constant\"  coefficient in front of $m^3$ is significantly worse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.031349 seconds (108 allocations: 7.645 MiB, 31.78% gc time)\n",
      "  0.138573 seconds (18.95 k allocations: 9.236 MiB)\n",
      "  1.471903 seconds (25 allocations: 7.936 MiB, 2.33% gc time)\n",
      "  2.999452 seconds (6.44 k allocations: 31.167 MiB, 2.77% gc time)\n"
     ]
    }
   ],
   "source": [
    "A1000 = rand(1000,1000)\n",
    "@time lufact(A1000)\n",
    "@time qrfact(A1000)\n",
    "@time eigvals(A1000)\n",
    "@time eig(A1000);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "89.20126901351644"
      ],
      "text/plain": [
       "89.20126901351644"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@elapsed(eig(A1000)) / @elapsed(lufact(A1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding eigenvalues and/or eigenvectors is not so cheap, but it is often worth it!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.6.0",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.0"
  },
  "widgets": {
   "state": {
    "1df4718a-d6a4-4ee1-9281-dbdb7f019e2d": {
     "views": [
      {
       "cell_index": 27
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}