CHW1.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "6DjNbXa-VC9M"
      },
      "source": [
        "<h1 align=\"center\">Mathematical Methods In Engineering - 25872</h1>\n",
        "<h4 align=\"center\">Dr. Amiri</h4>\n",
        "<h4 align=\"center\">Sharif University of Technology, Fall 2023</h4>\n",
        "<h4 align=\"center\">Python Assignment 1</h4>\n",
        "<h4 align=\"center\">feel free to ask your questions via telegram,\n",
        "\n",
        "questions 1,4 : @BeNameBalasari and questions 2,3,5 : @maahmoradi"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You should write your code in the <font color='green'>Code Cell</font> and then run the <font color='green'>Evaluation Cell</font> to check the output of your code.<br>\n",
        "<font color='red'>**Please do not edit the existing codes.**</font>"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "bggG3YqIVC9U"
      },
      "source": [
        "## 1. Introduction to matrices\n",
        "In this question, we want to get familiar with performing simple matrix operations and obtaining special features of matrices in Python <br>\n",
        "#### 1-1-  Vector P-Norm\n",
        " Let $p\\geq 1$  be  a real   number . The  p-norm ( also called \n",
        "$\\ell ^{p}$-norm) of  vector \n",
        "${\\displaystyle \\mathbf {x} =(x_{1},\\ldots ,x_{n})}$  is : \n",
        "${\\displaystyle \\|\\mathbf {x} \\|_{p}:=\\left(\\sum _{i=1}^{n}\\left|x_{i}\\right|^{p}\\right)^{1/p}}$ and\n",
        "${\\displaystyle \\|\\mathbf {x} \\|_{\\infty}:=max(|x_1| , |x_2| , \\cdots ,|x_n|)}$ \n",
        "> Write a function that takes a vector and p as input and gives p-norm as output then use it to calculate the norm-3 of the  following vector ( if the p is np.inf the function should give the infinity norm of the matrix ) :\n",
        "$$\n",
        "x = \\left(\\begin{array}{cc} \n",
        "-3.0\\\\ 1.0 \\\\2.0\n",
        "\\end{array}\\right)\n",
        "$$\n",
        "> then use np.linalg.norm to check your answer "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 460,
      "metadata": {},
      "outputs": [],
      "source": [
        "# import required packages\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 461,
      "metadata": {
        "id": "ZzFnxtOIVC9W"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.3019272488946263\n",
            "3.3019272488946263\n"
          ]
        }
      ],
      "source": [
        "def pnorm(x, p):\n",
        "    \n",
        "    # write your code here\n",
        "    if p == np.inf:\n",
        "        max_x = abs(x[0])\n",
        "        for i in range(len(x)):\n",
        "            if (abs(x[i]) > max_x):\n",
        "                max_x = x[i]\n",
        "        return max_x\n",
        "    sum  = 0\n",
        "    for i in range(0,len(x)):\n",
        "        sum += pow(abs(x[i]),p)\n",
        "    sum = pow(sum , 1/p)\n",
        "    return sum\n",
        "    pass\n",
        "    \n",
        "\n",
        "x = [-3,1,2]\n",
        "print(pnorm(x,3))\n",
        "print(np.linalg.norm(x,3))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 1-2- Matrix Norm\n",
        " The \n",
        " operator  norm of matrix $ \\mathbf{A}  $ is : \n",
        "${\\displaystyle \\|\\mathbf {A} \\|:=\\max\\limits_{x\\neq 0}\\left(\\frac{||Ax||}{||x||}\\right)}$\n",
        "\n",
        "and  The Frobenius  norm  is defined  so \n",
        "that   for  every  square  matrix $ \\mathbf{A} $ : ${\\displaystyle \\|\\mathbf {A} \\|_F:=\\left(\\sum_{i,j=1}^{n}(|a_{ij}|^2)\\right)^\\frac{1}{2}}$\n",
        "\n",
        "> Write a function that takes a Matrix  as input and gives frobenius norm as output then use it to calculate the norm of the  following Matrix :\n",
        "$$\n",
        "A = \\begin{bmatrix}\n",
        "    7 & 5 & 1\\\\\n",
        "    1 & 7 & 1\\\\\n",
        "    5 & 5 & 7\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "> then use np.linalg.norm to check your answer and use it to calculate the operator norm of A "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 462,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[7, 5, 1], [1, 7, 1], [5, 5, 7]]\n",
            "15.0\n",
            "15.0\n"
          ]
        }
      ],
      "source": [
        "def fnorm(A):\n",
        "    # write your code here\n",
        "    sum = 0\n",
        "    for i in range(0,len(A)):\n",
        "        for j in range(0, len(A[i])):\n",
        "            sum += pow(A[i][j],2)\n",
        "    sum = pow(sum,1/2)\n",
        "    return sum     \n",
        "\n",
        "    pass\n",
        "\n",
        "A = [[7,5,1],[1,7,1],[5,5,7]]\n",
        "print(A)\n",
        "print(fnorm(A))\n",
        "print(np.linalg.norm(A))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 1-3- Matrix Determinant And Matrix inverse \n",
        "Laplace expansion expresses the determinant of a matrix \n",
        "A recursively in terms of determinants of smaller matrices, known as its minors. The minor \n",
        ", $M_{i,j}$ is defined to be the determinant of the \n",
        "${\\displaystyle (n-1)\\times (n-1)}$ matrix that results from \n",
        "A by removing the \n",
        "i-th row and the \n",
        "j-th column. The expression \n",
        "${\\displaystyle (-1)^{i+j}M_{i,j}}$  is known as a cofactor. For every \n",
        "i, one has the equality :\n",
        "$$\n",
        "det(\\mathbf{A})=\\sum_{j=1}^n\\left((-1)^{i+j}a_{ij}M_{ij}\\right)\n",
        "$$\n",
        "> Write a function that takes a Matrix  as input and gives Determinant as output then use it to calculate the Determinant of the  following Matrix :\n",
        "$$\n",
        "A = \\begin{bmatrix}\n",
        "    7 & 5 & 1\\\\\n",
        "    1 & 7 & 1\\\\\n",
        "    5 & 5 & 7\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "> then use np.linalg.det to check your answer "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 463,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "268.0\n",
            "267.99999999999994\n"
          ]
        }
      ],
      "source": [
        "# Code cell\n",
        "def det(A):\n",
        "        # write your code here\n",
        "    sum = 0\n",
        "    if len(A) == 1:\n",
        "        return float(A[0][0])\n",
        "    for i in range(0,len(A)):\n",
        "        new_matrix = np.zeros((len(A) - 1 , len(A) - 1))\n",
        "        new_i = 0\n",
        "        new_j = 0\n",
        "        for x in range(0,len(A)):\n",
        "            for y in range(1,len(A)):\n",
        "                if i == x:\n",
        "                    new_i -= 1\n",
        "                    break\n",
        "                else :\n",
        "                    new_matrix[new_i][new_j] = float(A[x][y])\n",
        "                    new_j += 1\n",
        "            new_j = 0\n",
        "            new_i += 1\n",
        "        sum += pow(-1,i)*A[i][0]*det(new_matrix)\n",
        "    return sum \n",
        "    pass\n",
        "\n",
        "A = [[7,5,1],[1,7,1],[5,5,7]]\n",
        "print(det(A))\n",
        "print(np.linalg.det(A))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The inverse of a Matrix is defined as : \n",
        "$$\n",
        "\\mathbf{A}^{-1}=\\frac{adj(A)}{det(A)}\n",
        "$$\n",
        "The adjugate of $\\mathbf{A} \\ adj(\\mathbf{A})$ is the transpose of $\\mathbf{C}$, that is, the n × n matrix whose (i, j) entry is the (j, i) cofactor of A,\n",
        "$$\n",
        "adj(\\mathbf{A})=\\mathbf{C}^T=\\left((-1)^{i+j}M_{ji}\\right)_{1 \\leq i,j \\leq n}\n",
        "$$\n",
        "> Write a function that takes a Matrix  as input and gives inverse of Matrix as output then use it to calculate the inverse of the  following Matrix :\n",
        "$$\n",
        "A = \\begin{bmatrix}\n",
        "    7 & 5 & 1\\\\\n",
        "    1 & 7 & 1\\\\\n",
        "    5 & 5 & 7\n",
        "\\end{bmatrix}\n",
        "$$\n",
        "> then use np.linalg.inv to check your answer "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 464,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0.1641791  -0.1119403  -0.00746269]\n",
            " [-0.00746269  0.1641791  -0.02238806]\n",
            " [-0.1119403  -0.03731343  0.1641791 ]] \n",
            "\n",
            "[[ 0.1641791  -0.1119403  -0.00746269]\n",
            " [-0.00746269  0.1641791  -0.02238806]\n",
            " [-0.1119403  -0.03731343  0.1641791 ]]\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "# Code cell\n",
        "def inv(A):\n",
        "    \n",
        "        # write your code here\n",
        "    C = np.zeros((len(A),len(A)))\n",
        "    new_matrix = np.zeros((len(A) - 1 , len(A) - 1))\n",
        "    for i in range(0,len(A)):\n",
        "        for j in range(0, len(A)):\n",
        "            new_i = 0\n",
        "            new_j = 0\n",
        "            for x in range(0,len(A)):\n",
        "                if i == x:\n",
        "                    continue\n",
        "                for y in range(0,len(A)):\n",
        "                    if j == y:\n",
        "                        continue\n",
        "                    else :\n",
        "                        new_matrix[new_i][new_j] = A[x][y]\n",
        "                        new_j += 1\n",
        "                new_i +=1\n",
        "                new_j = 0\n",
        "            C[i][j] = det(new_matrix) * pow(-1,i+j)\n",
        "    C_T = np.zeros((len(A),len(A)))\n",
        "    for i in range(0,len(A)):\n",
        "        for j in range(0,len(A)):\n",
        "            C_T[i][j] = C[j][i]\n",
        "    return C_T/det(A)\n",
        "    \n",
        "A = [[7,5,1],[1,7,1],[5,5,7]]\n",
        "print(inv(A) , \"\\n\")\n",
        "print(np.linalg.inv(A))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Gauss-Jordan elimination\n",
        "#### 2-1-  Implementation\n",
        "The Gauss-Jordan Elimination method is an algorithm to solve a linear system of equations. This method solves the system by representing it as an augmented matrix, reducing it using row operations, and expressing the system in reduced row-echelon form to find the values of the variables. \\\n",
        "The function gauss_jordan_elimination takes two arguments: the matrix A representing the coefficients of the equations, and the vector b representing the constants on the right-hand side of the equations. It sets flag to 1 and returns the solution vector x if exists, else sets flag to 0 in case of 'No Solution' or 'Infinite Solutions' and prints the corresponding case.\n",
        "\n",
        "Here's an example of a system of equations $\\textbf{Ax = b}$\n",
        "\n",
        "the inputs of the function :\n",
        "\n",
        "$$\n",
        "A = \\begin{bmatrix}\n",
        "    2  & 1  & 5 \\\\\n",
        "    4  & 4  & -4 \\\\\n",
        "    1 & 3 & 1 \n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "$$\n",
        "b = \\begin{bmatrix}\n",
        "    8  \\\\\n",
        "    4  \\\\\n",
        "    5 \n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "the corresponding output :\n",
        "\n",
        "$$\n",
        "x = \\begin{bmatrix}\n",
        "    1  \\\\\n",
        "    1  \\\\\n",
        "    1 \n",
        "\\end{bmatrix}\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 465,
      "metadata": {},
      "outputs": [],
      "source": [
        "# import required packages\n",
        "import numpy as np\n",
        "import time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 466,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 1. 1.] 1\n"
          ]
        }
      ],
      "source": [
        "#Code cell\n",
        "def gauss_jordan_elimination(A, B):\n",
        "    \n",
        "        # write your code here\n",
        "\n",
        "    n = len(A)\n",
        "\n",
        "    x = np.zeros(n)\n",
        "\n",
        "    A_hat = np.zeros((n,n+1))\n",
        "    A_hat[:,:-1] = A\n",
        "    A_hat[:,n] = np.transpose(B)\n",
        "\n",
        "    pivot_vector = np.zeros(n)\n",
        "    for i in range(n):\n",
        "        for j in range(i,n):\n",
        "            if abs(A_hat[i][j]) > 1e-10:\n",
        "                if pivot_vector[i] == 0:\n",
        "                    pivot_vector[i] = j + 1\n",
        "                    for z in range(n):\n",
        "                        if z == j:\n",
        "                            continue\n",
        "                        if z != j:\n",
        "                            mult = A_hat[z][i]\n",
        "                            pivot = A_hat[i][j]\n",
        "                            A_hat[z,:] = A_hat[z,:] - (mult/pivot) * A_hat[j,:]\n",
        "                    break\n",
        "            else:\n",
        "                A_hat[i][j] = 0\n",
        "                \n",
        "        if pivot_vector[i] == 0:\n",
        "            if A_hat[i][n] > 1e-10:\n",
        "                print(\"No Solution\")\n",
        "                return None, 0\n",
        "            else:\n",
        "                print(\"Infinite Solutions\")\n",
        "                return None, 0\n",
        "    for i in range(n):\n",
        "        x[i] = A_hat[i,n] / A_hat[i,i]\n",
        "                 \n",
        "    return x,1\n",
        "\n",
        "A1 = [[2,1,5],[4,4,-4],[1,3,1]]\n",
        "B = [[8],[4],[5]]\n",
        "res , flag = gauss_jordan_elimination(A1,B)\n",
        "print(res , flag)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 467,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "status: successful, time elapsed: 2e-05 seconds\n",
            "No Solution\n",
            "None 0\n",
            "status: successful, time elapsed: 2e-05 seconds\n"
          ]
        }
      ],
      "source": [
        "# Evaluation Cell\n",
        "n = 10\n",
        "A = np.zeros((10,10))\n",
        "b = np.random.randint(100, size=(10))\n",
        "while np.linalg.matrix_rank(A) != n: \n",
        "  A = np.random.randint(0,100,(n, n))\n",
        "s = time.time()\n",
        "elapsed = time.time() - s\n",
        "x, flag = gauss_jordan_elimination(A,b)\n",
        "assert flag == 1, \"flag's not set correctly\"\n",
        "assert np.linalg.norm(A @ x - b) < 1e-7, \"Ax = b is not satisfied\"\n",
        "print(f'status: successful, time elapsed: {np.round(elapsed, 5)} seconds')\n",
        "b = np.random.randint(100, size=(10))\n",
        "A = np.random.randint(0, 100, (n, n))\n",
        "U, S, V = np.linalg.svd(A)\n",
        "r = 9  \n",
        "S[r:] = 0 \n",
        "A = U.dot(np.diag(S)).dot(V)\n",
        "b = np.random.randint(100, size=(10))\n",
        "s = time.time()\n",
        "elapsed = time.time() - s\n",
        "x, flag = gauss_jordan_elimination(A,b)\n",
        "print(x,flag)\n",
        "assert flag == 0, \"flag's not set correctly\"\n",
        "print(f'status: successful, time elapsed: {np.round(elapsed, 5)} seconds')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Statistics on random matrices\n",
        "\n",
        "On average, a random matrix is invertible. But what if the random matrix has entries that are either 0 or 1 with equal probability? What is the probability that a 5 by 5 matrix whose entries are all zeros or ones is singular? And what is the average number of pivot columns? That is what you will find out in this exercise.\n",
        "\n",
        "Create random integer matrices whose entries are either 0 or 1. To find the number of pivot columns of a matrix A, complete the function getrank below.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 468,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell\n",
        "import numpy as np\n",
        "def getrank(A):\n",
        "\n",
        "    # write your code here\n",
        "    n = len(A)\n",
        "    rank = 0 \n",
        "    for i in range(n):\n",
        "        if A[i][i] == 0:\n",
        "            for j in range(i+1,n):\n",
        "                if A[j][i] != 0:\n",
        "                    tmp = A[i].copy()\n",
        "                    A[i] = A[j]\n",
        "                    A[j] = tmp\n",
        "                    break\n",
        "        pivot = A[i][i]\n",
        "        for j in range(i + 1, n):\n",
        "            if pivot == 0:\n",
        "                break\n",
        "            mult = A[j][i]\n",
        "            for z in range(n):\n",
        "                A[j][z] -= (mult/pivot) * A[i][z]\n",
        "                if abs(A[i][z]) < 1e-5:\n",
        "                    A[i][z] = 0\n",
        "\n",
        "    j_rank = 0\n",
        "    for i in range(n):\n",
        "        for j in range(j_rank , n):\n",
        "            if A[i][j] != 0:\n",
        "                rank += 1\n",
        "                j_rank = j\n",
        "                break\n",
        "\n",
        "    return rank "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 469,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Rank average = 4.27\n",
            "Singularity Probability = 0.64\n"
          ]
        }
      ],
      "source": [
        "# Code cell\n",
        "\n",
        "num = 100;  # Number of random trials \n",
        "n = 5  # Size of matrix\n",
        "\n",
        "\n",
        "\n",
        "# (avg number of pivots, probability of being singular)\n",
        "# in the format [a.b,c.d] where you rounded the answer to one decimal place.\n",
        "\n",
        "# write your code here\n",
        "\n",
        "sum_ranks = 0\n",
        "invertible_m_num = 0\n",
        "for i in range(num):\n",
        "    A = np.zeros((5,5))\n",
        "    for i in range(n):\n",
        "        for j in range(n):\n",
        "            A[i][j] = np.random.randint(2)\n",
        "    rank = getrank(A)\n",
        "    sum_ranks += rank\n",
        "    if rank == n:\n",
        "        invertible_m_num += 1\n",
        "\n",
        "avg_rank = float(sum_ranks) / float(num)\n",
        "invertible_prob = float(invertible_m_num) / float(num)\n",
        "sing_prob = 1 - invertible_prob\n",
        "\n",
        "print(f'Rank average = {avg_rank}')\n",
        "print(f'Singularity Probability = {sing_prob}')\n",
        "# write your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We've looked at random matrices whose entries are 0 or 1. But how does size effect the rank and the probability of being singular? Repeat the previous exercise for 10 by 10 matrices with entries that are 0 or 1.\n",
        "\n",
        "Explore and plot the probability of singularity and the average number of pivots for different sizes of random matrices. Can you determine how this probability depends on the size of the matrix? You might try to find the probability of a 10 by 10 random matrix with entries 0 or 1 has rank 10, 9, 8, 7 etc. You can check your probabilities against the expected value to see if your probabilities match your observations. You might try to connect these probabilities with determinant formulas to see if you can predict the numbers from other formulas and prove a relationship. Happy explorations!\n",
        "\n",
        " guess what happens as $n \\rightarrow \\infty $\n",
        ", but only run up to 80"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 492,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For n:5\n",
            "Rank average = 4.414\n",
            "Singularity Probability = 0.506\n",
            "-----------------------------\n",
            "For n:10\n",
            "Rank average = 9.748\n",
            "Singularity Probability = 0.22999999999999998\n",
            "-----------------------------\n",
            "For n:20\n",
            "Rank average = 19.99\n",
            "Singularity Probability = 0.008000000000000007\n",
            "-----------------------------\n",
            "For n:40\n",
            "Rank average = 39.998\n",
            "Singularity Probability = 0.0020000000000000018\n",
            "-----------------------------\n",
            "For n:80\n",
            "Rank average = 79.998\n",
            "Singularity Probability = 0.0020000000000000018\n",
            "-----------------------------\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2000x1000 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Code cell\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "nvalues = [5,10,20,40,80]\n",
        "num = 500\n",
        "rank_avg_list = list()\n",
        "prob_list = list()\n",
        "for n in nvalues :    \n",
        "    sum_ranks = 0\n",
        "    invertible_m_num = 0\n",
        "    for i in range(num):\n",
        "        A = np.zeros((n,n))\n",
        "        for i in range(n):\n",
        "            for j in range(n):\n",
        "                A[i][j] = np.random.randint(2)\n",
        "        rank = getrank(A)\n",
        "        sum_ranks += rank\n",
        "        if rank == n:\n",
        "            invertible_m_num += 1\n",
        "\n",
        "    avg_rank = float(sum_ranks) / float(num)\n",
        "    rank_avg_list.append(avg_rank)\n",
        "    \n",
        "    invertible_prob = float(invertible_m_num) / float(num)\n",
        "\n",
        "    sing_prob = 1 - invertible_prob\n",
        "\n",
        "    prob_list.append(sing_prob)\n",
        "    print(f'For n:{n}')\n",
        "    print(f'Rank average = {avg_rank}')\n",
        "    print(f'Singularity Probability = {sing_prob}')\n",
        "    print('-----------------------------')\n",
        "    \n",
        "plt.figure(figsize=(20,10))\n",
        "plt.subplot(1,2,1)\n",
        "plt.ylabel(\"Rank average\")\n",
        "plt.xlabel(\"nvalues\")\n",
        "plt.title(\"Rank Average in base of nvalues\")\n",
        "plt.plot(nvalues,rank_avg_list,'o')\n",
        "plt.grid()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.ylabel(\"Singularity probability\")\n",
        "plt.xlabel(\"nvalues\")\n",
        "plt.title(\"Singularity probability in base of nvalues\")\n",
        "plt.plot(nvalues,prob_list,'o')\n",
        "\n",
        "plt.grid()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Application of Cholesky decomposition\n",
        "#### 4-1-  Cholesky decomposition\n",
        "In linear algebra, LU decomposition factors a matrix ($\\textbf{A} :n \\times n$) as the product of a lower triangular matrix ($\\textbf{L} :n \\times n$) and an upper triangular matrix ($\\textbf{U} :n \\times n$). The product sometimes includes a permutation matrix ($\\textbf{P} :n \\times n$) as well.\n",
        "$$ \\textbf{PA} = \\textbf{LU} $$\n",
        "We know that the elements on the main diagonal of the $\\textbf{U}$ are the pivots. So $\\textbf{U}$ can be decomposed into a diagonal matrix ($\\textbf{D} :n \\times n$) with elements whose pivots are on the main diagonal and a normalized $\\textbf{U}$ matrix.\n",
        "$$ \\textbf{PA} = \\textbf{LDU}  $$\n",
        "if the A is symmetric then we have the Cholesky decomposition :\n",
        "$$\n",
        "\\mathbf{A}^T=\\mathbf{A} \\longrightarrow \\mathbf{A} =LD^\\frac{1}{2}D^\\frac{1}{2} L^T= (LD^\\frac{1}{2})(LD^\\frac{1}{2})^T=L'{L'} ^T\n",
        "$$\n",
        "There are various methods for calculating the Cholesky decomposition one of them is $\\bold{Cholesky–Banachiewicz}$ algorithm :\n",
        "$$\n",
        "A=LL^T=\\begin{bmatrix}\n",
        "    L_{11}& 0 & 0\\\\\n",
        "    L_{21} & L_{22} & 0\\\\\n",
        "    L_{31}  & L_{32}  & L_{33} \n",
        "\\end{bmatrix}\\begin{bmatrix}\n",
        "    L_{11}  & L_{21}  & L_{31} \\\\\n",
        "    0  & L_{22}  & L_{32} \\\\\n",
        "    0 & 0 & L_{33} \n",
        "\\end{bmatrix}=\\begin{bmatrix}\n",
        "    L_{11}^2  &   & (symmetric) \\\\\n",
        "    L_{21}L_{11}  & L_{21}^2+L_{22}^2  &  \\\\\n",
        "    L_{31}L_{11}& L_{31}L_{21}+L_{32}L_{22}& L_{33}^2+L_{32}^2+L_{31}^2 \n",
        "\\end{bmatrix}\n",
        "$$\n",
        "\n",
        "and therefore the following formulas for the entries of L:\n",
        "\n",
        "$$\n",
        "L_{jj}=\\sqrt{A_{jj}-\\sum_{k=1}^{j-1}L_{jk}^2} \\\\\n",
        "\\\\\n",
        "L_{i,j}=\\frac{\\left(A_{ij}-\\sum_{k=1}^{j-1}L_{jk}L_{ik}\\right)}{L_{jj}} \\  \\ for \\ \\ i>j\n",
        "$$\n",
        "\n",
        "> Use this algorithm to write a function that takes a matrix and gives its cholesky decomposition. also print the output for the following matrix :\n",
        "$$\n",
        "\\mathbf{C}=\n",
        "\\begin{bmatrix}\n",
        "    1 & 0.7 \\\\\n",
        "    0.7 & 1\n",
        "\\end{bmatrix}\n",
        "$$ \n",
        "\n",
        "\n",
        "> then use np.linalg.cholesky to check your answer "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 480,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1.         0.        ]\n",
            " [0.7        0.71414284]] \n",
            "\n",
            "[[1.         0.        ]\n",
            " [0.7        0.71414284]]\n"
          ]
        }
      ],
      "source": [
        "# Code cell\n",
        "def Cholesky(A):\n",
        "    \n",
        "    # write your code here\n",
        "    n = len(A)\n",
        "    L = np.zeros((n,n))\n",
        "\n",
        "    for i in range(0,n):\n",
        "        for j in range(i,n):\n",
        "            sigma_l = 0\n",
        "            if i == j:\n",
        "                for z in range(0,i):\n",
        "                    sigma_l += pow(L[i][z],2)\n",
        "                L[i][i] = np.sqrt(A[i][i]-sigma_l)\n",
        "            else:\n",
        "                for k in range(0,i):\n",
        "                    sum_l += L[i][k]*L[j][k]\n",
        "                L[j][i] = (A[j][i]-sigma_l)/L[i][i]\n",
        "    return L\n",
        "    pass\n",
        "    \n",
        "C = [[1,0.7],[0.7,1]]\n",
        "print(Cholesky(C) , \"\\n\")\n",
        "print(np.linalg.cholesky(C))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 4-2-  Using Cholesky to generate correlated random numbers\n",
        "\n",
        "The co-variance Matrix of any random vector Y\n",
        " is given as $\\mathbf{E}(YY^T)$\n",
        ", where Y\n",
        " is a random column vector of size n×1\n",
        ". Now take a random vector, X\n",
        ", consisting of uncorrelated random variables with each random variable, $X_i$\n",
        ", having zero mean and unit variance 1\n",
        ". Since $X_i$\n",
        "'s are uncorrelated random variables with zero mean and unit variance, we have $\\mathbf{E}(X_i X_j^T)=δ_{ij}$\n",
        ". Hence,\n",
        "$$\n",
        "\\mathbf{E}(XX^T)=I\n",
        "$$\n",
        "To generate a random vector with a given covariance matrix $\\mathbf{C}$\n",
        ", look at the Cholesky decomposition of $C$\n",
        " i.e. $\\mathbf{C}=LL^T$\n",
        " \n",
        "Now look at the random vector $Z=LX$ :\n",
        "$$\n",
        "\\mathbf{E}(ZZ^T)=\\mathbf{E}\\left((LX)(LX)^T\\right)=L\\mathbf{E}(XX^T)L^T =LL^T=\\mathbf{C}\n",
        "$$\n",
        "Hence, the random vector $\\mathbf{Z}$\n",
        " has the desired co-variance matrix, $\\mathbf{C}$\n",
        "\n",
        " >Make the covarience matirx of $C$\n",
        "  $$\n",
        "\\mathbf{C}=\n",
        "\\begin{bmatrix}\n",
        "    1 & 0.7 \\\\\n",
        "    0.7 & 1\n",
        "\\end{bmatrix}\n",
        "$$ \n",
        "\n",
        " \n",
        " >Then we need another matrix with the desired standard deviation in the diagonal  $\\Tau$\n",
        " $$\n",
        "\\mathbf{\\Tau}=\n",
        "\\begin{bmatrix}\n",
        "    1 & 0 \\\\\n",
        "    0 & 2\n",
        "\\end{bmatrix}\n",
        "$$ \n",
        ">Then find the cholesky decomposition of $C$\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 481,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1.         0.        ]\n",
            " [0.7        0.71414284]] \n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Code cell\n",
        "C = [[1,0.7],[0.7,1]]\n",
        "T = [[1,0],[0,2]]\n",
        "\n",
        "L = Cholesky(C)\n",
        "print(L , \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Now  generate values for 2 independent random variables and put them in  2*1000 matrix $X$ (1000 samples)\n",
        "\n",
        "you can use np.random.normal ( generates iid random variables each time )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 482,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell\n",
        "X1 = np.random.normal(size=1000)\n",
        "X2 = np.random.normal(size=1000)\n",
        "X = np.vstack((np.transpose(X1),np.transpose(X2)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">then calculate $\\mathbf{Z}=\\Tau L X$ and then plot Z[1] in base of Z[0] and X[1] in base of X[0] "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 491,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 2000x1000 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#code here\n",
        "Z = np.matmul(np.matmul(T,L),X)\n",
        "plt.figure(figsize=(20,10))\n",
        "\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(Z[0],Z[1],'o')\n",
        "plt.xlabel(\"Z[0]\")\n",
        "plt.xlabel(\"Z[1]\")\n",
        "plt.title(\"Z[1] in base of Z[0]\")\n",
        "plt.grid()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.plot(X[0],X[1],'o')\n",
        "plt.xlabel(\"X[0]\")\n",
        "plt.xlabel(\"X[1]\")\n",
        "plt.title(\"X[1] in base of X[0]\")\n",
        "plt.grid()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">now  check the correlation in generated samples with using np.correlate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 489,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1286.53584091]\n"
          ]
        }
      ],
      "source": [
        "# Code cell\n",
        "colleration = np.correlate(Z[0],Z[1])\n",
        "print(colleration)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. Graphs (bonus)\n",
        "\n",
        "I suggest running this question's code cells in google colab to install the $\\textbf{PyGSP}$ package by  simply running the following code cell"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 475,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Defaulting to user installation because normal site-packages is not writeable\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pygsp in /home/sk2ip/.local/lib/python3.10/site-packages (0.5.1)\n",
            "Requirement already satisfied: numpy in /home/sk2ip/.local/lib/python3.10/site-packages (from pygsp) (1.26.1)\n",
            "Requirement already satisfied: scipy in /home/sk2ip/.local/lib/python3.10/site-packages (from pygsp) (1.11.3)\n",
            "\u001b[33mDEPRECATION: distro-info 1.1build1 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of distro-info or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n",
            "\u001b[0m"
          ]
        }
      ],
      "source": [
        "!pip install pygsp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "<!-- ![]( graph.png) -->\n",
        "<div style=\"text-align:center\">\n",
        "    <img src=\"graph.png\" alt=\"Image\" />\n",
        "</div> \n",
        "\n",
        "\n",
        "For the directed graph above the adjacency matrix is : \n",
        "$\n",
        "A = \\begin{bmatrix}\n",
        "    0  & 1  & 1 & 0\\\\\n",
        "    -1  & 0  & 1 & 1 \\\\\n",
        "    -1 & -1 & 0 & 1 \\\\\n",
        "    0  & -1  & -1 & 0\n",
        "\\end{bmatrix}\n",
        "$ \n",
        "\n",
        "If we change the nodes numbering, the properties of the graph don't change yet the adjacency matrix changes. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# import required packages\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from pygsp import graphs, filters, plotting\n",
        "import cv2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "#### 5-1-  Introduction to graphs \n",
        ">construct the permutation matrix $\\textbf{P}$ by modifying the Identity matrix. then use it to number the graph's nodes in reverse order"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell\n",
        "="
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "assert A_modified == np.matrix('0 -1 -1 0; 1 0 -1 -1; 1 1 0 -1; 0 1 1 0'), \"wrong!\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 5-2-  Graph image processing  \n",
        "\n",
        "Inpainting is a classical signal processing problem where we wish to fill in the missing values in a\n",
        "partially observed signal. This is here done in the context of image processing for inferring missing pixel values in\n",
        "an image. The signal in the image is considered to be the image matrix flattened while the image is modeled as a 2D grid graph.\n",
        "Inpainting for an image can be formulated as below:\n",
        "\n",
        "$$(M + \\alpha L)x = y$$\n",
        "\n",
        "where y is a partially observed graph signal (with missing values being 0), and M is a diagonal matrix that satisfies:\n",
        " $$ M(i, i)=   \\left\\{\n",
        "\\begin{array}{ll}\n",
        "      1, & if & y(i) & is & observed, \\\\\n",
        "      0, & if & y(i) & is & not & observed, \\\\\n",
        "\\end{array} \n",
        "\\right.  $$\n",
        "\n",
        "The Equation tries to find an x that nearly matches the observed values in y, and at the same time\n",
        "being smooth on the graph (the image here). The regularisation parameter α controls the trade-off between the data fidelity term and the\n",
        "smoothness prior. The solution can therefore be considered as an inpainted version of the partially observed signal."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Use the cv2 package to load a grayscale version of the cameraman image with a relatively low resolution, 64 by 64, then display the image using matplotlib.pyplot\n",
        "\n",
        "- do not forget to convert RGB to gray to reduce the 3 color channels to one"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Now flatten the image matrix to get the signal\\\n",
        ">Then, construct the diagonal matrix M which has its diagonal 0 except for $p = 50%$ of its elements that are randomly set to 1\\\n",
        ">At last, apply the observasion matrix M to the signal and construct y "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# do not edit this cell \n",
        "G = graphs.Grid2d(64,64)\n",
        "L = G.L"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">To get x, apply the $\\textbf{Cholesky decomposition}$ to ( $M+\\alpha L$ ) and then solve the stated equation applying np.linalg.inv() to the two terms multiplied by x ( note that L is given by the code cell above )\n",
        "- check the soloution with \"np.linalg.solve()\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">For values of alpha 0.001 , 0.1 , 10 and p values 50 , 75 display the original, the damaged and the Inpainted image in subplots"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Code cell"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "base",
      "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.10.6"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "a552c2ea7a7b6736ba4a8b66efcb40eda8d77c5e9d980e5b81f29aecaaefb085"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}