Gaussian_Elimination.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gaussian Elimination"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we define some Python functions to help us solve linear systems in the most direct way.  The algorithm is known as Gaussian Elimination, which we will simply refer to as **elimination** from this point forward.  The idea of elimination is to exchange the system we are given with another system that has the same solution, but is much easier to solve.  To this end we will perform a series of steps called **row operations** which preserve the solution of the system while gradually making the solution more accessible.  There are three such operations we may perform.\n",
    "1. Exchange the position of two equations.\n",
    "2. Multiply an equation by any nonzero number.\n",
    "3. Replace any equation with the sum of itself and a multiple of another equation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='GE1'></a>\n",
    "### Example 1:  Row operations and elimination\n",
    "\n",
    "Let's look at an example.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 + x_2 + 8x_3 & = & 18\\\\\n",
    "4x_1 + 2x_2 -3x_3 & = & -2 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "We could swap the first and last equation,\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "4x_1 + 2x_2 -3x_3 & = & -2 \\\\\n",
    "2x_1 + x_2 + 8x_3 & = & 18\\\\\n",
    "x_1 - x_2 + x_3 & = & 3\n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "or we could multiply the first equation by $5$,\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "5x_1 - 5x_2 + 5x_3 & = & 15\\\\\n",
    "2x_1 + x_2 + 8x_3 & = & 18\\\\\n",
    "4x_1 + 2x_2 -3x_3 & = & -2 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "or we could add 2 times the first equation to the last equation.\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 + x_2 + 3x_3 & = & 8\\\\\n",
    "6x_1 \\quad\\quad -x_3 & = & 4 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "The last operation is the most important because it allows us to *eliminate* a variable from one of the equations.  Note that the third equation no longer contains the $x_2$ term.  This is the key to the elimination algorithm.\n",
    "\n",
    "For computational purposes we can dispense with the variable names and the \"=\" symbol, and arrange all of the actual numbers in an array.\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\left[ \\begin{array}{rrrr} 1 & -1 & 1 & 3 \\\\ 2 & 1 & 8 & 18 \\\\ 4 & 2 & -3 & -2 \\end{array}\\right]\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "Now let's build a NumPy array with these values.  We'll assign the array the name $\\texttt{A}$, so that we can refer to it later. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "A=np.array([[1,-1,1,3],[2,1,8,18],[4,2,-3,-2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could dive in an start performing operations on our array, but instead we will first write a few bits of code that will do each of these operations individually.  We will tuck each operation inside a Python function so that we can use it again for future calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RowSwap(A,k,l):\n",
    "# =============================================================================\n",
    "#     A is a NumPy array.  RowSwap will return duplicate array with rows\n",
    "#     k and l swapped.\n",
    "# =============================================================================\n",
    "    m = A.shape[0]  # m is number of rows in A\n",
    "    n = A.shape[1]  # n is number of columns in A\n",
    "    \n",
    "    B = np.copy(A).astype('float64')\n",
    "        \n",
    "    for j in range(n):\n",
    "        temp = B[k][j]\n",
    "        B[k][j] = B[l][j]\n",
    "        B[l][j] = temp\n",
    "        \n",
    "    return B\n",
    "\n",
    "def RowScale(A,k,scale):\n",
    "# =============================================================================\n",
    "#     A is a NumPy array.  RowScale will return duplicate array with the\n",
    "#     entries of row k multiplied by scale.\n",
    "# =============================================================================\n",
    "    m = A.shape[0]  # m is number of rows in A\n",
    "    n = A.shape[1]  # n is number of columns in A\n",
    "    \n",
    "    B = np.copy(A).astype('float64')\n",
    "\n",
    "    for j in range(n):\n",
    "        B[k][j] *= scale\n",
    "        \n",
    "    return B\n",
    "\n",
    "def RowAdd(A,k,l,scale):\n",
    "# =============================================================================\n",
    "#     A is a numpy array.  RowAdd will return duplicate array with row\n",
    "#     l modifed.  The new values will be the old values of row l added to \n",
    "#     the values of row k, multiplied by scale.\n",
    "# =============================================================================\n",
    "    m = A.shape[0]  # m is number of rows in A\n",
    "    n = A.shape[1]  # n is number of columns in A\n",
    "    \n",
    "    B = np.copy(A).astype('float64')\n",
    "        \n",
    "    for j in range(n):\n",
    "        B[l][j] += B[k][j]*scale\n",
    "        \n",
    "    return B\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We now have three new functions called $\\texttt{RowSwap}$,$\\texttt{RowScale}$,and $\\texttt{RowAdd}$.  Let's try them out to see what they produce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "B1 = RowSwap(A,0,2)\n",
    "B2 = RowScale(A,2,0.5)\n",
    "B3 = RowAdd(A,0,1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 -1  1  3]\n",
      " [ 2  1  8 18]\n",
      " [ 4  2 -3 -2]]\n",
      "\n",
      "\n",
      "[[ 1.  -1.   1.   3. ]\n",
      " [ 2.   1.   8.  18. ]\n",
      " [ 2.   1.  -1.5 -1. ]]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "print('\\n')\n",
    "print(B2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of elimination is to perform row operations on this array in order to produce a new array with a structure that looks something like this.\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\left[ \\begin{array}{cccc} 1 & * & * & * \\\\ 0 & 1 & * & * \\\\ 0 & 0 & 1 & * \\end{array}\\right]\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "*(Note that the * symbols here represent different unknown values that may or may not be 0 or 1.)*\n",
    "\n",
    "We will carry out the row operations and save our progress as arrays with new names  after each step.  For example, we might name them $\\texttt{A1}$, $\\texttt{A2}$, $\\texttt{A3}$, etc. This way we can check the progress, or go back and make changes to our code if we like.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  3.  6. 12.]\n",
      " [ 4.  2. -3. -2.]] \n",
      "\n",
      "[[  1.  -1.   1.   3.]\n",
      " [  0.   3.   6.  12.]\n",
      " [  0.   6.  -7. -14.]] \n",
      "\n",
      "[[  1.  -1.   1.   3.]\n",
      " [  0.   3.   6.  12.]\n",
      " [  0.   0. -19. -38.]] \n",
      "\n",
      "[[  1.  -1.   1.   3.]\n",
      " [  0.   1.   2.   4.]\n",
      " [  0.   0. -19. -38.]] \n",
      "\n",
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  1.  2.  4.]\n",
      " [-0. -0.  1.  2.]]\n"
     ]
    }
   ],
   "source": [
    "## Add -2 times row 0 to row 1\n",
    "A1 = RowAdd(A,0,1,-2)\n",
    "print(A1,'\\n')\n",
    "\n",
    "## Add -4 times row 0 to row 2\n",
    "A2 = RowAdd(A1,0,2,-4)\n",
    "print(A2,'\\n')\n",
    "\n",
    "## Add -2 times row 1 to row 2\n",
    "A3 = RowAdd(A2,1,2,-2)\n",
    "print(A3,'\\n')\n",
    "\n",
    "## Multiply row 1 by 1/3\n",
    "A4 = RowScale(A3,1,1.0/3)\n",
    "print(A4,'\\n')\n",
    "\n",
    "## Multiply row 2 by 1/19\n",
    "A5 = RowScale(A4,2,1.0/-19.)\n",
    "print(A5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's translate this array back to the description of the system with all the symbols in place.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "x_2 + 2x_3 & = & 4\\\\\n",
    "x_3 & = & 2 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "After the steps of elimination, we have what is known as a **upper triangular** system.  The solution to this system can be found without much effort by working backwards from the last equation.  The last equation tells us that $x_3 = 2$.  If we substitute that value into the second equation, we find that $x_2 = 0$.  Finally, if we substitute these values back into the first equation, we find that $x_1 = 1.$  This process for finding the solution of the upper triangular system is called **back substitution**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2:  Elimination on a random array\n",
    "\n",
    "If a system of equations has a solution, the elimination algorithm will always result in a upper triangular system that can be solved by back substitution.  In this next example, we look at the calculation with a small change to see it in a more general way.  This time when we use the $\\texttt{RowAdd}$ function, we will set the *scale* parameter based on the values in the array.  \n",
    "\n",
    "To help us avoid writing the code based on the entries in any specific matrix, we will make up a matrix of random numbers using the $\\texttt{random}$ module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  5 -8 -4]\n",
      " [ 1 -6 -3 -6]\n",
      " [-6 -5 -2 -6]]\n"
     ]
    }
   ],
   "source": [
    "R = np.random.randint(-8,8,size=(3,4))\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.          5.         -8.         -4.        ]\n",
      " [-0.          1.         -0.45454545  0.18181818]\n",
      " [-0.         -0.          1.          0.89411765]]\n"
     ]
    }
   ],
   "source": [
    "## Scale the first row based on the first element in that row.\n",
    "R1 = RowScale(R,0,1.0/R[0][0])\n",
    "## Add the first row to the second based on the first element in the second row.\n",
    "R2 = RowAdd(R1,0,1,-R[1][0])\n",
    "## Add the first row to the last based on the first element in the last row.\n",
    "R3 = RowAdd(R2,0,2,-R2[2][0])\n",
    "## Scale the second row based on the second element in that row.\n",
    "R4 = RowScale(R3,1,1.0/R3[1][1])\n",
    "## Add the second row to the last based on the second element in the last row.\n",
    "R5 = RowAdd(R4,1,2,-R4[2][1])\n",
    "## Scale the last row based on the last element in that row.\n",
    "R6 = RowScale(R5,2,1.0/R5[2][2])\n",
    "print(R6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we understand how the row operations work, and we are sure that they are working correctly, we might not have any reason to store the results of the intermediate steps of elimination.  In that case, we could simplify the code considerably by resusing the same array name for each step.  The following code would produce the same result, but we would no longer have access to the original array, or any of the intermediate steps.\n",
    "\n",
    "```\n",
    "R = RowScale(R,0,1.0/R[0][0])\n",
    "R = RowAdd(R,0,1,-R[1][0])\n",
    "R = RowAdd(R,0,2,-R[2][0])\n",
    "R = RowScale(R,1,1.0/R[1][1])\n",
    "R = RowAdd(R,1,2,-R[2][1])\n",
    "R = RowScale(R,2,1.0/R[2][2])\n",
    "print(R)\n",
    "```\n",
    "\n",
    "\n",
    "Execute the code in this example several times.  Each time array $\\texttt{R}$ is created it will be populated with random integers between -8 and 8.  Does the code always produce a upper triangular system ready for back substitution?  See if you can figure out which part of the process might fail, and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3: Finding pivots\n",
    "\n",
    "As we can see, the code in the last example fails if a zero shows up as any of the entries in the array that we divide by in order to calculate the scale factors.  These critical entries are known as the **pivots**, and their locations in the matrix are called **pivot positions**.  By definition, pivots must be nonzero.  If a zero arises in a pivot position during the elimination steps, we can try to exchange the order of the rows to move a nonzero entry into the pivot position.  Let's first try this for a specific array before trying to write code that will work for a random array.\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 - 2x_2 + 4x_3 & = & 8\\\\\n",
    "3x_1 \\quad\\quad -9x_3 & = & 0 \n",
    "\\end{eqnarray*}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 -1  1  3]\n",
      " [ 2 -2  4  8]\n",
      " [ 3  0 -9  0]]\n"
     ]
    }
   ],
   "source": [
    "G=np.array([[1,-1,1,3],[2,-2,4,8],[3,0,-9,0]])\n",
    "print(G)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.  -1.   1.   3.]\n",
      " [  0.   0.   2.   2.]\n",
      " [  0.   3. -12.  -9.]]\n"
     ]
    }
   ],
   "source": [
    "## Add -2 times row 0 to row 1\n",
    "G1 = RowAdd(G,0,1,-2)\n",
    "## Add -3 times row 0 to row 2\n",
    "G2 = RowAdd(G1,0,2,-3)\n",
    "print(G2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now there is a zero in the middle pivot position.  We can swap the middle and last equation in order to carry on the elimination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  1. -4. -3.]\n",
      " [ 0.  0.  1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "## Swap rows 1 and 2\n",
    "G3 = RowSwap(G2,1,2)\n",
    "## Scale the new row 1 by 1/3\n",
    "G4 = RowScale(G3,1,1./3)\n",
    "## Scale the new row 2 by 1/2\n",
    "G5 = RowScale(G4,2,1./2)\n",
    "print(G5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We write the system again as a familar set of equations.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "x_2 - 4x_3 & = & -3\\\\\n",
    "x_3 & = & 1 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "Applying back substitution, we find that $x_2 = 1$ and $x_1=3$.\n",
    "\n",
    "It is worth noting that the swapping of rows is only necessary as a matter of organization.  Here is another way that we could have done the elimination and ended up with a system that is just the same.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  0.  1.  1.]\n",
      " [ 0.  1. -4. -3.]]\n"
     ]
    }
   ],
   "source": [
    "## Scale row 1 by 1/2\n",
    "G3_alternative = RowScale(G2,1,1./2)\n",
    "## Scale row 2 by 1/3\n",
    "G4_alternative = RowScale(G3_alternative,2,1./3)\n",
    "print(G4_alternative)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The array produced represents the same simplified system, with the equations in a different order of course.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "x_3 & = & 1 \\\\\n",
    "x_2 - 4x_3 & = & -3\n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "The idea of back substitution works just as well with this form of the system, but the organization of the algorithm becomes slightly more complicated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='GE4'></a>\n",
    "### Example 4:  Elimination fails\n",
    "\n",
    "Let's make a small change to the system in the previous example and observe an example of how the elimination process can break down.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 - 2x_2 + 4x_3 & = & 8\\\\\n",
    "3x_1 -3x_2 -9x_3 & = & 0 \n",
    "\\end{eqnarray*}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 -1  1  3]\n",
      " [ 2 -2  4  8]\n",
      " [ 3 -3 -9  0]]\n"
     ]
    }
   ],
   "source": [
    "H = np.array([[1,-1,1,3],[2,-2,4,8],[3,-3,-9,0]])\n",
    "print(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.  -1.   1.   3.]\n",
      " [  0.   0.   2.   2.]\n",
      " [  0.   0. -12.  -9.]]\n"
     ]
    }
   ],
   "source": [
    "## Add -2 times row 0 to row 1\n",
    "H1 = RowAdd(H,0,1,-2)\n",
    "## Add -3 times row 0 to row 2\n",
    "H2 = RowAdd(H1,0,2,-3)\n",
    "print(H2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case exchanging the second and third rows does not help since both rows have a zero in the middle entry.  This means that *there is no pivot* in the second column.  Let's scale the rows and look at the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.   -1.    1.    3.  ]\n",
      " [ 0.    0.    1.    1.  ]\n",
      " [-0.   -0.    1.    0.75]]\n"
     ]
    }
   ],
   "source": [
    "## Multiply row 1 by 1/2\n",
    "H3 = RowScale(H2,1,1./2)\n",
    "## Multiply row 2 by -1/12\n",
    "H4 = RowScale(H3,2,-1./12)\n",
    "print(H4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we write out the equations, we see that this system is **inconsistent**.  The last two equations contradict each other. \n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "x_3 & = & 1 \\\\\n",
    "x_3 & = & 0.75\n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "Note that we did not make any errors in the calculation and that there is no way to reorder the equations to alleviate the problem.  This system simply does not have a solution.  We will revisit this scenario in future sections and provide a characterization for such systems.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 5:  Nonunique solution\n",
    "\n",
    "In this final example of elimination, we observe another possible outcome of the process.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 - 2x_2 + 4x_3 & = & 8\\\\\n",
    "3x_1 -3x_2 +3x_3 & = & 9 \n",
    "\\end{eqnarray*}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 -1  1  3]\n",
      " [ 2 -2  4  8]\n",
      " [ 1 -1  3  5]]\n"
     ]
    }
   ],
   "source": [
    "F = np.array([[1,-1,1,3],[2,-2,4,8],[1,-1,3,5]])\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  0.  2.  2.]\n",
      " [ 0.  0.  2.  2.]]\n"
     ]
    }
   ],
   "source": [
    "## Add -2 times row 0 to row 1\n",
    "F1 = RowAdd(F,0,1,-2)\n",
    "## Add -3 times row 0 to row 2\n",
    "F2 = RowAdd(F1,0,2,-1)\n",
    "print(F2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the previous example, we see that there is no way to bring a nonzero number into the second column of the second row.  In this case though we see that the second and third equations do not contradict each other, but are in fact the same equation.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_3 & = & 2\\\\\n",
    "2x_3 & = & 2 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "Let's do just two more row operations to simplify this system even further."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1. -1.  1.  3.]\n",
      " [ 0.  0.  1.  1.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "## Add -1 times row 1 to row 2\n",
    "F3 = RowAdd(F2,1,2,-1)\n",
    "## Multiply row 1 by 1/2\n",
    "F4 = RowScale(F3,1,0.5)\n",
    "print(F4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the final equation is true for any values of $x_1$, $x_2$, $x_3$, we see that there are really only two equations to determine the values of the three unknowns.   \n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "x_3 & = & 1\\\\\n",
    "0 & = & 0 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n",
    "Since the middle equation tells us that $x_3=1$, we can plug that value into the first equation using the idea of back substitution.  This leaves us with the single equation $x_1-x_2 = 2$.  This equation, and thus the system as a whole, has an *infinite number of solutions*.  We will revist this idea and provide further details in the next chapter. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1:** In the system below, use a row operation functions to produce a zero coefficient in the location of the coefficient 12.  Do this first by hand and then create a NumPy array to represent the system and use the row operation functions.  (*There are two ways to create the zero using $\\texttt{RowAdd}$.  Try to find both.*)\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "4x_1 - 2x_2 + 7x_3 & = & 2\\\\\n",
    "x_1 + 3x_2 + 12x_3 & = & 4\\\\\n",
    "-7x_1 \\quad\\quad - 3x_3 & = & -1 \n",
    "\\end{eqnarray*}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code solution here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2:** Create a NumPy array to represent the system below.  Determine which coefficient should be zero in order for the system to be upper triangular.  Use $\\texttt{RowAdd}$ to carry out the row operation and then print your results.\n",
    "  \n",
    "  $$\n",
    "\\begin{eqnarray*}\n",
    "3x_1 + 4x_2 \\, - \\,\\,\\,\\,\\,  x_3 &   =   & -6\\\\\n",
    "-2x_2   +  10x_3  &   =   & -8\\\\\n",
    "4x_2   \\,  - \\,\\, 2x_3 &  =  & -2 \n",
    "\\end{eqnarray*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code solution here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3:** Carry out the elimination process on the following system.  Define a NumPy array and make use of the row operation functions.  Print the results of each step.  Write down the upper triangular system represented by the array after all steps are completed.\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 + x_3 & = & 3\\\\\n",
    "2x_1 + x_2 + 8x_3 & = & 18\\\\\n",
    "4x_1 + 2x_2 -3x_3 & = & -2 \n",
    "\\end{eqnarray*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4:** Use row operations on the system below to produce an **lower triangular** system.  The first equation of the lower triangular system should contain only $x_1$ and the second equation should contain only $x_1$ and $x_2$.\n",
    "\n",
    "  $$\n",
    "\\begin{eqnarray*}\n",
    "x_1 + 2x_2 + x_3 & = & 3\\\\\n",
    "3x_1 - x_2 - 3x_3 & = & -1\\\\\n",
    "2x_1 + 3x_2 + x_3 & = & 4\n",
    "\\end{eqnarray*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5:** Use elimination to determine whether the following system is **consistent** or **inconsistent**.\n",
    " \n",
    "$$\n",
    "\\begin{eqnarray*}\n",
    "x_1 - x_2 - x_3 & = & 4\\\\\n",
    "2x_1 - 2x_2 - 2x_3 & = & 8\\\\\n",
    "5x_1 - 5x_2 - 5x_3 & = & 20 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 6:** Use elimination to show that this system of equations has no solution.\n",
    "\n",
    "  $$\n",
    "\\begin{eqnarray*}\n",
    "x_1  +  x_2 +  x_3 & = & 0\\\\\n",
    "x_1 -  x_2 + 3x_3 & = & 3\\\\\n",
    "-x_1 - x_2 - x_3 & = & 2 \n",
    "\\end{eqnarray*}\n",
    "$$\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7:** Use  $\\texttt{random}$ module to produce a $3\\times 4$ array which contains random integers between $0$ and $5$. Write code that performs a row operation to produce a matrix with a zero in the first row, third column.  Run the code several times to be sure that it works on **different** random arrays.  Will the code ever fail?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 8:** Starting from the array that represents the upper triangular system in **Example 1** ($\\texttt{A5}$), use the row operations to produce an array of the following form.  Do one step at a time and again print your results to check that you are successful.  \n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\left[ \\begin{array}{cccc} 1 & 0 & 0 & 1 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 2 \\end{array}\\right]\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code solution here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 9:** Redo **Example 2** using the $\\texttt{random}$ module to produce a $3\\times 4$ array made up of random floats instead of random integers.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code solution here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 10:** Write a loop that will execute the elimination code in **Example 2** on 1000 different $3\\times 4$ arrays of random floats to see how frequently it fails.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Code solution here."
   ]
  }
 ],
 "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
}