C1/w2/C1w2_ungraded_lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "signed-sight",
   "metadata": {},
   "source": [
    "# Solving Linear Systems: 3 variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "representative-velvet",
   "metadata": {},
   "source": [
    "In this lab, you will keep developing your skills using Python to solve systems of linear equations. In this notebook you will:\n",
    "\n",
    "- Use `NumPy` linear algebra package to find the solutions to the system of linear equations\n",
    "- Perform row reduction to bring matrix into row echelon form\n",
    "- Find the solution for the system of linear equations using row reduced matrix\n",
    "- Evaluate the determinant of the matrix to see again the connection between matrix singularity and the number of solutions of the linear system"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "automated-bishop",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "- [ 1 - Representing and Solving a System of Linear Equations using Matrices](#1)\n",
    "  - [ 1.1 - System of Linear Equations](#1.1)\n",
    "  - [ 1.2 - Solving Systems of Linear Equations using Matrices](#1.2)\n",
    "  - [ 1.3 - Evaluating the Determinant of a Matrix](#1.3)\n",
    "- [ 2 - Solving System of Linear Equations using Row Reduction](#2)\n",
    "  - [ 2.1 - Preparation for Row Reduction](#2.1)\n",
    "  - [ 2.2 - Functions for Elementary Operations](#2.2)\n",
    "  - [ 2.3 - Row Reduction and Solution of the Linear System](#2.3)\n",
    "- [ 3 - System of Linear Equations with No Solutions](#3)\n",
    "- [ 4 - System of Linear Equations with Infinite Number of Solutions](#4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "persistent-sweden",
   "metadata": {},
   "source": [
    "## Packages\n",
    "\n",
    "Load the `NumPy` package to access its functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "metropolitan-shape",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chief-istanbul",
   "metadata": {},
   "source": [
    "<a name='1'></a>\n",
    "## 1 - Representing and Solving a System of Linear Equations using Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advance-count",
   "metadata": {},
   "source": [
    "<a name='1.1'></a>\n",
    "### 1.1 - System of Linear Equations\n",
    "\n",
    "Here is a **system of linear equations** (or **linear system**) with three equations and three unknown variables:\n",
    "\n",
    "\n",
    "$$\\begin{cases} \n",
    "4x_1-3x_2+x_3=-10, \\\\ 2x_1+x_2+3x_3=0, \\\\ -x_1+2x_2-5x_3=17, \\end{cases}\\tag{1}$$\n",
    "\n",
    "**To solve** this system of linear equations means to find such values of the variables $x_1$, $x_2$, $x_3$, that all of its equations are simultaneously satisfied."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sharp-strike",
   "metadata": {},
   "source": [
    "<a name='1.2'></a>\n",
    "### 1.2 - Solving Systems of Linear Equations using Matrices\n",
    "\n",
    "Let's prepare to solve the linear system $(1)$ using `NumPy`. $A$ will be a matrix, each row will represent one equation in the system and each column will correspond to the variable $x_1$, $x_2$, $x_3$. And $b$ is a 1-D array of the free (right side) coefficients:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "tired-filing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      "[[ 4. -3.  1.]\n",
      " [ 2.  1.  3.]\n",
      " [-1.  2. -5.]]\n",
      "\n",
      "Array b:\n",
      "[-10.   0.  17.]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([\n",
    "        [4, -3, 1],\n",
    "        [2, 1, 3],\n",
    "        [-1, 2, -5]\n",
    "    ], dtype=np.dtype(float))\n",
    "\n",
    "b = np.array([-10, 0, 17], dtype=np.dtype(float))\n",
    "\n",
    "print(\"Matrix A:\")\n",
    "print(A)\n",
    "print(\"\\nArray b:\")\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "premium-soviet",
   "metadata": {},
   "source": [
    "Check the dimensions of $A$ and $b$ using `shape()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "political-aberdeen",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of A: (3, 3)\n",
      "Shape of b: (3,)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Shape of A: {np.shape(A)}\")\n",
    "print(f\"Shape of b: {np.shape(b)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "complimentary-testimony",
   "metadata": {},
   "source": [
    "Now use `np.linalg.solve(A, b)` function to find the solution of the system $(1)$. The result will be saved in the 1-D array $x$. The elements will correspond to the values of $x_1$, $x_2$ and $x_3$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "broke-vietnamese",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution: [ 1.  4. -2.]\n"
     ]
    }
   ],
   "source": [
    "x = np.linalg.solve(A, b)\n",
    "\n",
    "print(f\"Solution: {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "correct-insert",
   "metadata": {},
   "source": [
    "Try to substitute those values of $x_1$, $x_2$ and $x_3$ into the original system of equations to check its consistency."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "applicable-senator",
   "metadata": {},
   "source": [
    "<a name='1.3'></a>\n",
    "### 1.3 - Evaluating the Determinant of a Matrix\n",
    "\n",
    "Matrix $A$ corresponding to the linear system $(1)$ is a **square matrix** - it has the same number of rows and columns. In the case of a square matrix it is possible to calculate its determinant - a real number that characterizes some properties of the matrix. A linear system containing three equations with three unknown variables will have one solution if and only if the matrix $A$ has a non-zero determinant.\n",
    "\n",
    "Let's calculate the determinant using `np.linalg.det(A)` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "median-potato",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinant of matrix A: -60.00\n"
     ]
    }
   ],
   "source": [
    "d = np.linalg.det(A)\n",
    "\n",
    "print(f\"Determinant of matrix A: {d:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "congressional-church",
   "metadata": {},
   "source": [
    "Please, note that its value is non-zero, as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "handed-tolerance",
   "metadata": {},
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Solving System of Linear Equations using Row Reduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intense-closer",
   "metadata": {},
   "source": [
    "<a name='2.1'></a>\n",
    "### 2.1 - Preparation for Row Reduction\n",
    "\n",
    "You can see how easy it is to use contemporary packages to solve linear equations. However, for a deeper understanding of mathematical concepts, it is important to practice some solution techniques manually. The programming approach can still help here to reduce the number of arithmetical calculations, and focus on the method itself.\n",
    "\n",
    "Here you can practice the row reduction method for the linear system with three variables. To apply it, first, unify matrix $A$ and array $b$ into one matrix using `np.hstack()` function. Note that the shape of the originally defined array $b$ was $(3,)$, to stack it with the $(3, 3)$ matrix you need to transform it so that it has the same number of dimensions. You can use `.reshape((3, 1))` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "diverse-mayor",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  4.  -3.   1. -10.]\n",
      " [  2.   1.   3.   0.]\n",
      " [ -1.   2.  -5.  17.]]\n"
     ]
    }
   ],
   "source": [
    "A_system = np.hstack((A, b.reshape((3, 1))))\n",
    "\n",
    "print(A_system)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "needed-organ",
   "metadata": {},
   "source": [
    "<a name='2.2'></a>\n",
    "### 2.2 - Functions for Elementary Operations\n",
    "\n",
    "Let's review **elementary operations**, which do not change the solution set of a linear system:\n",
    "\n",
    "- Multiply any row by a non-zero number\n",
    "- Add two rows and exchange one of the original rows with the result of the addition\n",
    "- Swap rows\n",
    "\n",
    "In the case of larger systems you will need to apply elementary operations multiple times. Thus, it is convenient to define the corresponding Python functions. Investigate them in the following code cells with the examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "unlimited-promotion",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix:\n",
      "[[  4.  -3.   1. -10.]\n",
      " [  2.   1.   3.   0.]\n",
      " [ -1.   2.  -5.  17.]]\n",
      "\n",
      "Matrix after its third row is multiplied by 2:\n",
      "[[  4.  -3.   1. -10.]\n",
      " [  2.   1.   3.   0.]\n",
      " [ -2.   4. -10.  34.]]\n"
     ]
    }
   ],
   "source": [
    "# exchange row_num of the matrix M with its multiple by row_num_multiple\n",
    "# Note: for simplicity, you can drop check if  row_num_multiple has non-zero value, which makes the operation valid\n",
    "def MultiplyRow(M, row_num, row_num_multiple):\n",
    "    # .copy() function is required here to keep the original matrix without any changes\n",
    "    M_new = M.copy()\n",
    "    M_new[row_num] = M_new[row_num] * row_num_multiple\n",
    "    return M_new\n",
    "\n",
    "print(\"Original matrix:\")\n",
    "print(A_system)\n",
    "print(\"\\nMatrix after its third row is multiplied by 2:\")\n",
    "# remember that indexing in Python starts from 0, thus index 2 will correspond to the third row\n",
    "print(MultiplyRow(A_system,2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "governmental-underwear",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix:\n",
      "[[  4.  -3.   1. -10.]\n",
      " [  2.   1.   3.   0.]\n",
      " [ -1.   2.  -5.  17.]]\n",
      "\n",
      "Matrix after exchange of the third row with the sum of itself and second row multiplied by 1/2:\n",
      "[[  4.   -3.    1.  -10. ]\n",
      " [  2.    1.    3.    0. ]\n",
      " [  0.    2.5  -3.5  17. ]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row_num_1 by row_num_1_multiple and add it to the row_num_2, \n",
    "# exchanging row_num_2 of the matrix M in the result\n",
    "def AddRows(M, row_num_1, row_num_2, row_num_1_multiple):\n",
    "    M_new = M.copy()\n",
    "    M_new[row_num_2] = row_num_1_multiple * M_new[row_num_1] + M_new[row_num_2]\n",
    "    return M_new\n",
    "\n",
    "print(\"Original matrix:\")\n",
    "print(A_system)\n",
    "print(\"\\nMatrix after exchange of the third row with the sum of itself and second row multiplied by 1/2:\")\n",
    "print(AddRows(A_system,1,2,1/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "musical-humanity",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix:\n",
      "[[  4.  -3.   1. -10.]\n",
      " [  2.   1.   3.   0.]\n",
      " [ -1.   2.  -5.  17.]]\n",
      "\n",
      "Matrix after exchange its first and third rows:\n",
      "[[ -1.   2.  -5.  17.]\n",
      " [  2.   1.   3.   0.]\n",
      " [  4.  -3.   1. -10.]]\n"
     ]
    }
   ],
   "source": [
    "# exchange row_num_1 and row_num_2 of the matrix M\n",
    "def SwapRows(M, row_num_1, row_num_2):\n",
    "    M_new = M.copy()\n",
    "    M_new[[row_num_1, row_num_2]] = M_new[[row_num_2, row_num_1]]\n",
    "    return M_new\n",
    "\n",
    "print(\"Original matrix:\")\n",
    "print(A_system)\n",
    "print(\"\\nMatrix after exchange its first and third rows:\")\n",
    "print(SwapRows(A_system,0,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hybrid-circuit",
   "metadata": {},
   "source": [
    "<a name='2.3'></a>\n",
    "### 2.3 - Row Reduction and Solution of the Linear System\n",
    "\n",
    "Now you can use the defined operations to bring the matrix into row reduced form. To do this manually, it is convenient to have $1$ or $-1$ value in the first element of the first row (the arithmetics of operations is easier then). Performing calculations in Python, won't provide much of a benefit, but it is better to do that for illustration purposes. So, let's swap the first and third rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "together-dancing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -1.   2.  -5.  17.]\n",
      " [  2.   1.   3.   0.]\n",
      " [  4.  -3.   1. -10.]]\n"
     ]
    }
   ],
   "source": [
    "A_ref = SwapRows(A_system,0,2)\n",
    "# Note: ref is an abbreviation of the row echelon form (row reduced form)\n",
    "print(A_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "composite-pocket",
   "metadata": {},
   "source": [
    "Now you would need to make such elementary operations, that the first elements in the second and third row become equal to zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "involved-messenger",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -1.   2.  -5.  17.]\n",
      " [  0.   5.  -7.  34.]\n",
      " [  4.  -3.   1. -10.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 0 of the new matrix A_ref by 2 and add it to the row 1\n",
    "A_ref = AddRows(A_ref,0,1,2)\n",
    "print(A_ref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "aboriginal-hydrogen",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -1.   2.  -5.  17.]\n",
      " [  0.   5.  -7.  34.]\n",
      " [  0.   5. -19.  58.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 0 of the new matrix A_ref by 4 and add it to the row 2\n",
    "A_ref = AddRows(A_ref,0,2,4)\n",
    "print(A_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "later-colonial",
   "metadata": {},
   "source": [
    "The next step will be to perform an operation by putting the second element in the third row equal to zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "brutal-scott",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -1.   2.  -5.  17.]\n",
      " [  0.   5.  -7.  34.]\n",
      " [  0.   0. -12.  24.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 1 of the new matrix A_ref by -1 and add it to the row 2\n",
    "A_ref = AddRows(A_ref,1,2,-1)\n",
    "print(A_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "south-taste",
   "metadata": {},
   "source": [
    "It is easy now to find the value of $x_3$ from the third row, as it corresponds to the equation $-12x_3=24$. Let's divide the row by -12:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "great-address",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.  2. -5. 17.]\n",
      " [ 0.  5. -7. 34.]\n",
      " [-0. -0.  1. -2.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 2 of the new matrix A_ref by -1/12\n",
    "A_ref = MultiplyRow(A_ref,2,-1/12)\n",
    "print(A_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "committed-jaguar",
   "metadata": {},
   "source": [
    "Now the second row of the matrix corresponds to the equation $5x_2-7x_3=34$ and the first row to the equation $-x_1+2x_2-5x_3=17$. Referring to the elements of the matrix, you can find the values of $x_2$ and $x_1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "complicated-price",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 4.0 -2\n"
     ]
    }
   ],
   "source": [
    "x_3 = -2\n",
    "x_2 = (A_ref[1,3] - A_ref[1,2] * x_3) / A_ref[1,1]\n",
    "x_1 = (A_ref[0,3] - A_ref[0,2] * x_3 - A_ref[0,1] * x_2) / A_ref[0,0]\n",
    "\n",
    "print(x_1, x_2, x_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accomplished-north",
   "metadata": {},
   "source": [
    "<a name='3'></a>\n",
    "## 3 - System of Linear Equations with No Solutions\n",
    "\n",
    "Given another system of linear equations:\n",
    "\n",
    "$$\\begin{cases} \n",
    "x_1+x_2+x_3=2, \\\\ x_2-3x_3=1, \\\\ 2x_1+x_2+5x_3=0, \\end{cases}\\tag{2}$$\n",
    "\n",
    "let's find the determinant of the corresponding matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "military-boost",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinant of matrix A_2: 0.00\n"
     ]
    }
   ],
   "source": [
    "A_2= np.array([\n",
    "        [1, 1, 1],\n",
    "        [0, 1, -3],\n",
    "        [2, 1, 5]\n",
    "    ], dtype=np.dtype(float))\n",
    "\n",
    "b_2 = np.array([2, 1, 0], dtype=np.dtype(float))\n",
    "\n",
    "d_2 = np.linalg.det(A_2)\n",
    "\n",
    "print(f\"Determinant of matrix A_2: {d_2:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "certain-territory",
   "metadata": {},
   "source": [
    "It is equal to zero, thus the system cannot have one unique solution. It will have either infinitely many solutions or none. The consistency of it will depend on the free coefficients (right side coefficients). You can uncomment and run the code in the following cell to check that the `np.linalg.solve()` function will give an error due to singularity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "significant-modern",
   "metadata": {},
   "outputs": [],
   "source": [
    "# x_2 = np.linalg.solve(A_2, b_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "artificial-compiler",
   "metadata": {},
   "source": [
    "You can check the system for consistency using ranks, but this is out of scope here (you can review this topic following the [link](https://www.onlinemath4all.com/solving-system-of-linear-equations-by-rank-method.html)). For now you can perform elementary operations to see that this particular system has no solutions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "mineral-nelson",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 2.  1.  5.  0.]]\n"
     ]
    }
   ],
   "source": [
    "A_2_system = np.hstack((A_2, b_2.reshape((3, 1))))\n",
    "print(A_2_system)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "polished-adaptation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 0. -1.  3. -4.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 0 by -2 and add it to the row 1\n",
    "A_2_ref = AddRows(A_2_system,0,2,-2)\n",
    "print(A_2_ref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "valid-balloon",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 0.  0.  0. -3.]]\n"
     ]
    }
   ],
   "source": [
    "# add row 1 of the new matrix A_2_ref to the row 2\n",
    "A_2_ref = AddRows(A_2_ref,1,2,1)\n",
    "print(A_2_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "breathing-value",
   "metadata": {},
   "source": [
    "The last row will correspond to the equation $0=-3$ which has no solution. Thus the whole linear system $(2)$ has no solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pointed-tolerance",
   "metadata": {},
   "source": [
    "<a name='4'></a>\n",
    "## 4 - System of Linear Equations with Infinite Number of Solutions\n",
    "\n",
    "You can bring system $(2)$ to consistency by changing only the free coefficients:\n",
    "\n",
    "$$\\begin{cases} \n",
    "x_1+x_2+x_3=2, \\\\ x_2-3x_3=1, \\\\ 2x_1+x_2+5x_3=3. \\end{cases}\\tag{3}$$\n",
    "\n",
    "Define the new array of free coefficients:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "exceptional-secret",
   "metadata": {},
   "outputs": [],
   "source": [
    "b_3 = np.array([2, 1, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dramatic-handbook",
   "metadata": {},
   "source": [
    "Prepare the new matrix, corresponding to the system $(3)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "radical-florida",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 2.  1.  5.  3.]]\n"
     ]
    }
   ],
   "source": [
    "A_3_system = np.hstack((A_2, b_3.reshape((3, 1))))\n",
    "print(A_3_system)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "theoretical-consolidation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 0. -1.  3. -1.]]\n"
     ]
    }
   ],
   "source": [
    "# multiply row 0 of the new matrix A_3_system by -2 and add it to the row 2\n",
    "A_3_ref = AddRows(A_3_system,0,2,-2)\n",
    "print(A_3_ref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "medieval-resource",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  2.]\n",
      " [ 0.  1. -3.  1.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "# add row 1 of the new matrix A_3_ref to the row 2\n",
    "A_3_ref = AddRows(A_3_ref,1,2,1)\n",
    "print(A_3_ref)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baking-jackson",
   "metadata": {},
   "source": [
    "Thus from the corresponding linear system\n",
    "\n",
    "$$\\begin{cases} \n",
    "x_1+x_2+x_3=2, \\\\ x_2-3x_3=1, \\\\ 0=0, \\end{cases}\\tag{4}$$\n",
    "\n",
    "you can find that $x_2=1+3x_3$, substitute it into the first equation and find $x_1$. Thus the solutions of the linear system $(3)$ are:\n",
    "\n",
    "$$\\begin{cases} \n",
    "x_1=1-4x_3, \\\\ x_2=1+3x_3, \\end{cases}\\tag{5}$$\n",
    "\n",
    "where $x_3$ is any real number."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "limiting-singing",
   "metadata": {},
   "source": [
    "Well done! You used the `NumPy` functions to solve a system of equations and also got more experience in solving it manually. As expected, using a predefined function is much easier, but gives much less insight into what is happening under the hood. Remember that `np.linalg.solve` gives an error if there are no or infinitely many solutions, thus when implementing it you will have to think carefully so not to make your program crash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "remarkable-evening",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}