From 6b82a8a4fa80ed0f231c77088d57836ba4d773ea Mon Sep 17 00:00:00 2001
From: Robert Lanzafame <R.C.Lanzafame@tudelft.nl>
Date: Sat, 5 Oct 2024 11:00:17 +0200
Subject: [PATCH] PA 1.6 nb

---
 content/Week_1_6/PA/PA_1_6_solution.ipynb     | 1330 ++++++-----------
 content/Week_1_6/PA/README.md                 |   34 +-
 content/Week_1_6/PA/Some_small_bugs.py        |   17 -
 content/Week_1_6/PA/figures/matrix01.svg      |  365 +++++
 content/Week_1_6/PA/figures/matrix02.svg      |  388 +++++
 content/Week_1_6/PA/script_01_small_bugs.py   |  103 ++
 ...6-Challenges_A.py => script_02_big_bug.py} |    0
 ..._no_errors.py => script_03_logical_bug.py} |   94 +-
 content/Week_1_6/PA/script_test.py            |    6 +
 content/Week_1_6/PA/test.py                   |    7 +
 10 files changed, 1361 insertions(+), 983 deletions(-)
 delete mode 100644 content/Week_1_6/PA/Some_small_bugs.py
 create mode 100644 content/Week_1_6/PA/figures/matrix01.svg
 create mode 100644 content/Week_1_6/PA/figures/matrix02.svg
 create mode 100644 content/Week_1_6/PA/script_01_small_bugs.py
 rename content/Week_1_6/PA/{PA6-Challenges_A.py => script_02_big_bug.py} (100%)
 rename content/Week_1_6/PA/{A_mistake_that_shows_no_errors.py => script_03_logical_bug.py} (97%)
 create mode 100644 content/Week_1_6/PA/script_test.py
 create mode 100644 content/Week_1_6/PA/test.py

diff --git a/content/Week_1_6/PA/PA_1_6_solution.ipynb b/content/Week_1_6/PA/PA_1_6_solution.ipynb
index b600814a..a77653d9 100644
--- a/content/Week_1_6/PA/PA_1_6_solution.ipynb
+++ b/content/Week_1_6/PA/PA_1_6_solution.ipynb
@@ -28,286 +28,95 @@
    "source": [
     "The purpose of this notebook is to introduce a few useful Python topics:\n",
     "\n",
-    "1. assert statements\n",
-    "2. list comprehension\n",
-    "3. plt.bar()\n",
-    "4. including a figure in a Markdown document\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "7affbc76",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on _ArrayFunctionDispatcher in module numpy:\n",
-      "\n",
-      "fill_diagonal(a, val, wrap=False)\n",
-      "    Fill the main diagonal of the given array of any dimensionality.\n",
-      "\n",
-      "    For an array `a` with ``a.ndim >= 2``, the diagonal is the list of\n",
-      "    locations with indices ``a[i, ..., i]`` all identical. This function\n",
-      "    modifies the input array in-place, it does not return a value.\n",
-      "\n",
-      "    Parameters\n",
-      "    ----------\n",
-      "    a : array, at least 2-D.\n",
-      "      Array whose diagonal is to be filled, it gets modified in-place.\n",
-      "\n",
-      "    val : scalar or array_like\n",
-      "      Value(s) to write on the diagonal. If `val` is scalar, the value is\n",
-      "      written along the diagonal. If array-like, the flattened `val` is\n",
-      "      written along the diagonal, repeating if necessary to fill all\n",
-      "      diagonal entries.\n",
-      "\n",
-      "    wrap : bool\n",
-      "      For tall matrices in NumPy version up to 1.6.2, the\n",
-      "      diagonal \"wrapped\" after N columns. You can have this behavior\n",
-      "      with this option. This affects only tall matrices.\n",
-      "\n",
-      "    See also\n",
-      "    --------\n",
-      "    diag_indices, diag_indices_from\n",
-      "\n",
-      "    Notes\n",
-      "    -----\n",
-      "    .. versionadded:: 1.4.0\n",
-      "\n",
-      "    This functionality can be obtained via `diag_indices`, but internally\n",
-      "    this version uses a much faster implementation that never constructs the\n",
-      "    indices and uses simple slicing.\n",
-      "\n",
-      "    Examples\n",
-      "    --------\n",
-      "    >>> a = np.zeros((3, 3), int)\n",
-      "    >>> np.fill_diagonal(a, 5)\n",
-      "    >>> a\n",
-      "    array([[5, 0, 0],\n",
-      "           [0, 5, 0],\n",
-      "           [0, 0, 5]])\n",
-      "\n",
-      "    The same function can operate on a 4-D array:\n",
-      "\n",
-      "    >>> a = np.zeros((3, 3, 3, 3), int)\n",
-      "    >>> np.fill_diagonal(a, 4)\n",
-      "\n",
-      "    We only show a few blocks for clarity:\n",
-      "\n",
-      "    >>> a[0, 0]\n",
-      "    array([[4, 0, 0],\n",
-      "           [0, 0, 0],\n",
-      "           [0, 0, 0]])\n",
-      "    >>> a[1, 1]\n",
-      "    array([[0, 0, 0],\n",
-      "           [0, 4, 0],\n",
-      "           [0, 0, 0]])\n",
-      "    >>> a[2, 2]\n",
-      "    array([[0, 0, 0],\n",
-      "           [0, 0, 0],\n",
-      "           [0, 0, 4]])\n",
-      "\n",
-      "    The wrap option affects only tall matrices:\n",
-      "\n",
-      "    >>> # tall matrices no wrap\n",
-      "    >>> a = np.zeros((5, 3), int)\n",
-      "    >>> np.fill_diagonal(a, 4)\n",
-      "    >>> a\n",
-      "    array([[4, 0, 0],\n",
-      "           [0, 4, 0],\n",
-      "           [0, 0, 4],\n",
-      "           [0, 0, 0],\n",
-      "           [0, 0, 0]])\n",
-      "\n",
-      "    >>> # tall matrices wrap\n",
-      "    >>> a = np.zeros((5, 3), int)\n",
-      "    >>> np.fill_diagonal(a, 4, wrap=True)\n",
-      "    >>> a\n",
-      "    array([[4, 0, 0],\n",
-      "           [0, 4, 0],\n",
-      "           [0, 0, 4],\n",
-      "           [0, 0, 0],\n",
-      "           [4, 0, 0]])\n",
-      "\n",
-      "    >>> # wide matrices\n",
-      "    >>> a = np.zeros((3, 5), int)\n",
-      "    >>> np.fill_diagonal(a, 4, wrap=True)\n",
-      "    >>> a\n",
-      "    array([[4, 0, 0, 0, 0],\n",
-      "           [0, 4, 0, 0, 0],\n",
-      "           [0, 0, 4, 0, 0]])\n",
-      "\n",
-      "    The anti-diagonal can be filled by reversing the order of elements\n",
-      "    using either `numpy.flipud` or `numpy.fliplr`.\n",
-      "\n",
-      "    >>> a = np.zeros((3, 3), int);\n",
-      "    >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip\n",
-      "    >>> a\n",
-      "    array([[0, 0, 1],\n",
-      "           [0, 2, 0],\n",
-      "           [3, 0, 0]])\n",
-      "    >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip\n",
-      "    >>> a\n",
-      "    array([[0, 0, 3],\n",
-      "           [0, 2, 0],\n",
-      "           [1, 0, 0]])\n",
-      "\n",
-      "    Note that the order in which the diagonal is filled varies depending\n",
-      "    on the flip function.\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "help(np.fill_diagonal)"
+    "1. Visualize a matrix with `plt.matshow` (Matplotlib)\n",
+    "2. Filling in the contents of a matrix (nxn Numpy array) with specific patterns and values\n",
+    "3. Illustrate the difference between `range` and `np.arange`\n",
+    "\n",
+    "At the end of the notebook there are a few practice problems to test your understanding.\n",
+    "\n",
+    "## Context\n",
+    "\n",
+    "For many scientific computing applications, in particular the field of numerical analysis, we formulate and solve our problems using matrices. The matrix itself is an arbitrary collection of values, however, the formulation and discretization of the problem will dictate a specific structure and meaning to the arrangement of the values inside a given matrix. When solving ordinary and partial differential equations with numerical schemes, we discretize space and time into discrete points or intervals, and the values of interest are specified by the elements of a matrix or vector. For example, a vector of the quantity $y$ can be discretized as `y = [y0, y1, y2, ... , yn]`, where each element `yi` refers to the $n$ spatial coordinate of $y_i$. For 2D problems, or perhaps problem with a temporal component (a dependence on time), we need to encode this information in matrices. Thus, when implementing numerical schemes, it is important to be able to fill in the values of a matrix in an efficient and reliable way."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "id": "342563b8",
+   "execution_count": 1,
+   "id": "0b13d0cf",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on function matshow in module matplotlib.pyplot:\n",
-      "\n",
-      "matshow(A: 'ArrayLike', fignum: 'None | int' = None, **kwargs) -> 'AxesImage'\n",
-      "    Display a 2D array as a matrix in a new figure window.\n",
-      "\n",
-      "    The origin is set at the upper left hand corner.\n",
-      "    The indexing is ``(row, column)`` so that the first index runs vertically\n",
-      "    and the second index runs horizontally in the figure:\n",
-      "\n",
-      "    .. code-block:: none\n",
-      "\n",
-      "        A[0, 0]   ⋯ A[0, M-1]\n",
-      "           â‹®             â‹®\n",
-      "        A[N-1, 0] ⋯ A[N-1, M-1]\n",
-      "\n",
-      "    The aspect ratio of the figure window is that of the array,\n",
-      "    unless this would make an excessively short or narrow figure.\n",
-      "\n",
-      "    Tick labels for the xaxis are placed on top.\n",
-      "\n",
-      "    Parameters\n",
-      "    ----------\n",
-      "    A : 2D array-like\n",
-      "        The matrix to be displayed.\n",
-      "\n",
-      "    fignum : None or int\n",
-      "        If *None*, create a new, appropriately sized figure window.\n",
-      "\n",
-      "        If 0, use the current Axes (creating one if there is none, without ever\n",
-      "        adjusting the figure size).\n",
-      "\n",
-      "        Otherwise, create a new Axes on the figure with the given number\n",
-      "        (creating it at the appropriate size if it does not exist, but not\n",
-      "        adjusting the figure size otherwise).  Note that this will be drawn on\n",
-      "        top of any preexisting Axes on the figure.\n",
-      "\n",
-      "    Returns\n",
-      "    -------\n",
-      "    `~matplotlib.image.AxesImage`\n",
-      "\n",
-      "    Other Parameters\n",
-      "    ----------------\n",
-      "    **kwargs : `~matplotlib.axes.Axes.imshow` arguments\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "help(plt.matshow)"
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "5c2e0c3d",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "id": "646aeb89",
+   "id": "3db64401",
    "metadata": {},
    "source": [
     "## Topic 1: Visualizing a Matrix\n",
     "\n",
-    "For many problems in numerical analysis we discretize time and space into small pieces and make a large number of small calculations repeatedly. Although our goal is to solve non-linear equations, this is much easier if we can convert the problem into a system of linear equations. Then we can solve with matrices!\n",
+    "At this point you should be familiar with the Numpy library and its key data type the `ndarray`. In other words, it should be very obvious why executing something like this:\n",
     "\n",
-    "Often we need to construct the matrices ourselves, or verify that the contents are implemented correctly. "
+    "```python\n",
+    "import numpy as np\n",
+    "x = np.array([1, 4, 7, 9])\n",
+    "```\n",
+    "\n",
+    "returns something like this:\n",
+    "```python\n",
+    "numpy.ndarray\n",
+    "```\n",
+    "\n",
+    "We have already also used Numpy to create 2D arrays to represent matrices. Often one of the challenges of working with matrices is visualizing their contents, especially when the matrices become very large. Fortunately there is a Matplotlib method that makes visualizing matrices very easy: `matshow`. When using the conventional import statement `import matplotlib.pyplot as plt`, we can use this method as `plt.matshow`."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "cdf73279",
+   "id": "43f29368",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
     "<b>Task 1.1:</b>   \n",
-    "Use Numpy to construct a 5x5 matrix where the diagonal contains value 5, the corners contain value 3 and every other element is a zero.\n",
+    "Use the Python <code>help</code> function to view the docstring (documentation) of the matrix visualization method.\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "id": "b927ac75",
+   "execution_count": 2,
+   "id": "6a834b6d",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[3. 0. 0. 0. 3.]\n",
-      " [0. 5. 0. 0. 0.]\n",
-      " [0. 0. 5. 0. 0.]\n",
-      " [0. 0. 0. 5. 0.]\n",
-      " [3. 0. 0. 0. 3.]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "A = np.zeros((5,5))\n",
-    "for i in range(5):\n",
-    "    A[i, i] = 5\n",
-    "A[0, 0] = 3\n",
-    "A[-1, -1] = 3\n",
-    "A[0, -1] = 3\n",
-    "A[-1, 0] = 3\n",
-    "print(A)\n"
+    "# help(plt.matshow)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "913ad7a6",
+   "id": "1e59a3f3",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
     "<b>Task 1.2:</b>   \n",
-    "Use <code>plt.matshow()</code> to visualize the matrix. Confirm that you defined A correctly.\n",
+    "Run the cell below to visualize the A matrix. Change the values and rerun the cell to see the effect, especially noting that each \"square\" corresponds to an element in the matrix. Simple, right?!\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
-   "id": "fa47e06f",
+   "execution_count": 3,
+   "id": "df0c2ff6",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 480x480 with 1 Axes>"
       ]
@@ -317,43 +126,37 @@
     }
    ],
    "source": [
+    "A = [[1, 2, 1, 1],\n",
+    "     [2, 3, 2, 2],\n",
+    "     [1, 2, 1, 1],\n",
+    "     [1, 2, 1, 1]]\n",
+    "\n",
     "plt.matshow(A)\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "ec47c730",
+   "id": "672ef6e9",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 1.2:</b>   \n",
-    "Use <code>np.fill_diagonal()</code> to fill the diagonal of a matrix B, then set the corner values to make it equivalent to A, checking that it was done properly with an assert statement.\n",
+    "<b>Task 1.3:</b>   \n",
+    "Run the cell below to see how a 100x100 matrix filled with random values looks.\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "id": "0e2d7682",
+   "execution_count": 4,
+   "id": "4bee96eb",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-2.066666666666667\n",
-      "[[-2.06666667  1.          0.          0.        ]\n",
-      " [ 1.         -2.06666667  1.          0.        ]\n",
-      " [ 0.          1.         -2.06666667  1.        ]\n",
-      " [ 0.          0.          1.         -2.06666667]]\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 480x480 with 1 Axes>"
       ]
@@ -363,602 +166,207 @@
     }
    ],
    "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    " \n",
-    " \n",
-    "hc = 40\n",
-    "P = 0.016\n",
-    "k = 240\n",
-    "Ac = 1.6e-5\n",
-    "h=0.02\n",
-    "Ts = 293\n",
-    "beta = hc*P/(k*Ac)\n",
-    "matrix_element = -(2+h**2*beta)\n",
-    "print(matrix_element)\n",
-    "b_element = -h**2*beta*Ts\n",
-    " \n",
-    "# grid creation\n",
-    "x = np.arange(0,0.1+h,h)\n",
-    "T = np.zeros(x.shape)\n",
-    " \n",
-    "# boundary conditions\n",
-    "T[0] = 473\n",
-    "T[-1] = 293\n",
-    " \n",
-    "# Building matrix A\n",
-    "A = np.zeros((len(x)-2,len(x)-2))\n",
-    "np.fill_diagonal(A, matrix_element)\n",
-    "A[np.arange(3), np.arange(1, 4)] = 1  # Upper diagonal\n",
-    "A[np.arange(1, 4), np.arange(3)] = 1  # Lower diagonal\n",
-    " \n",
-    "b = np.array([ b_element - T[0] , b_element, b_element,  b_element - T[-1]])\n",
-    " \n",
-    " \n",
-    "A_inv = np.linalg.inv(A)\n",
-    "T[1:-1] = A_inv @ b\n",
-    " \n",
-    "print(A)\n",
-    "plt.matshow(A);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a0330b70",
-   "metadata": {},
-   "source": [
-    "## Topic 1: Assert Statements\n",
-    "\n",
-    "Assert s"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2995706",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 1.1:</b>   \n",
-    "Execute the cell below and observe the error. Note that it very specifically is an <code>AssertionError</code>.\n",
-    "\n",
-    "See if you can fix the code to prevent the error from occurring.\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "646545ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'matrix_element' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[4], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m x \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m])\n\u001b[0;32m      3\u001b[0m A \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((\u001b[38;5;28mlen\u001b[39m(x)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m,\u001b[38;5;28mlen\u001b[39m(x)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m))\n\u001b[1;32m----> 4\u001b[0m np\u001b[38;5;241m.\u001b[39mfill_diagonal(A, matrix_element)\n\u001b[0;32m      5\u001b[0m A[np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m3\u001b[39m), np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m)] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m  \u001b[38;5;66;03m# Upper diagonal\u001b[39;00m\n\u001b[0;32m      6\u001b[0m A[np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m), np\u001b[38;5;241m.\u001b[39marange(\u001b[38;5;241m3\u001b[39m)] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
-      "\u001b[1;31mNameError\u001b[0m: name 'matrix_element' is not defined"
-     ]
-    }
-   ],
-   "source": [
-    "x = np.array([1, 2, 3, 4, 5])\n",
-    "\n",
-    "A = np.zeros((len(x)-2,len(x)-2))\n",
-    "np.fill_diagonal(A, matrix_element)\n",
-    "A[np.arange(3), np.arange(1, 4)] = 1  # Upper diagonal\n",
-    "A[np.arange(1, 4), np.arange(3)] = 1  # Lower diagonal"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "57973878",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 1.2:</b>   \n",
-    "Now try fixing the cell below by 1) adding your own error message (see Case 2 above), and 2) forcing the assert statement to fail. Confirm that you can see error message in the error report.\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "3c275192",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# y = 0\n",
-    "# assert y != 1, YOUR_MESSAGE_HERE\n",
-    "\n",
-    "# SOLUTION\n",
-    "y = 0\n",
-    "assert y != 1, \"y should not be 1 but it is\""
+    "A = np.random.rand(100, 100)\n",
+    "plt.matshow(A)\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "30ca5166",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 1.3:</b>   \n",
-    "Explore assert statements by writing your own. Experiment with different data types (e.g., strings, floats, arrays, lists) and use different logical statements from the list above.\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "27fa2738",
+   "id": "5c2e0c3d",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# YOUR_CODE_HERE"
+    "That's pretty much all there is to it. Note that the axes indicate the row and column indices."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "56a7f3a3",
+   "id": "3baa872d",
    "metadata": {},
    "source": [
-    "### Summary of Asserts\n",
+    "## Topic 2: Filling a Matrix\n",
     "\n",
-    "You are now an expert on `assert` statements. Remember these key points:\n",
+    "Now that we can visualize the contents of a matrix, lets find an efficient way to fill it with specific values, focusing on creating specific patterns in an efficient way with our Python code. First, let's recall a few more important things about Numpy arrays, focusing on the particular case of making a 2-dimensional arrays to represent 2-dimensional matrices.\n",
     "\n",
-    "- an assert statement answers a true/false question; it will will cause an error if false and do nothing if true\n",
-    "- the syntax is `assert <logical_statement>`\n",
-    "- you can easily customize the error message with the syntax `assert <logical_argument>, 'my error message'`\n",
-    "- the `<logical_statement>` must be a Boolean result"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "db9ff6b8",
-   "metadata": {},
-   "source": [
-    "## Part 2: List Comprehension\n",
+    "One of the first things to remember is that Numpy uses a parameter `shape` to define the dimension and length of each axis of an array. For the 2D case, this means an $m$-by-$n$ matrix is specified with a tuple containing two elements: `(m, n)`.\n",
     "\n",
-    "List and dictionary *comprehensions* are elegant constructs in Python that allow you to manipulate Python objects in a very compact and efficient way. You can think of them as writing a `for` loop in a single line. Here is the syntax:\n",
+    "Second, Numpy has _many_ methods that make it easy to create a matrix and fill it with specific values. Check out a cool list here: [Numpy array creation routines](https://numpy.org/doc/2.0/reference/routines.array-creation.html#). Some commonly used methods are:\n",
+    "- `np.zeros`\n",
+    "- `np.ones`\n",
+    "- `np.full`\n",
     "\n",
-    "```\n",
-    "[<DO_SOMETHING> for <ITEM> in <ITERABLE>]\n",
-    "```\n",
-    "\n",
-    "Note the following key elements:\n",
-    "- the list comprehension is enclosed in list brackets: `[ ... ]`\n",
-    "- `<DO_SOMETHING>` is any Python expression (for example, `print()` or `x**2`) \n",
-    "- `<ITEM>` is generally a (temporary) variable that is used in the expression `<DO_SOMETHING>` and represents all of the \"items\" in `<ITERABLE>`\n",
-    "- `<ITERABLE>` is an _iterable_ object. Don't worry about what this is, exactly (we will study it more later).\n",
+    "Third there are many Numpy methods that can _modify_ an existing matrix (see the same list linked above), for example: `np.fill_diagonal`. \n",
     "\n",
-    "For our purposes, it is enough to consider the following _iterables_:\n",
-    "- lists (e.g., `[1, 2, 3]`)\n",
-    "- ndarrays (Numpy)\n",
-    "- `range()`\n",
-    "- dictionaries\n",
+    "Finally, remember that arrays are quite smart when it comes to indexing. For example, we can use the `range` method (part of the standard Python library) to things to specific indices in an array.\n",
     "\n",
-    "As with assert statements, the best way to illustrate this is by example."
+    "With these tips in mind, let's go over a few warm-up exercises to see how to easily manipulate matrices."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "e759e651",
+   "id": "ac9d4769",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
     "<b>Task 2.1:</b>   \n",
-    "Read the cell below then execute it to see an example of a \"normal\" for loop that creates a list of squares from 0 to 9.\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f50a040b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "squares = []\n",
-    "for i in range(10):\n",
-    "    squares.append(i**2)\n",
     "\n",
-    "print(squares)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2f53396f",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 2.2:</b>   \n",
-    "Read the cell below then execute it to see an example of a list comprehension that does the same thing. It's much more compact, right?!\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "da714b14",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "squares = [i ** 2 for i in range(10)]\n",
+    "Refresh your memory on the <code>range</code> function by printing the documentation. Then comment the help line and confirm that you can use the function by using a list comprehension to print: a) values from 1 to 5, then b) values 2, 4, 6, 8, 10. \n",
     "\n",
-    "print(squares)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "344df335",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 2.3:</b>   \n",
-    "Read the cell below then execute it to see an example of a \"normal\" for loop that creates a dictionary that maps numbers to their squares.\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "b4be24ab",
+   "execution_count": 5,
+   "id": "a47d1b3a",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
+      "Part 1:\n",
+      "0\n",
+      "1\n",
+      "2\n",
+      "3\n",
+      "4\n",
+      "5\n",
+      "Part 2:\n",
+      "2\n",
+      "4\n",
+      "6\n",
+      "8\n",
+      "10\n"
      ]
-    }
-   ],
-   "source": [
-    "squares_dict = {}\n",
-    "for i in range(10):\n",
-    "    squares_dict[i] = i ** 2\n",
-    "\n",
-    "print(squares_dict)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7d95bdd5",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 2.4:</b>   \n",
-    "Read the cell below then execute it to see an example of a list comprehension that does the same thing. It's much more compact, right?!\n",
-    "</p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "1dbc3f22",
-   "metadata": {},
-   "outputs": [
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
-     ]
+     "data": {
+      "text/plain": [
+       "[None, None, None, None, None]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "squares_dict = {i: i ** 2 for i in range(10)}\n",
+    "# # help(range)\n",
+    "# \n",
+    "# print('Part a:')\n",
+    "# [print(i) for i in YOUR_CODE_HERE]\n",
+    "# print('Part b:')\n",
+    "# [print(i) for i in YOUR_CODE_HERE]\n",
     "\n",
-    "print(squares_dict)"
+    "# SOLUTION\n",
+    "print('Part 1:')\n",
+    "[print(i) for i in range(6)]\n",
+    "\n",
+    "print('Part 2:')\n",
+    "[print(i) for i in range(2, 11, 2)]"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a8687bf1",
+   "id": "15572568",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 2.5:</b>   \n",
-    "Now try it yourself! Create a new list from from the one defined below that has values that are half that of the original.\n",
+    "<b>Task 2.2:</b>   \n",
+    "\n",
+    "Use a Numpy method to create a 3x3 matrix filled with value 1.\n",
     "\n",
-    "<em>Note the use of asserts to make sure your answer is correct!</em>\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "id": "1ca75689",
+   "execution_count": 6,
+   "id": "8d09f380",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# my_list = [1, 2, 3, 4, 5]\n",
-    "# new_list = []\n",
-    "# print(new_list)\n",
-    "# assert new_list == [0.5, 1.0, 1.5, 2.0, 2.5], \"new_list values are not half of my_list!\" \n",
+    "# A = YOUR_CODE_HERE\n",
+    "# \n",
+    "# assert np.all(A==1)\n",
+    "# assert A.shape==(3, 3)\n",
     "\n",
     "# SOLUTION\n",
-    "my_list = [1, 2, 3, 4, 5]\n",
-    "new_list = [x/2 for x in my_list]\n",
-    "assert new_list == [0.5, 1.0, 1.5, 2.0, 2.5], \"new_list values are not half of my_list!\" "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3e8b83e6",
-   "metadata": {},
-   "source": [
-    "### Summary\n",
-    "\n",
-    "There are several reasons why you should use list comprehension, hopefully you can recognize them from the examples and tasks above:\n",
-    "\n",
-    "- Readability: Comprehensions often turn multiple lines of code into a single, readable line, making the code easier to understand at a glance.\n",
-    "- Efficiency: They are generally faster because they are optimized in the Python interpreter.\n",
-    "- Simplicity: Reduces the need for loop control variables and indexing, making the code simpler.\n",
-    "\n",
-    "Sometimes the hardest thing to remember is the order and syntax. The following list comprehension uses obvious variable names to illustrate it (assuming you have an object with \"stuff\" in it, for example, `objects = [1, 2, 3]`); if you can remember this, you can remember list comprehensions!\n",
-    "\n",
-    "```\n",
-    "[print(object) for object in objects]\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "16632cc2",
-   "metadata": {},
-   "source": [
-    "## The `plt.bar()` Method\n",
-    "\n",
-    "At this point we have created many figures in MUDE assignments using a method from the Matplotlib plotting library: `plt.plot()`. This is our \"bread and butter\" plot because it is so easy to plot lines, data, scatter plots, etc. However, there are _many_ more types of plots available in Matplotlib. Today we will try `bar()`, which, as you can imagine, creates bar plots.\n",
+    "A = np.ones((3,3))\n",
     "\n",
-    "First take a look at the documentation and see if you can figure out how it works."
+    "assert np.all(A==1)\n",
+    "assert A.shape==(3, 3)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "1e9690a5",
+   "id": "7011fd1c",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 3.1:</b>   \n",
-    "Run the cell below and read the docstring for the method. Can you determine the minimum type of inputs required, and what they will do?\n",
+    "<b>Task 2.3:</b>   \n",
+    "\n",
+    "Use a Numpy method to create a 3x3 matrix filled with value 3 on the diagonal and 0 elsewhere.\n",
+    "\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "id": "4ce7aa15",
+   "execution_count": 7,
+   "id": "d9b3bf0c",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on function bar in module matplotlib.pyplot:\n",
-      "\n",
-      "bar(x: 'float | ArrayLike', height: 'float | ArrayLike', width: 'float | ArrayLike' = 0.8, bottom: 'float | ArrayLike | None' = None, *, align: \"Literal['center', 'edge']\" = 'center', data=None, **kwargs) -> 'BarContainer'\n",
-      "    Make a bar plot.\n",
-      "\n",
-      "    The bars are positioned at *x* with the given *align*\\ment. Their\n",
-      "    dimensions are given by *height* and *width*. The vertical baseline\n",
-      "    is *bottom* (default 0).\n",
-      "\n",
-      "    Many parameters can take either a single value applying to all bars\n",
-      "    or a sequence of values, one for each bar.\n",
-      "\n",
-      "    Parameters\n",
-      "    ----------\n",
-      "    x : float or array-like\n",
-      "        The x coordinates of the bars. See also *align* for the\n",
-      "        alignment of the bars to the coordinates.\n",
-      "\n",
-      "    height : float or array-like\n",
-      "        The height(s) of the bars.\n",
-      "\n",
-      "        Note that if *bottom* has units (e.g. datetime), *height* should be in\n",
-      "        units that are a difference from the value of *bottom* (e.g. timedelta).\n",
-      "\n",
-      "    width : float or array-like, default: 0.8\n",
-      "        The width(s) of the bars.\n",
-      "\n",
-      "        Note that if *x* has units (e.g. datetime), then *width* should be in\n",
-      "        units that are a difference (e.g. timedelta) around the *x* values.\n",
-      "\n",
-      "    bottom : float or array-like, default: 0\n",
-      "        The y coordinate(s) of the bottom side(s) of the bars.\n",
-      "\n",
-      "        Note that if *bottom* has units, then the y-axis will get a Locator and\n",
-      "        Formatter appropriate for the units (e.g. dates, or categorical).\n",
-      "\n",
-      "    align : {'center', 'edge'}, default: 'center'\n",
-      "        Alignment of the bars to the *x* coordinates:\n",
-      "\n",
-      "        - 'center': Center the base on the *x* positions.\n",
-      "        - 'edge': Align the left edges of the bars with the *x* positions.\n",
-      "\n",
-      "        To align the bars on the right edge pass a negative *width* and\n",
-      "        ``align='edge'``.\n",
-      "\n",
-      "    Returns\n",
-      "    -------\n",
-      "    `.BarContainer`\n",
-      "        Container with all the bars and optionally errorbars.\n",
-      "\n",
-      "    Other Parameters\n",
-      "    ----------------\n",
-      "    color : :mpltype:`color` or list of :mpltype:`color`, optional\n",
-      "        The colors of the bar faces.\n",
-      "\n",
-      "    edgecolor : :mpltype:`color` or list of :mpltype:`color`, optional\n",
-      "        The colors of the bar edges.\n",
-      "\n",
-      "    linewidth : float or array-like, optional\n",
-      "        Width of the bar edge(s). If 0, don't draw edges.\n",
-      "\n",
-      "    tick_label : str or list of str, optional\n",
-      "        The tick labels of the bars.\n",
-      "        Default: None (Use default numeric labels.)\n",
-      "\n",
-      "    label : str or list of str, optional\n",
-      "        A single label is attached to the resulting `.BarContainer` as a\n",
-      "        label for the whole dataset.\n",
-      "        If a list is provided, it must be the same length as *x* and\n",
-      "        labels the individual bars. Repeated labels are not de-duplicated\n",
-      "        and will cause repeated label entries, so this is best used when\n",
-      "        bars also differ in style (e.g., by passing a list to *color*.)\n",
-      "\n",
-      "    xerr, yerr : float or array-like of shape(N,) or shape(2, N), optional\n",
-      "        If not *None*, add horizontal / vertical errorbars to the bar tips.\n",
-      "        The values are +/- sizes relative to the data:\n",
-      "\n",
-      "        - scalar: symmetric +/- values for all bars\n",
-      "        - shape(N,): symmetric +/- values for each bar\n",
-      "        - shape(2, N): Separate - and + values for each bar. First row\n",
-      "          contains the lower errors, the second row contains the upper\n",
-      "          errors.\n",
-      "        - *None*: No errorbar. (Default)\n",
-      "\n",
-      "        See :doc:`/gallery/statistics/errorbar_features` for an example on\n",
-      "        the usage of *xerr* and *yerr*.\n",
-      "\n",
-      "    ecolor : :mpltype:`color` or list of :mpltype:`color`, default: 'black'\n",
-      "        The line color of the errorbars.\n",
-      "\n",
-      "    capsize : float, default: :rc:`errorbar.capsize`\n",
-      "       The length of the error bar caps in points.\n",
-      "\n",
-      "    error_kw : dict, optional\n",
-      "        Dictionary of keyword arguments to be passed to the\n",
-      "        `~.Axes.errorbar` method. Values of *ecolor* or *capsize* defined\n",
-      "        here take precedence over the independent keyword arguments.\n",
-      "\n",
-      "    log : bool, default: False\n",
-      "        If *True*, set the y-axis to be log scale.\n",
-      "\n",
-      "    data : indexable object, optional\n",
-      "        If given, all parameters also accept a string ``s``, which is\n",
-      "        interpreted as ``data[s]`` (unless this raises an exception).\n",
-      "\n",
-      "    **kwargs : `.Rectangle` properties\n",
-      "\n",
-      "    Properties:\n",
-      "        agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image\n",
-      "        alpha: scalar or None\n",
-      "        angle: unknown\n",
-      "        animated: bool\n",
-      "        antialiased or aa: bool or None\n",
-      "        bounds: (left, bottom, width, height)\n",
-      "        capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
-      "        clip_box: `~matplotlib.transforms.BboxBase` or None\n",
-      "        clip_on: bool\n",
-      "        clip_path: Patch or (Path, Transform) or None\n",
-      "        color: :mpltype:`color`\n",
-      "        edgecolor or ec: :mpltype:`color` or None\n",
-      "        facecolor or fc: :mpltype:`color` or None\n",
-      "        figure: `~matplotlib.figure.Figure`\n",
-      "        fill: bool\n",
-      "        gid: str\n",
-      "        hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
-      "        height: unknown\n",
-      "        in_layout: bool\n",
-      "        joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
-      "        label: object\n",
-      "        linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
-      "        linewidth or lw: float or None\n",
-      "        mouseover: bool\n",
-      "        path_effects: list of `.AbstractPathEffect`\n",
-      "        picker: None or bool or float or callable\n",
-      "        rasterized: bool\n",
-      "        sketch_params: (scale: float, length: float, randomness: float)\n",
-      "        snap: bool or None\n",
-      "        transform: `~matplotlib.transforms.Transform`\n",
-      "        url: str\n",
-      "        visible: bool\n",
-      "        width: unknown\n",
-      "        x: unknown\n",
-      "        xy: (float, float)\n",
-      "        y: unknown\n",
-      "        zorder: float\n",
-      "\n",
-      "    See Also\n",
-      "    --------\n",
-      "    barh : Plot a horizontal bar plot.\n",
-      "\n",
-      "    Notes\n",
-      "    -----\n",
-      "\n",
-      "    .. note::\n",
-      "\n",
-      "        This is the :ref:`pyplot wrapper <pyplot_interface>` for `.axes.Axes.bar`.\n",
-      "\n",
-      "    Stacked bars can be achieved by passing individual *bottom* values per\n",
-      "    bar. See :doc:`/gallery/lines_bars_and_markers/bar_stacked`.\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "help(plt.bar)"
+    "# A = YOUR_CODE_HERE\n",
+    "# np.YOUR_CODE_HERE\n",
+    "# \n",
+    "# assert np.all(A.diagonal()==3)\n",
+    "# assert A.sum()==9\n",
+    "# assert A.shape==(3, 3)\n",
+    "\n",
+    "# SOLUTION\n",
+    "A = np.zeros((3,3))\n",
+    "np.fill_diagonal(A, 3)\n",
+    "\n",
+    "assert np.all(A.diagonal()==3)\n",
+    "assert A.sum()==9\n",
+    "assert A.shape==(3, 3)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d0c48669",
+   "id": "81c0b1a3",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 3.2:</b>   \n",
-    "That's right, it plots a bar chart where the first argument is the x coordinate of the bar and the second argument is the height. Fill in the empty lists below to create a bar plot with any values you like.\n",
+    "<b>Task 2.4:</b>   \n",
+    "\n",
+    "Use a Numpy method to create a 10x10 matrix, then assign every other element in the <em>diagonal</em> of the matrix to the value 1 using <code>range</code> and indexing. Use <code>plt.matshow()</code> to confirm that the matrix plot looks like a checkerboard.\n",
+    "\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "id": "512718a3",
+   "execution_count": 8,
+   "id": "9b2d0b82",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "<BarContainer object of 4 artists>"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<Figure size 480x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -966,61 +374,64 @@
     }
    ],
    "source": [
-    "# plt.bar([], [])\n",
+    "# A = YOUR_CODE_HERE\n",
+    "# A[YOUR_CODE_HERE, YOUR_CODE_HERE] = YOUR_CODE_HERE\n",
+    "\n",
+    "# plt.matshow(A)\n",
+    "# plt.show()\n",
+    "\n",
+    "# assert A.shape==(10, 10)\n",
+    "# assert A.sum()==5\n",
+    "# assert np.sum(A==1)==5\n",
+    "# assert np.sum(A==0)==95\n",
     "\n",
     "# SOLUTION\n",
-    "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6])"
+    "A = np.zeros((10,10))\n",
+    "A[range(1, 10, 2), range(1, 10, 2)] = 1\n",
+    "\n",
+    "plt.matshow(A)\n",
+    "plt.show()\n",
+    "\n",
+    "assert A.shape==(10, 10)\n",
+    "assert A.sum()==5\n",
+    "assert np.sum(A==1)==5\n",
+    "assert np.sum(A==0)==95"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "82b94893",
+   "id": "cfd56d4b",
    "metadata": {},
    "source": [
-    "Pretty easy, right? Let's try to do one more thing with this - suppose we don't like that the _center_ of the bar is over the value we enter. It's easy to change this using a _keyword argument_; these are the input arguments to the function that have the equals sign (e.g., `function(keyword_arg=<xxx>)`). These are optional arguments; they are generally not needed, but can be specified, along with a value, to change the default behavior of the function. For our purposes this week, we will want to change _two_ keyword arguments:\n",
+    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
+    "<p>\n",
+    "<b>Task 2.5:</b>   \n",
     "\n",
-    "1. `width`\n",
-    "2. `align`\n",
+    "Use a Numpy method to create a 5x5 matrix, fill the diagonal with value 5, then use <code>range</code> and indexing to assign the diagonal above and below the center diagonal to the value 1. The solution is illustrated in the imported Markdown figure below.\n",
     "\n",
-    "Fortunately the `help` function printed out the docstring for `bar()`, which contains all the information you need to figure out what these keyword arguments do and how to use them."
+    "</p>\n",
+    "</div>"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "501c9c7b",
+   "id": "1b903831",
    "metadata": {},
    "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 3.3:</b>   \n",
-    "Set the keyword arguments below to make the bars fill up the entire space between each bar (no white space) and to force the <b>left</b> side of the bar to align with the value specified.\n",
-    "\n",
-    "Note the addition of keyword argument <code>edgecolor</code> to make it easier to see the edges of the bar. \n",
-    "</p>\n",
-    "</div>"
+    "![solution for matrix 1](./figures/matrix01.svg)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "id": "6b1fd9c1",
+   "execution_count": 9,
+   "id": "42cf5b91",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "<BarContainer object of 4 artists>"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<Figure size 480x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -1028,52 +439,62 @@
     }
    ],
    "source": [
-    "# plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
-    "#         width=YOUR_CODE_HERE,\n",
-    "#         align=YOUR_CODE_HERE,\n",
-    "#         edgecolor='black')\n",
+    "# A = YOUR_CODE_HERE\n",
+    "# YOUR_CODE_HERE\n",
+    "# A[YOUR_CODE_HERE, YOUR_CODE_HERE] = YOUR_CODE_HERE\n",
+    "# A[YOUR_CODE_HERE, YOUR_CODE_HERE] = YOUR_CODE_HERE\n",
+    "\n",
+    "# plt.matshow(A)\n",
+    "# plt.show()\n",
+    "\n",
+    "# assert A.shape==(5, 5)\n",
+    "# assert A.sum()==(5*5 + 2*4)\n",
     "\n",
     "# SOLUTION\n",
-    "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
-    "        width=1,\n",
-    "        align='edge',\n",
-    "        edgecolor='black')"
+    "A = np.zeros((5, 5))\n",
+    "np.fill_diagonal(A, 5)\n",
+    "A[range(4), range(1, 5)] = 1\n",
+    "A[range(1, 5), range(4)] = 1\n",
+    "\n",
+    "plt.matshow(A)\n",
+    "plt.show()\n",
+    "\n",
+    "assert A.shape==(5, 5)\n",
+    "assert A.sum()==(5*5 + 2*4)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a3cc843c",
+   "id": "cdf73279",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 3.4:</b>   \n",
-    "Now set the keyword arguments below to make the bars fill up the entire space between each bar (no white space) and to force the <b>right</b> side of the bar to align with the value specified.\n",
+    "<b>Task 2.6:</b>   \n",
+    "Create the matrix illustrated in the figure below, where the values are either 0 or 1.\n",
     "</p>\n",
     "</div>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d9aa472d",
+   "metadata": {},
+   "source": [
+    "![solution for matrix 1](./figures/matrix02.svg)"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "id": "4958e71a",
+   "execution_count": 16,
+   "id": "b927ac75",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "<BarContainer object of 4 artists>"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<Figure size 480x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -1081,175 +502,288 @@
     }
    ],
    "source": [
-    "# plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
-    "#         width=YOUR_CODE_HERE,\n",
-    "#         align=YOUR_CODE_HERE,\n",
-    "#         edgecolor='black')\n",
+    "# A = YOUR_CODE_HERE\n",
+    "# for i in YOUR_CODE_HERE:\n",
+    "#     YOUR_CODE_HERE\n",
+    "\n",
+    "# plt.matshow(A)\n",
+    "# plt.show()\n",
+    "\n",
+    "# assert A.shape==(10, 10)\n",
+    "# assert A.sum()==25\n",
     "\n",
     "# SOLUTION\n",
-    "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6],\n",
-    "        width=-1,\n",
-    "        align='edge',\n",
-    "        edgecolor='black')"
+    "A = np.zeros((10, 10))\n",
+    "for i in range(0, 10, 2):\n",
+    "    A[i, range(0, 10, 2)] = 1\n",
+    "\n",
+    "plt.matshow(A)\n",
+    "plt.show()\n",
+    "\n",
+    "assert A.shape==(10, 10)\n",
+    "assert A.sum()==25"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "58811f81",
+   "id": "7ae4458c",
    "metadata": {},
    "source": [
-    "## Topic 4: Exporting a Figure and Including it in a Markdown Notebook\n",
-    "\n",
-    "Now that we can create a wider variety of figures, we should be able to include them in our Reports for communicating the results of our analyses. Here we show you a very simple way to save a figure generated in your notebook, then use Markdown to visualize the figure. Once a figure is made it is easy, use this syntax:\n",
-    "\n",
-    "```\n",
-    "![<an arbitrary label for my figure>](<relative path to my figure>)\n",
-    "```\n",
-    "\n",
-    "The label is simply a name that will appear in case the figure fails to load. It can also be read by a website-reading app (for example, then a blind person could understand what the content of the figure may be). Here is an example for what this could look like in practice:\n",
-    "\n",
-    "```\n",
-    "![bar chart of dummy data](./my_bar_chart.svg)\n",
-    "```\n",
-    "\n",
-    "This is very easy, so once again we lead by example! However, first a couple notes about filepaths.\n",
-    "\n",
-    "### File Paths\n",
-    "\n",
-    "A _file path_ is like an address to a file. There are generally two types, _absolute_ and _relative._ Most of our activities focus on working in a  _working directory,_ so we will focus almost entirely on relative paths. The general format is like this:\n",
-    "\n",
-    "```\n",
-    "./subdirectory_1/subdir_2/filename.ext\n",
-    "```\n",
-    "\n",
-    "where:\n",
-    "- the dot `.` indicates one should use the current directory of the file (or the CLI) as the current location (the `.` is like saying \" start _here_\")\n",
-    "- forward slashes `/` separate subdirectories\n",
-    "- the last two words are the file name and extension. For example, common image extensions are `.jpg`, `.png` or `.svg`\n",
-    "- in this example, the image file is stored inside a folder called `subdir_2` which is inside a folder called `subdirectory_1` which is in our working directory.\n",
+    "## Topic 3: a `range` and `arange`\n",
     "\n",
-    "As a general rule, **always use forward slashes whenever possible.** Although backward slashes are the default and must be used at times on Windows, they don't work on Mac or Linux systems. This causes problems when sharing code with others running these systems (or when we check your assignments on GitHub!!!). Remember that we try to do things in a way that allows easy collaboration: using approaches that are agnostic of the operating system (i.e., works on all platforms). This is hard to guarantee in practice, but consistently using forward slashes will get us close!\n",
+    "The previous part used `range` to fill in the items of a matrix. However, you may also be familiar with a method from the Numpy library called `arange`. On the one hand, both methods do similar things, which can roughly be described as follows:\n",
     "\n",
-    "### Try it out yourself\n",
+    "- if one input, a, is given, count integers from 0 to a\n",
+    "- if two inputs, a and b, are given, count integers from a to b\n",
+    "- if three inputs, a, b and c, are given, count from a to b by (integer!) increment c\n",
+    "- in all cases, exclude b\n",
     "\n",
-    "We will try this out, but first we need to create a figure! The code below is a quick way of saving a Matplotlib figure as an svg file."
+    "Despite these similarities they return different object types, which often leads to confusion or errors if used without explicitly accounting for this difference. Let's take a closer look to find out more."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8ca99b68",
+   "id": "0ba7be84",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 4.1:</b>   \n",
-    "Run the cell below to create the svg file. Confirm that it is created successfully by examining your working directory.\n",
+    "<b>Task 3.1:</b>   \n",
+    "\n",
+    "Print the documentation for <code>np.arange</code> and compare it to <code>range</code> until you can identify the differences.\n",
+    "\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "id": "3c82a997",
+   "execution_count": 41,
+   "id": "fe539dec",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on built-in function arange in module numpy:\n",
+      "\n",
+      "arange(...)\n",
+      "    arange([start,] stop[, step,], dtype=None, *, like=None)\n",
+      "\n",
+      "    Return evenly spaced values within a given interval.\n",
+      "\n",
+      "    ``arange`` can be called with a varying number of positional arguments:\n",
+      "\n",
+      "    * ``arange(stop)``: Values are generated within the half-open interval\n",
+      "      ``[0, stop)`` (in other words, the interval including `start` but\n",
+      "      excluding `stop`).\n",
+      "    * ``arange(start, stop)``: Values are generated within the half-open\n",
+      "      interval ``[start, stop)``.\n",
+      "    * ``arange(start, stop, step)`` Values are generated within the half-open\n",
+      "      interval ``[start, stop)``, with spacing between values given by\n",
+      "      ``step``.\n",
+      "\n",
+      "    For integer arguments the function is roughly equivalent to the Python\n",
+      "    built-in :py:class:`range`, but returns an ndarray rather than a ``range``\n",
+      "    instance.\n",
+      "\n",
+      "    When using a non-integer step, such as 0.1, it is often better to use\n",
+      "    `numpy.linspace`.\n",
+      "\n",
+      "    See the Warning sections below for more information.\n",
+      "\n",
+      "    Parameters\n",
+      "    ----------\n",
+      "    start : integer or real, optional\n",
+      "        Start of interval.  The interval includes this value.  The default\n",
+      "        start value is 0.\n",
+      "    stop : integer or real\n",
+      "        End of interval.  The interval does not include this value, except\n",
+      "        in some cases where `step` is not an integer and floating point\n",
+      "        round-off affects the length of `out`.\n",
+      "    step : integer or real, optional\n",
+      "        Spacing between values.  For any output `out`, this is the distance\n",
+      "        between two adjacent values, ``out[i+1] - out[i]``.  The default\n",
+      "        step size is 1.  If `step` is specified as a position argument,\n",
+      "        `start` must also be given.\n",
+      "    dtype : dtype, optional\n",
+      "        The type of the output array.  If `dtype` is not given, infer the data\n",
+      "        type from the other input arguments.\n",
+      "    like : array_like, optional\n",
+      "        Reference object to allow the creation of arrays which are not\n",
+      "        NumPy arrays. If an array-like passed in as ``like`` supports\n",
+      "        the ``__array_function__`` protocol, the result will be defined\n",
+      "        by it. In this case, it ensures the creation of an array object\n",
+      "        compatible with that passed in via this argument.\n",
+      "\n",
+      "        .. versionadded:: 1.20.0\n",
+      "\n",
+      "    Returns\n",
+      "    -------\n",
+      "    arange : ndarray\n",
+      "        Array of evenly spaced values.\n",
+      "\n",
+      "        For floating point arguments, the length of the result is\n",
+      "        ``ceil((stop - start)/step)``.  Because of floating point overflow,\n",
+      "        this rule may result in the last element of `out` being greater\n",
+      "        than `stop`.\n",
+      "\n",
+      "    Warnings\n",
+      "    --------\n",
+      "    The length of the output might not be numerically stable.\n",
+      "\n",
+      "    Another stability issue is due to the internal implementation of\n",
+      "    `numpy.arange`.\n",
+      "    The actual step value used to populate the array is\n",
+      "    ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss\n",
+      "    can occur here, due to casting or due to using floating points when\n",
+      "    `start` is much larger than `step`. This can lead to unexpected\n",
+      "    behaviour. For example::\n",
+      "\n",
+      "      >>> np.arange(0, 5, 0.5, dtype=int)\n",
+      "      array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
+      "      >>> np.arange(-3, 3, 0.5, dtype=int)\n",
+      "      array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])\n",
+      "\n",
+      "    In such cases, the use of `numpy.linspace` should be preferred.\n",
+      "\n",
+      "    The built-in :py:class:`range` generates :std:doc:`Python built-in integers\n",
+      "    that have arbitrary size <python:c-api/long>`, while `numpy.arange`\n",
+      "    produces `numpy.int32` or `numpy.int64` numbers. This may result in\n",
+      "    incorrect results for large integer values::\n",
+      "\n",
+      "      >>> power = 40\n",
+      "      >>> modulo = 10000\n",
+      "      >>> x1 = [(n ** power) % modulo for n in range(8)]\n",
+      "      >>> x2 = [(n ** power) % modulo for n in np.arange(8)]\n",
+      "      >>> print(x1)\n",
+      "      [0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct\n",
+      "      >>> print(x2)\n",
+      "      [0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect\n",
+      "\n",
+      "    See Also\n",
+      "    --------\n",
+      "    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.\n",
+      "    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.\n",
+      "    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.\n",
+      "    :ref:`how-to-partition`\n",
+      "\n",
+      "    Examples\n",
+      "    --------\n",
+      "    >>> np.arange(3)\n",
+      "    array([0, 1, 2])\n",
+      "    >>> np.arange(3.0)\n",
+      "    array([ 0.,  1.,  2.])\n",
+      "    >>> np.arange(3,7)\n",
+      "    array([3, 4, 5, 6])\n",
+      "    >>> np.arange(3,7,2)\n",
+      "    array([3, 5])\n",
+      "\n"
+     ]
     }
    ],
    "source": [
-    "fig, ax = plt.subplots(1,1,figsize = (8,6))\n",
-    "plt.bar([1, 2, 3, 4],[0.2, 0.5, 0.1, 0.6])\n",
-    "fig.savefig('my_figure.svg')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3b62b94f",
-   "metadata": {},
-   "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 4.2:</b>   \n",
-    "Now that the image is created, use the Markdown cell below to display it in this notebook.\n",
-    "</p>\n",
-    "</div>"
+    "help(np.arange)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "2c71b287",
+   "id": "a2c95e09",
    "metadata": {},
    "source": [
-    "Use this Markdown cell to try visualizing the figure we just saved using Markdown!\n",
+    "In particular, note the following sentences in the docstring for `np.arange`:\n",
     "\n",
-    "![a figure]()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "847c2d7e",
-   "metadata": {},
-   "source": [
-    "**SOLUTION**\n",
+    "```\n",
+    "For integer arguments the function is roughly equivalent to the Python\n",
+    "built-in :py:class:`range`, but returns an ndarray rather than a ``range``\n",
+    "instance.\n",
     "\n",
+    "When using a non-integer step, such as 0.1, it is often better to use\n",
+    "`numpy.linspace`.\n",
     "```\n",
-    "![a figure](./my_figure.svg)\n",
-    "````\n",
     "\n",
-    "![a figure](./my_figure.svg)"
+    "The main difference is that `np.arange` **returns an array!**"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "26492dd2",
+   "id": "e1dcf427",
    "metadata": {},
    "source": [
     "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
     "<p>\n",
-    "<b>Task 4.3:</b>   \n",
-    "Test your understanding of relative file paths by moving the csv file to a subdirectory with name <code>figure</code> and getting the following Markdown cell to display the figure.\n",
+    "<b>Task 3.2:</b>   \n",
     "\n",
-    "<pre>\n",
-    "<code>\n",
-    "![a figure](./figures/my_figure.svg)\n",
-    "</code>\n",
-    "</pre>\n",
+    "Confirm that you understand the usage of <code>np.arange</code> by creating the same two sets of integer values as in Task 2.1 (integers 0 through 5 and 2 through 10 by 2's), except this time you will produce Numpy arrays in addition the printing the indices.\n",
     "\n",
     "</p>\n",
     "</div>"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "b23f5743",
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "797fb5a2",
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Part 1:\n",
+      "0\n",
+      "1\n",
+      "2\n",
+      "3\n",
+      "4\n",
+      "5\n",
+      "Part 2:\n",
+      "2\n",
+      "4\n",
+      "6\n",
+      "8\n",
+      "10\n"
+     ]
+    }
+   ],
    "source": [
-    "** MAKE SURE A FIGURE APPEARS HERE BY MODIFYING THIS MARKDOWN CELL**\n",
+    "# x = YOUR_CODE_HERE\n",
+    "# print('Part 1:')\n",
+    "# [print(i) for i in YOUR_CODE_HERE]\n",
+    "# \n",
+    "# assert type(x) == np.ndarray\n",
+    "# assert np.all(x == [0, 1, 2, 3, 4, 5])\n",
+    "# \n",
+    "# x = YOUR_CODE_HERE\n",
+    "# print('Part 2:')\n",
+    "# [print(i) for i in YOUR_CODE_HERE]\n",
+    "# \n",
+    "# assert type(x) == np.ndarray\n",
+    "# assert np.all(x == [2, 4, 6, 8, 10])\n",
+    "\n",
+    "# SOLUTION\n",
+    "x = np.arange(6)\n",
+    "print('Part 1:')\n",
+    "[print(i) for i in x]\n",
     "\n",
-    "![a figure](./test/my_figure.svg)"
+    "assert type(x) == np.ndarray\n",
+    "assert np.all(x == [0, 1, 2, 3, 4, 5])\n",
+    "\n",
+    "x = np.arange(2, 11, 2)\n",
+    "print('Part 2:')\n",
+    "[print(i) for i in x]\n",
+    "\n",
+    "assert type(x) == np.ndarray\n",
+    "assert np.all(x == [2, 4, 6, 8, 10])"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "0d7a487d",
+   "id": "4ee8daf6",
    "metadata": {},
    "source": [
-    "<div style=\"background-color:#AABAB2; color: black; width:95%; vertical-align: middle; padding:15px; margin: 10px; border-radius: 10px\">\n",
-    "<p>\n",
-    "<b>Task 4.4:</b>   \n",
-    "Now add the figure to an actual markdown while, specifically <code>myfigure.md</code>. Then visualize to confirm you did it properly (remember to use `CTRL+SHIFT+V` in VSC, the [Markdown All-in-one extension](https://mude.citg.tudelft.nl/2024/book/external/learn-programming/book/install/ide/vsc/extensions.html#markdown-all-in-one))\n",
-    "\n",
-    "</p>\n",
-    "</div>"
+    "This Part is not meant to be complicated; rather, it is meant to explicitly indicate the difference between `range` and `np.arange` to help you debug your code more easily. The **main takeaway** is that you should use `range` when you are iterating through indices and don't need to use the indices as values, whereas `np.arange` is necessary when the indices are needed as values. It is also good to recognize that `range` is part of the standard Python library, whereas `np.arange` is not (it is part of Numpy). This is because `range` returns a `range` object, whereas `np.arange` returns a Numpy array."
    ]
   },
   {
diff --git a/content/Week_1_6/PA/README.md b/content/Week_1_6/PA/README.md
index 1c5034fd..d1a4dd4e 100644
--- a/content/Week_1_6/PA/README.md
+++ b/content/Week_1_6/PA/README.md
@@ -1,38 +1,30 @@
-# PA 1.5: MUDE-git-crossword and Ice prediction
+# PA 1.5: Boxes and Bugs
 *[CEGM1000 MUDE](http://mude.citg.tudelft.nl/): Week 1.6. Due: before Friday, October 11th, 2024.*
 
 This PA consists of 4 parts:
 
-1. `PA_1_5_.useful_tricks.ipynb`: a notebook covering a few simple Python topics that are especially useful for the WS and GA assignments this week.
-2. [Programming for Week 1.5](https://mude.citg.tudelft.nl/2024/book/programming/week_1_5.html) (Online Textbook): read this chapter, which covers more Git topics: branching, forking, pull requests and merge conflicts
-3. `crossword.md`: file containing a crossword puzzle, which you will use to work on a separate branch and merge commits into the `main` branch.
-4. `predictions.txt`: a file in a _separate_ repository [github.com/iceclassic/mude-pa-1-5](https://github.com/iceclassic/mude-pa-1-5). where you will contribute a commit from your own fork of the separate repository
+1. [Programming for Week 1.6](https://mude.citg.tudelft.nl/2024/book/programming/week_1_6.html) (Online Textbook): read this chapter, which covers errors and error handling in Python.
+2. `PA_1_6_Boxes_and_Bugs.ipynb`: a notebook covering a few simple Python topics that are especially useful for the WS and GA assignments this week.
+3. Python file `script_test.py`: prints a simple statement to your CLI to confirm you have VS Code set up properly for executing Python scripts (instructions below).
+4. Various `*.py` files, each of which contains some code with a few bugs that you must find and solve using the Python traceback that is generated in the CLI after running them.
 
-Notes:
-- The notebook can be completed independently from the other parts; try to finish complete this before the Wednesday in-class session.
-- This PA actually involves 3 repositories: the one created for this assignment, the ice repository and your own personal fork of the ice repository, which you will create.
+## Running Python Scripts in VS Code
 
-## Ice Classic Repo
+So far we have mostly been using Jupyter notebooks, with a few examples of importing functions using `*.py` files. However, it is important to recognize that **Jupyter notebooks are not the only way to run Python code.** With your MUDE setup of conda and VS Code it is very easy to execute the contents of a `*.py` file directly, with output being generated in the command line interface. This workflow is called _scripting_ and the contents of the `*.py` files are referred to as scripts. 
 
-For Part 4 you will be making a prediction for the 2025 ice classic! The repo is: [github.com/iceclassic/mude-pa-1-5](https://github.com/iceclassic/mude-pa-1-5).
+Try running a script by opening `script_test.py` in the editor and clicking the triangular "Run Python files" button in the top right corner. You should see a simple message printed in the CLI. If this works, you are ready to read the Python traceback in the CLIE and debug the other `*.py` files in the repo and complete the PA.
 
-**To add your prediction,** find your GitHub username in the list in `predictions.txt` and enter a prediction in the format `(YYYY-MM-DD HH:MM:SS)` (year,month, day, hour minute, seconds). That's it! 
-
-- The repo already contains a figure that displays all of the historic breakup days and times, and the predictions of MUDE students will be added on top. Here is a direct link to the figure: [predictions.svg](https://github.com/iceclassic/test_pa15/blob/main/test.svg).
-- The repo is set up to automatically update the figure every time a commit is made. Note, however that it may take some time before your change is visible, as the instructors must approve the pull requests.
+If this does not work, ask an instructor for help during question hours.
 
 ## Grading Criteria
 
 You will pass this PA if:
-1. For the python and markdown topics of this PA.
-  - Your notebook `PA_1_5_useful_tricks.ipynb` runs without errors.
-  - Your repository contains a file `my_figure.svg` located in subdirectory `/figures`
-  - You update the `myfigure.md` file to include a reference to the previous figure.
-2. For the branching part of this PA: you successfully merged a pull request from your own branch.
-3. For the forking part of this PA: You successfully created a pull request to the ice repo with your bet (it should be visible on the [Pull Requests tab of the repo](https://github.com/iceclassic/mude-pa-1-5/pulls)). After your pull request is accepted (this requires some manual actions from your teachers on your pull request) you can confirm that your bet is approved by seeing it in the figure `guesses.svg`.
+1. Your notebook `PA_1_6_Boxes_and_Bugs.ipynb` runs without errors.
+2. All of the Python scripts in your repository run without errors.
 
-You can verify that you passed checks 1 and 2 by looking for the green circle in this repository. It runs automatically just like last week when you uploaded your notebook. Check 3 will be done manually by your teachers.
+You can verify that you passed both checks by looking for the green circle in this repository (the last workflow run).
 
+If your check is failing, view the Python traceback by going to the Actions tab, click the most recent workflow run, click the job (the box diagram) and expand and read the command line interface output.
 
 **End of file.**
 
diff --git a/content/Week_1_6/PA/Some_small_bugs.py b/content/Week_1_6/PA/Some_small_bugs.py
deleted file mode 100644
index 02f591b3..00000000
--- a/content/Week_1_6/PA/Some_small_bugs.py
+++ /dev/null
@@ -1,17 +0,0 @@
-## Some small bugs for you to find!
-import numpy as np
-import matplotlib.pylab as plt
-import pandas as pd
-
-a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-b = np.linspace(0, 10, 11)
-
-print(a.size())
-
-for i in range(0, a.size):
-    a[i] = a[i] +a[i-1]
-
-# Does this look like a sine wave?
-plt.plot(a, np.sin(a), label='sin(a)')
-
-c = a+b
diff --git a/content/Week_1_6/PA/figures/matrix01.svg b/content/Week_1_6/PA/figures/matrix01.svg
new file mode 100644
index 00000000..0cd3b118
--- /dev/null
+++ b/content/Week_1_6/PA/figures/matrix01.svg
@@ -0,0 +1,365 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="345.6pt" height="345.6pt" viewBox="0 0 345.6 345.6" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2024-10-05T10:50:58.580608</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.9.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 345.6 
+L 345.6 345.6 
+L 345.6 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 51.84 314.496 
+L 319.68 314.496 
+L 319.68 46.656 
+L 51.84 46.656 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g clip-path="url(#p34451a0954)">
+    <image xlink:href="data:image/png;base64,
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" id="image57af476cfb" transform="scale(1 -1) translate(0 -267.84)" x="51.84" y="-46.656" width="268.56" height="267.84"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="m1fd9c04119" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m1fd9c04119" x="78.624" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_2">
+      <defs>
+       <path id="m3ec662af0e" d="M 0 0 
+L 0 -3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m3ec662af0e" x="78.624" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- 0 -->
+      <g transform="translate(75.44275 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#m1fd9c04119" x="132.192" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#m3ec662af0e" x="132.192" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- 1 -->
+      <g transform="translate(129.01075 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#m1fd9c04119" x="185.76" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_6">
+      <g>
+       <use xlink:href="#m3ec662af0e" x="185.76" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <!-- 2 -->
+      <g transform="translate(182.57875 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <g>
+       <use xlink:href="#m1fd9c04119" x="239.328" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_8">
+      <g>
+       <use xlink:href="#m3ec662af0e" x="239.328" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <!-- 3 -->
+      <g transform="translate(236.14675 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-33" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-33"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#m1fd9c04119" x="292.896" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_10">
+      <g>
+       <use xlink:href="#m3ec662af0e" x="292.896" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <!-- 4 -->
+      <g transform="translate(289.71475 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-34" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-34"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_11">
+      <defs>
+       <path id="m2dafb0fbe5" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#m2dafb0fbe5" x="51.84" y="73.44" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <!-- 0 -->
+      <g transform="translate(38.4775 77.239219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-30"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_12">
+      <g>
+       <use xlink:href="#m2dafb0fbe5" x="51.84" y="127.008" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <!-- 1 -->
+      <g transform="translate(38.4775 130.807219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-31"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_13">
+      <g>
+       <use xlink:href="#m2dafb0fbe5" x="51.84" y="180.576" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_8">
+      <!-- 2 -->
+      <g transform="translate(38.4775 184.375219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-32"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_14">
+      <g>
+       <use xlink:href="#m2dafb0fbe5" x="51.84" y="234.144" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <!-- 3 -->
+      <g transform="translate(38.4775 237.943219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-33"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_15">
+      <g>
+       <use xlink:href="#m2dafb0fbe5" x="51.84" y="287.712" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <!-- 4 -->
+      <g transform="translate(38.4775 291.511219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-34"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 51.84 314.496 
+L 51.84 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 319.68 314.496 
+L 319.68 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 51.84 314.496 
+L 319.68 314.496 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 51.84 46.656 
+L 319.68 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p34451a0954">
+   <rect x="51.84" y="46.656" width="267.84" height="267.84"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/content/Week_1_6/PA/figures/matrix02.svg b/content/Week_1_6/PA/figures/matrix02.svg
new file mode 100644
index 00000000..f1c87a53
--- /dev/null
+++ b/content/Week_1_6/PA/figures/matrix02.svg
@@ -0,0 +1,388 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="345.6pt" height="345.6pt" viewBox="0 0 345.6 345.6" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:date>2024-10-05T10:56:32.349445</dc:date>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.9.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 345.6 
+L 345.6 345.6 
+L 345.6 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 51.84 314.496 
+L 319.68 314.496 
+L 319.68 46.656 
+L 51.84 46.656 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g clip-path="url(#p333aaadcf2)">
+    <image xlink:href="data:image/png;base64,
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" id="image55d3d235c6" transform="scale(1 -1) translate(0 -267.84)" x="51.84" y="-46.656" width="268.56" height="267.84"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="me552d468d2" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#me552d468d2" x="65.232" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_2">
+      <defs>
+       <path id="mbac9283a20" d="M 0 0 
+L 0 -3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mbac9283a20" x="65.232" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- 0 -->
+      <g transform="translate(62.05075 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#me552d468d2" x="118.8" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#mbac9283a20" x="118.8" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- 2 -->
+      <g transform="translate(115.61875 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#me552d468d2" x="172.368" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_6">
+      <g>
+       <use xlink:href="#mbac9283a20" x="172.368" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <!-- 4 -->
+      <g transform="translate(169.18675 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-34" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-34"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <g>
+       <use xlink:href="#me552d468d2" x="225.936" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_8">
+      <g>
+       <use xlink:href="#mbac9283a20" x="225.936" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <!-- 6 -->
+      <g transform="translate(222.75475 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#me552d468d2" x="279.504" y="314.496" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="line2d_10">
+      <g>
+       <use xlink:href="#mbac9283a20" x="279.504" y="46.656" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <!-- 8 -->
+      <g transform="translate(276.32275 37.576313) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-38" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-38"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_11">
+      <defs>
+       <path id="mb280eb99e4" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mb280eb99e4" x="51.84" y="60.048" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <!-- 0 -->
+      <g transform="translate(38.4775 63.847219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-30"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_12">
+      <g>
+       <use xlink:href="#mb280eb99e4" x="51.84" y="113.616" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <!-- 2 -->
+      <g transform="translate(38.4775 117.415219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-32"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_13">
+      <g>
+       <use xlink:href="#mb280eb99e4" x="51.84" y="167.184" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_8">
+      <!-- 4 -->
+      <g transform="translate(38.4775 170.983219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-34"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_14">
+      <g>
+       <use xlink:href="#mb280eb99e4" x="51.84" y="220.752" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <!-- 6 -->
+      <g transform="translate(38.4775 224.551219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-36"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_15">
+      <g>
+       <use xlink:href="#mb280eb99e4" x="51.84" y="274.32" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <!-- 8 -->
+      <g transform="translate(38.4775 278.119219) scale(0.1 -0.1)">
+       <use xlink:href="#DejaVuSans-38"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 51.84 314.496 
+L 51.84 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 319.68 314.496 
+L 319.68 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 51.84 314.496 
+L 319.68 314.496 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 51.84 46.656 
+L 319.68 46.656 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p333aaadcf2">
+   <rect x="51.84" y="46.656" width="267.84" height="267.84"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/content/Week_1_6/PA/script_01_small_bugs.py b/content/Week_1_6/PA/script_01_small_bugs.py
new file mode 100644
index 00000000..ccc13e94
--- /dev/null
+++ b/content/Week_1_6/PA/script_01_small_bugs.py
@@ -0,0 +1,103 @@
+## Some small bugs for you to find!
+import numpy as np
+import matplotlib.pylab as plt
+import pandas as pd
+
+"""SOLUTION
+
+Traceback excerpt:
+==================
+
+
+Explanation:
+============
+
+
+Solution:
+=========
+
+"""
+
+a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+b = np.linspace(0, 10, 11)
+
+print(a.size())
+
+for i in range(0, a.size):
+    a[i] = a[i] +a[i-1]
+
+# Does this look like a sine wave?
+plt.plot(a, np.sin(a), label='sin(a)')
+
+c = a+b
+
+# Create a matrix with 5's on the diagonal and 1's on the diagonal
+# below the main diagonal
+A = np.zeros((5, 5))
+np.fill_diagonal(A, 5)
+A[range(3), range(1, 5)] = 1
+
+"""SOLUTION
+
+Traceback excerpt:
+==================
+A[np.arange(3), np.arange(1, 5)] = 1
+IndexError: shape mismatch: indexing arrays could not be broadcast
+together with shapes (3,) (4,)
+
+Explanation:
+============
+IndexError indicates that we have indexed the matrix wrong, but its
+not clear why. The first guess might be that we are referring to
+an index that is out of bounds, but that is not the case here. It
+turns out that the problem is that the two arrays we are creating with
+np.arange are of different lengths. The first array has length 3, and
+the second array has length 4. As the indices are used to change the
+values in the matrix, they need to be of the same length. To fix this,
+the two arange arrays should be of the same length. Because we know
+the lower diagonal is being set and the matrix is 5x5, we need to
+change 4 values, so arange(4) should be used instead of arange(3).
+
+Solution:
+=========
+Change index from 4 to 3 so each range() has same number of elements:
+    A[range(3), range(1, 5)] = 1
+"""
+
+# Part X
+# We want to compute the exponent of x = 0, 4, 8, 12, 16, 20 
+x = range(0, 21, 4)
+y = np.exp(x)
+
+# then we want to change the first value of x to 1 instead of 0
+x[0] = 1
+y = np.exp(x)
+
+assert x[0]==1, "The first value of x should be 1"
+assert y[0]==np.exp(1), "The first value of y should be exp(1)"
+
+"""SOLUTION
+
+Traceback excerpt:
+==================
+    x[0] = 1
+TypeError: 'range' object does not support item assignment
+
+Explanation:
+============
+The error message mentions "item assignment", which is what we are
+trying to do: assign the value 1 to the first _item_ in x. The mistake
+is that we are doing this as if x is an Numpy array, but it is clearly
+a range object. The fix is simple: define x using np.arange instead of
+range.
+
+If the line of code were more complex (e.g., included more terms and
+variable assignments), it might not have been apparent which object
+was the range, so a good debugging strategy would be to check the type
+of each object.
+
+Solution:
+=========
+Define x as an array with np.arange(); first line is thus:
+    x = np.arange(0, 21, 4)
+"""
\ No newline at end of file
diff --git a/content/Week_1_6/PA/PA6-Challenges_A.py b/content/Week_1_6/PA/script_02_big_bug.py
similarity index 100%
rename from content/Week_1_6/PA/PA6-Challenges_A.py
rename to content/Week_1_6/PA/script_02_big_bug.py
diff --git a/content/Week_1_6/PA/A_mistake_that_shows_no_errors.py b/content/Week_1_6/PA/script_03_logical_bug.py
similarity index 97%
rename from content/Week_1_6/PA/A_mistake_that_shows_no_errors.py
rename to content/Week_1_6/PA/script_03_logical_bug.py
index a4a8990c..d3e62add 100644
--- a/content/Week_1_6/PA/A_mistake_that_shows_no_errors.py
+++ b/content/Week_1_6/PA/script_03_logical_bug.py
@@ -1,48 +1,48 @@
-## IMPORTS ##
-import numpy as np
-import matplotlib.pylab as plt
-import pandas as pd
-import os
-
-## FILE PATHS ##
-file_path = os.path.join(os.path.dirname(__file__), 'justIce.csv')
-data = pd.read_csv(filepath_or_buffer=file_path, index_col=0)
-data.index = pd.to_datetime(data.index, format="%Y-%m-%d")
-
-plt.figure(figsize=(15,4))
-plt.scatter(data.index,data, color='green', marker='x')
-plt.xlabel('Year')
-plt.ylabel('Ice thickness [cm]')
-plt.grid()
-
-## DATA ANALYSIS ##
-data_2021 = data.loc['2021']
-h_ice = (data_2021.to_numpy()).ravel()
-t_days = ((data_2021.index - data_2021.index[0]).days).to_numpy()
-dh_dt_FD = (h_ice[1:]-h_ice[:-1])/(t_days[1:]-t_days[:-1]) 
-dh_dt_BD = (h_ice[1:]-h_ice[:-1])/(t_days[1:]-t_days[:-1]) 
-dh_dt_CD = [(h_ice[i+1] - h_ice[i-1]) / (t_days[i+1] - t_days[i-1]) for i in range(0, len(t_days)-1)]
-
-## PLOTTING ##
-fig, ax1 = plt.subplots(figsize=(15,4))
-ax1.scatter(t_days[:-1], dh_dt_FD,
-            color='blue', marker='o', label='dh_dt_FE Forward Difference')
-ax1.scatter(t_days[1:], dh_dt_BD,
-            color='red', marker='o', label='dh_dt_BE Backward Difference')
-ax1.scatter((t_days[1:]+t_days[:-1])/2, dh_dt_CD,
-            color='purple', marker='o', label='dh_dt_CD Central Difference')
-ax1.set_xlabel('Days')
-ax1.set_ylabel('Growth Rate [cm/day]', color='blue')
-ax1.tick_params(axis='y', labelcolor='blue')
-ax1.grid()
-
-ax2 = ax1.twinx()
-ax2.scatter(t_days, h_ice, color='green', marker='x', label='h_ice Measurements')
-ax2.set_ylabel('Ice thickness [cm]', color='green')
-ax2.tick_params(axis='y', labelcolor='green')
-
-handles, labels = ax1.get_legend_handles_labels()
-handles2, labels2 = ax2.get_legend_handles_labels()
-ax1.legend(handles + handles2, labels + labels2, loc='upper left')
-
+## IMPORTS ##
+import numpy as np
+import matplotlib.pylab as plt
+import pandas as pd
+import os
+
+## FILE PATHS ##
+file_path = os.path.join(os.path.dirname(__file__), 'justIce.csv')
+data = pd.read_csv(filepath_or_buffer=file_path, index_col=0)
+data.index = pd.to_datetime(data.index, format="%Y-%m-%d")
+
+plt.figure(figsize=(15,4))
+plt.scatter(data.index,data, color='green', marker='x')
+plt.xlabel('Year')
+plt.ylabel('Ice thickness [cm]')
+plt.grid()
+
+## DATA ANALYSIS ##
+data_2021 = data.loc['2021']
+h_ice = (data_2021.to_numpy()).ravel()
+t_days = ((data_2021.index - data_2021.index[0]).days).to_numpy()
+dh_dt_FD = (h_ice[1:]-h_ice[:-1])/(t_days[1:]-t_days[:-1]) 
+dh_dt_BD = (h_ice[1:]-h_ice[:-1])/(t_days[1:]-t_days[:-1]) 
+dh_dt_CD = [(h_ice[i+1] - h_ice[i-1]) / (t_days[i+1] - t_days[i-1]) for i in range(0, len(t_days)-1)]
+
+## PLOTTING ##
+fig, ax1 = plt.subplots(figsize=(15,4))
+ax1.scatter(t_days[:-1], dh_dt_FD,
+            color='blue', marker='o', label='dh_dt_FE Forward Difference')
+ax1.scatter(t_days[1:], dh_dt_BD,
+            color='red', marker='o', label='dh_dt_BE Backward Difference')
+ax1.scatter((t_days[1:]+t_days[:-1])/2, dh_dt_CD,
+            color='purple', marker='o', label='dh_dt_CD Central Difference')
+ax1.set_xlabel('Days')
+ax1.set_ylabel('Growth Rate [cm/day]', color='blue')
+ax1.tick_params(axis='y', labelcolor='blue')
+ax1.grid()
+
+ax2 = ax1.twinx()
+ax2.scatter(t_days, h_ice, color='green', marker='x', label='h_ice Measurements')
+ax2.set_ylabel('Ice thickness [cm]', color='green')
+ax2.tick_params(axis='y', labelcolor='green')
+
+handles, labels = ax1.get_legend_handles_labels()
+handles2, labels2 = ax2.get_legend_handles_labels()
+ax1.legend(handles + handles2, labels + labels2, loc='upper left')
+
 plt.show()
\ No newline at end of file
diff --git a/content/Week_1_6/PA/script_test.py b/content/Week_1_6/PA/script_test.py
new file mode 100644
index 00000000..fb4ce8f7
--- /dev/null
+++ b/content/Week_1_6/PA/script_test.py
@@ -0,0 +1,6 @@
+# Run me first!
+# Click the triangle button in the top right, "Run Python file"
+print('\n')
+print('If you see this message in your CLI, VS Code is set up properly!')
+print('\n  Note the command executed above in the CLI. The button uses')
+print('  the Python interpreter to run the script (this file)')
\ No newline at end of file
diff --git a/content/Week_1_6/PA/test.py b/content/Week_1_6/PA/test.py
new file mode 100644
index 00000000..bc57cd00
--- /dev/null
+++ b/content/Week_1_6/PA/test.py
@@ -0,0 +1,7 @@
+import numpy as np
+import matplotlib.pylab as plt
+import pandas as pd
+
+A = np.zeros((5, 5))
+np.fill_diagonal(A, 5)
+A[range(4), range(1, 5)] = 1
\ No newline at end of file
-- 
GitLab